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

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.Logger 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.Logger

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:dfb71a4b43f7b0f0676eda9212e2d86868a535bb5e45a15b14d2e53cd8e079c2","contract":["Logger is an interface implemented by custom types or LoggerFunc providing a Log method","NewNopLogger returns a Logger that silently drops all keyvals returning nil","With wraps a Logger to prepend contextual key-value pairs to log events","WithPrefix wraps a Logger to prepend key-value pairs before existing context","WithSuffix wraps a Logger to append key-value pairs after log call keyvals","With appends ErrMissingValue when passed an odd number of keyvals","NewSyncLogger wraps a Logger to synchronize Log invocations across goroutines","Logger implementations interact with Valuer functions to evaluate dynamic contextual values"],"goal":"verify github.com/go-kit/log.Logger 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.Logger"]},"contractCommand":["go","run","./test"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","executionContext":"go","language":"go","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","runtime":"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.Logger"],"verifierAdapter":"golang@1"}

module sample-go-kit-logger

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.Logger 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.Logger"
  ]
}

package main

import (
	"errors"
	"fmt"
	"os"
	"sync"
	"sync/atomic"

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

// customLogger implements log.Logger
type customLogger struct {
	lastKvs []interface{}
}

func (c *customLogger) Log(keyvals ...interface{}) error {
	c.lastKvs = make([]interface{}, len(keyvals))
	copy(c.lastKvs, keyvals)
	return nil
}

func main() {
	// 1. Logger is an interface implemented by custom types providing a Log method
	{
		var l log.Logger
		custom := &customLogger{}
		l = custom
		if err := l.Log("key", "value", "count", 1); err != nil {
			fmt.Fprintf(os.Stderr, "Contract 1 failed: unexpected error: %v\n", err)
			os.Exit(1)
		}
		if len(custom.lastKvs) != 4 || custom.lastKvs[0] != "key" || custom.lastKvs[1] != "value" || custom.lastKvs[2] != "count" || custom.lastKvs[3] != 1 {
			fmt.Fprintf(os.Stderr, "Contract 1 failed: unexpected kvs: %v\n", custom.lastKvs)
			os.Exit(1)
		}

		// Also verify LoggerFunc adapter satisfies Logger
		var called bool
		funcLogger := log.LoggerFunc(func(keyvals ...interface{}) error {
			called = true
			if len(keyvals) != 2 || keyvals[0] != "fnKey" || keyvals[1] != "fnVal" {
				return errors.New("mismatched args")
			}
			return nil
		})
		l = funcLogger
		if err := l.Log("fnKey", "fnVal"); err != nil || !called {
			fmt.Fprintf(os.Stderr, "Contract 1 failed (LoggerFunc): %v\n", err)
			os.Exit(1)
		}
	}

	// 2. NewNopLogger implements Logger and silently drops all keyvals returning nil
	{
		nop := log.NewNopLogger()
		var l log.Logger = nop
		if err := l.Log("drop", "this", 123, true); err != nil {
			fmt.Fprintf(os.Stderr, "Contract 2 failed: unexpected error: %v\n", err)
			os.Exit(1)
		}
	}

	// 3. With wraps a Logger to prepend contextual key-value pairs to log events
	{
		custom := &customLogger{}
		ctxLogger := log.With(custom, "component", "auth", "version", 1)
		if err := ctxLogger.Log("event", "login", "user", "alice"); err != nil {
			fmt.Fprintf(os.Stderr, "Contract 3 failed: unexpected error: %v\n", err)
			os.Exit(1)
		}
		expected := []interface{}{"component", "auth", "version", 1, "event", "login", "user", "alice"}
		if len(custom.lastKvs) != len(expected) {
			fmt.Fprintf(os.Stderr, "Contract 3 failed: length mismatch: got %v, expected %v\n", custom.lastKvs, expected)
			os.Exit(1)
		}
		for i, v := range expected {
			if custom.lastKvs[i] != v {
				fmt.Fprintf(os.Stderr, "Contract 3 failed at %d: got %v, expected %v\n", i, custom.lastKvs[i], v)
				os.Exit(1)
			}
		}
	}

	// 4. WithPrefix wraps a Logger to prepend key-value pairs before existing context
	{
		custom := &customLogger{}
		base := log.With(custom, "baseKey", "baseVal")
		prefixed := log.WithPrefix(base, "prefixKey", "prefixVal")
		if err := prefixed.Log("msgKey", "msgVal"); err != nil {
			fmt.Fprintf(os.Stderr, "Contract 4 failed: unexpected error: %v\n", err)
			os.Exit(1)
		}
		expected := []interface{}{"prefixKey", "prefixVal", "baseKey", "baseVal", "msgKey", "msgVal"}
		if len(custom.lastKvs) != len(expected) {
			fmt.Fprintf(os.Stderr, "Contract 4 failed: length mismatch: got %v, expected %v\n", custom.lastKvs, expected)
			os.Exit(1)
		}
		for i, v := range expected {
			if custom.lastKvs[i] != v {
				fmt.Fprintf(os.Stderr, "Contract 4 failed at %d: got %v, expected %v\n", i, custom.lastKvs[i], v)
				os.Exit(1)
			}
		}
	}

	// 5. WithSuffix wraps a Logger to append key-value pairs after log call keyvals
	{
		custom := &customLogger{}
		base := log.With(custom, "baseKey", "baseVal")
		suffixed := log.WithSuffix(base, "suffixKey", "suffixVal")
		if err := suffixed.Log("msgKey", "msgVal"); err != nil {
			fmt.Fprintf(os.Stderr, "Contract 5 failed: unexpected error: %v\n", err)
			os.Exit(1)
		}
		expected := []interface{}{"baseKey", "baseVal", "msgKey", "msgVal", "suffixKey", "suffixVal"}
		if len(custom.lastKvs) != len(expected) {
			fmt.Fprintf(os.Stderr, "Contract 5 failed: length mismatch: got %v, expected %v\n", custom.lastKvs, expected)
			os.Exit(1)
		}
		for i, v := range expected {
			if custom.lastKvs[i] != v {
				fmt.Fprintf(os.Stderr, "Contract 5 failed at %d: got %v, expected %v\n", i, custom.lastKvs[i], v)
				os.Exit(1)
			}
		}
	}

	// 6. With appends ErrMissingValue when passed an odd number of keyvals
	{
		custom := &customLogger{}
		oddLogger := log.With(custom, "orphanKey")
		if err := oddLogger.Log("msg", "test"); err != nil {
			fmt.Fprintf(os.Stderr, "Contract 6 failed: unexpected error: %v\n", err)
			os.Exit(1)
		}
		expected := []interface{}{"orphanKey", log.ErrMissingValue, "msg", "test"}
		if len(custom.lastKvs) != len(expected) {
			fmt.Fprintf(os.Stderr, "Contract 6 failed: length mismatch: got %v, expected %v\n", custom.lastKvs, expected)
			os.Exit(1)
		}
		for i, v := range expected {
			if custom.lastKvs[i] != v {
				fmt.Fprintf(os.Stderr, "Contract 6 failed at %d: got %v, expected %v\n", i, custom.lastKvs[i], v)
				os.Exit(1)
			}
		}
	}

	// 7. NewSyncLogger wraps a Logger to synchronize Log invocations across goroutines
	{
		var counter int64
		safeLogger := log.NewSyncLogger(log.LoggerFunc(func(keyvals ...interface{}) error {
			atomic.AddInt64(&counter, 1)
			return nil
		}))
		var wg sync.WaitGroup
		const goroutines = 10
		const callsPerGoroutine = 50
		for i := 0; i < goroutines; i++ {
			wg.Add(1)
			go func() {
				defer wg.Done()
				for j := 0; j < callsPerGoroutine; j++ {
					_ = safeLogger.Log("routine", i, "call", j)
				}
			}()
		}
		wg.Wait()
		if atomic.LoadInt64(&counter) != int64(goroutines*callsPerGoroutine) {
			fmt.Fprintf(os.Stderr, "Contract 7 failed: expected %d calls, got %d\n", goroutines*callsPerGoroutine, counter)
			os.Exit(1)
		}
	}

	// 8. Logger implementations interact seamlessly with Valuer functions to evaluate dynamic context
	{
		custom := &customLogger{}
		callCount := 0
		customValuer := log.Valuer(func() interface{} {
			callCount++
			return callCount
		})
		dynLogger := log.With(custom, "call_id", customValuer)
		if err := dynLogger.Log("action", "first"); err != nil {
			fmt.Fprintf(os.Stderr, "Contract 8 failed: %v\n", err)
			os.Exit(1)
		}
		if len(custom.lastKvs) != 4 || custom.lastKvs[1] != 1 {
			fmt.Fprintf(os.Stderr, "Contract 8 failed on first log: got %v\n", custom.lastKvs)
			os.Exit(1)
		}
		if err := dynLogger.Log("action", "second"); err != nil {
			fmt.Fprintf(os.Stderr, "Contract 8 failed: %v\n", err)
			os.Exit(1)
		}
		if len(custom.lastKvs) != 4 || custom.lastKvs[1] != 2 {
			fmt.Fprintf(os.Stderr, "Contract 8 failed on second log: got %v\n", custom.lastKvs)
			os.Exit(1)
		}
	}

	fmt.Println("All contract assertions passed.")
}