github.com/go-kit/log v0.1.0: With

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify github.com/go-kit/log.With in pkg:golang/github.com/go-kit/log@v0.1.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/go-kit/log@v0.1.0
Demonstrate these symbols/APIs:
  - github.com/go-kit/log.With

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:0bca2577af1d48a9c79b3401d48ebe0db87875f4337f9e59b94284636378024d","contract":["log.With returns a new Logger preserving context key-value pairs across log calls","log.With does not mutate parent logger when creating child context loggers","log.With supports chaining multiple context layers in sequential order","log.With dynamically evaluates Valuer functions on each log invocation","log.WithPrefix prepends key-value pairs before subsequent contextual and call arguments","log.With works concurrently across goroutines when backed by a synchronized logger"],"goal":"verify github.com/go-kit/log.With in pkg:golang/github.com/go-kit/log@v0.1.0","kind":"HOW","packages":["pkg:golang/github.com/go-kit/log@v0.1.0"],"schemaVersion":1,"symbols":["github.com/go-kit/log.With"]},"contractCommand":["go","run","./test"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","language":"go","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/github.com/go-kit/log@v0.1.0"],"schemaVersion":1,"subject":"pkg:golang/github.com/go-kit/log@v0.1.0","symbols":["github.com/go-kit/log.With"],"verifierAdapter":"golang@1"}

module sample

go 1.26.6

require github.com/go-kit/log v0.1.0

require github.com/go-logfmt/logfmt v0.5.0 // indirect

github.com/go-kit/log v0.1.0 h1:DGJh0Sm43HbOeYDNnVZFl8BvcYVvjD5bqYJvp0REbwQ=
github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
github.com/go-logfmt/logfmt v0.5.0 h1:TrB8swr/68K7m9CcGut2g3UOihhbcbiMAYiuTXdEih4=
github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
github.com/go-stack/stack v1.8.0 h1:5SgMzNM5HxrEjV0ww2lTmX6E2Izsfxas4+YHWRs3Lsk=
github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=

{
  "schemaVersion": 1,
  "goal": "verify github.com/go-kit/log.With in pkg:golang/github.com/go-kit/log@v0.1.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/go-kit/log@v0.1.0"
  ],
  "symbols": [
    "github.com/go-kit/log.With"
  ]
}

package main

import (
	"bytes"
	"fmt"
	"os"
	"strings"
	"sync"
	"sync/atomic"
	"time"

	"github.com/go-kit/log"
)

func main() {
	if err := runTests(); err != nil {
		fmt.Fprintf(os.Stderr, "Contract test failed: %v\n", err)
		os.Exit(1)
	}
	fmt.Println("All contract tests passed successfully.")
}

