go.opentelemetry.io/otel v1.35.0: GetMeterProvider, SetMeterProvider, Meter

# go.opentelemetry.io/otel - Global Providers, Instruments, and Error Handling

## Search Result
`search_known_solution` answered `NO_SAFE_MATCH` for `go.opentelemetry.io/otel` global MeterProvider, instruments, and error handling.

## Release Pinned
- Package: `go.opentelemetry.io/otel`
- Version: `v1.35.0`

## Observed Behaviour
1. **Global MeterProvider & Instruments**:
   - `otel.GetMeterProvider()` returns the configured global `metric.MeterProvider` (defaulting to a non-nil provider).
   - `otel.Meter(name, opts...)` creates a named `metric.Meter` with options like `metric.WithInstrumentationVersion` and `metric.WithSchemaURL`.
   - Synchronous instruments (`Int64Counter`, `Int64UpDownCounter`, `Float64Histogram`) and asynchronous instruments (`Int64ObservableGauge` with callback registration and unregistration) can be constructed and recorded.
   - `otel.SetMeterProvider(mp)` updates the active global meter provider.

2. **Global TracerProvider & Tracer**:
   - `otel.GetTracerProvider()` returns the global `trace.TracerProvider`.
   - `otel.Tracer(name, opts...)` constructs a named tracer with options.
   - `otel.SetTracerProvider(tp)` updates the active global tracer provider.

3. **Global Error Handling**:
   - `otel.GetErrorHandler()` returns the active global error handler.
   - `otel.SetErrorHandler(...)` configures custom error handling using `otel.ErrorHandlerFunc`.
   - `otel.Handle(err)` safely dispatches errors including `nil` without panic and supports concurrent invocations.

4. **Global TextMapPropagator**:
   - `otel.GetTextMapPropagator()` and `otel.SetTextMapPropagator(...)` manage the global composite propagator configuration.

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/go.opentelemetry.io/otel@v1.35.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/go.opentelemetry.io/otel@v1.35.0
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:dc40e7aa110c4d9d9d2522d37a5037b36acc42a49c3d117a4135ed2895aa88a7","contract":["otel.GetMeterProvider returns default non-nil MeterProvider and otel.SetMeterProvider updates the global MeterProvider","otel.Meter creates named Meter with options to construct synchronous (Int64Counter, Int64UpDownCounter, Float64Histogram) and asynchronous (Int64ObservableGauge) instruments","otel.GetTracerProvider returns default non-nil TracerProvider and otel.SetTracerProvider updates the global TracerProvider","otel.Tracer creates named Tracer capable of starting spans, adding events, and recording errors","otel.SetErrorHandler registers ErrorHandlerFunc to handle errors dispatched via otel.Handle safely and concurrently","otel.GetTextMapPropagator and otel.SetTextMapPropagator manage global composite text map propagators"],"goal":"verify pkg:golang/go.opentelemetry.io/otel@v1.35.0","kind":"HOW","packages":["pkg:golang/go.opentelemetry.io/otel@v1.35.0"],"schemaVersion":1,"symbols":["otel.GetMeterProvider","otel.SetMeterProvider","otel.Meter","otel.GetTracerProvider","otel.SetTracerProvider","otel.Tracer","otel.SetErrorHandler","otel.GetErrorHandler","otel.Handle"]},"contractCommand":["go","test","./..."],"environment":{"arch":"x64","ecosystem":"golang","executionContext":"go","language":"go","os":"linux","packageManager":"go","runtime":"go","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/go.opentelemetry.io/otel@v1.35.0"],"schemaVersion":1,"subject":"pkg:golang/go.opentelemetry.io/otel@v1.35.0","symbols":["otel.GetMeterProvider","otel.SetMeterProvider","otel.Meter","otel.GetTracerProvider","otel.SetTracerProvider","otel.Tracer","otel.SetErrorHandler","otel.GetErrorHandler","otel.Handle"],"verifierAdapter":"golang@1"}

module example.com/sample

go 1.22.0

require (
	go.opentelemetry.io/otel v1.35.0
	go.opentelemetry.io/otel/metric v1.35.0
	go.opentelemetry.io/otel/trace v1.35.0
)

