github.com/go-logr/logr v1.3.0: FromContext

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

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/go-logr/logr@v1.3.0
Demonstrate these symbols/APIs:
  - github.com/go-logr/logr.FromContext

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.

package contextlogger

import (
	"context"
	"fmt"

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

// WithLogger associates a Logger instance with a context.Context.
func WithLogger(ctx context.Context, logger logr.Logger) context.Context {
	return logr.NewContext(ctx, logger)
}

// FromContext extracts a Logger instance from a context.Context or returns an error if absent.
func FromContext(ctx context.Context) (logr.Logger, error) {
	return logr.FromContext(ctx)
}

// FromContextOrFallback extracts a Logger from context, returning the fallback Logger if none is found.
func FromContextOrFallback(ctx context.Context, fallback logr.Logger) logr.Logger {
	l, err := logr.FromContext(ctx)
	if err != nil {
		return fallback
	}
	return l
}

// IsNotFoundError checks whether an error indicates that no Logger was found in context.
func IsNotFoundError(err error) bool {
	if nfe, ok := err.(interface{ IsNotFound() bool }); ok {
		return nfe.IsNotFound()
	}
	return false
}

// ExecuteOperation retrieves the contextual logger to record structured operation progress.
func ExecuteOperation(ctx context.Context, opName string, step int) error {
	logger, err := logr.FromContext(ctx)
	if err != nil {
		return fmt.Errorf("context logger required for operation %q: %w", opName, err)
	}

	logger.Info("executing operation step", "operation", opName, "step", step)
	return nil
}

{"case":{"caseId":"case:sha256:1459ebba8f70cdd34b14ee5cfa476afc26bd2e20cf1ff6b50fda84afa348492e","contract":["logr.FromContext retrieves the Logger associated with a context via logr.NewContext","logr.FromContext returns an error implementing IsNotFound and an uninitialized Logger when absent","logr.FromContext preserves Logger hierarchy, name segments, and structured key-value attributes","logr.FromContext respects context inheritance and supports child context logger overrides","logr.FromContextOrDiscard returns Discard logger when absent and contextual logger when present"],"goal":"verify github.com/go-logr/logr.FromContext in pkg:golang/github.com/go-logr/logr@v1.3.0","kind":"HOW","packages":["pkg:golang/github.com/go-logr/logr@v1.3.0"],"schemaVersion":1,"symbols":["github.com/go-logr/logr.FromContext"]},"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.3.0"],"schemaVersion":1,"subject":"pkg:golang/github.com/go-logr/logr@v1.3.0","symbols":["github.com/go-logr/logr.FromContext"],"verifierAdapter":"golang@1"}

module example.com/logr-fromcontext

go 1.22.0

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

github.com/go-logr/logr v1.3.0 h1:2y3SDp0ZXuc6/cjLSZ+Q3ir+QB9T/iG5yYRXqsagWSY=
github.com/go-logr/logr v1.3.0/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=

{
  "schemaVersion": 1,
  "goal": "verify github.com/go-logr/logr.FromContext in pkg:golang/github.com/go-logr/logr@v1.3.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/go-logr/logr@v1.3.0"
  ],
  "symbols": [
    "github.com/go-logr/logr.FromContext"
  ]
}

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"os"
	"sync"

	contextlogger "example.com/logr-fromcontext"
	"github.com/go-logr/logr"
	"github.com/go-logr/logr/funcr"
)