func runTests() error {
	// 1. log.With returns a new Logger preserving context key-value pairs across log calls
	var buf bytes.Buffer
	baseLogger := log.NewLogfmtLogger(&buf)
	ctxLogger := log.With(baseLogger, "service", "auth", "env", "prod")

	if err := ctxLogger.Log("msg", "user login", "user_id", 101); err != nil {
		return fmt.Errorf("ctxLogger.Log call 1 failed: %w", err)
	}
	if err := ctxLogger.Log("msg", "token issued", "status", "ok"); err != nil {
		return fmt.Errorf("ctxLogger.Log call 2 failed: %w", err)
	}

	lines := strings.Split(strings.TrimSpace(buf.String()), "\n")
	if len(lines) != 2 {
		return fmt.Errorf("expected 2 log lines, got %d", len(lines))
	}
	if lines[0] != `service=auth env=prod msg="user login" user_id=101` {
		return fmt.Errorf("unexpected log line 1: %q", lines[0])
	}
	if lines[1] != `service=auth env=prod msg="token issued" status=ok` {
		return fmt.Errorf("unexpected log line 2: %q", lines[1])
	}

	// 2. log.With does not mutate parent logger when creating child context loggers
	buf.Reset()
	if err := baseLogger.Log("msg", "base log event"); err != nil {
		return fmt.Errorf("baseLogger.Log failed: %w", err)
	}
	out := strings.TrimSpace(buf.String())
	if out != `msg="base log event"` {
		return fmt.Errorf("baseLogger was mutated, got: %q", out)
	}

	// 3. log.With supports chaining multiple context layers in sequential order
	buf.Reset()
	layer1 := log.With(baseLogger, "layer", 1, "region", "us-east")
	layer2 := log.With(layer1, "layer", 2, "component", "http-server")
	if err := layer2.Log("msg", "request handled"); err != nil {
		return fmt.Errorf("chained layer2.Log failed: %w", err)
	}
	out = strings.TrimSpace(buf.String())
	if out != `layer=1 region=us-east layer=2 component=http-server msg="request handled"` {
		return fmt.Errorf("unexpected chained output: %q", out)
	}

	// 4. log.With dynamically evaluates Valuer functions on each log invocation
	buf.Reset()
	var callCount int64
	dynamicValuer := log.Valuer(func() interface{} {
		return atomic.AddInt64(&callCount, 1)
	})
	valLogger := log.With(baseLogger, "call_id", dynamicValuer)

	if err := valLogger.Log("action", "first"); err != nil {
		return fmt.Errorf("valLogger first call failed: %w", err)
	}
	if err := valLogger.Log("action", "second"); err != nil {
		return fmt.Errorf("valLogger second call failed: %w", err)
	}

	lines = strings.Split(strings.TrimSpace(buf.String()), "\n")
	if len(lines) != 2 {
		return fmt.Errorf("expected 2 lines from valLogger, got %d", len(lines))
	}
	if lines[0] != `call_id=1 action=first` {
		return fmt.Errorf("unexpected valuer line 1: %q", lines[0])
	}
	if lines[1] != `call_id=2 action=second` {
		return fmt.Errorf("unexpected valuer line 2: %q", lines[1])
	}

	// 5. log.WithPrefix prepends key-value pairs before subsequent contextual and call arguments
	buf.Reset()
	fixedTime := time.Date(2026, 8, 26, 0, 0, 0, 0, time.UTC)
	tsValuer := log.Timestamp(func() time.Time {
		return fixedTime
	})
	prefixLogger := log.WithPrefix(baseLogger, "ts", tsValuer)
	childWithPrefix := log.With(prefixLogger, "module", "router")
	if err := childWithPrefix.Log("event", "route_matched", "path", "/api/v1"); err != nil {
		return fmt.Errorf("childWithPrefix.Log failed: %w", err)
	}
	out = strings.TrimSpace(buf.String())
	if out != `ts=2026-08-26T00:00:00Z module=router event=route_matched path=/api/v1` {
		return fmt.Errorf("unexpected prefix logger output: %q", out)
	}

	// 6. log.With works concurrently across goroutines when backed by a synchronized logger
	buf.Reset()
	syncLogger := log.NewSyncLogger(baseLogger)
	workerLogger := log.With(syncLogger, "role", "worker")

	var wg sync.WaitGroup
	const numGoroutines = 8
	for i := 0; i < numGoroutines; i++ {
		wg.Add(1)
		workerID := i
		go func() {
			defer wg.Done()
			scopedLogger := log.With(workerLogger, "worker_id", workerID)
			_ = scopedLogger.Log("status", "done")
		}()
	}
	wg.Wait()

	lines = strings.Split(strings.TrimSpace(buf.String()), "\n")
	if len(lines) != numGoroutines {
		return fmt.Errorf("expected %d lines from concurrent workers, got %d", numGoroutines, len(lines))
	}
	for _, l := range lines {
		if !strings.Contains(l, "role=worker") || !strings.Contains(l, "status=done") || !strings.Contains(l, "worker_id=") {
			return fmt.Errorf("malformed concurrent line: %q", l)
		}
	}

	return nil
}