Merge branch 'origin/main' into 'next-release/main'

go.mod

@@ -99,7 +99,7 @@ require (
 	go.opentelemetry.io/contrib/zpages v0.63.0
 	go.opentelemetry.io/otel v1.39.0
 	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.39.0
-	go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.38.0
+	go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.39.0
 	go.opentelemetry.io/otel/sdk v1.39.0
 	go.opentelemetry.io/otel/trace v1.39.0
 	golang.org/x/crypto v0.47.0

go.sum

@@ -1323,8 +1323,8 @@ go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.39.0 h1:in9O8
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.39.0/go.mod h1:Rp0EXBm5tfnv0WL+ARyO/PHBEaEAT8UUHQ6AGJcSq6c=
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.38.0 h1:aTL7F04bJHUlztTsNGJ2l+6he8c+y/b//eR0jjjemT4=
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.38.0/go.mod h1:kldtb7jDTeol0l3ewcmd8SDvx3EmIE7lyvqbasU3QC4=
-go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.38.0 h1:kJxSDN4SgWWTjG/hPp3O7LCGLcHXFlvS2/FFOrwL+SE=
-go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.38.0/go.mod h1:mgIOzS7iZeKJdeB8/NYHrJ48fdGc71Llo5bJ1J4DWUE=
+go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.39.0 h1:8UPA4IbVZxpsD76ihGOQiFml99GPAEZLohDXvqHdi6U=
+go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.39.0/go.mod h1:MZ1T/+51uIVKlRzGw1Fo46KEWThjlCBZKl2LzY5nv4g=
 go.opentelemetry.io/otel/metric v1.39.0 h1:d1UzonvEZriVfpNKEVmHXbdf909uGTOQjA0HF0Ls5Q0=
 go.opentelemetry.io/otel/metric v1.39.0/go.mod h1:jrZSWL33sD7bBxg1xjrqyDjnuzTUB0x1nBERXd7Ftcs=
 go.opentelemetry.io/otel/sdk v1.39.0 h1:nMLYcjVsvdui1B/4FRkwjzoRVsMK8uL/cj0OyhKzt18=

vendor/go.opentelemetry.io/otel/exporters/stdout/stdouttrace/internal/gen.go

@@ -0,0 +1,12 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+// Package internal provides internal functionality for the stdouttrace
+// package.
+package internal // import "go.opentelemetry.io/otel/exporters/stdout/stdouttrace/internal"
+
+//go:generate gotmpl --body=../../../../internal/shared/counter/counter.go.tmpl "--data={ \"pkg\": \"go.opentelemetry.io/otel/exporters/stdout/stdouttrace/internal/counter\" }" --out=counter/counter.go
+//go:generate gotmpl --body=../../../../internal/shared/counter/counter_test.go.tmpl "--data={}" --out=counter/counter_test.go
+
+//go:generate gotmpl --body=../../../../internal/shared/x/x.go.tmpl "--data={ \"pkg\": \"go.opentelemetry.io/otel/exporters/stdout/stdouttrace\" }" --out=x/x.go
+//go:generate gotmpl --body=../../../../internal/shared/x/x_test.go.tmpl "--data={}" --out=x/x_test.go

vendor/go.opentelemetry.io/otel/exporters/stdout/stdouttrace/internal/observ/instrumentation.go

@@ -0,0 +1,214 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+// Package observ provides experimental observability instrumentation
+// for the stdout trace exporter.
+package observ // import "go.opentelemetry.io/otel/exporters/stdout/stdouttrace/internal/observ"
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync"
+	"time"
+
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/exporters/stdout/stdouttrace/internal"
+	"go.opentelemetry.io/otel/exporters/stdout/stdouttrace/internal/x"
+	"go.opentelemetry.io/otel/metric"
+	semconv "go.opentelemetry.io/otel/semconv/v1.37.0"
+	"go.opentelemetry.io/otel/semconv/v1.37.0/otelconv"
+)
+
+const (
+	// ComponentType uniquely identifies the OpenTelemetry Exporter component
+	// being instrumented.
+	//
+	// The STDOUT trace exporter is not a standardized OTel component type, so
+	// it uses the Go package prefixed type name to ensure uniqueness and
+	// identity.
+	ComponentType = "go.opentelemetry.io/otel/exporters/stdout/stdouttrace.Exporter"
+
+	// ScopeName is the unique name of the meter used for instrumentation.
+	ScopeName = "go.opentelemetry.io/otel/exporters/stdout/stdouttrace/internal/observ"
+
+	// SchemaURL is the schema URL of the metrics produced by this
+	// instrumentation.
+	SchemaURL = semconv.SchemaURL
+
+	// Version is the current version of this instrumentation.
+	//
+	// This matches the version of the exporter.
+	Version = internal.Version
+)
+
+var (
+	measureAttrsPool = &sync.Pool{
+		New: func() any {
+			// "component.name" + "component.type" + "error.type"
+			const n = 1 + 1 + 1
+			s := make([]attribute.KeyValue, 0, n)
+			// Return a pointer to a slice instead of a slice itself
+			// to avoid allocations on every call.
+			return &s
+		},
+	}
+
+	addOptPool = &sync.Pool{
+		New: func() any {
+			const n = 1 // WithAttributeSet
+			o := make([]metric.AddOption, 0, n)
+			return &o
+		},
+	}
+
+	recordOptPool = &sync.Pool{
+		New: func() any {
+			const n = 1 // WithAttributeSet
+			o := make([]metric.RecordOption, 0, n)
+			return &o
+		},
+	}
+)
+
+func get[T any](p *sync.Pool) *[]T { return p.Get().(*[]T) }
+
+func put[T any](p *sync.Pool, s *[]T) {
+	*s = (*s)[:0] // Reset.
+	p.Put(s)
+}
+
+func ComponentName(id int64) string {
+	return fmt.Sprintf("%s/%d", ComponentType, id)
+}
+
+// Instrumentation is experimental instrumentation for the exporter.
+type Instrumentation struct {
+	inflightSpans metric.Int64UpDownCounter
+	exportedSpans metric.Int64Counter
+	opDuration    metric.Float64Histogram
+
+	attrs  []attribute.KeyValue
+	setOpt metric.MeasurementOption
+}
+
+// NewInstrumentation returns instrumentation for a STDOUT trace exporter with
+// the provided ID using the global MeterProvider.
+//
+// If the experimental observability is disabled, nil is returned.
+func NewInstrumentation(id int64) (*Instrumentation, error) {
+	if !x.Observability.Enabled() {
+		return nil, nil
+	}
+
+	i := &Instrumentation{
+		attrs: []attribute.KeyValue{
+			semconv.OTelComponentName(ComponentName(id)),
+			semconv.OTelComponentTypeKey.String(ComponentType),
+		},
+	}
+
+	s := attribute.NewSet(i.attrs...)
+	i.setOpt = metric.WithAttributeSet(s)
+
+	mp := otel.GetMeterProvider()
+	m := mp.Meter(
+		ScopeName,
+		metric.WithInstrumentationVersion(Version),
+		metric.WithSchemaURL(SchemaURL),
+	)
+
+	var err error
+
+	inflightSpans, e := otelconv.NewSDKExporterSpanInflight(m)
+	if e != nil {
+		e = fmt.Errorf("failed to create span inflight metric: %w", e)
+		err = errors.Join(err, e)
+	}
+	i.inflightSpans = inflightSpans.Inst()
+
+	exportedSpans, e := otelconv.NewSDKExporterSpanExported(m)
+	if e != nil {
+		e = fmt.Errorf("failed to create span exported metric: %w", e)
+		err = errors.Join(err, e)
+	}
+	i.exportedSpans = exportedSpans.Inst()
+
+	opDuration, e := otelconv.NewSDKExporterOperationDuration(m)
+	if e != nil {
+		e = fmt.Errorf("failed to create operation duration metric: %w", e)
+		err = errors.Join(err, e)
+	}
+	i.opDuration = opDuration.Inst()
+
+	return i, err
+}
+
+// ExportSpans instruments the ExportSpans method of the exporter. It returns a
+// function that needs to be deferred so it is called when the method returns.
+func (i *Instrumentation) ExportSpans(ctx context.Context, nSpans int) ExportOp {
+	start := time.Now()
+
+	addOpt := get[metric.AddOption](addOptPool)
+	defer put(addOptPool, addOpt)
+	*addOpt = append(*addOpt, i.setOpt)
+	i.inflightSpans.Add(ctx, int64(nSpans), *addOpt...)
+
+	return ExportOp{
+		ctx:    ctx,
+		start:  start,
+		nSpans: int64(nSpans),
+		inst:   i,
+	}
+}
+
+// ExportOp is an in-progress ExportSpans operation.
+type ExportOp struct {
+	ctx    context.Context
+	start  time.Time
+	nSpans int64
+	inst   *Instrumentation
+}
+
+// End ends the ExportSpans operation, recording its success and duration.
+//
+// The success parameter indicates how many spans were successfully exported.
+// The err parameter indicates whether the operation failed. If err is not nil,
+// the number of failed spans (nSpans - success) is also recorded.
+func (e ExportOp) End(success int64, err error) {
+	addOpt := get[metric.AddOption](addOptPool)
+	defer put(addOptPool, addOpt)
+	*addOpt = append(*addOpt, e.inst.setOpt)
+
+	e.inst.inflightSpans.Add(e.ctx, -e.nSpans, *addOpt...)
+
+	// Record the success and duration of the operation.
+	//
+	// Do not exclude 0 values, as they are valid and indicate no spans
+	// were exported which is meaningful for certain aggregations.
+	e.inst.exportedSpans.Add(e.ctx, success, *addOpt...)
+
+	mOpt := e.inst.setOpt
+	if err != nil {
+		attrs := get[attribute.KeyValue](measureAttrsPool)
+		defer put(measureAttrsPool, attrs)
+		*attrs = append(*attrs, e.inst.attrs...)
+		*attrs = append(*attrs, semconv.ErrorType(err))
+
+		// Do not inefficiently make a copy of attrs by using
+		// WithAttributes instead of WithAttributeSet.
+		set := attribute.NewSet(*attrs...)
+		mOpt = metric.WithAttributeSet(set)
+
+		// Reset addOpt with new attribute set.
+		*addOpt = append((*addOpt)[:0], mOpt)
+
+		e.inst.exportedSpans.Add(e.ctx, e.nSpans-success, *addOpt...)
+	}
+
+	recordOpt := get[metric.RecordOption](recordOptPool)
+	defer put(recordOptPool, recordOpt)
+	*recordOpt = append(*recordOpt, mOpt)
+	e.inst.opDuration.Record(e.ctx, time.Since(e.start).Seconds(), *recordOpt...)
+}

