github.com/go-logfmt/logfmt v0.6.0: NewEncoder

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-logfmt/logfmt.NewEncoder in pkg:golang/github.com/go-logfmt/logfmt@v0.6.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/go-logfmt/logfmt@v0.6.0
Demonstrate these symbols/APIs:
  - github.com/go-logfmt/logfmt.NewEncoder
Constraints:
  - executionContext: node
Required runtime conditions:
  - ecosystem: npm
  - language: javascript
  - moduleSystem: cjs
  - packageManager: npm@10.9.8
  - runtime: node@22.23.2

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:5a43a0d066787716a701029ca4b9cb199dc1de1e3e1cfb084684c7abf9c6e9df","contract":["logfmt.NewEncoder creates an Encoder writing logfmt formatted records to an io.Writer","Encoder.EncodeKeyval encodes individual key=value pairs and EndRecord appends a newline","Encoder.EncodeKeyvals encodes alternating key-value pairs without trailing newline until EndRecord","Encoder formats time.Time in RFC3339 format by default","Encoder escapes quotes and whitespace in values with double quotes according to the logfmt specification","Encoder.Reset clears encoder state allowing subsequent encoding operations"],"goal":"verify github.com/go-logfmt/logfmt.NewEncoder in pkg:golang/github.com/go-logfmt/logfmt@v0.6.0","kind":"HOW","packages":["pkg:golang/github.com/go-logfmt/logfmt@v0.6.0"],"schemaVersion":1,"symbols":["github.com/go-logfmt/logfmt.NewEncoder"]},"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-logfmt/logfmt@v0.6.0"],"schemaVersion":1,"subject":"pkg:golang/github.com/go-logfmt/logfmt@v0.6.0","symbols":["github.com/go-logfmt/logfmt.NewEncoder"],"verifierAdapter":"golang@1"}

module sample

go 1.22

require github.com/go-logfmt/logfmt v0.6.0

github.com/go-logfmt/logfmt v0.6.0 h1:wGYYu3uicYdqXVgoYbvnkrPVXkuLM1p1ifugDMEdRi4=
github.com/go-logfmt/logfmt v0.6.0/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs=

package sample

import (
	"io"

	"github.com/go-logfmt/logfmt"
)

// Encoder wraps logfmt.Encoder to format key-value pairs into logfmt formatted output.
type Encoder struct {
	enc *logfmt.Encoder
}

// NewEncoder returns a new Encoder writing to w.
func NewEncoder(w io.Writer) *Encoder {
	return &Encoder{
		enc: logfmt.NewEncoder(w),
	}
}

// EncodeKeyval encodes a single key-value pair.
func (e *Encoder) EncodeKeyval(k, v interface{}) error {
	return e.enc.EncodeKeyval(k, v)
}

// EncodeKeyvals encodes key-value pairs and finishes the record.
func (e *Encoder) EncodeKeyvals(keyvals ...interface{}) error {
	return e.enc.EncodeKeyvals(keyvals...)
}

// EndRecord writes a newline terminating the current record.
func (e *Encoder) EndRecord() error {
	return e.enc.EndRecord()
}

// Reset resets the encoder state.
func (e *Encoder) Reset() {
	e.enc.Reset()
}

{
  "schemaVersion": 1,
  "goal": "verify github.com/go-logfmt/logfmt.NewEncoder in pkg:golang/github.com/go-logfmt/logfmt@v0.6.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/go-logfmt/logfmt@v0.6.0"
  ],
  "symbols": [
    "github.com/go-logfmt/logfmt.NewEncoder"
  ],
  "constraints": {
    "executionContext": "node"
  },
  "runtimeConditions": {
    "ecosystem": "npm",
    "language": "javascript",
    "moduleSystem": "cjs",
    "packageManager": "npm@10.9.8",
    "runtime": "node@22.23.2"
  }
}

package main

import (
	"bytes"
	"fmt"
	"os"
	"strings"
	"time"

	"github.com/go-logfmt/logfmt"
	"sample"
)

