ref(core): Remove otel-based suppressTracing implementation

packages/cloudflare/src/async.ts

@@ -69,16 +69,7 @@ export function setAsyncLocalStorageAsyncContextStrategy(): void {
     });
   }
 
-  // In contrast to the browser, we can rely on async context isolation here
-  function suppressTracing<T>(callback: () => T): T {
-    return withScope(scope => {
-      scope.setSDKProcessingMetadata({ __SENTRY_SUPPRESS_TRACING__: true });
-      return callback();
-    });
-  }
-
   setAsyncContextStrategy({
-    suppressTracing,
     withScope,
     withSetScope,
     withIsolationScope,

packages/core/src/asyncContext/stackStrategy.ts

@@ -1,6 +1,7 @@
 import type { Client } from '../client';
 import { getDefaultCurrentScope, getDefaultIsolationScope } from '../defaultScopes';
 import { Scope } from '../scope';
+import { SUPPRESS_TRACING_KEY } from '../tracing/constants';
 import { chainAndCopyPromiseLike } from '../utils/chain-and-copy-promiselike';
 import { isThenable } from '../utils/is';
 import { getMainCarrier, getSentryCarrier } from './../carrier';
@@ -148,6 +149,7 @@ function withIsolationScope<T>(callback: (isolationScope: Scope) => T): T {
  */
 export function getStackAsyncContextStrategy(): AsyncContextStrategy {
   return {
+    suppressTracing: suppressTracingInStack,
     withIsolationScope,
     withScope,
     withSetScope,
@@ -158,3 +160,19 @@ export function getStackAsyncContextStrategy(): AsyncContextStrategy {
     getIsolationScope: () => getAsyncContextStack().getIsolationScope(),
   };
 }
+
+/**
+ * In stack-based ACS, we do not wait for the callback to finish before we reset the metadata
+ * the reason for this is that otherwise, in the stack this can lead to very weird behavior
+ * as there is only a single top scope, if the callback takes longer to finish,
+ * other, unrelated spans may also be suppressed, which we do not want
+ * so instead, we only suppress tracing synchronoysly in the stack.
+ */
+function suppressTracingInStack<T>(callback: () => T): T {
+  return withScope(scope => {
+    scope.setSDKProcessingMetadata({ [SUPPRESS_TRACING_KEY]: true });
+    const res = callback();
+    scope.setSDKProcessingMetadata({ [SUPPRESS_TRACING_KEY]: undefined });
+    return res;
+  });
+}

packages/core/src/integrations/http/client-subscriptions.ts

@@ -18,10 +18,10 @@ import { addOutgoingRequestBreadcrumb } from './add-outgoing-request-breadcrumb'
 import {
   bindScopeToEmitter,
   getSpanStatusFromHttpCode,
+  isTracingSuppressed,
   SPAN_STATUS_ERROR,
   SPAN_STATUS_UNSET,
   startInactiveSpan,
-  SUPPRESS_TRACING_KEY,
   withActiveSpan,
 } from '../../tracing';
 import { debug } from '../../utils/debug-logger';
@@ -33,7 +33,7 @@ import type { HttpInstrumentationOptions, HttpClientRequest, HttpIncomingMessage
 import { DEBUG_BUILD } from '../../debug-build';
 import { LOG_PREFIX, HTTP_ON_CLIENT_REQUEST } from './constants';
 import type { ClientSubscriptionName } from './constants';
-import { getClient, getCurrentScope } from '../../currentScopes';
+import { getClient } from '../../currentScopes';
 import { hasSpansEnabled } from '../../utils/hasSpansEnabled';
 import { doubleWrapWarning } from './double-wrap-warning';
 
@@ -48,7 +48,7 @@ export function getHttpClientSubscriptions(options: HttpInstrumentationOptions):
   const onHttpClientRequestCreated: ChannelListener = (data: unknown): void => {
     // Skip all instrumentation if tracing is suppressed
     // (e.g., Sentry's own transport uses this to avoid self-instrumentation)
-    if (getCurrentScope().getScopeData().sdkProcessingMetadata[SUPPRESS_TRACING_KEY] === true) {
+    if (isTracingSuppressed()) {
       return;
     }
 

packages/core/src/tracing/constants.ts

@@ -0,0 +1 @@
+export const SUPPRESS_TRACING_KEY = '__SENTRY_SUPPRESS_TRACING__';

packages/core/src/tracing/index.ts

@@ -32,7 +32,6 @@ export {
   isTracingSuppressed,
   startNewTrace,
   spanIsIgnored,
-  SUPPRESS_TRACING_KEY,
 } from './trace';
 export { bindScopeToEmitter } from './bindScopeToEmitter';
 export {

packages/core/src/tracing/trace.ts

@@ -34,8 +34,7 @@ import { SentrySpan } from './sentrySpan';
 import { SPAN_STATUS_ERROR } from './spanstatus';
 import { setCapturedScopesOnSpan } from './utils';
 import type { Client } from '../client';
-
-export const SUPPRESS_TRACING_KEY = '__SENTRY_SUPPRESS_TRACING__';
+import { SUPPRESS_TRACING_KEY } from './constants';
 
 /**
  * Wraps a function with a transaction/span and finishes the span after the function is done.
@@ -293,15 +292,8 @@ export function suppressTracing<T>(callback: () => T): T {
   }
 
   return withScope(scope => {
-    // Note: We do not wait for the callback to finish before we reset the metadata
-    // the reason for this is that otherwise, in the browser this can lead to very weird behavior
-    // as there is only a single top scope, if the callback takes longer to finish,
-    // other, unrelated spans may also be suppressed, which we do not want
-    // so instead, we only suppress tracing synchronoysly in the browser
     scope.setSDKProcessingMetadata({ [SUPPRESS_TRACING_KEY]: true });
-    const res = callback();
-    scope.setSDKProcessingMetadata({ [SUPPRESS_TRACING_KEY]: undefined });
-    return res;
+    return callback();
   });
 }
 

packages/core/test/lib/integrations/http/client-subscriptions.test.ts

@@ -3,7 +3,7 @@ import * as breadcrumbModule from '../../../../src/integrations/http/add-outgoin
 import { HTTP_ON_CLIENT_REQUEST } from '../../../../src/integrations/http/constants';
 import { getHttpClientSubscriptions } from '../../../../src/integrations/http/client-subscriptions';
 import type { HttpClientRequest, HttpIncomingMessage } from '../../../../src/integrations/http/types';
-import { SUPPRESS_TRACING_KEY } from '../../../../src/tracing';
+import { SUPPRESS_TRACING_KEY } from '../../../../src/tracing/constants';
 import { getCurrentScope, withScope } from '../../../../src/currentScopes';
 
 function makeMockRequest(): HttpClientRequest & {

packages/core/test/lib/tracing/trace.test.ts

@@ -25,7 +25,6 @@ import {
   startInactiveSpan,
   startSpan,
   startSpanManual,
-  SUPPRESS_TRACING_KEY,
   suppressTracing,
   withActiveSpan,
 } from '../../../src/tracing';
@@ -37,6 +36,7 @@ import type { StartSpanOptions } from '../../../src/types/startSpanOptions';
 import { _setSpanForScope } from '../../../src/utils/spanOnScope';
 import { getActiveSpan, getRootSpan, getSpanDescendants, spanIsSampled } from '../../../src/utils/spanUtils';
 import { getDefaultTestClientOptions, TestClient } from '../../mocks/client';
+import { SUPPRESS_TRACING_KEY } from '../../../src/tracing/constants';
 
 const enum Type {
   Sync = 'sync',

packages/deno/src/async.ts

@@ -77,16 +77,7 @@ export function setAsyncLocalStorageAsyncContextStrategy(): void {
     });
   }
 
-  // In contrast to the browser, we can rely on async context isolation here
-  function suppressTracing<T>(callback: () => T): T {
-    return withScope(scope => {
-      scope.setSDKProcessingMetadata({ __SENTRY_SUPPRESS_TRACING__: true });
-      return callback();
-    });
-  }
-
   setAsyncContextStrategy({
-    suppressTracing,
     withScope,
     withSetScope,
     withIsolationScope,

packages/node/src/integrations/fs/index.ts

@@ -17,7 +17,13 @@ export const fsIntegration = defineIntegration((options: FsInstrumentationConfig
   return {
     name: INTEGRATION_NAME,
     setupOnce() {
-      enableFsInstrumentation(options);
+      // Defer patching `fs` by a tick. Integrations are set up during `Sentry.init` before the
+      // OpenTelemetry context manager is registered (which happens later in `initOpenTelemetry`). If we
+      // patched synchronously, `fs` operations that run during the remainder of init would go through
+      // our instrumentation while OpenTelemetry's `NoopContextManager` is still active - and there
+      // `suppressTracing` (which we call for every `fs` operation) cannot fork the scope, so it leaks
+      // the suppression flag onto the long-lived current scope and silently disables tracing.
+      setImmediate(() => enableFsInstrumentation(options));
     },
   };
 });

packages/opentelemetry/src/asyncContextStrategy.ts

@@ -11,7 +11,6 @@ import type { CurrentScopes } from './types';
 import { getContextFromScope, getScopesFromContext } from './utils/contextData';
 import { getActiveSpan } from './utils/getActiveSpan';
 import { getTraceData } from './utils/getTraceData';
-import { suppressTracing, isTracingSuppressed } from './utils/suppressTracing';
 
 /**
  * Sets the async context strategy to use follow the OTEL context under the hood.
@@ -103,8 +102,6 @@ export function setOpenTelemetryContextAsyncContextStrategy(options?: {
     startSpanManual,
     startInactiveSpan,
     getActiveSpan,
-    suppressTracing,
-    isTracingSuppressed,
     getTraceData,
     continueTrace,
     startNewTrace,

packages/opentelemetry/src/exports.ts

@@ -4,8 +4,6 @@ export { enhanceDscWithOpenTelemetryRootSpanName } from './utils/enhanceDscWithO
 
 export { getTraceContextForScope } from './trace';
 
-export { suppressTracing } from './utils/suppressTracing';
-
 export { setupEventContextTrace } from './setupEventContextTrace';
 
 // eslint-disable-next-line typescript/no-deprecated

packages/opentelemetry/src/propagator.ts

@@ -1,6 +1,6 @@
 import type { Baggage, Context, Span, SpanContext, TextMapGetter, TextMapSetter } from '@opentelemetry/api';
 import { context, INVALID_TRACEID, propagation, trace, TraceFlags } from '@opentelemetry/api';
-import { isTracingSuppressed, W3CBaggagePropagator } from '@opentelemetry/core';
+import { W3CBaggagePropagator } from '@opentelemetry/core';
 import { HTTP_URL, URL_FULL } from '@sentry/conventions/attributes';
 import type { Client, continueTrace, DynamicSamplingContext, Scope } from '@sentry/core';
 import {
@@ -27,6 +27,7 @@ import { getScopesFromContext, setScopesOnContext } from './utils/contextData';
 import { getSampledForPropagation, getSamplingDecision } from './utils/getSamplingDecision';
 import { makeTraceState } from './utils/makeTraceState';
 import { setIsSetup } from './utils/setupCheck';
+import { isTracingSuppressed } from './utils/suppressTracing';
 
 /**
  * Injects and extracts `sentry-trace` and `baggage` headers from carriers.

packages/opentelemetry/src/sampler.ts

@@ -32,6 +32,7 @@ import { getScopesFromContext } from './utils/contextData';
 import { getSamplingDecision } from './utils/getSamplingDecision';
 import { inferSpanData } from './utils/parseSpanDescription';
 import { setIsSetup } from './utils/setupCheck';
+import { isTracingSuppressed } from './utils/suppressTracing';
 
 /**
  * A custom OTEL sampler that uses Sentry sampling rates to make its decision
@@ -61,7 +62,10 @@ export class SentrySampler implements Sampler {
     const parentSpan = getValidSpan(context);
     const parentContext = parentSpan?.spanContext();
 
-    if (!hasSpansEnabled(options)) {
+    // When tracing is suppressed, we never want to record a span. The full OpenTelemetry `Tracer`
+    // relies on the sampler for this (unlike our `SentryTracer`, which short-circuits itself), so we
+    // enforce the scope-based suppression here as well.
+    if (isTracingSuppressed(context) || !hasSpansEnabled(options)) {
       return wrapSamplingDecision({ decision: undefined, context, spanAttributes });
     }
 

packages/opentelemetry/src/trace.ts

@@ -1,6 +1,5 @@
 import type { Context, Span, SpanContext, SpanOptions, TimeInput, Tracer } from '@opentelemetry/api';
 import { context, SpanStatusCode, trace, TraceFlags } from '@opentelemetry/api';
-import { isTracingSuppressed, suppressTracing } from '@opentelemetry/core';
 import type {
   Client,
   continueTrace as baseContinueTrace,
@@ -25,6 +24,7 @@ import {
   SEMANTIC_ATTRIBUTE_SENTRY_OP,
   spanToJSON,
   spanToTraceContext,
+  suppressTracing,
 } from '@sentry/core';
 import { continueTraceAsRemoteSpan } from './propagator';
 import type { OpenTelemetrySpanContext } from './types';
@@ -49,59 +49,44 @@ function _startSpan<T>(options: OpenTelemetrySpanContext, callback: (span: Span)
   return wrapper(() => {
     const activeCtx = getContext(options.scope, options.forceTransaction);
     const missingRequiredParent = options.onlyIfParent && !trace.getSpan(activeCtx);
-    const ctx = missingRequiredParent ? suppressTracing(activeCtx) : activeCtx;
 
     if (missingRequiredParent) {
       getClient()?.recordDroppedEvent('no_parent_span', '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 => {
-          patchSpanEnd(span);
-          // Restore the original unsuppressed context for the callback execution
-          // so that custom OpenTelemetry spans maintain the correct context.
-          // We use activeCtx (not ctx) because ctx may be suppressed when onlyIfParent is true
-          // and no parent span exists. Using activeCtx ensures custom OTel spans are never
-          // inadvertently suppressed.
-          return context.with(activeCtx, () => {
-            return handleCallbackErrors(
-              () => callback(span),
-              () => {
-                // Only set the span status to ERROR when there wasn't any error status set before, in order to avoid stomping useful span statuses
-                if (spanToJSON(span).status === 'ok') {
-                  span.setStatus({ code: SpanStatusCode.ERROR });
-                }
-              },
-              autoEnd ? () => span.end() : undefined,
-            );
-          });
-        });
+    const spansEnabled = hasSpansEnabled();
+
+    const startActiveSpan = (ctx: Context): T => {
+      return tracer.startActiveSpan(name, spanOptions, ctx, span => {
+        patchSpanEnd(span);
+        const runCallback = (): T =>
+          handleCallbackErrors(
+            () => callback(span),
+            () => {
+              // Only set the span status to ERROR when there wasn't any error status set before, in order to avoid stomping useful span statuses
+              if (spanToJSON(span).status === 'ok') {
+                span.setStatus({ code: SpanStatusCode.ERROR });
+              }
+            },
+            autoEnd ? () => span.end() : undefined,
+          );
+
+        // If spans are disabled, we suppress the span creation above but preserve the original,
+        // unsuppressed 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.
+        return spansEnabled ? runCallback() : context.with(activeCtx, runCallback);
       });
+    };
+
+    // We suppress tracing (making the span non-recording) when a required parent is missing, or when
+    // spans are disabled entirely. We rely on `@sentry/core`'s scope-based suppression for this.
+    if (missingRequiredParent || !spansEnabled) {
+      return context.with(activeCtx, () => suppressTracing(() => startActiveSpan(context.active())));
     }
 
-    return tracer.startActiveSpan(name, spanOptions, ctx, span => {
-      patchSpanEnd(span);
-      return handleCallbackErrors(
-        () => callback(span),
-        () => {
-          // Only set the span status to ERROR when there wasn't any error status set before, in order to avoid stomping useful span statuses
-          if (spanToJSON(span).status === 'ok') {
-            span.setStatus({ code: SpanStatusCode.ERROR });
-          }
-        },
-        autoEnd ? () => span.end() : undefined,
-      );
-    });
+    return startActiveSpan(activeCtx);
   });
 }
 
@@ -156,21 +141,26 @@ export function startInactiveSpan(options: OpenTelemetrySpanContext): Span {
   return wrapper(() => {
     const activeCtx = getContext(options.scope, options.forceTransaction);
     const missingRequiredParent = options.onlyIfParent && !trace.getSpan(activeCtx);
-    let ctx = missingRequiredParent ? suppressTracing(activeCtx) : activeCtx;
 
     if (missingRequiredParent) {
       getClient()?.recordDroppedEvent('no_parent_span', 'span');
     }
 
     const spanOptions = getSpanOptions(options);
 
-    if (!hasSpansEnabled()) {
-      ctx = isTracingSuppressed(ctx) ? ctx : suppressTracing(ctx);
+    const startSpan = (ctx: Context): Span => {
+      const span = tracer.startSpan(name, spanOptions, ctx);
+      patchSpanEnd(span);
+      return span;
+    };
+
+    // We suppress tracing (making the span non-recording) when a required parent is missing, or when
+    // spans are disabled entirely. We rely on `@sentry/core`'s scope-based suppression for this.
+    if (missingRequiredParent || !hasSpansEnabled()) {
+      return context.with(activeCtx, () => suppressTracing(() => startSpan(context.active())));
     }
 
-    const span = tracer.startSpan(name, spanOptions, ctx);
-    patchSpanEnd(span);
-    return span;
+    return startSpan(activeCtx);
   });
 }
 

packages/opentelemetry/src/tracer.ts

@@ -1,6 +1,5 @@
 import type { Context, Span as OpenTelemetrySpan, SpanOptions, Tracer } from '@opentelemetry/api';
 import { context, trace } from '@opentelemetry/api';
-import { isTracingSuppressed } from '@opentelemetry/core';
 import {
   _INTERNAL_safeMathRandom,
   _INTERNAL_setSpanForScope,
@@ -24,6 +23,7 @@ import type { Span, SpanAttributes, SpanLink } from '@sentry/core';
 import { applyOtelSpanData } from './applyOtelSpanData';
 import { SENTRY_FORK_SET_ISOLATION_SCOPE_CONTEXT_KEY, SENTRY_TRACE_STATE_DSC } from './constants';
 import { getSamplingDecision } from './utils/getSamplingDecision';
+import { isTracingSuppressed } from './utils/suppressTracing';
 import { SENTRY_KIND } from '@sentry/conventions/attributes';
 
 export class SentryTracer implements Tracer {