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

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

## Search Result
`search_known_solution` returned solutions for older versions (v1.35.0, v1.37.0, v1.45.0), but no exact sample for `v1.47.0`.

## Release Pinned
- Package: `go.opentelemetry.io/otel`
- Version: `v1.47.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 LoggerProvider & Logger**:
   - `otel.GetLoggerProvider()` returns the global `log.LoggerProvider`.
   - `otel.Logger(name, opts...)` constructs a named logger with options.
   - Emits structured log records using `log.Record` and `attribute.KeyValue` attributes.
   - `otel.SetLoggerProvider(lp)` updates the active global logger provider.

4. **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.

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

6. **Version**:
   - `otel.Version()` reports the active OpenTelemetry release version.

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.47.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/go.opentelemetry.io/otel@v1.47.0

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:3792572682413c7ace1482866e5d3fc9e71c5e6eb9dcf2ff6f45071387671831","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.GetLoggerProvider returns default non-nil LoggerProvider and otel.SetLoggerProvider updates the global LoggerProvider","otel.Logger creates named Logger capable of emitting structured log records","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","otel.Version returns the active OpenTelemetry release version"],"goal":"verify pkg:golang/go.opentelemetry.io/otel@v1.47.0","kind":"HOW","packages":["pkg:golang/go.opentelemetry.io/otel@v1.47.0"],"schemaVersion":1,"symbols":["otel.GetMeterProvider","otel.SetMeterProvider","otel.Meter","otel.GetTracerProvider","otel.SetTracerProvider","otel.Tracer","otel.GetLoggerProvider","otel.SetLoggerProvider","otel.Logger","otel.SetErrorHandler","otel.GetErrorHandler","otel.Handle","otel.GetTextMapPropagator","otel.SetTextMapPropagator","otel.Version"]},"contractCommand":["go","test","./..."],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","executionContext":"go","language":"go","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","runtime":"go","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/go.opentelemetry.io/otel@v1.47.0"],"schemaVersion":1,"subject":"pkg:golang/go.opentelemetry.io/otel@v1.47.0","symbols":["otel.GetMeterProvider","otel.SetMeterProvider","otel.Meter","otel.GetTracerProvider","otel.SetTracerProvider","otel.Tracer","otel.GetLoggerProvider","otel.SetLoggerProvider","otel.Logger","otel.SetErrorHandler","otel.GetErrorHandler","otel.Handle","otel.GetTextMapPropagator","otel.SetTextMapPropagator","otel.Version"],"verifierAdapter":"golang@1"}

module sample

go 1.26.0

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

require (
	github.com/cespare/xxhash/v2 v2.3.0 // indirect
	github.com/go-logr/logr v1.4.4 // indirect
	github.com/go-logr/stdr v1.2.2 // indirect
	go.opentelemetry.io/auto/sdk v1.2.1 // 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/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8=
github.com/go-logr/logr v1.4.4/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/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE=
github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg=
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.47.0 h1:j7ALJ/zgkS7Z6aeJW09p8VC9804bC+PpeTfCD4XPnOM=
go.opentelemetry.io/otel v1.47.0/go.mod h1:8wS9O2qfXrYrzp6hIF/HOYJJf/wIhFPhR2xLuP+iXQU=
go.opentelemetry.io/otel/log v1.47.0 h1:cOTS1CcLbSQeZKanGJ+0JpF/+t4PELi3O3bbl2lqCcI=
go.opentelemetry.io/otel/log v1.47.0/go.mod h1:9byitSQ5pLC6PpqwGXjqdMKya6ZTswHRZh2vvXT33nw=
go.opentelemetry.io/otel/metric v1.47.0 h1:4PptaldXx3Eat1XjMZ68pPJEs5wrhlemctZE9a3UdWY=
go.opentelemetry.io/otel/metric v1.47.0/go.mod h1:ADGSXxRrXM6bjbvLo535EstVFlPpPYZm4LBKixjDHwU=
go.opentelemetry.io/otel/trace v1.47.0 h1:JOjX/Oci8K94QHddo+bbfya/Ai/nf6/dt9ZfrFNWSrM=
go.opentelemetry.io/otel/trace v1.47.0/go.mod h1:jNaSLa2PZEYFG6fRjJABAu+bw4FS08uDmPg28lTghu0=
go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw=
go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg=

package sample

import (
	"context"
	"errors"
	"strings"
	"sync"
	"sync/atomic"
	"testing"
	"time"

	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/log"
	nooplog "go.opentelemetry.io/otel/log/noop"
	"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) {
	origMP := otel.GetMeterProvider()
	defer otel.SetMeterProvider(origMP)

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

	meter := otel.Meter(
		"example.com/sample/meter",
		metric.WithInstrumentationVersion("v1.47.0"),
		metric.WithSchemaURL("https://opentelemetry.io/schemas/1.24.0"),
	)
	if meter == nil {
		t.Fatal("expected non-nil Meter")
	}

	ctx := context.Background()

	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)))

	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)
	}

	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)

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

	tracer := otel.Tracer(
		"example.com/sample/tracer",
		trace.WithInstrumentationVersion("v1.47.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()

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

func TestGlobalLoggerProviderAndLogger(t *testing.T) {
	origLP := otel.GetLoggerProvider()
	defer otel.SetLoggerProvider(origLP)

	lp := otel.GetLoggerProvider()
	if lp == nil {
		t.Fatal("expected non-nil default LoggerProvider")
	}

	logger := otel.Logger(
		"example.com/sample/logger",
		log.WithInstrumentationVersion("v1.47.0"),
		log.WithSchemaURL("https://opentelemetry.io/schemas/1.24.0"),
	)
	if logger == nil {
		t.Fatal("expected non-nil Logger")
	}

	ctx := context.Background()
	var record log.Record
	record.SetTimestamp(time.Now())
	record.SetSeverity(log.SeverityInfo)
	record.SetSeverityText("INFO")
	record.SetBody(attribute.StringValue("User logged in"))
	record.AddAttributes(attribute.String("user.id", "42"))

	logger.Emit(ctx, record)

	customLP := nooplog.NewLoggerProvider()
	otel.SetLoggerProvider(customLP)
	if otel.GetLoggerProvider() != customLP {
		t.Fatal("expected GetLoggerProvider to return registered custom LoggerProvider")
	}
}

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

	if otel.GetErrorHandler() == nil {
		t.Fatal("expected non-nil default ErrorHandler")
	}

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

	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()

	otel.Handle(nil)

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

	mu.Lock()
	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)

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

	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")
	}
}

func TestVersion(t *testing.T) {
	v := otel.Version()
	if v == "" {
		t.Fatal("expected non-empty Version")
	}
	if !strings.Contains(v, "1.47.0") {
		t.Fatalf("expected version to contain 1.47.0, got %q", v)
	}
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:golang/go.opentelemetry.io/otel@v1.47.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/go.opentelemetry.io/otel@v1.47.0"
  ]
}