func main() {
	var buf bytes.Buffer

	// Assertion 1: logfmt.NewEncoder creates a valid encoder writing to an io.Writer
	enc := logfmt.NewEncoder(&buf)
	if enc == nil {
		fmt.Fprintf(os.Stderr, "expected non-nil Encoder from logfmt.NewEncoder\n")
		os.Exit(1)
	}

	// Assertion 2: EncodeKeyval writes formatted key=value pairs and EndRecord appends a newline
	if err := enc.EncodeKeyval("msg", "hello world"); err != nil {
		fmt.Fprintf(os.Stderr, "EncodeKeyval failed: %v\n", err)
		os.Exit(1)
	}
	if err := enc.EncodeKeyval("count", 42); err != nil {
		fmt.Fprintf(os.Stderr, "EncodeKeyval count failed: %v\n", err)
		os.Exit(1)
	}
	if err := enc.EndRecord(); err != nil {
		fmt.Fprintf(os.Stderr, "EndRecord failed: %v\n", err)
		os.Exit(1)
	}

	got := buf.String()
	expected := "msg=\"hello world\" count=42\n"
	if got != expected {
		fmt.Fprintf(os.Stderr, "expected output %q, got %q\n", expected, got)
		os.Exit(1)
	}

	// Assertion 3: EncodeKeyvals encodes multiple key-value pairs in a single call without trailing newline
	buf.Reset()
	t := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)
	if err := enc.EncodeKeyvals("level", "info", "ts", t, "user", "alice"); err != nil {
		fmt.Fprintf(os.Stderr, "EncodeKeyvals failed: %v\n", err)
		os.Exit(1)
	}
	if err := enc.EndRecord(); err != nil {
		fmt.Fprintf(os.Stderr, "EndRecord failed: %v\n", err)
		os.Exit(1)
	}

	gotKeyvals := buf.String()
	expectedKeyvals := "level=info ts=2026-01-01T00:00:00Z user=alice\n"
	if gotKeyvals != expectedKeyvals {
		fmt.Fprintf(os.Stderr, "expected output %q, got %q\n", expectedKeyvals, gotKeyvals)
		os.Exit(1)
	}

	// Assertion 4: Wrapper in sample package correctly formats keyvals
	buf.Reset()
	sEnc := sample.NewEncoder(&buf)
	if err := sEnc.EncodeKeyvals("action", "test", "status", "ok"); err != nil {
		fmt.Fprintf(os.Stderr, "sample.EncodeKeyvals failed: %v\n", err)
		os.Exit(1)
	}
	if err := sEnc.EndRecord(); err != nil {
		fmt.Fprintf(os.Stderr, "sample.EndRecord failed: %v\n", err)
		os.Exit(1)
	}
	if buf.String() != "action=test status=ok\n" {
		fmt.Fprintf(os.Stderr, "sample wrapper output mismatch: got %q\n", buf.String())
		os.Exit(1)
	}

	// Assertion 5: Special characters and quotes are properly escaped according to logfmt specification
	buf.Reset()
	if err := enc.EncodeKeyvals("quote", "hello \"escaped\" world", "newline", "line1\nline2"); err != nil {
		fmt.Fprintf(os.Stderr, "EncodeKeyvals with special chars failed: %v\n", err)
		os.Exit(1)
	}
	if err := enc.EndRecord(); err != nil {
		fmt.Fprintf(os.Stderr, "EndRecord failed: %v\n", err)
		os.Exit(1)
	}
	if !strings.Contains(buf.String(), "quote=\"hello \\\"escaped\\\" world\"") {
		fmt.Fprintf(os.Stderr, "expected escaped quotes in output, got %q\n", buf.String())
		os.Exit(1)
	}
	if !strings.Contains(buf.String(), "newline=\"line1\\nline2\"") {
		fmt.Fprintf(os.Stderr, "expected escaped newline in output, got %q\n", buf.String())
		os.Exit(1)
	}

	// Assertion 6: Reset clears error state on the encoder
	buf.Reset()
	enc.Reset()
	if err := enc.EncodeKeyval("status", "reset_ok"); err != nil {
		fmt.Fprintf(os.Stderr, "EncodeKeyval after reset failed: %v\n", err)
		os.Exit(1)
	}
	if err := enc.EndRecord(); err != nil {
		fmt.Fprintf(os.Stderr, "EndRecord after reset failed: %v\n", err)
		os.Exit(1)
	}
	if buf.String() != "status=reset_ok\n" {
		fmt.Fprintf(os.Stderr, "output after reset mismatch: got %q\n", buf.String())
		os.Exit(1)
	}

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