require (
	github.com/go-logr/logr v1.4.2 // indirect
	github.com/go-logr/stdr v1.2.2 // indirect
	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
)

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.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
github.com/go-logr/logr v1.4.2/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.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
go.opentelemetry.io/otel v1.35.0 h1:xKWKPxrxB6OtMCbmMY021CqC45J+3Onta9MqjhnusiQ=
go.opentelemetry.io/otel v1.35.0/go.mod h1:UEqy8Zp11hpkUrL73gSlELM0DupHoiq72dR+Zqel/+Y=
go.opentelemetry.io/otel/metric v1.35.0 h1:0znxYu2SNyuMSQT4Y9WDWej0VpcsxkuklLa4/siN90M=
go.opentelemetry.io/otel/metric v1.35.0/go.mod h1:nKVFgxBZ2fReX6IlyW28MgZojkoAkJGaE8CpgeAU3oE=
go.opentelemetry.io/otel/trace v1.35.0 h1:dPpEfJu1sDIqruz7BHFG3c7528f6ddfSWfFDVt/xgMs=
go.opentelemetry.io/otel/trace v1.35.0/go.mod h1:WUk7DtFp1Aw2MkvqGdwiXYDZZNvA/1J8o6xRXLrIkyc=
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"
	"errors"
	"sync"
	"sync/atomic"
	"testing"

	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/metric"
	noopmetric "go.opentelemetry.io/otel/metric/noop"
	"go.opentelemetry.io/otel/propagation"
	"go.opentelemetry.io/otel/trace"
	nooptrace "go.opentelemetry.io/otel/trace/noop"
)

func TestGlobalMeterProviderAndInstruments(t *testing.T) {
	// Restore default meter provider at end of test
	origMP := otel.GetMeterProvider()
	defer otel.SetMeterProvider(origMP)

	// 1. otel.GetMeterProvider returns default MeterProvider
	mp := otel.GetMeterProvider()
	if mp == nil {
		t.Fatal("expected non-nil default MeterProvider")
	}

	// 2. otel.Meter creates named Meter with options from global MeterProvider
	meter := otel.Meter(
		"example.com/sample/meter",
		metric.WithInstrumentationVersion("v1.35.0"),
		metric.WithSchemaURL("https://opentelemetry.io/schemas/1.24.0"),
	)
	if meter == nil {
		t.Fatal("expected non-nil Meter")
	}

	ctx := context.Background()

	// 3. Create synchronous instruments: Counter, UpDownCounter, Histogram
	counter, err := meter.Int64Counter(
		"http_requests_total",
		metric.WithDescription("Total number of HTTP requests"),
		metric.WithUnit("{request}"),
	)
	if err != nil {
		t.Fatalf("unexpected error creating Int64Counter: %v", err)
	}
	counter.Add(ctx, 1, metric.WithAttributes(attribute.String("path", "/api/v1/resource")))

	upDownCounter, err := meter.Int64UpDownCounter(
		"active_connections",
		metric.WithDescription("Number of active connections"),
		metric.WithUnit("{connection}"),
	)
	if err != nil {
		t.Fatalf("unexpected error creating Int64UpDownCounter: %v", err)
	}
	upDownCounter.Add(ctx, 5)
	upDownCounter.Add(ctx, -2)

	histogram, err := meter.Float64Histogram(
		"request_duration_seconds",
		metric.WithDescription("Duration of HTTP requests in seconds"),
		metric.WithUnit("s"),
		metric.WithExplicitBucketBoundaries(0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0),
	)
	if err != nil {
		t.Fatalf("unexpected error creating Float64Histogram: %v", err)
	}
	histogram.Record(ctx, 0.045, metric.WithAttributes(attribute.Int("status_code", 200)))

	// 4. Create asynchronous observable instrument with callback
	var gaugeValue int64 = 42
	gauge, err := meter.Int64ObservableGauge(
		"system_memory_usage_bytes",
		metric.WithDescription("Current system memory usage"),
		metric.WithUnit("By"),
	)
	if err != nil {
		t.Fatalf("unexpected error creating Int64ObservableGauge: %v", err)
	}

	registration, err := meter.RegisterCallback(
		func(ctx context.Context, obs metric.Observer) error {
			obs.ObserveInt64(gauge, atomic.LoadInt64(&gaugeValue), metric.WithAttributes(attribute.String("pool", "heap")))
			return nil
		},
		gauge,
	)
	if err != nil {
		t.Fatalf("unexpected error registering callback: %v", err)
	}
	if err := registration.Unregister(); err != nil {
		t.Fatalf("unexpected error unregistering callback: %v", err)
	}

	// 5. otel.SetMeterProvider updates global MeterProvider
	customMP := noopmetric.NewMeterProvider()
	otel.SetMeterProvider(customMP)
	if otel.GetMeterProvider() != customMP {
		t.Fatal("expected GetMeterProvider to return registered custom MeterProvider")
	}
}

