trace: SpanFromContext and SpanContextFromContext make no allocs (#5049)

pellared · pull[bot] · commit 57b25ae93893 · 2024-05-21T21:04:42.000Z
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -8,6 +8,10 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ## [Unreleased]
 
+### Changed
+
+- `SpanFromContext` and `SpanContextFromContext` in `go.opentelemetry.io/otel/trace` no longer make a heap allocation when the passed context has no span. (#5049)
+
 ### Fixed
 
 - Clarify the documentation about equivalence guarantees for the `Set` and `Distinct` types in `go.opentelemetry.io/otel/attribute`. (#5027)
diff --git a/trace/context.go b/trace/context.go
@@ -36,12 +36,12 @@ func ContextWithRemoteSpanContext(parent context.Context, rsc SpanContext) conte
 // performs no operations is returned.
 func SpanFromContext(ctx context.Context) Span {
 	if ctx == nil {
-		return noopSpan{}
+		return noopSpanInstance
 	}
 	if span, ok := ctx.Value(currentSpanKey).(Span); ok {
 		return span
 	}
-	return noopSpan{}
+	return noopSpanInstance
 }
 
 // SpanContextFromContext returns the current Span's SpanContext.
diff --git a/trace/context_test.go b/trace/context_test.go
@@ -77,6 +77,16 @@ func TestSpanFromContext(t *testing.T) {
 			// Ensure SpanContextFromContext is just
 			// SpanFromContext(…).SpanContext().
 			assert.Equal(t, tc.expectedSpan.SpanContext(), SpanContextFromContext(tc.context))
+
+			// Check that SpanFromContext does not produce any heap allocation.
+			assert.Equal(t, 0.0, testing.AllocsPerRun(5, func() {
+				SpanFromContext(tc.context)
+			}), "SpanFromContext allocs")
+
+			// Check that SpanContextFromContext does not produce any heap allocation.
+			assert.Equal(t, 0.0, testing.AllocsPerRun(5, func() {
+				SpanContextFromContext(tc.context)
+			}), "SpanContextFromContext allocs")
 		})
 	}
 }
diff --git a/trace/noop.go b/trace/noop.go
@@ -41,15 +41,15 @@ func (t noopTracer) Start(ctx context.Context, name string, _ ...SpanStartOption
 	span := SpanFromContext(ctx)
 	if _, ok := span.(nonRecordingSpan); !ok {
 		// span is likely already a noopSpan, but let's be sure
-		span = noopSpan{}
+		span = noopSpanInstance
 	}
 	return ContextWithSpan(ctx, span), span
 }
 
 // noopSpan is an implementation of Span that performs no operations.
 type noopSpan struct{ embedded.Span }
 
-var _ Span = noopSpan{}
+var noopSpanInstance Span = noopSpan{}
 
 // SpanContext returns an empty span context.
 func (noopSpan) SpanContext() SpanContext { return SpanContext{} }

Original file line number	Diff line number	Diff line change
`@@ -36,12 +36,12 @@ func ContextWithRemoteSpanContext(parent context.Context, rsc SpanContext) conte`
`36`	`36`	`// performs no operations is returned.`
`37`	`37`	`func SpanFromContext(ctx context.Context) Span {`
`38`	`38`	`if ctx == nil {`
`39`		`- return noopSpan{}`
	`39`	`+ return noopSpanInstance`
`40`	`40`	`}`
`41`	`41`	`if span, ok := ctx.Value(currentSpanKey).(Span); ok {`
`42`	`42`	`return span`
`43`	`43`	`}`
`44`		`- return noopSpan{}`
	`44`	`+ return noopSpanInstance`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`// SpanContextFromContext returns the current Span's SpanContext.`