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

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

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:d4053e32d5d5e458c51d16d7bc7261769e902b6c3a0aef7d409177c0767b5296","contract":["log.MessageKey overrides the default msg key for standard library log messages redirected through StdlibAdapter","log.MessageKey interoperates with TimestampKey to preserve custom field naming across structured output","log.MessageKey maintains message extraction when handling standard library logger prefixes","log.MessageKey routes formatted messages into both logfmt and JSON logger backends using the specified key","log.MessageKey preserves the configured message key across sequential logging calls"],"goal":"verify github.com/go-kit/log.MessageKey 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.MessageKey"]},"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.MessageKey"],"verifierAdapter":"golang@1"}

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

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	stdlog "log"
	"os"
	"strings"

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

func main() {
	// 1. log.MessageKey overrides the default msg key for standard library log messages redirected through StdlibAdapter
	{
		var defBuf bytes.Buffer
		defLogger := gokitlog.NewLogfmtLogger(&defBuf)
		defAdapter := gokitlog.NewStdlibAdapter(defLogger)
		stdDef := stdlog.New(defAdapter, "", 0)
		stdDef.Print("default message test")
		if got := strings.TrimSpace(defBuf.String()); got != `msg="default message test"` {
			fmt.Fprintf(os.Stderr, "Contract 1 failed: expected msg=\"default message test\", got %q\n", got)
			os.Exit(1)
		}

		var customBuf bytes.Buffer
		customLogger := gokitlog.NewLogfmtLogger(&customBuf)
		customAdapter := gokitlog.NewStdlibAdapter(customLogger, gokitlog.MessageKey("custom_message"))
		stdCustom := stdlog.New(customAdapter, "", 0)
		stdCustom.Print("custom message test")
		if got := strings.TrimSpace(customBuf.String()); got != `custom_message="custom message test"` {
			fmt.Fprintf(os.Stderr, "Contract 1 failed: expected custom_message=\"custom message test\", got %q\n", got)
			os.Exit(1)
		}
	}

	// 2. log.MessageKey interoperates with TimestampKey to preserve custom field naming across structured output
	{
		var buf bytes.Buffer
		logger := gokitlog.NewLogfmtLogger(&buf)
		adapter := gokitlog.NewStdlibAdapter(
			logger,
			gokitlog.MessageKey("payload"),
			gokitlog.TimestampKey("event_time"),
		)
		input := "2026/09/03 15:04:05 database connection established\n"
		if _, err := fmt.Fprint(adapter, input); err != nil {
			fmt.Fprintf(os.Stderr, "Contract 2 failed: write error: %v\n", err)
			os.Exit(1)
		}
		got := strings.TrimSpace(buf.String())
		expected := `event_time="2026/09/03 15:04:05" payload="database connection established"`
		if got != expected {
			fmt.Fprintf(os.Stderr, "Contract 2 failed: expected %q, got %q\n", expected, got)
			os.Exit(1)
		}
	}

	// 3. log.MessageKey maintains message extraction when handling standard library logger prefixes
	{
		// 3a. Prefix stripped (joinPrefixToMsg = false)
		var buf1 bytes.Buffer
		logger1 := gokitlog.NewLogfmtLogger(&buf1)
		adapter1 := gokitlog.NewStdlibAdapter(
			logger1,
			gokitlog.MessageKey("log_text"),
			gokitlog.Prefix("[HTTP] ", false),
		)
		std1 := stdlog.New(adapter1, "[HTTP] ", 0)
		std1.Print("handled request")
		got1 := strings.TrimSpace(buf1.String())
		expected1 := `log_text="handled request"`
		if got1 != expected1 {
			fmt.Fprintf(os.Stderr, "Contract 3a failed: expected %q, got %q\n", expected1, got1)
			os.Exit(1)
		}

		// 3b. Prefix joined (joinPrefixToMsg = true)
		var buf2 bytes.Buffer
		logger2 := gokitlog.NewLogfmtLogger(&buf2)
		adapter2 := gokitlog.NewStdlibAdapter(
			logger2,
			gokitlog.MessageKey("log_text"),
			gokitlog.Prefix("[HTTP] ", true),
		)
		std2 := stdlog.New(adapter2, "[HTTP] ", 0)
		std2.Print("handled request")
		got2 := strings.TrimSpace(buf2.String())
		expected2 := `log_text="[HTTP] handled request"`
		if got2 != expected2 {
			fmt.Fprintf(os.Stderr, "Contract 3b failed: expected %q, got %q\n", expected2, got2)
			os.Exit(1)
		}
	}

	// 4. log.MessageKey routes formatted messages into both logfmt and JSON logger backends using the specified key
	{
		var buf bytes.Buffer
		jsonLogger := gokitlog.NewJSONLogger(&buf)
		adapter := gokitlog.NewStdlibAdapter(jsonLogger, gokitlog.MessageKey("description"))
		std := stdlog.New(adapter, "", 0)
		std.Print("structured json payload")

		var parsed map[string]interface{}
		if err := json.Unmarshal(buf.Bytes(), &parsed); err != nil {
			fmt.Fprintf(os.Stderr, "Contract 4 failed: json unmarshal error: %v\n", err)
			os.Exit(1)
		}
		if val, ok := parsed["description"]; !ok || val != "structured json payload" {
			fmt.Fprintf(os.Stderr, "Contract 4 failed: key 'description' missing or unexpected: %v\n", parsed)
			os.Exit(1)
		}
		if _, ok := parsed["msg"]; ok {
			fmt.Fprintf(os.Stderr, "Contract 4 failed: unexpected 'msg' key found in JSON output\n")
			os.Exit(1)
		}
	}

	// 5. log.MessageKey preserves the configured message key across sequential logging calls
	{
		var buf bytes.Buffer
		logger := gokitlog.NewLogfmtLogger(&buf)
		adapter := gokitlog.NewStdlibAdapter(logger, gokitlog.MessageKey("event"))
		std := stdlog.New(adapter, "", 0)
		std.Print("step 1")
		std.Print("step 2")

		lines := strings.Split(strings.TrimSpace(buf.String()), "\n")
		if len(lines) != 2 || lines[0] != `event="step 1"` || lines[1] != `event="step 2"` {
			fmt.Fprintf(os.Stderr, "Contract 5 failed: unexpected sequential lines: %q\n", buf.String())
			os.Exit(1)
		}
	}

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