go.opentelemetry.io/otel/metric v1.37.0: Meter

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/metric.Meter in pkg:golang/go.opentelemetry.io/otel/metric@v1.37.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/go.opentelemetry.io/otel/metric@v1.37.0
Demonstrate these symbols/APIs:
  - go.opentelemetry.io/otel/metric.Meter

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"
	"testing"

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

func TestContractMeter(t *testing.T) {
	ctx := context.Background()

	// 1. Initialize MetricManager using noop.NewMeterProvider
	provider := noop.NewMeterProvider()
	manager, err := NewMetricManager(provider, "test-meter")
	if err != nil {
		t.Fatalf("failed to initialize MetricManager: %v", err)
	}
	if manager == nil {
		t.Fatal("expected non-nil MetricManager")
	}

	meter := manager.Meter()
	if meter == nil {
		t.Fatal("expected non-nil Meter")
	}

	// 2. Test recording synchronous metrics through manager
	manager.RecordRequest(ctx, 1, "/api/v1/users", 200)
	manager.ConnectionOpened(ctx)
	manager.ConnectionClosed(ctx)
	manager.RecordLatency(ctx, 0.035, "/api/v1/users")

	// 3. Test direct instrument creation on the Meter
	customCounter, err := meter.Int64Counter(
		"app.custom.counter",
		metric.WithDescription("Custom application counter"),
		metric.WithUnit("{item}"),
	)
	if err != nil {
		t.Fatalf("failed to create custom counter: %v", err)
	}
	customCounter.Add(ctx, 10, metric.WithAttributes(attribute.String("key", "val")))

	floatCounter, err := meter.Float64Counter(
		"app.custom.float_counter",
		metric.WithDescription("Custom float counter"),
	)
	if err != nil {
		t.Fatalf("failed to create float counter: %v", err)
	}
	floatCounter.Add(ctx, 3.14)

	customHist, err := meter.Float64Histogram(
		"app.custom.histogram",
		metric.WithDescription("Custom histogram"),
		metric.WithUnit("ms"),
	)
	if err != nil {
		t.Fatalf("failed to create custom histogram: %v", err)
	}
	customHist.Record(ctx, 12.34)

	// 4. Test Observable Instruments and Callback Registration on Meter
	asyncGauge, err := meter.Float64ObservableGauge(
		"app.custom.observable_gauge",
		metric.WithDescription("Observable float gauge"),
	)
	if err != nil {
		t.Fatalf("failed to create observable gauge: %v", err)
	}

	reg, err := meter.RegisterCallback(
		func(cbCtx context.Context, obs metric.Observer) error {
			obs.ObserveFloat64(asyncGauge, 42.0, metric.WithAttributes(attribute.String("env", "test")))
			return nil
		},
		asyncGauge,
	)
	if err != nil {
		t.Fatalf("failed to register callback: %v", err)
	}
	if reg == nil {
		t.Fatal("expected non-nil Registration")
	}

	if err := reg.Unregister(); err != nil {
		t.Fatalf("failed to unregister callback: %v", err)
	}

	// 5. Clean up manager
	if err := manager.Close(); err != nil {
		t.Fatalf("failed to close manager: %v", err)
	}
}

