// Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 package metricdatatest_test import ( "context" "fmt" "time" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/metric" sdkmetric "go.opentelemetry.io/otel/sdk/metric" "go.opentelemetry.io/otel/sdk/metric/metricdata" "go.opentelemetry.io/otel/sdk/metric/metricdata/metricdatatest" ) func ExampleAssertEqual() { ctx := context.Background() // Create a meterprovider with a reader reader := sdkmetric.NewManualReader() mp := sdkmetric.NewMeterProvider(sdkmetric.WithReader(reader)) defer func() { _ = mp.Shutdown(ctx) }() // Create an instrument(eg: counter/histogram/gauge) and simulate an operation meter := mp.Meter("payment-service") counter, _ := meter.Int64Counter("payment.requests") counter.Add(ctx, 5) // Collect the metrics rm := &metricdata.ResourceMetrics{} _ = reader.Collect(ctx, rm) got, _ := getMetrics("payment.requests", rm) want := metricdata.Metrics{ Name: "payment.requests", Data: metricdata.Sum[int64]{ DataPoints: []metricdata.DataPoint[int64]{{Value: 5}}, Temporality: metricdata.CumulativeTemporality, IsMonotonic: true, }, } // Compare expected metrics with the received one t := &mockTestingT{} assertEqual := metricdatatest.AssertEqual( t, want, got, metricdatatest.IgnoreTimestamp(), // ignoring timestamps ) fmt.Printf("Metrics are equal: %t\n", assertEqual) // Output: // Metrics are equal: true } func ExampleAssertAggregationsEqual() { ctx := context.Background() // Create a meterprovider with a reader reader := sdkmetric.NewManualReader() mp := sdkmetric.NewMeterProvider(sdkmetric.WithReader(reader)) defer func() { _ = mp.Shutdown(ctx) }() // Create an instrument(eg: counter/histogram/gauge) and simulate an operation meter := mp.Meter("payment-service") counter, _ := meter.Int64Counter("payment.count") counter.Add(ctx, 5) // Collect the metrics rm := &metricdata.ResourceMetrics{} _ = reader.Collect(ctx, rm) got, _ := getMetrics("payment.count", rm) want := metricdata.Metrics{ Data: metricdata.Sum[int64]{ DataPoints: []metricdata.DataPoint[int64]{{Value: 5}}, Temporality: metricdata.CumulativeTemporality, IsMonotonic: true, }, } // Verify the expected data with the received one. t := &mockTestingT{} // Compare Aggregations hasEqualAggregations := metricdatatest.AssertAggregationsEqual( t, want.Data, got.Data, metricdatatest.IgnoreTimestamp(), ) fmt.Printf("Aggregations are equal: %t\n", hasEqualAggregations) // Output: // Aggregations are equal: true } func ExampleAssertHasAttributes() { ctx := context.Background() // Create a meterprovider with a reader reader := sdkmetric.NewManualReader() mp := sdkmetric.NewMeterProvider(sdkmetric.WithReader(reader)) defer func() { _ = mp.Shutdown(ctx) }() // Simulate an operation using an instrument(eg: counter) meter := mp.Meter("payment-service") counter, _ := meter.Int64Counter("payment.requests") // Add attribute to the measurement attributes := attribute.NewSet(attribute.String("payment.method", "credit_card")) counter.Add(ctx, 5, metric.WithAttributeSet(attributes)) // Collect the metrics rm := &metricdata.ResourceMetrics{} _ = reader.Collect(ctx, rm) metrics, _ := getMetrics("payment.requests", rm) // Verify the attributes in the received metrics t := &mockTestingT{} hasAttributes := metricdatatest.AssertHasAttributes(t, metrics, attributes.ToSlice()...) fmt.Printf("Metrics contains attributes: %t\n", hasAttributes) // Output: // Metrics contains attributes: true } func ExampleIgnoreValue() { want := metricdata.Metrics{ Name: "payment.duration", Data: metricdata.Histogram[float64]{ DataPoints: []metricdata.HistogramDataPoint[float64]{ { Count: 2, Sum: 224.0, Bounds: []float64{0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000}, BucketCounts: []uint64{0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0}, }, }, Temporality: metricdata.CumulativeTemporality, }, } got := metricdata.Metrics{ Name: "payment.duration", Data: metricdata.Histogram[float64]{ // Aggregate measurements are different in received metrics DataPoints: []metricdata.HistogramDataPoint[float64]{ { Count: 10, Sum: 0, Bounds: []float64{0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000}, BucketCounts: []uint64{1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0}, }, }, Temporality: metricdata.CumulativeTemporality, }, } t := &mockTestingT{} // Compare metrics without values ignoreValue := metricdatatest.AssertEqual( t, want, got, metricdatatest.IgnoreValue(), ) fmt.Printf("Metrics are equal(ignoring values): %t\n", ignoreValue) // Output: // Metrics are equal(ignoring values): true } func ExampleIgnoreExemplars() { // Histogram data with Exemplars want := metricdata.Metrics{ Name: "payment.duration", Data: metricdata.Histogram[float64]{ DataPoints: []metricdata.HistogramDataPoint[float64]{ { Count: 2, Sum: 224.0, Bounds: []float64{0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000}, BucketCounts: []uint64{0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0}, Exemplars: []metricdata.Exemplar[float64]{ { FilteredAttributes: []attribute.KeyValue{ attribute.String("payment.type", "recurring"), }, Time: time.Now(), Value: 15.0, SpanID: []byte{1, 2, 3, 4, 5, 6, 7, 8}, TraceID: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}, }, }, }, }, Temporality: metricdata.CumulativeTemporality, }, } // Histogram data without Exemplars got := metricdata.Metrics{ Name: "payment.duration", Data: metricdata.Histogram[float64]{ // Aggregate measurements are different in received metrics(exemplars) DataPoints: []metricdata.HistogramDataPoint[float64]{ { Count: 2, Sum: 224.0, Bounds: []float64{0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000}, BucketCounts: []uint64{0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0}, }, }, Temporality: metricdata.CumulativeTemporality, }, } t := &mockTestingT{} // Compare metrics ignoreExemplars := metricdatatest.AssertEqual( t, want, got, metricdatatest.IgnoreExemplars(), ) fmt.Printf("Metrics are equal(ignoring exemplars): %t\n", ignoreExemplars) // Output: // Metrics are equal(ignoring exemplars): true } // Helper function to retrieve the metrics. // nolint:unparam // 'bool' return value currently unused, but retained for completeness func getMetrics(name string, rm *metricdata.ResourceMetrics) (metricdata.Metrics, bool) { for _, scopeMetrics := range rm.ScopeMetrics { for _, m := range scopeMetrics.Metrics { if m.Name == name { return m, true } } } return metricdata.Metrics{}, false } // mockTestingT implements the [metricdatatest.TestingT] interface for examples. // Usually, we use [*testing.T] as a substitute. type mockTestingT struct{} func (*mockTestingT) Helper() {} func (*mockTestingT) Error(...any) {}