func main() {
	// Assertion 1: logr.FromContext retrieves the Logger associated with a context via logr.NewContext
	{
		var lines []string
		var mu sync.Mutex
		sinkLogger := funcr.NewJSON(func(obj string) {
			mu.Lock()
			defer mu.Unlock()
			lines = append(lines, obj)
		}, funcr.Options{})

		namedLogger := sinkLogger.WithName("worker")
		ctx := logr.NewContext(context.Background(), namedLogger)

		extracted, err := logr.FromContext(ctx)
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 1]: unexpected error from FromContext: %v\n", err)
			os.Exit(1)
		}
		if extracted.IsZero() {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 1]: extracted logger is zero value\n")
			os.Exit(1)
		}

		extracted.Info("task started", "task_id", 42)

		mu.Lock()
		count := len(lines)
		var output string
		if count > 0 {
			output = lines[0]
		}
		mu.Unlock()

		if count != 1 {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 1]: expected 1 log line, got %d\n", count)
			os.Exit(1)
		}

		var payload map[string]any
		if err := json.Unmarshal([]byte(output), &payload); err != nil {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 1]: invalid JSON output: %v\n", err)
			os.Exit(1)
		}

		if payload["logger"] != "worker" {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 1]: expected logger='worker', got %v\n", payload["logger"])
			os.Exit(1)
		}
		if payload["msg"] != "task started" {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 1]: expected msg='task started', got %v\n", payload["msg"])
			os.Exit(1)
		}
		if payload["task_id"] != float64(42) {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 1]: expected task_id=42, got %v\n", payload["task_id"])
			os.Exit(1)
		}
	}

	// Assertion 2: logr.FromContext returns an error implementing IsNotFound and an uninitialized Logger when absent
	{
		emptyCtx := context.Background()
		zeroLogger, err := logr.FromContext(emptyCtx)
		if err == nil {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 2]: expected error from empty context, got nil\n")
			os.Exit(1)
		}
		if err.Error() != "no logr.Logger was present" {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 2]: unexpected error message: %q\n", err.Error())
			os.Exit(1)
		}
		if !contextlogger.IsNotFoundError(err) {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 2]: error did not implement IsNotFound() bool\n")
			os.Exit(1)
		}
		if !zeroLogger.IsZero() {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 2]: expected zero Logger when absent, got non-zero\n")
			os.Exit(1)
		}

		// Fallback helper verification
		var lines []string
		var mu sync.Mutex
		fallback := funcr.NewJSON(func(obj string) {
			mu.Lock()
			defer mu.Unlock()
			lines = append(lines, obj)
		}, funcr.Options{}).WithName("fallback")

		chosen := contextlogger.FromContextOrFallback(emptyCtx, fallback)
		chosen.Info("fallback message")

		mu.Lock()
		count := len(lines)
		var output string
		if count > 0 {
			output = lines[0]
		}
		mu.Unlock()

		if count != 1 {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 2]: fallback logger did not record entry\n")
			os.Exit(1)
		}
		var payload map[string]any
		_ = json.Unmarshal([]byte(output), &payload)
		if payload["logger"] != "fallback" {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 2]: expected fallback logger name, got %v\n", payload["logger"])
			os.Exit(1)
		}
	}

	// Assertion 3: logr.FromContext preserves Logger hierarchy, name segments, and structured key-value attributes
	{
		var lines []string
		var mu sync.Mutex
		rootLogger := funcr.NewJSON(func(obj string) {
			mu.Lock()
			defer mu.Unlock()
			lines = append(lines, obj)
		}, funcr.Options{})

		serviceLogger := rootLogger.WithName("payments").WithValues("service", "billing", "region", "us-central")
		ctx := contextlogger.WithLogger(context.Background(), serviceLogger)

		if err := contextlogger.ExecuteOperation(ctx, "process-invoice", 3); err != nil {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 3]: ExecuteOperation failed: %v\n", err)
			os.Exit(1)
		}

		mu.Lock()
		count := len(lines)
		var output string
		if count > 0 {
			output = lines[0]
		}
		mu.Unlock()

		if count != 1 {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 3]: expected 1 log line, got %d\n", count)
			os.Exit(1)
		}

		var payload map[string]any
		if err := json.Unmarshal([]byte(output), &payload); err != nil {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 3]: invalid JSON: %v\n", err)
			os.Exit(1)
		}

		if payload["logger"] != "payments" {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 3]: expected logger='payments', got %v\n", payload["logger"])
			os.Exit(1)
		}
		if payload["service"] != "billing" || payload["region"] != "us-central" {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 3]: missing initial values: %v\n", payload)
			os.Exit(1)
		}
		if payload["operation"] != "process-invoice" || payload["step"] != float64(3) {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 3]: missing operation attributes: %v\n", payload)
			os.Exit(1)
		}
	}

	// Assertion 4: logr.FromContext respects context inheritance and supports child context logger overrides
	{
		var parentLines []string
		var childLines []string
		var mu sync.Mutex

		pLogger := funcr.NewJSON(func(obj string) {
			mu.Lock()
			defer mu.Unlock()
			parentLines = append(parentLines, obj)
		}, funcr.Options{}).WithName("parent-logger")

		cLogger := funcr.NewJSON(func(obj string) {
			mu.Lock()
			defer mu.Unlock()
			childLines = append(childLines, obj)
		}, funcr.Options{}).WithName("child-logger")

		parentCtx := logr.NewContext(context.Background(), pLogger)

		// Derived context without logger changes inherits parent logger
		derivedCtx, cancel := context.WithCancel(parentCtx)
		defer cancel()

		inheritedLog, err := logr.FromContext(derivedCtx)
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 4]: failed extracting inherited logger: %v\n", err)
			os.Exit(1)
		}
		inheritedLog.Info("from derived context")

		// Overridden child context
		overrideCtx := logr.NewContext(derivedCtx, cLogger)
		overriddenLog, err := logr.FromContext(overrideCtx)
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 4]: failed extracting overridden logger: %v\n", err)
			os.Exit(1)
		}
		overriddenLog.Info("from child override")

		// Parent context remains unchanged
		origLog, err := logr.FromContext(parentCtx)
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 4]: failed extracting parent logger: %v\n", err)
			os.Exit(1)
		}
		origLog.Info("from parent context")

		mu.Lock()
		pCount := len(parentLines)
		cCount := len(childLines)
		mu.Unlock()

		if pCount != 2 {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 4]: expected 2 parent logger lines, got %d\n", pCount)
			os.Exit(1)
		}
		if cCount != 1 {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 4]: expected 1 child logger line, got %d\n", cCount)
			os.Exit(1)
		}
	}

	// Assertion 5: logr.FromContextOrDiscard returns Discard logger when absent and contextual logger when present
	{
		emptyCtx := context.Background()
		discardLog := logr.FromContextOrDiscard(emptyCtx)
		if discardLog != logr.Discard() {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 5]: expected FromContextOrDiscard to return Discard() on empty context\n")
			os.Exit(1)
		}
		// Calling Info on discard logger succeeds without panic
		discardLog.Info("discarded message")

		// When present, returns configured logger
		activeLogger := funcr.NewJSON(func(obj string) {}, funcr.Options{}).WithName("active")
		activeCtx := logr.NewContext(emptyCtx, activeLogger)
		extracted := logr.FromContextOrDiscard(activeCtx)
		if extracted.IsZero() {
			fmt.Fprintf(os.Stderr, "FAIL [Assertion 5]: expected non-zero active logger from FromContextOrDiscard\n")
			os.Exit(1)
		}
	}

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