{"case":{"caseId":"case:sha256:a5aa81ea1603de7226f14cc288d6acefba26f641e49d26cdab63fb6b21a45474","contract":["Meter creates synchronous instruments (Int64Counter, Int64UpDownCounter, Float64Histogram) with options","Meter creates asynchronous observable instruments (Int64ObservableGauge, Float64ObservableGauge)","Meter registers and unregisters asynchronous measurement callbacks with RegisterCallback","Meter instruments record measurements with contextual attributes and options"],"goal":"verify go.opentelemetry.io/otel/metric.Meter in pkg:golang/go.opentelemetry.io/otel/metric@v1.37.0","kind":"HOW","packages":["pkg:golang/go.opentelemetry.io/otel/metric@v1.37.0"],"schemaVersion":1,"symbols":["go.opentelemetry.io/otel/metric.Meter"]},"contractCommand":["go","test","./..."],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","language":"go","libc":"glibc","libcVersion":"2.39","moduleSystem":"go-modules","os":"linux","osVersionBucket":"24","packageManager":"go","runtime":"go","runtimeVersion":"1.26","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/go.opentelemetry.io/otel/metric@v1.37.0"],"schemaVersion":1,"subject":"pkg:golang/go.opentelemetry.io/otel/metric@v1.37.0","symbols":["go.opentelemetry.io/otel/metric.Meter"],"verifierAdapter":"golang@1"}

module sample

go 1.24

require (
	go.opentelemetry.io/otel v1.37.0
	go.opentelemetry.io/otel/metric v1.37.0
)

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.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.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.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
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"
	"fmt"

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

// MetricManager manages telemetry instruments created from a metric.Meter.
type MetricManager struct {
	meter             metric.Meter
	requestCounter    metric.Int64Counter
	activeConnections metric.Int64UpDownCounter
	latencyHistogram  metric.Float64Histogram
	systemMemoryGauge metric.Int64ObservableGauge
	registration      metric.Registration
}

// NewMetricManager initializes metrics using the provided MeterProvider and meter name.
// If provider is nil, a no-op MeterProvider is used.
func NewMetricManager(provider metric.MeterProvider, meterName string) (*MetricManager, error) {
	if provider == nil {
		provider = noop.NewMeterProvider()
	}

	meter := provider.Meter(
		meterName,
		metric.WithInstrumentationVersion("v1.37.0"),
	)

	reqCounter, err := meter.Int64Counter(
		"http.server.requests",
		metric.WithDescription("Total count of processed HTTP requests"),
		metric.WithUnit("{request}"),
	)
	if err != nil {
		return nil, fmt.Errorf("failed to create request counter: %w", err)
	}

	activeConn, err := meter.Int64UpDownCounter(
		"http.server.active_connections",
		metric.WithDescription("Current active HTTP connection count"),
		metric.WithUnit("{connection}"),
	)
	if err != nil {
		return nil, fmt.Errorf("failed to create active connections counter: %w", err)
	}

	latencyHist, err := meter.Float64Histogram(
		"http.server.duration",
		metric.WithDescription("HTTP request duration in seconds"),
		metric.WithUnit("s"),
		metric.WithExplicitBucketBoundaries(0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5),
	)
	if err != nil {
		return nil, fmt.Errorf("failed to create latency histogram: %w", err)
	}

	memGauge, err := meter.Int64ObservableGauge(
		"system.memory.usage",
		metric.WithDescription("System memory usage in bytes"),
		metric.WithUnit("By"),
	)
	if err != nil {
		return nil, fmt.Errorf("failed to create memory observable gauge: %w", err)
	}

	// Register an asynchronous callback on the meter
	reg, err := meter.RegisterCallback(
		func(ctx context.Context, observer metric.Observer) error {
			observer.ObserveInt64(memGauge, 1024*1024*64, metric.WithAttributes(
				attribute.String("pool", "heap"),
			))
			return nil
		},
		memGauge,
	)
	if err != nil {
		return nil, fmt.Errorf("failed to register callback: %w", err)
	}

	return &MetricManager{
		meter:             meter,
		requestCounter:    reqCounter,
		activeConnections: activeConn,
		latencyHistogram:  latencyHist,
		systemMemoryGauge: memGauge,
		registration:      reg,
	}, nil
}

// RecordRequest increments the request counter with attributes.
func (m *MetricManager) RecordRequest(ctx context.Context, count int64, route string, status int) {
	m.requestCounter.Add(
		ctx,
		count,
		metric.WithAttributes(
			attribute.String("http.route", route),
			attribute.Int("http.response.status_code", status),
		),
	)
}

// ConnectionOpened increments active connection count.
func (m *MetricManager) ConnectionOpened(ctx context.Context) {
	m.activeConnections.Add(ctx, 1)
}

// ConnectionClosed decrements active connection count.
func (m *MetricManager) ConnectionClosed(ctx context.Context) {
	m.activeConnections.Add(ctx, -1)
}

// RecordLatency records a latency observation in seconds.
func (m *MetricManager) RecordLatency(ctx context.Context, duration float64, route string) {
	m.latencyHistogram.Record(
		ctx,
		duration,
		metric.WithAttributes(
			attribute.String("http.route", route),
		),
	)
}

// Meter returns the underlying metric.Meter instance.
func (m *MetricManager) Meter() metric.Meter {
	return m.meter
}

// Close unregisters any callbacks associated with the meter.
func (m *MetricManager) Close() error {
	if m.registration != nil {
		return m.registration.Unregister()
	}
	return nil
}

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