fix(opentelemetry): Ensure Sentry spans don't leak when tracing is disabled

Currently, when using Sentry alongside a custom OpenTelemetry setup, any spans
started via our Sentry.startSpanX apis leak into the OpenTelemetry setup even if
tracing is disabled.

This fix suppresses tracing for span creation via our startSpanX apis but
ensures tracing is not suppressed within the callback so that for example custom
OTel spans created within Sentry.startSpanX calls are not suppresed.

Closes: #17826

Author: andreiborza

packages/opentelemetry/src/trace.ts

@@ -1,6 +1,6 @@
 import type { Context, Span, SpanContext, SpanOptions, Tracer } from '@opentelemetry/api';
 import { context, SpanStatusCode, trace, TraceFlags } from '@opentelemetry/api';
-import { suppressTracing } from '@opentelemetry/core';
+import { isTracingSuppressed, suppressTracing } from '@opentelemetry/core';
 import type {
   Client,
   continueTrace as baseContinueTrace,
@@ -17,6 +17,7 @@ import {
   getRootSpan,
   getTraceContextFromScope,
   handleCallbackErrors,
+  hasSpansEnabled,
   SDK_VERSION,
   SEMANTIC_ATTRIBUTE_SENTRY_OP,
   spanToJSON,
@@ -53,6 +54,34 @@ export function startSpan<T>(options: OpenTelemetrySpanContext, callback: (span:
 
     const spanOptions = getSpanOptions(options);
 
+    // If spans are not enabled, ensure we suppress tracing for the span creation
+    // but preserve the original context for the callback execution
+    // This ensures that we don't create spans when tracing is disabled which
+    // would otherwise be a problem for users that don't enable tracing but use
+    // custom OpenTelemetry setups.
+    if (!hasSpansEnabled()) {
+      const suppressedCtx = isTracingSuppressed(ctx) ? ctx : suppressTracing(ctx);
+
+      return context.with(suppressedCtx, () => {
+        return tracer.startActiveSpan(name, spanOptions, suppressedCtx, span => {
+          // Restore the original context for the callback execution
+          // so that custom OpenTelemetry spans maintain the correct context
+          return context.with(ctx, () => {
+            return handleCallbackErrors(
+              () => callback(span),
+              () => {
+                // Only set the span status to ERROR when there wasn't any status set before, in order to avoid stomping useful span statuses
+                if (spanToJSON(span).status === undefined) {
+                  span.setStatus({ code: SpanStatusCode.ERROR });
+                }
+              },
+              () => span.end(),
+            );
+          });
+        });
+      });
+    }
+
     return tracer.startActiveSpan(name, spanOptions, ctx, span => {
       return handleCallbackErrors(
         () => callback(span),
@@ -96,6 +125,33 @@ export function startSpanManual<T>(
 
     const spanOptions = getSpanOptions(options);
 
+    if (!hasSpansEnabled()) {
+      // If spans are not enabled, ensure we suppress tracing for the span creation
+      // but preserve the original context for the callback execution
+      // This ensures that we don't create spans when tracing is disabled which
+      // would otherwise be a problem for users that don't enable tracing but use
+      // custom OpenTelemetry setups.
+      const suppressedCtx = isTracingSuppressed(ctx) ? ctx : suppressTracing(ctx);
+
+      return context.with(suppressedCtx, () => {
+        return tracer.startActiveSpan(name, spanOptions, suppressedCtx, span => {
+          // Restore the original context for the callback execution
+          // so that custom OpenTelemetry spans maintain the correct context
+          return context.with(ctx, () => {
+            return handleCallbackErrors(
+              () => callback(span, () => span.end()),
+              () => {
+                // Only set the span status to ERROR when there wasn't any status set before, in order to avoid stomping useful span statuses
+                if (spanToJSON(span).status === undefined) {
+                  span.setStatus({ code: SpanStatusCode.ERROR });
+                }
+              },
+            );
+          });
+        });
+      });
+    }
+
     return tracer.startActiveSpan(name, spanOptions, ctx, span => {
       return handleCallbackErrors(
         () => callback(span, () => span.end()),
@@ -134,9 +190,12 @@ export function startInactiveSpan(options: OpenTelemetrySpanContext): Span {
 
     const spanOptions = getSpanOptions(options);
 
-    const span = tracer.startSpan(name, spanOptions, ctx);
+    if (!hasSpansEnabled()) {
+      const suppressedCtx = isTracingSuppressed(ctx) ? ctx : suppressTracing(ctx);
+      return tracer.startSpan(name, spanOptions, suppressedCtx);
+    }
 
-    return span;
+    return tracer.startSpan(name, spanOptions, ctx);
   });
 }
 

packages/opentelemetry/test/trace.test.ts

@@ -1388,6 +1388,55 @@ describe('trace (tracing disabled)', () => {
   });
 });
 
+describe('trace (spans disabled)', () => {
+  beforeEach(() => {
+    // Initialize SDK without any tracing configuration (no tracesSampleRate or tracesSampler)
+    mockSdkInit({ tracesSampleRate: undefined, tracesSampler: undefined });
+  });
+
+  afterEach(async () => {
+    await cleanupOtel();
+  });
+
+  it('startSpan creates non-recording spans when hasSpansEnabled() === false', () => {
+    const val = startSpan({ name: 'outer' }, outerSpan => {
+      expect(outerSpan).toBeDefined();
+      expect(outerSpan.isRecording()).toBe(false);
+
+      // Nested spans should also be non-recording
+      return startSpan({ name: 'inner' }, innerSpan => {
+        expect(innerSpan).toBeDefined();
+        expect(innerSpan.isRecording()).toBe(false);
+        return 'test value';
+      });
+    });
+
+    expect(val).toEqual('test value');
+  });
+
+  it('startSpanManual creates non-recording spans when hasSpansEnabled() === false', () => {
+    const val = startSpanManual({ name: 'outer' }, outerSpan => {
+      expect(outerSpan).toBeDefined();
+      expect(outerSpan.isRecording()).toBe(false);
+
+      return startSpanManual({ name: 'inner' }, innerSpan => {
+        expect(innerSpan).toBeDefined();
+        expect(innerSpan.isRecording()).toBe(false);
+        return 'test value';
+      });
+    });
+
+    expect(val).toEqual('test value');
+  });
+
+  it('startInactiveSpan returns non-recording spans when hasSpansEnabled() === false', () => {
+    const span = startInactiveSpan({ name: 'test' });
+
+    expect(span).toBeDefined();
+    expect(span.isRecording()).toBe(false);
+  });
+});
+
 describe('trace (sampling)', () => {
   afterEach(async () => {
     await cleanupOtel();