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

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

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:a4ff033186a1c06931831e927198f57661bd244f6ce99712ecd817628c27580f","contract":["log.TimestampKey configures the timestamp field key for StdlibAdapter","StdlibAdapter uses default timestamp key 'ts' when TimestampKey is omitted","StdlibAdapter uses the customized timestamp key when parsing standard library log timestamps"],"goal":"verify github.com/go-kit/log.TimestampKey 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.TimestampKey"]},"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.TimestampKey"],"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.TimestampKey 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.TimestampKey"
  ]
}

package main

import (
	"fmt"
	stdlog "log"
	"os"

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

func findKey(keyvals []interface{}, targetKey string) (interface{}, bool) {
	for i := 0; i < len(keyvals)-1; i += 2 {
		if k, ok := keyvals[i].(string); ok && k == targetKey {
			return keyvals[i+1], true
		}
	}
	return nil, false
}

func main() {
	var captured []interface{}
	testLogger := log.LoggerFunc(func(keyvals ...interface{}) error {
		captured = append([]interface{}{}, keyvals...)
		return nil
	})

	// Assertion 1: Default StdlibAdapter uses "ts" as the timestamp key
	defaultAdapter := log.NewStdlibAdapter(testLogger)
	captured = nil
	if _, err := defaultAdapter.Write([]byte("2026/09/04 12:00:00 default message\n")); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: default adapter write failed: %v\n", err)
		os.Exit(1)
	}

	tsVal, hasTS := findKey(captured, "ts")
	if !hasTS {
		fmt.Fprintf(os.Stderr, "FAIL: expected 'ts' key in default adapter output, got %v\n", captured)
		os.Exit(1)
	}
	if tsVal != "2026/09/04 12:00:00" {
		fmt.Fprintf(os.Stderr, "FAIL: expected timestamp value '2026/09/04 12:00:00', got %v\n", tsVal)
		os.Exit(1)
	}

	// Assertion 2: log.TimestampKey configures a custom timestamp key
	customAdapter := log.NewStdlibAdapter(testLogger, log.TimestampKey("custom_ts"))
	captured = nil
	if _, err := customAdapter.Write([]byte("2026/09/04 12:00:00 custom message\n")); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: custom adapter write failed: %v\n", err)
		os.Exit(1)
	}

	if _, hasOldTS := findKey(captured, "ts"); hasOldTS {
		fmt.Fprintf(os.Stderr, "FAIL: did not expect 'ts' key when custom TimestampKey is set: %v\n", captured)
		os.Exit(1)
	}

	customVal, hasCustom := findKey(captured, "custom_ts")
	if !hasCustom {
		fmt.Fprintf(os.Stderr, "FAIL: expected 'custom_ts' key in custom adapter output, got %v\n", captured)
		os.Exit(1)
	}
	if customVal != "2026/09/04 12:00:00" {
		fmt.Fprintf(os.Stderr, "FAIL: expected timestamp '2026/09/04 12:00:00', got %v\n", customVal)
		os.Exit(1)
	}

	msgVal, hasMsg := findKey(captured, "msg")
	if !hasMsg || msgVal != "custom message" {
		fmt.Fprintf(os.Stderr, "FAIL: expected msg 'custom message', got %v\n", msgVal)
		os.Exit(1)
	}

	// Assertion 3: sample.NewCustomTimestampAdapter helper with "@timestamp"
	helperAdapter := sample.NewCustomTimestampAdapter(testLogger, "@timestamp")
	captured = nil
	if _, err := helperAdapter.Write([]byte("2026/09/04 15:30:45 helper message\n")); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: helper adapter write failed: %v\n", err)
		os.Exit(1)
	}

	atTimestampVal, hasAtTimestamp := findKey(captured, "@timestamp")
	if !hasAtTimestamp || atTimestampVal != "2026/09/04 15:30:45" {
		fmt.Fprintf(os.Stderr, "FAIL: expected '@timestamp' key with value '2026/09/04 15:30:45', got %v\n", captured)
		os.Exit(1)
	}

	// Assertion 4: Integration with standard library log.Logger
	timeAdapter := log.NewStdlibAdapter(testLogger, log.TimestampKey("time"))
	stdLogger := stdlog.New(timeAdapter, "", stdlog.Ldate|stdlog.Ltime)
	captured = nil
	stdLogger.Print("stdlib log message")

	timeVal, hasTime := findKey(captured, "time")
	if !hasTime || timeVal == "" {
		fmt.Fprintf(os.Stderr, "FAIL: expected 'time' key in stdlib adapted output, got %v\n", captured)
		os.Exit(1)
	}
	stdMsgVal, hasStdMsg := findKey(captured, "msg")
	if !hasStdMsg || stdMsgVal != "stdlib log message" {
		fmt.Fprintf(os.Stderr, "FAIL: expected 'msg' with 'stdlib log message', got %v\n", captured)
		os.Exit(1)
	}

	fmt.Println("PASS: github.com/go-kit/log.TimestampKey contract verified")
}

package sample

import (
	"io"

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

// NewCustomTimestampAdapter creates a new StdlibAdapter using a custom timestamp key.
func NewCustomTimestampAdapter(logger log.Logger, key string) io.Writer {
	return log.NewStdlibAdapter(logger, log.TimestampKey(key))
}

// NewDefaultTimestampAdapter creates a new StdlibAdapter with default settings.
func NewDefaultTimestampAdapter(logger log.Logger) io.Writer {
	return log.NewStdlibAdapter(logger)
}