go.opentelemetry.io/otel/log v0.19.0: LoggerProvider

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 go.opentelemetry.io/otel/log.LoggerProvider in pkg:golang/go.opentelemetry.io/otel/log@v0.19.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/go.opentelemetry.io/otel/log@v0.19.0
Demonstrate these symbols/APIs:
  - go.opentelemetry.io/otel/log.LoggerProvider
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.

package sample

import (
	"context"
	"sync"
	"testing"
	"time"

	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/log"
	"go.opentelemetry.io/otel/log/noop"
)

func TestContractLoggerProviderAndLogger(t *testing.T) {
	provider := NewInMemoryLoggerProvider()

	// 1. Verify LoggerProvider creates and configures Logger with options
	scopeName := "example.com/app/service"
	loggerObj := provider.Logger(
		scopeName,
		log.WithInstrumentationVersion("1.2.0"),
		log.WithSchemaURL("https://opentelemetry.io/schemas/1.24.0"),
		log.WithInstrumentationAttributes(attribute.String("component", "auth")),
	)

	inMemLogger, ok := provider.GetLogger(scopeName)
	if !ok {
		t.Fatalf("expected logger %q to be registered in provider", scopeName)
	}

	cfg := inMemLogger.Config()
	if cfg.InstrumentationVersion() != "1.2.0" {
		t.Fatalf("expected instrumentation version 1.2.0, got %s", cfg.InstrumentationVersion())
	}
	if cfg.SchemaURL() != "https://opentelemetry.io/schemas/1.24.0" {
		t.Fatalf("expected schema url https://opentelemetry.io/schemas/1.24.0, got %s", cfg.SchemaURL())
	}
	attrs := cfg.InstrumentationAttributes()
	attrVal, hasAttr := attrs.Value("component")
	if !hasAttr || attrVal.AsString() != "auth" {
		t.Fatalf("expected instrumentation attribute component=auth")
	}

	// 2. Test Enabled method with EnabledParameters
	ctx := context.Background()
	inMemLogger.SetMinSeverity(log.SeverityInfo)

	if inMemLogger.Enabled(ctx, log.EnabledParameters{Severity: log.SeverityDebug}) {
		t.Fatalf("expected Enabled to return false for SeverityDebug when min is Info")
	}
	if !inMemLogger.Enabled(ctx, log.EnabledParameters{Severity: log.SeverityInfo}) {
		t.Fatalf("expected Enabled to return true for SeverityInfo")
	}
	if !inMemLogger.Enabled(ctx, log.EnabledParameters{Severity: log.SeverityError}) {
		t.Fatalf("expected Enabled to return true for SeverityError")
	}

	// 3. Emit structured records through Logger interface
	now := time.Date(2026, 8, 31, 10, 0, 0, 0, time.UTC)
	var rec log.Record
	rec.SetTimestamp(now)
	rec.SetSeverity(log.SeverityInfo)
	rec.SetSeverityText("INFO")
	rec.SetBody(log.StringValue("user login successful"))
	rec.AddAttributes(
		log.String("user.id", "usr-456"),
		log.Int("attempts", 1),
	)

	loggerObj.Emit(ctx, rec)

	records := inMemLogger.Records()
	if len(records) != 1 {
		t.Fatalf("expected 1 record, got %d", len(records))
	}

	captured := records[0]
	if !captured.Timestamp().Equal(now) {
		t.Fatalf("expected timestamp %v, got %v", now, captured.Timestamp())
	}
	if captured.Severity() != log.SeverityInfo {
		t.Fatalf("expected severity INFO, got %v", captured.Severity())
	}
	if captured.SeverityText() != "INFO" {
		t.Fatalf("expected severity text 'INFO', got %s", captured.SeverityText())
	}
	if captured.Body().AsString() != "user login successful" {
		t.Fatalf("expected body 'user login successful', got %s", captured.Body().AsString())
	}
	if captured.AttributesLen() != 2 {
		t.Fatalf("expected 2 attributes, got %d", captured.AttributesLen())
	}

	// 4. Verify concurrent safe emission
	var wg sync.WaitGroup
	for i := 0; i < 20; i++ {
		wg.Add(1)
		go func(idx int) {
			defer wg.Done()
			var r log.Record
			r.SetSeverity(log.SeverityWarn)
			r.SetBody(log.IntValue(idx))
			loggerObj.Emit(ctx, r)
		}(i)
	}
	wg.Wait()

	if len(inMemLogger.Records()) != 21 {
		t.Fatalf("expected 21 total records, got %d", len(inMemLogger.Records()))
	}

	// 5. Verify noop LoggerProvider
	noopProvider := noop.NewLoggerProvider()
	noopLogger := noopProvider.Logger("noop-logger")
	if noopLogger == nil {
		t.Fatalf("expected non-nil noop logger")
	}
	noopLogger.Emit(ctx, rec)
}

