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

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

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:8c95df0b5c591effd96cdaad8f9224b6eb8ca279db08d2b11951ef8c4394f040","contract":["log.NewSyncLogger wraps a Logger and serializes concurrent calls to Log without error","log.NewSyncLogger passes key-value pairs through to the underlying logger preserving formatting","log.NewSyncLogger propagates errors returned by the underlying logger","log.NewSyncLogger safely handles concurrent Log invocations from multiple goroutines without data loss or corruption","log.NewSyncLogger integrates with contextual loggers created via log.With"],"goal":"verify github.com/go-kit/log.NewSyncLogger 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.NewSyncLogger"]},"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.NewSyncLogger"],"verifierAdapter":"golang@1"}

module sample-sync-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.NewSyncLogger 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.NewSyncLogger"
  ]
}

package synclogger

import (
	"io"

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

// SafeLogger wraps a thread-safe logger created with log.NewSyncLogger.
type SafeLogger struct {
	logger log.Logger
}

// New creates a new SafeLogger synchronizing log calls around the provided logger.
func New(logger log.Logger) *SafeLogger {
	return &SafeLogger{
		logger: log.NewSyncLogger(logger),
	}
}

// NewSyncLogfmtLogger creates a synchronized logfmt logger writing to w.
func NewSyncLogfmtLogger(w io.Writer) *SafeLogger {
	return New(log.NewLogfmtLogger(w))
}

// Log writes keyvals safely to the synchronized underlying logger.
func (s *SafeLogger) Log(keyvals ...interface{}) error {
	return s.logger.Log(keyvals...)
}

// Underlying returns the wrapped synchronized log.Logger.
func (s *SafeLogger) Underlying() log.Logger {
	return s.logger
}

package main

import (
	"bytes"
	"errors"
	"fmt"
	"os"
	"strings"
	"sync"

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

type mockErrorLogger struct {
	err error
}

func (m *mockErrorLogger) Log(keyvals ...interface{}) error {
	return m.err
}

func main() {
	// 1. log.NewSyncLogger wraps a Logger and serializes concurrent calls to Log without error
	{
		var buf bytes.Buffer
		baseLogger := log.NewLogfmtLogger(&buf)
		syncLogger := log.NewSyncLogger(baseLogger)
		if err := syncLogger.Log("status", "initialized", "active", true); err != nil {
			fmt.Fprintf(os.Stderr, "Assertion 1 failed: %v\n", err)
			os.Exit(1)
		}
	}

	// 2. log.NewSyncLogger passes key-value pairs through to the underlying logger preserving formatting
	{
		var buf bytes.Buffer
		baseLogger := log.NewLogfmtLogger(&buf)
		syncLogger := log.NewSyncLogger(baseLogger)
		if err := syncLogger.Log("msg", "hello world", "status", "ok", "code", 200); err != nil {
			fmt.Fprintf(os.Stderr, "Assertion 2 failed: %v\n", err)
			os.Exit(1)
		}
		expected := "msg=\"hello world\" status=ok code=200\n"
		if buf.String() != expected {
			fmt.Fprintf(os.Stderr, "Assertion 2 failed: expected %q, got %q\n", expected, buf.String())
			os.Exit(1)
		}
	}

	// 3. log.NewSyncLogger propagates errors returned by the underlying logger
	{
		expectedErr := errors.New("custom logger failure")
		errLogger := &mockErrorLogger{err: expectedErr}
		syncLogger := log.NewSyncLogger(errLogger)
		err := syncLogger.Log("attempt", 1)
		if !errors.Is(err, expectedErr) {
			fmt.Fprintf(os.Stderr, "Assertion 3 failed: expected error %v, got %v\n", expectedErr, err)
			os.Exit(1)
		}
	}

	// 4. log.NewSyncLogger safely handles concurrent Log invocations from multiple goroutines without data loss or corruption
	{
		var buf bytes.Buffer
		syncLogger := log.NewSyncLogger(log.NewLogfmtLogger(&buf))

		const numGoroutines = 10
		const logsPerGoroutine = 50
		var wg sync.WaitGroup
		start := make(chan struct{})

		for i := 0; i < numGoroutines; i++ {
			wg.Add(1)
			go func(workerID int) {
				defer wg.Done()
				<-start
				for j := 0; j < logsPerGoroutine; j++ {
					if err := syncLogger.Log("worker", workerID, "seq", j); err != nil {
						fmt.Fprintf(os.Stderr, "Assertion 4 failed: concurrent log error: %v\n", err)
						os.Exit(1)
					}
				}
			}(i)
		}

		close(start)
		wg.Wait()

		lines := strings.Split(strings.TrimSpace(buf.String()), "\n")
		expectedCount := numGoroutines * logsPerGoroutine
		if len(lines) != expectedCount {
			fmt.Fprintf(os.Stderr, "Assertion 4 failed: expected %d lines, got %d\n", expectedCount, len(lines))
			os.Exit(1)
		}
	}

	// 5. log.NewSyncLogger integrates with contextual loggers created via log.With
	{
		var buf bytes.Buffer
		baseLogger := log.NewLogfmtLogger(&buf)
		syncLogger := log.NewSyncLogger(baseLogger)
		ctxLogger := log.With(syncLogger, "service", "payment", "env", "prod")
		if err := ctxLogger.Log("event", "charge", "amount", 100); err != nil {
			fmt.Fprintf(os.Stderr, "Assertion 5 failed: %v\n", err)
			os.Exit(1)
		}
		expected := "service=payment env=prod event=charge amount=100\n"
		if buf.String() != expected {
			fmt.Fprintf(os.Stderr, "Assertion 5 failed: expected %q, got %q\n", expected, buf.String())
			os.Exit(1)
		}
	}

	// 6. synclogger.SafeLogger convenience wrapper provides synchronized logging
	{
		var buf bytes.Buffer
		safe := synclogger.NewSyncLogfmtLogger(&buf)
		if err := safe.Log("msg", "safe logger verified"); err != nil {
			fmt.Fprintf(os.Stderr, "SafeLogger failed: %v\n", err)
			os.Exit(1)
		}
		expected := "msg=\"safe logger verified\"\n"
		if buf.String() != expected {
			fmt.Fprintf(os.Stderr, "SafeLogger output mismatch: expected %q, got %q\n", expected, buf.String())
			os.Exit(1)
		}
		if safe.Underlying() == nil {
			fmt.Fprintf(os.Stderr, "SafeLogger Underlying() is nil\n")
			os.Exit(1)
		}
	}

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