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

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

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.

package stdlibadapter

import (
	"io"
	"log"

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

// SetupStdlibLogging configures standard library logging to forward entries to a Go kit Logger.
func SetupStdlibLogging(logger kitlog.Logger, options ...kitlog.StdlibAdapterOption) io.Writer {
	return kitlog.NewStdlibAdapter(logger, options...)
}

// NewStandardLogger creates a standard library *log.Logger that routes through the given kit logger.
func NewStandardLogger(logger kitlog.Logger, prefix string, flag int, options ...kitlog.StdlibAdapterOption) *log.Logger {
	writer := kitlog.NewStdlibAdapter(logger, options...)
	return log.New(writer, prefix, flag)
}

{"case":{"caseId":"case:sha256:2f3318a357ec9f64a8c998e4caf38f27e0f0d8169ed51294199e48a71e388045","contract":["log.NewStdlibAdapter redirects standard library log output to a go-kit Logger as structured key-values","log.NewStdlibAdapter parses standard log date, time, and caller flags into ts and caller keys","log.TimestampKey, log.FileKey, and log.MessageKey customize output field names","log.Prefix strips configured log prefix or prepends it to message when joinPrefixToMsg is true","log.NewStdlibAdapter propagates underlying logger errors on write"],"goal":"verify github.com/go-kit/log.NewStdlibAdapter 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.NewStdlibAdapter"]},"contractCommand":["go","run","./test"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","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.NewStdlibAdapter"],"verifierAdapter":"golang@1"}

module example.com/stdlibadapter-sample

go 1.22.0

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

package main

import (
	"bytes"
	"errors"
	"fmt"
	"log"
	"os"

	stdlibadapter "example.com/stdlibadapter-sample"
	kitlog "github.com/go-kit/log"
)

type failingLogger struct{}

func (f failingLogger) Log(keyvals ...interface{}) error {
	return errors.New("simulated logger error")
}

func main() {
	// Contract 1: log.NewStdlibAdapter redirects standard library log output to a go-kit Logger as structured key-values
	{
		var buf bytes.Buffer
		logger := kitlog.NewLogfmtLogger(&buf)
		adapter := kitlog.NewStdlibAdapter(logger)
		stdlog := log.New(adapter, "", 0)

		stdlog.Print("service initialized")
		expected := "msg=\"service initialized\"\n"
		if buf.String() != expected {
			fmt.Fprintf(os.Stderr, "Contract 1 failed: expected %q, got %q\n", expected, buf.String())
			os.Exit(1)
		}

		buf.Reset()
		stdlog2 := stdlibadapter.NewStandardLogger(logger, "", 0)
		stdlog2.Print("adapter ready")
		expected2 := "msg=\"adapter ready\"\n"
		if buf.String() != expected2 {
			fmt.Fprintf(os.Stderr, "Contract 1 (helper) failed: expected %q, got %q\n", expected2, buf.String())
			os.Exit(1)
		}
	}

	// Contract 2: log.NewStdlibAdapter parses standard log date, time, and caller flags into ts and caller keys
	{
		var buf bytes.Buffer
		logger := kitlog.NewLogfmtLogger(&buf)
		adapter := kitlog.NewStdlibAdapter(logger)

		// Date and time extraction
		buf.Reset()
		if _, err := fmt.Fprint(adapter, "2026/09/03 12:00:00: system ping\n"); err != nil {
			fmt.Fprintf(os.Stderr, "Contract 2 (timestamp) failed write: %v\n", err)
			os.Exit(1)
		}
		expectedTS := "ts=\"2026/09/03 12:00:00\" msg=\"system ping\"\n"
		if buf.String() != expectedTS {
			fmt.Fprintf(os.Stderr, "Contract 2 (timestamp) failed: expected %q, got %q\n", expectedTS, buf.String())
			os.Exit(1)
		}

		// Caller extraction
		buf.Reset()
		if _, err := fmt.Fprint(adapter, "/app/server.go:42: connection established\n"); err != nil {
			fmt.Fprintf(os.Stderr, "Contract 2 (caller) failed write: %v\n", err)
			os.Exit(1)
		}
		expectedCaller := "caller=/app/server.go:42 msg=\"connection established\"\n"
		if buf.String() != expectedCaller {
			fmt.Fprintf(os.Stderr, "Contract 2 (caller) failed: expected %q, got %q\n", expectedCaller, buf.String())
			os.Exit(1)
		}

		// Combined timestamp and caller
		buf.Reset()
		if _, err := fmt.Fprint(adapter, "2026/09/03 12:00:00 /app/server.go:42: server started\n"); err != nil {
			fmt.Fprintf(os.Stderr, "Contract 2 (combined) failed write: %v\n", err)
			os.Exit(1)
		}
		expectedCombined := "ts=\"2026/09/03 12:00:00\" caller=/app/server.go:42 msg=\"server started\"\n"
		if buf.String() != expectedCombined {
			fmt.Fprintf(os.Stderr, "Contract 2 (combined) failed: expected %q, got %q\n", expectedCombined, buf.String())
			os.Exit(1)
		}
	}

	// Contract 3: log.TimestampKey, log.FileKey, and log.MessageKey customize output field names
	{
		var buf bytes.Buffer
		logger := kitlog.NewLogfmtLogger(&buf)
		customAdapter := kitlog.NewStdlibAdapter(
			logger,
			kitlog.TimestampKey("timestamp"),
			kitlog.FileKey("location"),
			kitlog.MessageKey("payload"),
		)

		if _, err := fmt.Fprint(customAdapter, "2026/09/03 /app/server.go:42: custom fields\n"); err != nil {
			fmt.Fprintf(os.Stderr, "Contract 3 failed write: %v\n", err)
			os.Exit(1)
		}
		expected := "timestamp=2026/09/03 location=/app/server.go:42 payload=\"custom fields\"\n"
		if buf.String() != expected {
			fmt.Fprintf(os.Stderr, "Contract 3 failed: expected %q, got %q\n", expected, buf.String())
			os.Exit(1)
		}
	}

	// Contract 4: log.Prefix strips configured log prefix or prepends it to message when joinPrefixToMsg is true
	{
		var buf bytes.Buffer
		logger := kitlog.NewLogfmtLogger(&buf)

		// Prefix stripped
		buf.Reset()
		prefixedAdapter := kitlog.NewStdlibAdapter(logger, kitlog.Prefix("myapp: ", false))
		if _, err := fmt.Fprint(prefixedAdapter, "myapp: worker started\n"); err != nil {
			fmt.Fprintf(os.Stderr, "Contract 4 (stripped) failed write: %v\n", err)
			os.Exit(1)
		}
		expectedStripped := "msg=\"worker started\"\n"
		if buf.String() != expectedStripped {
			fmt.Fprintf(os.Stderr, "Contract 4 (stripped) failed: expected %q, got %q\n", expectedStripped, buf.String())
			os.Exit(1)
		}

		// Prefix joined to message
		buf.Reset()
		joinedAdapter := kitlog.NewStdlibAdapter(logger, kitlog.Prefix("myapp: ", true))
		if _, err := fmt.Fprint(joinedAdapter, "myapp: worker started\n"); err != nil {
			fmt.Fprintf(os.Stderr, "Contract 4 (joined) failed write: %v\n", err)
			os.Exit(1)
		}
		expectedJoined := "msg=\"myapp: worker started\"\n"
		if buf.String() != expectedJoined {
			fmt.Fprintf(os.Stderr, "Contract 4 (joined) failed: expected %q, got %q\n", expectedJoined, buf.String())
			os.Exit(1)
		}
	}

	// Contract 5: log.NewStdlibAdapter propagates underlying logger errors on write
	{
		failingAdapter := kitlog.NewStdlibAdapter(failingLogger{})
		_, err := failingAdapter.Write([]byte("some message\n"))
		if err == nil {
			fmt.Fprintf(os.Stderr, "Contract 5 failed: expected error, got nil\n")
			os.Exit(1)
		}
		if err.Error() != "simulated logger error" {
			fmt.Fprintf(os.Stderr, "Contract 5 failed: expected 'simulated logger error', got %q\n", err.Error())
			os.Exit(1)
		}
	}

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