{"case":{"caseId":"case:sha256:4c31eb83ad43762419023f20bfe0b116b3ed4075ba8233fed2fb1144ecf2613c","contract":["LoggerProvider returns Logger configured with instrumentation version, schema URL, and attributes","Logger Enabled checks severity against configured threshold","Logger Emit captures structured log records with timestamp, severity, body, and attributes","Logger Emit handles concurrent log emissions safely","noop.NewLoggerProvider returns non-nil noop LoggerProvider and Logger"],"goal":"verify go.opentelemetry.io/otel/log.LoggerProvider in pkg:golang/go.opentelemetry.io/otel/log@v0.19.0","kind":"HOW","packages":["pkg:golang/go.opentelemetry.io/otel/log@v0.19.0"],"schemaVersion":1,"symbols":["go.opentelemetry.io/otel/log.LoggerProvider"]},"contractCommand":["go","test","-p","1","-vet=off","."],"environment":{"arch":"x64","distro":"alpine","ecosystem":"golang","libc":"musl","os":"linux","packageManager":"go","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/go.opentelemetry.io/otel/log@v0.19.0"],"schemaVersion":1,"subject":"pkg:golang/go.opentelemetry.io/otel/log@v0.19.0","symbols":["go.opentelemetry.io/otel/log.LoggerProvider"],"verifierAdapter":"golang@1"}

module sample

go 1.25.0

require (
	go.opentelemetry.io/otel v1.43.0
	go.opentelemetry.io/otel/log v0.19.0
)

require (
	github.com/cespare/xxhash/v2 v2.3.0 // indirect
	github.com/go-logr/logr v1.4.3 // indirect
	github.com/go-logr/stdr v1.2.2 // indirect
	go.opentelemetry.io/auto/sdk v1.2.1 // indirect
	go.opentelemetry.io/otel/metric v1.43.0 // indirect
	go.opentelemetry.io/otel/trace v1.43.0 // indirect
)

github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64=
go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y=
go.opentelemetry.io/otel v1.43.0 h1:mYIM03dnh5zfN7HautFE4ieIig9amkNANT+xcVxAj9I=
go.opentelemetry.io/otel v1.43.0/go.mod h1:JuG+u74mvjvcm8vj8pI5XiHy1zDeoCS2LB1spIq7Ay0=
go.opentelemetry.io/otel/log v0.19.0 h1:KUZs/GOsw79TBBMfDWsXS+KZ4g2Ckzksd1ymzsIEbo4=
go.opentelemetry.io/otel/log v0.19.0/go.mod h1:5DQYeGmxVIr4n0/BcJvF4upsraHjg6vudJJpnkL6Ipk=
go.opentelemetry.io/otel/metric v1.43.0 h1:d7638QeInOnuwOONPp4JAOGfbCEpYb+K6DVWvdxGzgM=
go.opentelemetry.io/otel/metric v1.43.0/go.mod h1:RDnPtIxvqlgO8GRW18W6Z/4P462ldprJtfxHxyKd2PY=
go.opentelemetry.io/otel/trace v1.43.0 h1:BkNrHpup+4k4w+ZZ86CZoHHEkohws8AY+WTX09nk+3A=
go.opentelemetry.io/otel/trace v1.43.0/go.mod h1:/QJhyVBUUswCphDVxq+8mld+AvhXZLhe+8WVFxiFff0=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