func TestGlobalTracerProviderAndTracer(t *testing.T) {
	origTP := otel.GetTracerProvider()
	defer otel.SetTracerProvider(origTP)

	// 1. otel.GetTracerProvider returns default TracerProvider
	tp := otel.GetTracerProvider()
	if tp == nil {
		t.Fatal("expected non-nil default TracerProvider")
	}

	// 2. otel.Tracer creates named Tracer with options
	tracer := otel.Tracer(
		"example.com/sample/tracer",
		trace.WithInstrumentationVersion("v1.35.0"),
		trace.WithSchemaURL("https://opentelemetry.io/schemas/1.24.0"),
	)
	if tracer == nil {
		t.Fatal("expected non-nil Tracer")
	}

	ctx := context.Background()
	ctx, span := tracer.Start(
		ctx,
		"operation_sample",
		trace.WithSpanKind(trace.SpanKindServer),
		trace.WithAttributes(attribute.String("service.name", "order-service")),
	)
	if span == nil {
		t.Fatal("expected non-nil Span")
	}
	span.AddEvent("cache_miss", trace.WithAttributes(attribute.String("key", "user:123")))
	span.RecordError(errors.New("transient database warning"))
	span.End()

	// 3. otel.SetTracerProvider updates global TracerProvider
	customTP := nooptrace.NewTracerProvider()
	otel.SetTracerProvider(customTP)
	if otel.GetTracerProvider() != customTP {
		t.Fatal("expected GetTracerProvider to return registered custom TracerProvider")
	}
}

func TestGlobalErrorHandler(t *testing.T) {
	origHandler := otel.GetErrorHandler()
	defer otel.SetErrorHandler(origHandler)

	// 1. Default ErrorHandler is defined
	if otel.GetErrorHandler() == nil {
		t.Fatal("expected non-nil default ErrorHandler")
	}

	// 2. SetErrorHandler with ErrorHandlerFunc adapter
	var (
		mu         sync.Mutex
		seenErrors []error
	)
	customHandler := otel.ErrorHandlerFunc(func(err error) {
		mu.Lock()
		defer mu.Unlock()
		seenErrors = append(seenErrors, err)
	})
	otel.SetErrorHandler(customHandler)

	// 3. Handle dispatches error to registered ErrorHandler
	testErr1 := errors.New("simulated otel exporter failure")
	testErr2 := errors.New("simulated batch timeout")

	otel.Handle(testErr1)
	otel.Handle(testErr2)

	mu.Lock()
	if len(seenErrors) != 2 {
		t.Fatalf("expected 2 errors handled, got %d", len(seenErrors))
	}
	if seenErrors[0] != testErr1 || seenErrors[1] != testErr2 {
		t.Fatalf("unexpected error slice content: %v", seenErrors)
	}
	mu.Unlock()

	// 4. Handle nil does not panic
	otel.Handle(nil)

	// 5. Concurrent error handling is safe
	var wg sync.WaitGroup
	for i := 0; i < 50; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			otel.Handle(errors.New("concurrent error"))
		}(i)
	}
	wg.Wait()

	mu.Lock()
	// 2 from before + 1 nil + 50 concurrent = 53
	if len(seenErrors) != 53 {
		t.Fatalf("expected 53 handled errors, got %d", len(seenErrors))
	}
	mu.Unlock()
}

func TestGlobalTextMapPropagator(t *testing.T) {
	origProp := otel.GetTextMapPropagator()
	defer otel.SetTextMapPropagator(origProp)

	// 1. Default TextMapPropagator is non-nil
	if otel.GetTextMapPropagator() == nil {
		t.Fatal("expected non-nil default TextMapPropagator")
	}

	// 2. SetCompositeTextMapPropagator
	composite := propagation.NewCompositeTextMapPropagator(
		propagation.TraceContext{},
		propagation.Baggage{},
	)
	otel.SetTextMapPropagator(composite)

	carrier := propagation.MapCarrier{}
	ctx := context.Background()
	otel.GetTextMapPropagator().Inject(ctx, carrier)

	extractedCtx := otel.GetTextMapPropagator().Extract(context.Background(), carrier)
	if extractedCtx == nil {
		t.Fatal("expected non-nil extracted context")
	}
}

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