vendor/go.opentelemetry.io/otel/exporters/stdout/stdouttrace/internal/version.go

@@ -0,0 +1,8 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package internal // import "go.opentelemetry.io/otel/exporters/stdout/stdouttrace/internal"
+
+// Version is the current release version of the OpenTelemetry stdouttrace
+// exporter in use.
+const Version = "1.39.0"

vendor/go.opentelemetry.io/otel/exporters/stdout/stdouttrace/internal/x/README.md

@@ -8,13 +8,13 @@ See the [Compatibility and Stability](#compatibility-and-stability) section for
 
 ## Features
 
-- [Self-Observability](#self-observability)
+- [Observability](#observability)
 
-### Self-Observability
+### Observability
 
-The `stdouttrace` exporter provides a self-observability feature that allows you to monitor the SDK itself.
+The `stdouttrace` exporter can be configured to provide observability about itself using OpenTelemetry metrics.
 
-To opt-in, set the environment variable `OTEL_GO_X_SELF_OBSERVABILITY` to `true`.
+To opt-in, set the environment variable `OTEL_GO_X_OBSERVABILITY` to `true`.
 
 When enabled, the SDK will create the following metrics using the global `MeterProvider`:
 

vendor/go.opentelemetry.io/otel/exporters/stdout/stdouttrace/internal/x/features.go

@@ -0,0 +1,23 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+// Package x documents experimental features for [go.opentelemetry.io/otel/exporters/stdout/stdouttrace].
+package x // import "go.opentelemetry.io/otel/exporters/stdout/stdouttrace/internal/x"
+
+import "strings"
+
+// Observability is an experimental feature flag that determines if exporter
+// observability metrics are enabled.
+//
+// To enable this feature set the OTEL_GO_X_OBSERVABILITY environment variable
+// to the case-insensitive string value of "true" (i.e. "True" and "TRUE"
+// will also enable this).
+var Observability = newFeature(
+	[]string{"OBSERVABILITY", "SELF_OBSERVABILITY"},
+	func(v string) (string, bool) {
+		if strings.EqualFold(v, "true") {
+			return v, true
+		}
+		return "", false
+	},
+)

vendor/go.opentelemetry.io/otel/exporters/stdout/stdouttrace/internal/x/x.go

@@ -1,3 +1,6 @@
+// Code generated by gotmpl. DO NOT MODIFY.
+// source: internal/shared/x/x.go.tmpl
+
 // Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -6,40 +9,30 @@ package x // import "go.opentelemetry.io/otel/exporters/stdout/stdouttrace/inter
 
 import (
 	"os"
-	"strings"
 )
 
-// SelfObservability is an experimental feature flag that determines if SDK
-// self-observability metrics are enabled.
-//
-// To enable this feature set the OTEL_GO_X_SELF_OBSERVABILITY environment variable
-// to the case-insensitive string value of "true" (i.e. "True" and "TRUE"
-// will also enable this).
-var SelfObservability = newFeature("SELF_OBSERVABILITY", func(v string) (string, bool) {
-	if strings.EqualFold(v, "true") {
-		return v, true
-	}
-	return "", false
-})
-
 // Feature is an experimental feature control flag. It provides a uniform way
 // to interact with these feature flags and parse their values.
 type Feature[T any] struct {
-	key   string
+	keys  []string
 	parse func(v string) (T, bool)
 }
 
-func newFeature[T any](suffix string, parse func(string) (T, bool)) Feature[T] {
+func newFeature[T any](suffix []string, parse func(string) (T, bool)) Feature[T] {
 	const envKeyRoot = "OTEL_GO_X_"
+	keys := make([]string, 0, len(suffix))
+	for _, s := range suffix {
+		keys = append(keys, envKeyRoot+s)
+	}
 	return Feature[T]{
-		key:   envKeyRoot + suffix,
+		keys:  keys,
 		parse: parse,
 	}
 }
 
-// Key returns the environment variable key that needs to be set to enable the
+// Keys returns the environment variable keys that can be set to enable the
 // feature.
-func (f Feature[T]) Key() string { return f.key }
+func (f Feature[T]) Keys() []string { return f.keys }
 
 // Lookup returns the user configured value for the feature and true if the
 // user has enabled the feature. Otherwise, if the feature is not enabled, a
@@ -49,11 +42,13 @@ func (f Feature[T]) Lookup() (v T, ok bool) {
 	//
 	// > The SDK MUST interpret an empty value of an environment variable the
 	// > same way as when the variable is unset.
-	vRaw := os.Getenv(f.key)
-	if vRaw == "" {
-		return v, ok
+	for _, key := range f.keys {
+		vRaw := os.Getenv(key)
+		if vRaw != "" {
+			return f.parse(vRaw)
+		}
 	}
-	return f.parse(vRaw)
+	return v, ok
 }
 
 // Enabled reports whether the feature is enabled.

vendor/go.opentelemetry.io/otel/exporters/stdout/stdouttrace/trace.go

@@ -11,23 +11,12 @@ import (
 	"sync"
 	"time"
 
-	"go.opentelemetry.io/otel"
-	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/exporters/stdout/stdouttrace/internal/counter"
-	"go.opentelemetry.io/otel/exporters/stdout/stdouttrace/internal/x"
-	"go.opentelemetry.io/otel/metric"
-	"go.opentelemetry.io/otel/sdk"
+	"go.opentelemetry.io/otel/exporters/stdout/stdouttrace/internal/observ"
 	"go.opentelemetry.io/otel/sdk/trace"
 	"go.opentelemetry.io/otel/sdk/trace/tracetest"
-	semconv "go.opentelemetry.io/otel/semconv/v1.37.0"
-	"go.opentelemetry.io/otel/semconv/v1.37.0/otelconv"
 )
 
-// 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/stdouttrace.Exporter"
-
 var zeroTime time.Time
 
 var _ trace.SpanExporter = &Exporter{}
@@ -46,39 +35,8 @@ func New(options ...Option) (*Exporter, error) {
 		timestamps: cfg.Timestamps,
 	}
 
-	if !x.SelfObservability.Enabled() {
-		return exporter, nil
-	}
-
-	exporter.selfObservabilityEnabled = true
-	exporter.selfObservabilityAttrs = []attribute.KeyValue{
-		semconv.OTelComponentName(fmt.Sprintf("%s/%d", otelComponentType, counter.NextExporterID())),
-		semconv.OTelComponentTypeKey.String(otelComponentType),
-	}
-	s := attribute.NewSet(exporter.selfObservabilityAttrs...)
-	exporter.selfObservabilitySetOpt = metric.WithAttributeSet(s)
-
-	mp := otel.GetMeterProvider()
-	m := mp.Meter(
-		"go.opentelemetry.io/otel/exporters/stdout/stdouttrace",
-		metric.WithInstrumentationVersion(sdk.Version()),
-		metric.WithSchemaURL(semconv.SchemaURL),
-	)
-
-	var err, e error
-	if exporter.spanInflightMetric, e = otelconv.NewSDKExporterSpanInflight(m); e != nil {
-		e = fmt.Errorf("failed to create span inflight metric: %w", e)
-		err = errors.Join(err, e)
-	}
-	if exporter.spanExportedMetric, e = otelconv.NewSDKExporterSpanExported(m); e != nil {
-		e = fmt.Errorf("failed to create span exported metric: %w", e)
-		err = errors.Join(err, e)
-	}
-	if exporter.operationDurationMetric, e = otelconv.NewSDKExporterOperationDuration(m); e != nil {
-		e = fmt.Errorf("failed to create operation duration metric: %w", e)
-		err = errors.Join(err, e)
-	}
-
+	var err error
+	exporter.inst, err = observ.NewInstrumentation(counter.NextExporterID())
 	return exporter, err
 }
 
@@ -91,107 +49,15 @@ type Exporter struct {
 	stoppedMu sync.RWMutex
 	stopped   bool
 
-	selfObservabilityEnabled bool
-	selfObservabilityAttrs   []attribute.KeyValue // selfObservability common attributes
-	selfObservabilitySetOpt  metric.MeasurementOption
-	spanInflightMetric       otelconv.SDKExporterSpanInflight
-	spanExportedMetric       otelconv.SDKExporterSpanExported
-	operationDurationMetric  otelconv.SDKExporterOperationDuration
+	inst *observ.Instrumentation
 }
 
-var (
-	measureAttrsPool = sync.Pool{
-		New: func() any {
-			// "component.name" + "component.type" + "error.type"
-			const n = 1 + 1 + 1
-			s := make([]attribute.KeyValue, 0, n)
-			// Return a pointer to a slice instead of a slice itself
-			// to avoid allocations on every call.
-			return &s
-		},
-	}
-
-	addOptPool = &sync.Pool{
-		New: func() any {
-			const n = 1 // WithAttributeSet
-			o := make([]metric.AddOption, 0, n)
-			return &o
-		},
-	}
-
-	recordOptPool = &sync.Pool{
-		New: func() any {
-			const n = 1 // WithAttributeSet
-			o := make([]metric.RecordOption, 0, n)
-			return &o
-		},
-	}
-)
-
 // ExportSpans writes spans in json format to stdout.
 func (e *Exporter) ExportSpans(ctx context.Context, spans []trace.ReadOnlySpan) (err error) {
 	var success int64
-	if e.selfObservabilityEnabled {
-		count := int64(len(spans))
-
-		addOpt := addOptPool.Get().(*[]metric.AddOption)
-		defer func() {
-			*addOpt = (*addOpt)[:0]
-			addOptPool.Put(addOpt)
-		}()
-
-		*addOpt = append(*addOpt, e.selfObservabilitySetOpt)
-
-		e.spanInflightMetric.Inst().Add(ctx, count, *addOpt...)
-		defer func(starting time.Time) {
-			e.spanInflightMetric.Inst().Add(ctx, -count, *addOpt...)
-
-			// Record the success and duration of the operation.
-			//
-			// Do not exclude 0 values, as they are valid and indicate no spans
-			// were exported which is meaningful for certain aggregations.
-			e.spanExportedMetric.Inst().Add(ctx, success, *addOpt...)
-
-			mOpt := e.selfObservabilitySetOpt
-			if err != nil {
-				// additional attributes for self-observability,
-				// only spanExportedMetric and operationDurationMetric are supported.
-				attrs := measureAttrsPool.Get().(*[]attribute.KeyValue)
-				defer func() {
-					*attrs = (*attrs)[:0] // reset the slice for reuse
-					measureAttrsPool.Put(attrs)
-				}()
-				*attrs = append(*attrs, e.selfObservabilityAttrs...)
-				*attrs = append(*attrs, semconv.ErrorType(err))
-
-				// Do not inefficiently make a copy of attrs by using
-				// WithAttributes instead of WithAttributeSet.
-				set := attribute.NewSet(*attrs...)
-				mOpt = metric.WithAttributeSet(set)
-
-				// Reset addOpt with new attribute set.
-				*addOpt = append((*addOpt)[:0], mOpt)
-
-				e.spanExportedMetric.Inst().Add(
-					ctx,
-					count-success,
-					*addOpt...,
-				)
-			}
-
-			recordOpt := recordOptPool.Get().(*[]metric.RecordOption)
-			defer func() {
-				*recordOpt = (*recordOpt)[:0]
-				recordOptPool.Put(recordOpt)
-			}()
-
-			*recordOpt = append(*recordOpt, mOpt)
-			e.operationDurationMetric.Inst().Record(
-				ctx,
-				time.Since(starting).Seconds(),
-				*recordOpt...,
-			)
-		}(time.Now())
+	if e.inst != nil {
+		op := e.inst.ExportSpans(ctx, len(spans))
+		defer func() { op.End(success, err) }()
 	}
 
 	if err := ctx.Err(); err != nil {

vendor/modules.txt

@@ -2370,10 +2370,12 @@ go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/observ
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/otlpconfig
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/retry
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/x
-# go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.38.0
-## explicit; go 1.23.0
+# go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.39.0
+## explicit; go 1.24.0
 go.opentelemetry.io/otel/exporters/stdout/stdouttrace
+go.opentelemetry.io/otel/exporters/stdout/stdouttrace/internal
 go.opentelemetry.io/otel/exporters/stdout/stdouttrace/internal/counter
+go.opentelemetry.io/otel/exporters/stdout/stdouttrace/internal/observ
 go.opentelemetry.io/otel/exporters/stdout/stdouttrace/internal/x
 # go.opentelemetry.io/otel/metric v1.39.0
 ## explicit; go 1.24.0