stdoutmetric: self-observability: exporter metrics

CHANGELOG.md

@@ -57,6 +57,8 @@ The next release will require at least [Go 1.24].
 - Add experimental self-observability trace exporter metrics in `go.opentelemetry.io/otel/exporters/stdout/stdouttrace`.
   Check the `go.opentelemetry.io/otel/exporters/stdout/stdouttrace/internal/x` package documentation for more information. (#7133)
 - Support testing of [Go 1.25]. (#7187)
+- Add experimental self-observability stdoutmetric exporter metrics in `go.opentelemetry.io/otel/exporters/stdout/stdoutmetric`.
+  Check the `go.opentelemetry.io/otel/exporters/stdout/stdoutmetric/internal/x` package documentation for more information. (#7150)
 
 ### Changed
 

exporters/stdout/stdoutmetric/exporter.go

@@ -10,11 +10,27 @@ import (
 	"sync"
 	"sync/atomic"
 
+	"go.opentelemetry.io/otel/exporters/stdout/stdoutmetric/internal/selfobservability"
+	"go.opentelemetry.io/otel/exporters/stdout/stdoutmetric/internal/x"
 	"go.opentelemetry.io/otel/internal/global"
 	"go.opentelemetry.io/otel/sdk/metric"
 	"go.opentelemetry.io/otel/sdk/metric/metricdata"
+	semconv "go.opentelemetry.io/otel/semconv/v1.36.0"
 )
 
+// otelComponentType is a name identifying the type of the OpenTelemetry
+// component. It is not a standardized OTel component type, so it uses the
+// Go package prefixed type name to ensure uniqueness and identity.
+const otelComponentType = "go.opentelemetry.io/otel/exporters/stdout/stdoutmetric.exporter"
+
+var exporterIDCounter atomic.Int64
+
+// nextExporterID returns an identifier for this stdoutmetric exporter,
+// starting with 0 and incrementing by 1 each time it is called.
+func nextExporterID() int64 {
+	return exporterIDCounter.Add(1) - 1
+}
+
 // exporter is an OpenTelemetry metric exporter.
 type exporter struct {
 	encVal atomic.Value // encoderHolder
@@ -25,6 +41,9 @@ type exporter struct {
 	aggregationSelector metric.AggregationSelector
 
 	redactTimestamps bool
+
+	selfObservabilityEnabled bool
+	exporterMetric           *selfobservability.ExporterMetrics
 }
 
 // New returns a configured metric exporter.
@@ -34,12 +53,22 @@ type exporter struct {
 func New(options ...Option) (metric.Exporter, error) {
 	cfg := newConfig(options...)
 	exp := &exporter{
-		temporalitySelector: cfg.temporalitySelector,
-		aggregationSelector: cfg.aggregationSelector,
-		redactTimestamps:    cfg.redactTimestamps,
+		temporalitySelector:      cfg.temporalitySelector,
+		aggregationSelector:      cfg.aggregationSelector,
+		redactTimestamps:         cfg.redactTimestamps,
+		selfObservabilityEnabled: x.SelfObservability.Enabled(),
 	}
 	exp.encVal.Store(*cfg.encoder)
-	return exp, nil
+	var err error
+	if exp.selfObservabilityEnabled {
+		componentName := fmt.Sprintf("%s/%d", otelComponentType, nextExporterID())
+		exp.exporterMetric, err = selfobservability.NewExporterMetrics(
+			"go.opentelemetry.io/otel/exporters/stdout/stdoutmetric",
+			semconv.OTelComponentName(componentName),
+			semconv.OTelComponentTypeKey.String(otelComponentType),
+		)
+	}
+	return exp, err
 }
 
 func (e *exporter) Temporality(k metric.InstrumentKind) metricdata.Temporality {
@@ -50,17 +79,28 @@ func (e *exporter) Aggregation(k metric.InstrumentKind) metric.Aggregation {
 	return e.aggregationSelector(k)
 }
 
-func (e *exporter) Export(ctx context.Context, data *metricdata.ResourceMetrics) error {
-	if err := ctx.Err(); err != nil {
-		return err
+func (e *exporter) Export(ctx context.Context, data *metricdata.ResourceMetrics) (err error) {
+	trackExportFunc := e.trackExport(context.Background(), countDataPoints(data))
+	defer func() { trackExportFunc(err) }()
+	err = ctx.Err()
+	if err != nil {
+		return
 	}
 	if e.redactTimestamps {
 		redactTimestamps(data)
 	}
 
 	global.Debug("STDOUT exporter export", "Data", data)
 
-	return e.encVal.Load().(encoderHolder).Encode(data)
+	err = e.encVal.Load().(encoderHolder).Encode(data)
+	return
+}
+
+func (e *exporter) trackExport(ctx context.Context, count int64) func(err error) {
+	if !e.selfObservabilityEnabled {
+		return func(error) {}
+	}
+	return e.exporterMetric.TrackExport(ctx, count)
 }
 
 func (*exporter) ForceFlush(context.Context) error {
@@ -159,3 +199,37 @@ func redactDataPointTimestamps[T int64 | float64](sdp []metricdata.DataPoint[T])
 	}
 	return out
 }
+
+// countDataPoints counts the total number of data points in a ResourceMetrics.
+func countDataPoints(rm *metricdata.ResourceMetrics) int64 {
+	if rm == nil {
+		return 0
+	}
+
+	var total int64
+	for _, sm := range rm.ScopeMetrics {
+		for _, m := range sm.Metrics {
+			switch data := m.Data.(type) {
+			case metricdata.Gauge[int64]:
+				total += int64(len(data.DataPoints))
+			case metricdata.Gauge[float64]:
+				total += int64(len(data.DataPoints))
+			case metricdata.Sum[int64]:
+				total += int64(len(data.DataPoints))
+			case metricdata.Sum[float64]:
+				total += int64(len(data.DataPoints))
+			case metricdata.Histogram[int64]:
+				total += int64(len(data.DataPoints))
+			case metricdata.Histogram[float64]:
+				total += int64(len(data.DataPoints))
+			case metricdata.ExponentialHistogram[int64]:
+				total += int64(len(data.DataPoints))
+			case metricdata.ExponentialHistogram[float64]:
+				total += int64(len(data.DataPoints))
+			case metricdata.Summary:
+				total += int64(len(data.DataPoints))
+			}
+		}
+	}
+	return total
+}

exporters/stdout/stdoutmetric/exporter_test.go

@@ -7,16 +7,22 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"errors"
 	"io"
+	"strconv"
 	"testing"
 	"time"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/exporters/stdout/stdoutmetric"
 	"go.opentelemetry.io/otel/sdk/metric"
 	"go.opentelemetry.io/otel/sdk/metric/metricdata"
+	semconv "go.opentelemetry.io/otel/semconv/v1.36.0"
+	"go.opentelemetry.io/otel/semconv/v1.36.0/otelconv"
 )
 
 func testEncoderOption() stdoutmetric.Option {
@@ -25,6 +31,13 @@ func testEncoderOption() stdoutmetric.Option {
 	return stdoutmetric.WithEncoder(enc)
 }
 
+// failingEncoder always returns an error when Encode is called.
+type failingEncoder struct{}
+
+func (failingEncoder) Encode(any) error {
+	return errors.New("encoding failed")
+}
+
 func testCtxErrHonored(factory func(*testing.T) func(context.Context) error) func(t *testing.T) {
 	return func(t *testing.T) {
 		t.Helper()
@@ -178,3 +191,200 @@ func TestAggregationSelector(t *testing.T) {
 	var unknownKind metric.InstrumentKind
 	assert.Equal(t, metric.AggregationDrop{}, exp.Aggregation(unknownKind))
 }
+
+func TestExporter_Export_SelfObservability(t *testing.T) {
+	tests := []struct {
+		name                     string
+		selfObservabilityEnabled bool
+		expectedExportedCount    int64
+	}{
+		{
+			name:                     "Enabled",
+			selfObservabilityEnabled: true,
+			expectedExportedCount:    19,
+		},
+		{
+			name:                     "Disabled",
+			selfObservabilityEnabled: false,
+			expectedExportedCount:    0,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Setenv("OTEL_GO_X_SELF_OBSERVABILITY", strconv.FormatBool(tt.selfObservabilityEnabled))
+			reader := metric.NewManualReader()
+			mp := metric.NewMeterProvider(metric.WithReader(reader))
+			origMp := otel.GetMeterProvider()
+			otel.SetMeterProvider(mp)
+			defer otel.SetMeterProvider(origMp)
+
+			exp, err := stdoutmetric.New(testEncoderOption())
+			require.NoError(t, err)
+
+			rm := &metricdata.ResourceMetrics{
+				ScopeMetrics: []metricdata.ScopeMetrics{
+					{
+						Metrics: []metricdata.Metrics{
+							{
+								Name: "gauge_int64",
+								Data: metricdata.Gauge[int64]{
+									DataPoints: []metricdata.DataPoint[int64]{{Value: 1}, {Value: 2}},
+								},
+							},
+							{
+								Name: "gauge_float64",
+								Data: metricdata.Gauge[float64]{
+									DataPoints: []metricdata.DataPoint[float64]{
+										{Value: 1.0},
+										{Value: 2.0},
+										{Value: 3.0},
+									},
+								},
+							},
+							{
+								Name: "sum_int64",
+								Data: metricdata.Sum[int64]{
+									DataPoints: []metricdata.DataPoint[int64]{{Value: 10}},
+								},
+							},
+							{
+								Name: "sum_float64",
+								Data: metricdata.Sum[float64]{
+									DataPoints: []metricdata.DataPoint[float64]{{Value: 10.5}, {Value: 20.5}},
+								},
+							},
+							{
+								Name: "histogram_int64",
+								Data: metricdata.Histogram[int64]{
+									DataPoints: []metricdata.HistogramDataPoint[int64]{
+										{Count: 1},
+										{Count: 2},
+										{Count: 3},
+									},
+								},
+							},
+							{
+								Name: "histogram_float64",
+								Data: metricdata.Histogram[float64]{
+									DataPoints: []metricdata.HistogramDataPoint[float64]{{Count: 1}},
+								},
+							},
+							{
+								Name: "exponential_histogram_int64",
+								Data: metricdata.ExponentialHistogram[int64]{
+									DataPoints: []metricdata.ExponentialHistogramDataPoint[int64]{
+										{Count: 1},
+										{Count: 2},
+									},
+								},
+							},
+							{
+								Name: "exponential_histogram_float64",
+								Data: metricdata.ExponentialHistogram[float64]{
+									DataPoints: []metricdata.ExponentialHistogramDataPoint[float64]{
+										{Count: 1},
+										{Count: 2},
+										{Count: 3},
+										{Count: 4},
+									},
+								},
+							},
+							{
+								Name: "summary",
+								Data: metricdata.Summary{
+									DataPoints: []metricdata.SummaryDataPoint{{Count: 1}},
+								},
+							},
+						},
+					},
+				},
+			}
+
+			ctx := context.Background()
+			err = exp.Export(ctx, rm)
+			require.NoError(t, err)
+
+			var metrics metricdata.ResourceMetrics
+			err = reader.Collect(ctx, &metrics)
+			require.NoError(t, err)
+
+			var foundExported, foundDuration, foundInflight bool
+			var exportedCount int64
+
+			for _, sm := range metrics.ScopeMetrics {
+				for _, m := range sm.Metrics {
+					switch m.Name {
+					case otelconv.SDKExporterMetricDataPointExported{}.Name():
+						foundExported = true
+						if sum, ok := m.Data.(metricdata.Sum[int64]); ok {
+							for _, dp := range sum.DataPoints {
+								exportedCount += dp.Value
+							}
+						}
+					case otelconv.SDKExporterOperationDuration{}.Name():
+						foundDuration = true
+					case otelconv.SDKExporterMetricDataPointInflight{}.Name():
+						foundInflight = true
+					}
+				}
+			}
+
+			assert.Equal(t, tt.selfObservabilityEnabled, foundExported)
+			assert.Equal(t, tt.selfObservabilityEnabled, foundDuration)
+			assert.Equal(t, tt.selfObservabilityEnabled, foundInflight)
+			assert.Equal(t, tt.expectedExportedCount, exportedCount)
+		})
+	}
+}
+
+func TestExporter_Export_EncodingErrorTracking(t *testing.T) {
+	t.Setenv("OTEL_GO_X_SELF_OBSERVABILITY", "true")
+	reader := metric.NewManualReader()
+	mp := metric.NewMeterProvider(metric.WithReader(reader))
+	origMp := otel.GetMeterProvider()
+	otel.SetMeterProvider(mp)
+	defer otel.SetMeterProvider(origMp)
+
+	exp, err := stdoutmetric.New(stdoutmetric.WithEncoder(failingEncoder{}))
+	assert.NoError(t, err)
+
+	rm := &metricdata.ResourceMetrics{
+		ScopeMetrics: []metricdata.ScopeMetrics{
+			{
+				Metrics: []metricdata.Metrics{
+					{
+						Name: "test_gauge",
+						Data: metricdata.Gauge[int64]{
+							DataPoints: []metricdata.DataPoint[int64]{{Value: 1}, {Value: 2}},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	ctx := context.Background()
+	err = exp.Export(ctx, rm)
+	assert.EqualError(t, err, "encoding failed")
+
+	var metrics metricdata.ResourceMetrics
+	err = reader.Collect(ctx, &metrics)
+	require.NoError(t, err)
+
+	var foundErrorType bool
+	for _, sm := range metrics.ScopeMetrics {
+		for _, m := range sm.Metrics {
+			x := otelconv.SDKExporterMetricDataPointExported{}.Name()
+			if m.Name == x {
+				if sum, ok := m.Data.(metricdata.Sum[int64]); ok {
+					for _, dp := range sum.DataPoints {
+						var attr attribute.Value
+						attr, foundErrorType = dp.Attributes.Value(semconv.ErrorTypeKey)
+						assert.Equal(t, "*errors.errorString", attr.AsString())
+					}
+				}
+			}
+		}
+	}
+	assert.True(t, foundErrorType)
+}

exporters/stdout/stdoutmetric/go.mod

@@ -5,6 +5,7 @@ go 1.23.0
 require (
 	github.com/stretchr/testify v1.11.0
 	go.opentelemetry.io/otel v1.37.0
+	go.opentelemetry.io/otel/metric v1.37.0
 	go.opentelemetry.io/otel/sdk v1.37.0
 	go.opentelemetry.io/otel/sdk/metric v1.37.0
 )
@@ -16,7 +17,6 @@ require (
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
 	go.opentelemetry.io/otel/trace v1.37.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect