Statically define trace observability attributes (#7263)

There are a finite set of attributes that can be recorded with self
observability instruments. Cache these combinations to avoid computation
and allocations on the hot-path of tracing.

### Benchmarks

```console
$ benchstat main_25d02741f.txt cache-trace-obs-sets_05fd6ee.txt
goos: linux
goarch: amd64
pkg: go.opentelemetry.io/otel/sdk/trace
cpu: Intel(R) Core(TM) i7-8550U CPU @ 1.80GHz
                                      │ main_25d02741f.txt │  cache-trace-obs-sets_05fd6ee.txt   │
                                      │       sec/op       │   sec/op     vs base                │
SpanEnd/SelfObservabilityEnabled-8             366.2n ± 5%   229.2n ± 3%  -37.39% (p=0.000 n=10)
TraceStart/SelfObservabilityEnabled-8         1076.0n ± 2%   800.2n ± 2%  -25.63% (p=0.000 n=10)
geomean                                        627.7n        428.3n       -31.76%

                                      │ main_25d02741f.txt │  cache-trace-obs-sets_05fd6ee.txt  │
                                      │        B/op        │    B/op     vs base                │
SpanEnd/SelfObservabilityEnabled-8             192.00 ± 0%   64.00 ± 0%  -66.67% (p=0.000 n=10)
TraceStart/SelfObservabilityEnabled-8           992.0 ± 0%   608.0 ± 0%  -38.71% (p=0.000 n=10)
geomean                                         436.4        197.3       -54.80%

                                      │ main_25d02741f.txt │  cache-trace-obs-sets_05fd6ee.txt  │
                                      │     allocs/op      │ allocs/op   vs base                │
SpanEnd/SelfObservabilityEnabled-8              4.000 ± 0%   2.000 ± 0%  -50.00% (p=0.000 n=10)
TraceStart/SelfObservabilityEnabled-8           9.000 ± 0%   5.000 ± 0%  -44.44% (p=0.000 n=10)
geomean                                         6.000        3.162       -47.30%
```

Author: MrAlias

sdk/trace/span.go

@@ -21,7 +21,6 @@ import (
 	"go.opentelemetry.io/otel/sdk/instrumentation"
 	"go.opentelemetry.io/otel/sdk/resource"
 	semconv "go.opentelemetry.io/otel/semconv/v1.37.0"
-	"go.opentelemetry.io/otel/semconv/v1.37.0/otelconv"
 	"go.opentelemetry.io/otel/trace"
 	"go.opentelemetry.io/otel/trace/embedded"
 )
@@ -499,20 +498,11 @@ func (s *recordingSpan) End(options ...trace.SpanEndOption) {
 
 	if s.tracer.selfObservabilityEnabled {
 		defer func() {
-			// Determine the sampling result and create the corresponding attribute.
-			var attrSamplingResult attribute.KeyValue
-			if s.spanContext.IsSampled() {
-				attrSamplingResult = s.tracer.spanLiveMetric.AttrSpanSamplingResult(
-					otelconv.SpanSamplingResultRecordAndSample,
-				)
-			} else {
-				attrSamplingResult = s.tracer.spanLiveMetric.AttrSpanSamplingResult(otelconv.SpanSamplingResultRecordOnly)
-			}
-
 			// Add the span to the context to ensure the metric is recorded
 			// with the correct span context.
 			ctx := trace.ContextWithSpan(context.Background(), s)
-			s.tracer.spanLiveMetric.Add(ctx, -1, attrSamplingResult)
+			set := spanLiveSet(s.spanContext.IsSampled())
+			s.tracer.spanLiveMetric.AddSet(ctx, -1, set)
 		}()
 	}
 

sdk/trace/span_test.go

@@ -400,18 +400,42 @@ func BenchmarkRecordingSpanSetAttributes(b *testing.B) {
 }
 
 func BenchmarkSpanEnd(b *testing.B) {
-	tracer := NewTracerProvider().Tracer("")
+	cases := []struct {
+		name string
+		env  map[string]string
+	}{
+		{
+			name: "Default",
+		},
+		{
+			name: "SelfObservabilityEnabled",
+			env: map[string]string{
+				"OTEL_GO_X_SELF_OBSERVABILITY": "True",
+			},
+		},
+	}
+
 	ctx := trace.ContextWithSpanContext(context.Background(), trace.SpanContext{})
 
-	spans := make([]trace.Span, b.N)
-	for i := 0; i < b.N; i++ {
-		_, span := tracer.Start(ctx, "")
-		spans[i] = span
-	}
+	for _, c := range cases {
+		b.Run(c.name, func(b *testing.B) {
+			for k, v := range c.env {
+				b.Setenv(k, v)
+			}
+
+			tracer := NewTracerProvider().Tracer("")
+
+			spans := make([]trace.Span, b.N)
+			for i := 0; i < b.N; i++ {
+				_, span := tracer.Start(ctx, "")
+				spans[i] = span
+			}
 
-	b.ReportAllocs()
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		spans[i].End()
+			b.ReportAllocs()
+			b.ResetTimer()
+			for i := 0; i < b.N; i++ {
+				spans[i].End()
+			}
+		})
 	}
 }

sdk/trace/trace_test.go

@@ -2872,7 +2872,6 @@ func TestRecordOnlySampler(t *testing.T) {
 }
 
 func BenchmarkTraceStart(b *testing.B) {
-	tracer := NewTracerProvider().Tracer("")
 	ctx := trace.ContextWithSpanContext(context.Background(), trace.SpanContext{})
 
 	l1 := trace.Link{SpanContext: trace.SpanContext{}, Attributes: []attribute.KeyValue{}}
@@ -2882,6 +2881,7 @@ func BenchmarkTraceStart(b *testing.B) {
 
 	for _, tt := range []struct {
 		name    string
+		env     map[string]string
 		options []trace.SpanStartOption
 	}{
 		{
@@ -2902,8 +2902,20 @@ func BenchmarkTraceStart(b *testing.B) {
 				),
 			},
 		},
+		{
+			name: "SelfObservabilityEnabled",
+			env: map[string]string{
+				"OTEL_GO_X_SELF_OBSERVABILITY": "True",
+			},
+		},
 	} {
 		b.Run(tt.name, func(b *testing.B) {
+			for k, v := range tt.env {
+				b.Setenv(k, v)
+			}
+
+			tracer := NewTracerProvider().Tracer("")
+
 			spans := make([]trace.Span, b.N)
 			b.ReportAllocs()
 			b.ResetTimer()

sdk/trace/tracer.go

@@ -54,32 +54,9 @@ func (tr *tracer) Start(
 	s := tr.newSpan(ctx, name, &config)
 	newCtx := trace.ContextWithSpan(ctx, s)
 	if tr.selfObservabilityEnabled {
-		// Check if the span has a parent span and set the origin attribute accordingly.
-		var attrParentOrigin attribute.KeyValue
-		if psc := trace.SpanContextFromContext(ctx); psc.IsValid() {
-			if psc.IsRemote() {
-				attrParentOrigin = tr.spanStartedMetric.AttrSpanParentOrigin(otelconv.SpanParentOriginRemote)
-			} else {
-				attrParentOrigin = tr.spanStartedMetric.AttrSpanParentOrigin(otelconv.SpanParentOriginLocal)
-			}
-		} else {
-			attrParentOrigin = tr.spanStartedMetric.AttrSpanParentOrigin(otelconv.SpanParentOriginNone)
-		}
-
-		// Determine the sampling result and create the corresponding attribute.
-		var attrSamplingResult attribute.KeyValue
-		switch {
-		case s.SpanContext().IsSampled() && s.IsRecording():
-			attrSamplingResult = tr.spanStartedMetric.AttrSpanSamplingResult(
-				otelconv.SpanSamplingResultRecordAndSample,
-			)
-		case s.IsRecording():
-			attrSamplingResult = tr.spanStartedMetric.AttrSpanSamplingResult(otelconv.SpanSamplingResultRecordOnly)
-		default:
-			attrSamplingResult = tr.spanStartedMetric.AttrSpanSamplingResult(otelconv.SpanSamplingResultDrop)
-		}
-
-		tr.spanStartedMetric.Add(newCtx, 1, attrParentOrigin, attrSamplingResult)
+		psc := trace.SpanContextFromContext(ctx)
+		set := spanStartedSet(psc, s)
+		tr.spanStartedMetric.AddSet(newCtx, 1, set)
 	}
 
 	if rw, ok := s.(ReadWriteSpan); ok && s.IsRecording() {
@@ -192,20 +169,11 @@ func (tr *tracer) newRecordingSpan(
 	s.SetAttributes(config.Attributes()...)
 
 	if tr.selfObservabilityEnabled {
-		// Determine the sampling result and create the corresponding attribute.
-		var attrSamplingResult attribute.KeyValue
-		if s.spanContext.IsSampled() {
-			attrSamplingResult = tr.spanLiveMetric.AttrSpanSamplingResult(
-				otelconv.SpanSamplingResultRecordAndSample,
-			)
-		} else {
-			attrSamplingResult = tr.spanLiveMetric.AttrSpanSamplingResult(otelconv.SpanSamplingResultRecordOnly)
-		}
-
 		// Propagate any existing values from the context with the new span to
 		// the measurement context.
 		ctx = trace.ContextWithSpan(ctx, s)
-		tr.spanLiveMetric.Add(ctx, 1, attrSamplingResult)
+		set := spanLiveSet(s.spanContext.IsSampled())
+		tr.spanLiveMetric.AddSet(ctx, 1, set)
 	}
 
 	return s
@@ -215,3 +183,112 @@ func (tr *tracer) newRecordingSpan(
 func (tr *tracer) newNonRecordingSpan(sc trace.SpanContext) nonRecordingSpan {
 	return nonRecordingSpan{tracer: tr, sc: sc}
 }
+
+type parentState int
+
+const (
+	parentStateNoParent parentState = iota
+	parentStateLocalParent
+	parentStateRemoteParent
+)
+
+type samplingState int
+
+const (
+	samplingStateDrop samplingState = iota
+	samplingStateRecordOnly
+	samplingStateRecordAndSample
+)
+
+type spanStartedSetKey struct {
+	parent   parentState
+	sampling samplingState
+}
+
+var spanStartedSetCache = map[spanStartedSetKey]attribute.Set{
+	{parentStateNoParent, samplingStateDrop}: attribute.NewSet(
+		otelconv.SDKSpanStarted{}.AttrSpanParentOrigin(otelconv.SpanParentOriginNone),
+		otelconv.SDKSpanStarted{}.AttrSpanSamplingResult(otelconv.SpanSamplingResultDrop),
+	),
+	{parentStateLocalParent, samplingStateDrop}: attribute.NewSet(
+		otelconv.SDKSpanStarted{}.AttrSpanParentOrigin(otelconv.SpanParentOriginLocal),
+		otelconv.SDKSpanStarted{}.AttrSpanSamplingResult(otelconv.SpanSamplingResultDrop),
+	),
+	{parentStateRemoteParent, samplingStateDrop}: attribute.NewSet(
+		otelconv.SDKSpanStarted{}.AttrSpanParentOrigin(otelconv.SpanParentOriginRemote),
+		otelconv.SDKSpanStarted{}.AttrSpanSamplingResult(otelconv.SpanSamplingResultDrop),
+	),
+
+	{parentStateNoParent, samplingStateRecordOnly}: attribute.NewSet(
+		otelconv.SDKSpanStarted{}.AttrSpanParentOrigin(otelconv.SpanParentOriginNone),
+		otelconv.SDKSpanStarted{}.AttrSpanSamplingResult(otelconv.SpanSamplingResultRecordOnly),
+	),
+	{parentStateLocalParent, samplingStateRecordOnly}: attribute.NewSet(
+		otelconv.SDKSpanStarted{}.AttrSpanParentOrigin(otelconv.SpanParentOriginLocal),
+		otelconv.SDKSpanStarted{}.AttrSpanSamplingResult(otelconv.SpanSamplingResultRecordOnly),
+	),
+	{parentStateRemoteParent, samplingStateRecordOnly}: attribute.NewSet(
+		otelconv.SDKSpanStarted{}.AttrSpanParentOrigin(otelconv.SpanParentOriginRemote),
+		otelconv.SDKSpanStarted{}.AttrSpanSamplingResult(otelconv.SpanSamplingResultRecordOnly),
+	),
+
+	{parentStateNoParent, samplingStateRecordAndSample}: attribute.NewSet(
+		otelconv.SDKSpanStarted{}.AttrSpanParentOrigin(otelconv.SpanParentOriginNone),
+		otelconv.SDKSpanStarted{}.AttrSpanSamplingResult(otelconv.SpanSamplingResultRecordAndSample),
+	),
+	{parentStateLocalParent, samplingStateRecordAndSample}: attribute.NewSet(
+		otelconv.SDKSpanStarted{}.AttrSpanParentOrigin(otelconv.SpanParentOriginLocal),
+		otelconv.SDKSpanStarted{}.AttrSpanSamplingResult(otelconv.SpanSamplingResultRecordAndSample),
+	),
+	{parentStateRemoteParent, samplingStateRecordAndSample}: attribute.NewSet(
+		otelconv.SDKSpanStarted{}.AttrSpanParentOrigin(otelconv.SpanParentOriginRemote),
+		otelconv.SDKSpanStarted{}.AttrSpanSamplingResult(otelconv.SpanSamplingResultRecordAndSample),
+	),
+}
+
+func spanStartedSet(psc trace.SpanContext, span trace.Span) attribute.Set {
+	key := spanStartedSetKey{
+		parent:   parentStateNoParent,
+		sampling: samplingStateDrop,
+	}
+
+	if psc.IsValid() {
+		if psc.IsRemote() {
+			key.parent = parentStateRemoteParent
+		} else {
+			key.parent = parentStateLocalParent
+		}
+	}
+
+	if span.IsRecording() {
+		if span.SpanContext().IsSampled() {
+			key.sampling = samplingStateRecordAndSample
+		} else {
+			key.sampling = samplingStateRecordOnly
+		}
+	}
+
+	return spanStartedSetCache[key]
+}
+
+type spanLiveSetKey struct {
+	sampled bool
+}
+
+var spanLiveSetCache = map[spanLiveSetKey]attribute.Set{
+	{true}: attribute.NewSet(
+		otelconv.SDKSpanLive{}.AttrSpanSamplingResult(
+			otelconv.SpanSamplingResultRecordAndSample,
+		),
+	),
+	{false}: attribute.NewSet(
+		otelconv.SDKSpanLive{}.AttrSpanSamplingResult(
+			otelconv.SpanSamplingResultRecordOnly,
+		),
+	),
+}
+
+func spanLiveSet(sampled bool) attribute.Set {
+	key := spanLiveSetKey{sampled: sampled}
+	return spanLiveSetCache[key]
+}