github.com/go-logfmt/logfmt v0.6.0: Encode and decode logfmt formatted key-value pairs

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: Encode and decode logfmt formatted key-value pairs
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/go-logfmt/logfmt@v0.6.0
Demonstrate these symbols/APIs:
  - Decoder.ScanRecord
  - Encoder.EncodeKeyval
  - NewDecoder
  - 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:63c0c3877173e11e2947bc43afe09bdefc7cdc6d1a6145d1da5e91e04a9a02ef","contract":["NewEncoder formats key-value pairs and ends record with newline","NewDecoder scans logfmt records and extracts keys and values","Round-trip encoding and decoding through sample helpers"],"goal":"Encode and decode logfmt formatted key-value pairs","kind":"HOW","packages":["pkg:golang/github.com/go-logfmt/logfmt@v0.6.0"],"schemaVersion":1,"symbols":["Decoder.ScanRecord","Encoder.EncodeKeyval","NewDecoder","NewEncoder"]},"contractCommand":["go","test","./..."],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","language":"go","libc":"glibc","libcVersion":"2.39","moduleSystem":"go.mod","os":"linux","osVersionBucket":"24","packageManager":"go","runtime":"go","runtimeVersion":"1.26","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":["Decoder.ScanRecord","Encoder.EncodeKeyval","NewDecoder","NewEncoder"],"verifierAdapter":"golang@1"}

module example.com/logfmt-sample

go 1.24.0

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 (
	"bytes"
	"fmt"
	"io"

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

// LogRecord represents parsed key-value pairs from a logfmt record.
type LogRecord struct {
	Fields map[string]string
}

// EncodeRecord formats key-value pairs into a single logfmt line.
func EncodeRecord(fields map[string]interface{}) (string, error) {
	var buf bytes.Buffer
	enc := logfmt.NewEncoder(&buf)

	for k, v := range fields {
		if err := enc.EncodeKeyval(k, v); err != nil {
			return "", fmt.Errorf("failed to encode keyval %q: %w", k, err)
		}
	}
	if err := enc.EndRecord(); err != nil {
		return "", fmt.Errorf("failed to end record: %w", err)
	}

	return buf.String(), nil
}

// DecodeRecords parses multiple logfmt formatted records from an io.Reader.
func DecodeRecords(r io.Reader) ([]LogRecord, error) {
	dec := logfmt.NewDecoder(r)
	var records []LogRecord

	for dec.ScanRecord() {
		rec := LogRecord{
			Fields: make(map[string]string),
		}
		for dec.ScanKeyval() {
			k := string(dec.Key())
			v := string(dec.Value())
			rec.Fields[k] = v
		}
		if err := dec.Err(); err != nil {
			return nil, fmt.Errorf("error scanning keyval: %w", err)
		}
		records = append(records, rec)
	}

	if err := dec.Err(); err != nil {
		return nil, fmt.Errorf("error scanning record: %w", err)
	}

	return records, nil
}

{
  "schemaVersion": 1,
  "goal": "Encode and decode logfmt formatted key-value pairs",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/go-logfmt/logfmt@v0.6.0"
  ],
  "symbols": [
    "Decoder.ScanRecord",
    "Encoder.EncodeKeyval",
    "NewDecoder",
    "NewEncoder"
  ],
  "constraints": {
    "executionContext": "node"
  },
  "runtimeConditions": {
    "ecosystem": "npm",
    "language": "javascript",
    "moduleSystem": "cjs",
    "packageManager": "npm@10.9.8",
    "runtime": "node@22.23.2"
  }
}

package test

import (
	"bytes"
	"strings"
	"testing"

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

func TestLogfmtContract(t *testing.T) {
	// 1. NewEncoder formats key-value pairs and ends record with newline
	var buf bytes.Buffer
	enc := logfmt.NewEncoder(&buf)
	if err := enc.EncodeKeyval("level", "info"); err != nil {
		t.Fatalf("EncodeKeyval failed: %v", err)
	}
	if err := enc.EncodeKeyval("msg", "task started"); err != nil {
		t.Fatalf("EncodeKeyval failed: %v", err)
	}
	if err := enc.EndRecord(); err != nil {
		t.Fatalf("EndRecord failed: %v", err)
	}
	encoded := buf.String()
	if !strings.Contains(encoded, "level=info") || !strings.Contains(encoded, "msg=\"task started\"") {
		t.Fatalf("unexpected encoded output: %q", encoded)
	}

	// 2. NewDecoder scans logfmt records and extracts keys and values
	input := "level=info msg=\"task started\" count=42\nlevel=error msg=\"operation failed\" code=500\n"
	dec := logfmt.NewDecoder(strings.NewReader(input))

	if !dec.ScanRecord() {
		t.Fatalf("expected first record, got none: %v", dec.Err())
	}
	kvs1 := make(map[string]string)
	for dec.ScanKeyval() {
		kvs1[string(dec.Key())] = string(dec.Value())
	}
	if kvs1["level"] != "info" || kvs1["msg"] != "task started" || kvs1["count"] != "42" {
		t.Fatalf("unexpected first record fields: %+v", kvs1)
	}

	if !dec.ScanRecord() {
		t.Fatalf("expected second record, got none: %v", dec.Err())
	}
	kvs2 := make(map[string]string)
	for dec.ScanKeyval() {
		kvs2[string(dec.Key())] = string(dec.Value())
	}
	if kvs2["level"] != "error" || kvs2["msg"] != "operation failed" || kvs2["code"] != "500" {
		t.Fatalf("unexpected second record fields: %+v", kvs2)
	}

	if dec.ScanRecord() {
		t.Fatal("expected no more records")
	}
	if err := dec.Err(); err != nil {
		t.Fatalf("unexpected decoder error: %v", err)
	}

	// 3. Round-trip encoding and decoding through sample helpers
	helperRecords, err := sample.DecodeRecords(strings.NewReader(input))
	if err != nil {
		t.Fatalf("DecodeRecords helper failed: %v", err)
	}
	if len(helperRecords) != 2 {
		t.Fatalf("expected 2 records, got %d", len(helperRecords))
	}
	if helperRecords[0].Fields["msg"] != "task started" {
		t.Fatalf("mismatched helper record content: %+v", helperRecords[0])
	}
}