testing

func NewSpanCollector ¶

func NewSpanCollector(t *testing.T, exporter *tracetest.InMemoryExporter) *SpanCollector

NewSpanCollector creates a span collector from an in-memory exporter.

func InstallTestMeterProvider ¶ added in v0.64.0

func InstallTestMeterProvider(t *testing.T) *TestMeterProvider

InstallTestMeterProvider creates a test meter provider, installs it as the global meter provider, and registers a t.Cleanup that restores the previous provider. It leaves the text-map propagator alone.

Like InstallTestTraceProvider it never calls Shutdown: otel's default delegating provider binds to the FIRST provider installed in the binary via a sync.Once and never rebinds, so shutting an installed provider down would silently stop every later otel.Meter call that routes through that delegate.

The OTel globals are process-wide, so the install-to-cleanup window is not safe to overlap: do not call this from a t.Parallel test, and do not nest it inside another install whose cleanup runs later. Cleanups unwind LIFO, so sequential nesting restores correctly, but two overlapping installs can capture each other's provider and restore the wrong one.

Example:

mp := InstallTestMeterProvider(t)
counter, _ := otel.Meter("test").Int64Counter("test.counter")
counter.Add(context.Background(), 1)
rm := mp.Collect(t)

func NewTestMeterProvider ¶

func NewTestMeterProvider() *TestMeterProvider

NewTestMeterProvider creates a MeterProvider with a manual reader for testing. The manual reader allows collecting metrics on-demand for assertions without periodic exports.

Example:

mp := NewTestMeterProvider()

// To install it globally, use InstallTestMeterProvider(t), which restores
// the previous provider in t.Cleanup; never Shutdown a provider you
// installed (see the package doc — otel's delegate binds once).
meter := mp.Meter("test")
counter, _ := meter.Int64Counter("test.counter")
counter.Add(context.Background(), 1)

// Collect metrics for assertions
rm := mp.Collect(t)

package main

import (
	"context"
	"fmt"

	"go.opentelemetry.io/otel"

	obtest "github.com/gaborage/go-bricks/observability/testing"
)

func main() {
	// Create a test meter provider with manual reader
	mp := obtest.NewTestMeterProvider()

	// Set as global provider (or use directly), and restore the previous one when
	// done. Do NOT shut mp down — see ExampleNewTestTraceProvider (#1093).
	prev := otel.GetMeterProvider()
	defer otel.SetMeterProvider(prev)
	otel.SetMeterProvider(mp)

	// Your code that records metrics
	meter := mp.Meter("example-service")
	counter, _ := meter.Int64Counter("requests.count") // Metric options can be added here

	counter.Add(context.Background(), 1) // Attributes can be added to metric recordings

	counter.Add(context.Background(), 2)

	// Collect metrics for assertions
	// In real usage, you would pass the testing.T instance
	// rm := mp.Collect(t)
	fmt.Println("Metrics collected successfully")
}

Output:
Metrics collected successfully

func InstallTestTraceProvider ¶ added in v0.64.0

func InstallTestTraceProvider(t *testing.T) *TestTraceProvider

InstallTestTraceProvider creates a test trace provider, installs it as the global tracer provider together with a W3C trace-context propagator, and registers a t.Cleanup that restores the previous provider and propagator.

It never calls Shutdown, on the provider it created or any other: otel's default delegating provider binds to the FIRST provider installed in the binary via a sync.Once and never rebinds, so a later otel.Tracer call made through that restored default still routes into the first-installed provider. Shutting one down would make those calls record nothing, with no error. Restoring the previous provider is safe; shutting one down is not.

The OTel globals are process-wide, so the install-to-cleanup window is not safe to overlap: do not call this from a t.Parallel test, and do not nest it inside another install whose cleanup runs later. Cleanups unwind LIFO, so sequential nesting restores correctly, but two overlapping installs can capture each other's provider and restore the wrong one.

Example:

tp := InstallTestTraceProvider(t)
_, span := tp.TestTracer().Start(context.Background(), "operation")
span.End()
spans := tp.Exporter.GetSpans()

func NewTestTraceProvider ¶

func NewTestTraceProvider() *TestTraceProvider

NewTestTraceProvider creates a TracerProvider with an in-memory exporter for testing. The returned provider captures all spans in memory for assertion without sending them to an external backend.

Example:

tp := NewTestTraceProvider()

// To install it globally, use InstallTestTraceProvider(t), which restores
// the previous provider in t.Cleanup; never Shutdown a provider you
// installed (see the package doc — otel's delegate binds once).

// Later, get spans for assertions
spans := tp.Exporter.GetSpans()

package main

import (
	"context"
	"fmt"

	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/attribute"

	obtest "github.com/gaborage/go-bricks/observability/testing"
)

const httpMethodAttr = "http.method"

func main() {
	// Create a test trace provider with in-memory exporter
	tp := obtest.NewTestTraceProvider()

	// Set as global provider (or use directly), and restore the previous one when
	// done. Do NOT shut tp down: otel's default delegating provider binds to the
	// first provider installed in the binary and never rebinds
	// (internal/global/state.go sync.Once, #1093), so shutting tp down can silence
	// otel.Tracer calls made through that restored default afterwards.
	prev := otel.GetTracerProvider()
	defer otel.SetTracerProvider(prev)
	otel.SetTracerProvider(tp)

	// Your code that creates spans
	tracer := tp.Tracer("example-service")
	_, span := tracer.Start(context.Background(), "process-request")
	span.SetAttributes(
		attribute.String(httpMethodAttr, "GET"),
		attribute.String("http.url", "/api/users"),
		attribute.Int("http.status_code", 200),
	)
	span.End()

	// Get captured spans for assertions
	spans := tp.Exporter.GetSpans()
	fmt.Printf("Captured %d spans\n", len(spans))
}

Output:
Captured 1 spans