github.com/go-logr/logr v1.4.2

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 pkg:golang/github.com/go-logr/logr@v1.4.2
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/go-logr/logr@v1.4.2
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:219972bfae7a410689246946818590de1c32257a61e7eccb962ccb176e217768","contract":["funcr.New logs structured messages with WithName prefix and WithValues key-value pairs","logger.V respects verbosity threshold configured in funcr.Options","logr.NewContext and logr.FromContext store and retrieve logr.Logger across context boundaries","logr.FromSlogHandler adapts standard library slog.Handler to logr.Logger"],"goal":"verify pkg:golang/github.com/go-logr/logr@v1.4.2","kind":"HOW","packages":["pkg:golang/github.com/go-logr/logr@v1.4.2"],"schemaVersion":1},"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-logr/logr@v1.4.2"],"schemaVersion":1,"verifierAdapter":"golang@1"}

module example.com/sample

go 1.26.6

require github.com/go-logr/logr v1.4.2

github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=

package main

import (
	"context"
	"errors"
	"fmt"
	"log/slog"
	"os"

	"github.com/go-logr/logr"
	"github.com/go-logr/logr/funcr"
)

// RequestHandler processes incoming requests and logs events using logr.Logger.
type RequestHandler struct {
	logger logr.Logger
}

// NewRequestHandler creates a new RequestHandler with an associated logger.
func NewRequestHandler(logger logr.Logger) *RequestHandler {
	return &RequestHandler{
		logger: logger.WithName("httpHandler"),
	}
}

// Handle executes a simulated request, demonstrating contextual values and verbosity levels.
func (h *RequestHandler) Handle(ctx context.Context, requestID string, path string) error {
	reqLogger := h.logger.WithValues("requestId", requestID, "path", path)
	ctx = logr.NewContext(ctx, reqLogger)

	reqLogger.Info("handling incoming request")
	reqLogger.V(1).Info("detailed request headers verified", "authType", "bearer")

	if path == "/error" {
		err := errors.New("simulated internal error")
		reqLogger.Error(err, "failed to process endpoint")
		return err
	}

	reqLogger.Info("request completed successfully", "statusCode", 200)
	return nil
}

func main() {
	// Initialize a structured logger using funcr
	logger := funcr.New(func(prefix, args string) {
		if prefix != "" {
			fmt.Fprintf(os.Stdout, "[%s] %s\n", prefix, args)
		} else {
			fmt.Fprintln(os.Stdout, args)
		}
	}, funcr.Options{
		Verbosity: 1,
	})

	handler := NewRequestHandler(logger)
	ctx := context.Background()

	_ = handler.Handle(ctx, "req-101", "/api/v1/resource")

	// Interoperability with standard library slog
	slogLogger := slog.Default()
	adaptedLogger := logr.FromSlogHandler(slogLogger.Handler())
	adaptedLogger.Info("message logged via slog handler adapter", "component", "bridge")
}

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

package main

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"log/slog"
	"os"
	"strings"
	"sync"

	"github.com/go-logr/logr"
	"github.com/go-logr/logr/funcr"
)

