go.uber.org/zap v1.26.0: NewStdLog

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 zap.NewStdLog in pkg:golang/go.uber.org/zap@v1.26.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/go.uber.org/zap@v1.26.0
Demonstrate these symbols/APIs:
  - zap.NewStdLog

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:90b3ded462edd12f27ca89b98959a52ae8ab75e4585046c8f691a35d182c34ea","contract":["zap.NewStdLog returns a standard library *log.Logger that redirects output to the zap logger at InfoLevel","zap.NewStdLog dispatches Print and Printf messages formatted as structured zap info entries","zap.NewStdLog entries are filtered when the underlying zap core level threshold is above InfoLevel"],"goal":"verify zap.NewStdLog in pkg:golang/go.uber.org/zap@v1.26.0","kind":"HOW","packages":["pkg:golang/go.uber.org/zap@v1.26.0"],"schemaVersion":1,"symbols":["zap.NewStdLog"]},"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/go.uber.org/zap@v1.26.0"],"schemaVersion":1,"subject":"pkg:golang/go.uber.org/zap@v1.26.0","symbols":["zap.NewStdLog"],"verifierAdapter":"golang@1"}

module example.com/zapstdlog

go 1.22.0

require go.uber.org/zap v1.26.0

require go.uber.org/multierr v1.10.0 // indirect

go.uber.org/multierr v1.10.0 h1:S0h4aNzvfcFsC3dRF1jLoaov7oRaKqRGC/pUEJ2yvPQ=
go.uber.org/multierr v1.10.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
go.uber.org/zap v1.26.0 h1:sI7k6L95XOKS281NhVKOFCUNIvv9e0w4BF8N3u+tCRo=
go.uber.org/zap v1.26.0/go.mod h1:dtElttAiwGvoJ/vj4IwHBS/gXsEu/pZ50mUIRWuG0so=

{
  "schemaVersion": 1,
  "goal": "verify zap.NewStdLog in pkg:golang/go.uber.org/zap@v1.26.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/go.uber.org/zap@v1.26.0"
  ],
  "symbols": [
    "zap.NewStdLog"
  ]
}

package zapstdlog

import (
	"log"

	"go.uber.org/zap"
)

// NewStandardLogger creates a standard library *log.Logger that routes entries to the given zap.Logger at InfoLevel.
func NewStandardLogger(logger *zap.Logger) *log.Logger {
	return zap.NewStdLog(logger)
}

package main

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

	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"

	zapstdlog "example.com/zapstdlog"
)

type syncer struct {
	buf bytes.Buffer
}

func (s *syncer) Write(p []byte) (n int, err error) {
	return s.buf.Write(p)
}

func (s *syncer) Sync() error {
	return nil
}

func (s *syncer) Reset() {
	s.buf.Reset()
}

func (s *syncer) Lines() []string {
	raw := strings.TrimSpace(s.buf.String())
	if raw == "" {
		return nil
	}
	return strings.Split(raw, "\n")
}

func newLogger(level zapcore.LevelEnabler) (*zap.Logger, *syncer) {
	sink := &syncer{}
	encCfg := zapcore.EncoderConfig{
		MessageKey:     "msg",
		LevelKey:       "level",
		EncodeLevel:    zapcore.LowercaseLevelEncoder,
		EncodeDuration: zapcore.StringDurationEncoder,
	}
	core := zapcore.NewCore(
		zapcore.NewJSONEncoder(encCfg),
		sink,
		level,
	)
	return zap.New(core), sink
}

func parseLine(raw string) (map[string]interface{}, error) {
	var entry map[string]interface{}
	if err := json.Unmarshal([]byte(raw), &entry); err != nil {
		return nil, fmt.Errorf("failed to parse JSON log %q: %w", raw, err)
	}
	return entry, nil
}

func main() {
	// Assertion 1: zap.NewStdLog returns a standard library *log.Logger that redirects output to the zap logger at InfoLevel
	logger, sink := newLogger(zapcore.DebugLevel)
	stdLogger := zapstdlog.NewStandardLogger(logger)
	if stdLogger == nil {
		fmt.Fprintln(os.Stderr, "FAIL: expected non-nil *log.Logger from zap.NewStdLog")
		os.Exit(1)
	}

	stdLogger.Println("test standard library log output")
	lines := sink.Lines()
	if len(lines) != 1 {
		fmt.Fprintf(os.Stderr, "FAIL: expected 1 log line, got %d\n", len(lines))
		os.Exit(1)
	}
	entry, err := parseLine(lines[0])
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: %v\n", err)
		os.Exit(1)
	}
	if entry["level"] != "info" {
		fmt.Fprintf(os.Stderr, "FAIL: expected level 'info', got %v\n", entry["level"])
		os.Exit(1)
	}
	msg, _ := entry["msg"].(string)
	if !strings.Contains(msg, "test standard library log output") {
		fmt.Fprintf(os.Stderr, "FAIL: expected message to contain 'test standard library log output', got %v\n", msg)
		os.Exit(1)
	}

	// Assertion 2: zap.NewStdLog dispatches Print and Printf messages formatted as structured zap info entries
	sink.Reset()
	stdLogger.Print("print message without newline")
	stdLogger.Printf("formatted message: count=%d", 42)

	lines = sink.Lines()
	if len(lines) != 2 {
		fmt.Fprintf(os.Stderr, "FAIL: expected 2 log lines, got %d\n", len(lines))
		os.Exit(1)
	}
	entry1, err := parseLine(lines[0])
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: %v\n", err)
		os.Exit(1)
	}
	if entry1["level"] != "info" || !strings.Contains(entry1["msg"].(string), "print message without newline") {
		fmt.Fprintf(os.Stderr, "FAIL: unexpected entry 1: %v\n", entry1)
		os.Exit(1)
	}
	entry2, err := parseLine(lines[1])
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: %v\n", err)
		os.Exit(1)
	}
	if entry2["level"] != "info" || !strings.Contains(entry2["msg"].(string), "formatted message: count=42") {
		fmt.Fprintf(os.Stderr, "FAIL: unexpected entry 2: %v\n", entry2)
		os.Exit(1)
	}

	// Assertion 3: zap.NewStdLog entries are filtered when the underlying zap core level threshold is above InfoLevel
	warnLogger, warnSink := newLogger(zapcore.WarnLevel)
	warnStdLogger := zapstdlog.NewStandardLogger(warnLogger)
	warnStdLogger.Println("this info level message should be filtered out")

	if len(warnSink.Lines()) != 0 {
		fmt.Fprintf(os.Stderr, "FAIL: expected 0 log lines when core is at WarnLevel, got %d\n", len(warnSink.Lines()))
		os.Exit(1)
	}

	fmt.Println("PASS: zap.NewStdLog contract passed")
}