package sample

import (
	"context"
	"sync"

	"go.opentelemetry.io/otel/log"
	"go.opentelemetry.io/otel/log/embedded"
)

// InMemoryLogger implements log.Logger and stores emitted log records in memory.
type InMemoryLogger struct {
	embedded.Logger
	name        string
	config      log.LoggerConfig
	minSeverity log.Severity
	mu          sync.Mutex
	records     []log.Record
}

// Name returns the logger's instrumentation name.
func (l *InMemoryLogger) Name() string {
	return l.name
}

// Config returns the logger's LoggerConfig.
func (l *InMemoryLogger) Config() log.LoggerConfig {
	return l.config
}

// Emit safely captures a log.Record.
func (l *InMemoryLogger) Emit(ctx context.Context, record log.Record) {
	l.mu.Lock()
	defer l.mu.Unlock()
	l.records = append(l.records, record.Clone())
}

// Enabled checks if logging is enabled for the given parameters.
func (l *InMemoryLogger) Enabled(ctx context.Context, param log.EnabledParameters) bool {
	if param.Severity != log.SeverityUndefined && param.Severity < l.minSeverity {
		return false
	}
	return true
}

// SetMinSeverity sets the minimum severity threshold.
func (l *InMemoryLogger) SetMinSeverity(sev log.Severity) {
	l.mu.Lock()
	defer l.mu.Unlock()
	l.minSeverity = sev
}

// Records returns a slice of all emitted records.
func (l *InMemoryLogger) Records() []log.Record {
	l.mu.Lock()
	defer l.mu.Unlock()
	copied := make([]log.Record, len(l.records))
	copy(copied, l.records)
	return copied
}

// InMemoryLoggerProvider implements log.LoggerProvider.
type InMemoryLoggerProvider struct {
	embedded.LoggerProvider
	mu      sync.Mutex
	loggers map[string]*InMemoryLogger
}

// NewInMemoryLoggerProvider creates a new InMemoryLoggerProvider instance.
func NewInMemoryLoggerProvider() *InMemoryLoggerProvider {
	return &InMemoryLoggerProvider{
		loggers: make(map[string]*InMemoryLogger),
	}
}

// Logger returns a log.Logger configured with the provided name and options.
func (p *InMemoryLoggerProvider) Logger(name string, options ...log.LoggerOption) log.Logger {
	p.mu.Lock()
	defer p.mu.Unlock()

	if l, exists := p.loggers[name]; exists {
		return l
	}

	cfg := log.NewLoggerConfig(options...)
	logger := &InMemoryLogger{
		name:        name,
		config:      cfg,
		minSeverity: log.SeverityInfo,
	}
	p.loggers[name] = logger
	return logger
}

// GetLogger retrieves a registered InMemoryLogger by name.
func (p *InMemoryLoggerProvider) GetLogger(name string) (*InMemoryLogger, bool) {
	p.mu.Lock()
	defer p.mu.Unlock()
	l, ok := p.loggers[name]
	return l, ok
}

{
  "schemaVersion": 1,
  "goal": "verify go.opentelemetry.io/otel/log.LoggerProvider in pkg:golang/go.opentelemetry.io/otel/log@v0.19.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/go.opentelemetry.io/otel/log@v0.19.0"
  ],
  "symbols": [
    "go.opentelemetry.io/otel/log.LoggerProvider"
  ],
  "constraints": {
    "executionContext": "node"
  },
  "runtimeConditions": {
    "ecosystem": "npm",
    "language": "javascript",
    "moduleSystem": "cjs",
    "packageManager": "npm@10.9.8",
    "runtime": "node@22.23.2"
  }
}