func main() {
	// Contract 1: funcr.New logs structured messages with WithName prefix and WithValues key-value pairs
	{
		var buf bytes.Buffer
		var mu sync.Mutex
		logger := funcr.New(func(prefix, args string) {
			mu.Lock()
			defer mu.Unlock()
			if prefix != "" {
				buf.WriteString(prefix + ": ")
			}
			buf.WriteString(args + "\n")
		}, funcr.Options{})

		subLogger := logger.WithName("authService").WithValues("env", "prod")
		subLogger.Info("user logged in", "userId", 42, "role", "admin")

		out := buf.String()
		if !strings.Contains(out, "authService") {
			fmt.Fprintf(os.Stderr, "FAIL: expected name prefix 'authService' in output: %s\n", out)
			os.Exit(1)
		}
		if !strings.Contains(out, `"msg"="user logged in"`) && !strings.Contains(out, `user logged in`) {
			fmt.Fprintf(os.Stderr, "FAIL: expected message in output: %s\n", out)
			os.Exit(1)
		}
		if !strings.Contains(out, `"env"="prod"`) && !strings.Contains(out, `env="prod"`) {
			fmt.Fprintf(os.Stderr, "FAIL: expected key-value 'env=prod' in output: %s\n", out)
			os.Exit(1)
		}
		if !strings.Contains(out, `"userId"=42`) && !strings.Contains(out, `userId=42`) {
			fmt.Fprintf(os.Stderr, "FAIL: expected key-value 'userId=42' in output: %s\n", out)
			os.Exit(1)
		}
	}

	// Contract 2: logger.V respects verbosity threshold configured in funcr.Options
	{
		var lines []string
		var mu sync.Mutex
		logger := funcr.New(func(prefix, args string) {
			mu.Lock()
			defer mu.Unlock()
			lines = append(lines, args)
		}, funcr.Options{
			Verbosity: 1,
		})

		logger.V(0).Info("level 0 info")
		logger.V(1).Info("level 1 info")
		logger.V(2).Info("level 2 debug - should be skipped")

		mu.Lock()
		count := len(lines)
		mu.Unlock()

		if count != 2 {
			fmt.Fprintf(os.Stderr, "FAIL: expected 2 log lines logged for verbosity 1, got %d\n", count)
			os.Exit(1)
		}
		if !logger.V(1).Enabled() {
			fmt.Fprintf(os.Stderr, "FAIL: V(1) should be enabled\n")
			os.Exit(1)
		}
		if logger.V(2).Enabled() {
			fmt.Fprintf(os.Stderr, "FAIL: V(2) should be disabled\n")
			os.Exit(1)
		}
	}

	// Contract 3: logr.NewContext and logr.FromContext store and retrieve logr.Logger across context boundaries
	{
		var captured string
		customLogger := funcr.New(func(prefix, args string) {
			captured = args
		}, funcr.Options{})

		ctx := logr.NewContext(context.Background(), customLogger)
		retrieved, err := logr.FromContext(ctx)
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: unexpected error from FromContext: %v\n", err)
			os.Exit(1)
		}

		retrieved.Info("test context logger")
		if !strings.Contains(captured, "test context logger") {
			fmt.Fprintf(os.Stderr, "FAIL: retrieved logger failed to log: %s\n", captured)
			os.Exit(1)
		}

		emptyCtxLogger, err := logr.FromContext(context.Background())
		if err == nil {
			fmt.Fprintf(os.Stderr, "FAIL: expected error when retrieving logger from empty context\n")
			os.Exit(1)
		}
		discardLogger := logr.FromContextOrDiscard(context.Background())
		discardLogger.Info("discard message")
		_ = emptyCtxLogger
	}

	// Contract 4: logr.FromSlogHandler adapts standard library slog.Handler to logr.Logger
	{
		var slogBuf bytes.Buffer
		slogHandler := slog.NewTextHandler(&slogBuf, &slog.HandlerOptions{
			Level: slog.LevelInfo,
		})

		adaptedLogger := logr.FromSlogHandler(slogHandler)
		adaptedLogger.Info("adapted slog message", "component", "gateway", "code", 200)

		out := slogBuf.String()
		if !strings.Contains(out, "msg=\"adapted slog message\"") && !strings.Contains(out, "adapted slog message") {
			fmt.Fprintf(os.Stderr, "FAIL: slog adapter missing msg: %s\n", out)
			os.Exit(1)
		}
		if !strings.Contains(out, "component=gateway") {
			fmt.Fprintf(os.Stderr, "FAIL: slog adapter missing component=gateway: %s\n", out)
			os.Exit(1)
		}
		if !strings.Contains(out, "code=200") {
			fmt.Fprintf(os.Stderr, "FAIL: slog adapter missing code=200: %s\n", out)
			os.Exit(1)
		}

		testErr := errors.New("connection reset")
		adaptedLogger.Error(testErr, "failed request", "retries", 3)
		errOut := slogBuf.String()
		if !strings.Contains(errOut, "connection reset") {
			fmt.Fprintf(os.Stderr, "FAIL: slog adapter missing error in output: %s\n", errOut)
			os.Exit(1)
		}
	}

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