feat(node)!: Default most SDKs to a no-tracer-provider setup

MIGRATION.md

@@ -82,6 +82,31 @@ Only `@sentry/nextjs` and `@sentry/sveltekit` still set up an OpenTelemetry comp
 
 This means you can run your own OpenTelemetry setup cleanly alongside Sentry without having Sentry spans leak into your pipeline anymore. Your OpenTelemetry setup will no longer be required to use Sentry components for exporting, context management and trace propagation.
 
+This behavior is controlled by the existing `skipOpenTelemetrySetup` option, whose default was flipped in v11. It now defaults to `true` for most server SDKs (including `@sentry/node`, `@sentry/bun`, the serverless SDKs, and `@sentry/cloudflare`) and to `false` for `@sentry/nextjs` and `@sentry/sveltekit`. When `true`, the SDK skips the tracer provider and isolates scopes with a native AsyncLocalStorage strategy; it still emits its own spans, but spans you create through `@opentelemetry/api` are not captured. Set it to `false` to have Sentry register its own `SentryTracerProvider` as the global OpenTelemetry tracer provider, so those `@opentelemetry/api` spans become Sentry spans:
+
+```js
+Sentry.init({
+  dsn: '__DSN__',
+  // Register Sentry's OpenTelemetry tracer provider so spans created via `@opentelemetry/api` are captured
+  skipOpenTelemetrySetup: false,
+});
+```
+
+Note that `skipOpenTelemetrySetup: false` makes Sentry the OpenTelemetry tracer provider. If you run your own tracer provider, keep `skipOpenTelemetrySetup: true` so Sentry does not register a competing provider. The SDK no longer ships a `SentrySpanProcessor` or other components to route your OpenTelemetry spans into Sentry, so spans from your own provider stay in your OpenTelemetry pipeline and are not sent to Sentry.
+
+In v10, setting `skipOpenTelemetrySetup: true` also turned Sentry's own HTTP and fetch spans off by default, on the assumption that your own OpenTelemetry `HttpInstrumentation` would emit them instead. That is no longer the case: Sentry now emits HTTP and fetch spans whenever tracing is enabled, regardless of `skipOpenTelemetrySetup`. If you run your own OpenTelemetry HTTP instrumentation alongside Sentry, disable Sentry's spans to avoid duplicates:
+
+```js
+Sentry.init({
+  dsn: '__DSN__',
+  integrations: [
+    // Let your own OpenTelemetry HttpInstrumentation own HTTP & fetch spans
+    Sentry.httpIntegration({ spans: false }),
+    Sentry.nativeNodeFetchIntegration({ spans: false }),
+  ],
+});
+```
+
 With this, we also heavily reduced our OpenTelemetry dependencies, with `@opentelemetry/api` being the only remaining package we abide by. These changes also mean `@sentry/node-core` no longer serves any purpose and was [merged back into `@sentry/node`](#sentrynode-core-was-merged-back-into-sentrynode).
 
 For most users, day-to-day tracing is **unchanged**.

dev-packages/cloudflare-integration-tests/suites/tracing/vercelai/v6/index.ts

@@ -11,6 +11,9 @@ export default Sentry.withSentry(
     dsn: env.SENTRY_DSN,
     traceLifecycle: 'static',
     tracesSampleRate: 1,
+    // The Vercel AI SDK emits its spans through `@opentelemetry/api`, so they are only picked up when
+    // the Cloudflare OpenTelemetry tracer provider is set up.
+    skipOpenTelemetrySetup: false,
   }),
   {
     async fetch(_request, _env, _ctx) {

dev-packages/e2e-tests/test-applications/nestjs-basic/package.json

@@ -44,5 +44,14 @@
   },
   "volta": {
     "extends": "../../package.json"
+  },
+  "sentryTest": {
+    "variants": [
+      {
+        "build-command": "E2E_TEST_OTEL_SETUP=true pnpm test:build",
+        "assert-command": "E2E_TEST_OTEL_SETUP=true pnpm test:assert",
+        "label": "nestjs-basic (tracer provider)"
+      }
+    ]
   }
 }

dev-packages/e2e-tests/test-applications/nestjs-basic/src/instrument.ts

@@ -10,4 +10,7 @@ Sentry.init({
     // We expect the app to send a lot of events in a short time
     bufferSize: 1000,
   },
+  // Opt into the Sentry OpenTelemetry tracer provider in the "(tracer provider)" e2e variant.
+  // Leaving it `undefined` otherwise keeps the SDK's default (no provider).
+  skipOpenTelemetrySetup: process.env.E2E_TEST_OTEL_SETUP === 'true' ? false : undefined,
 });

dev-packages/e2e-tests/test-applications/node-express/package.json

@@ -31,5 +31,14 @@
   },
   "volta": {
     "extends": "../../package.json"
+  },
+  "sentryTest": {
+    "variants": [
+      {
+        "build-command": "E2E_TEST_OTEL_SETUP=true pnpm test:build",
+        "assert-command": "E2E_TEST_OTEL_SETUP=true pnpm test:assert",
+        "label": "node-express (tracer provider)"
+      }
+    ]
   }
 }

dev-packages/e2e-tests/test-applications/node-express/src/app.ts

@@ -14,6 +14,9 @@ Sentry.init({
   debug: !!process.env.DEBUG,
   tunnel: `http://localhost:3031/`, // proxy server
   tracesSampleRate: 1,
+  // Opt into the Sentry OpenTelemetry tracer provider in the "(tracer provider)" e2e variant.
+  // Leaving it `undefined` otherwise keeps the SDK's default (no provider).
+  skipOpenTelemetrySetup: process.env.E2E_TEST_OTEL_SETUP === 'true' ? false : undefined,
   integrations: [
     Sentry.nativeNodeFetchIntegration({
       headersToSpanAttributes: {

dev-packages/e2e-tests/test-applications/node-fastify-5/package.json

@@ -25,5 +25,14 @@
   },
   "volta": {
     "extends": "../../package.json"
+  },
+  "sentryTest": {
+    "variants": [
+      {
+        "build-command": "E2E_TEST_OTEL_SETUP=true pnpm test:build",
+        "assert-command": "E2E_TEST_OTEL_SETUP=true pnpm test:assert",
+        "label": "node-fastify-5 (tracer provider)"
+      }
+    ]
   }
 }

dev-packages/e2e-tests/test-applications/node-fastify-5/src/app.ts

@@ -38,6 +38,9 @@ Sentry.init({
   tracesSampleRate: 1,
   tunnel: 'http://localhost:3031/', // proxy server
   tracePropagationTargets: ['http://localhost:3030', '/external-allowed'],
+  // Opt into the Sentry OpenTelemetry tracer provider in the "(tracer provider)" e2e variant.
+  // Leaving it `undefined` otherwise keeps the SDK's default (no provider).
+  skipOpenTelemetrySetup: process.env.E2E_TEST_OTEL_SETUP === 'true' ? false : undefined,
 });
 
 import type * as H from 'http';

dev-packages/e2e-tests/test-applications/nuxt-4/package.json

@@ -33,6 +33,13 @@
     "node": "22.20.0"
   },
   "sentryTest": {
+    "variants": [
+      {
+        "build-command": "E2E_TEST_OTEL_SETUP=true pnpm test:build",
+        "assert-command": "E2E_TEST_OTEL_SETUP=true pnpm test:assert",
+        "label": "nuxt-4 (tracer provider)"
+      }
+    ],
     "optionalVariants": [
       {
         "build-command": "pnpm test:build-canary",

dev-packages/e2e-tests/test-applications/nuxt-4/sentry.server.config.ts

@@ -5,4 +5,7 @@ Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   tracesSampleRate: 1.0, //  Capture 100% of the transactions
   tunnel: 'http://localhost:3031/', // proxy server
+  // Opt into the Sentry OpenTelemetry tracer provider in the "(tracer provider)" e2e variant.
+  // Leaving it `undefined` otherwise keeps the SDK's default (no provider).
+  skipOpenTelemetrySetup: process.env.E2E_TEST_OTEL_SETUP === 'true' ? false : undefined,
 });

dev-packages/node-integration-tests/suites/tracing/http-client-spans/http-otel-double-instrumentation/instrument-mitigation.mjs

@@ -7,6 +7,8 @@ Sentry.init({
   release: '1.0',
   tracesSampleRate: 1.0,
   transport: loggingTransport,
+  // The user-owned OTel HttpInstrumentation's spans reach Sentry through the tracer provider.
+  skipOpenTelemetrySetup: false,
   integrations: [
     // Disable Sentry's span creation so that OTel HttpInstrumentation
     // is the only source of http.client spans. Breadcrumbs and

dev-packages/node-integration-tests/suites/tracing/http-client-spans/http-otel-double-instrumentation/instrument.mjs

@@ -8,6 +8,9 @@ Sentry.init({
   tracesSampleRate: 1.0,
   transport: loggingTransport,
   debug: true,
+  // This suite exercises coexistence with a user-owned OTel HttpInstrumentation whose spans reach
+  // Sentry through the tracer provider, so it must run with the provider enabled.
+  skipOpenTelemetrySetup: false,
 });
 
 // Simulate a user who independently sets up OTel HttpInstrumentation

dev-packages/node-integration-tests/suites/tracing/tracer-start-active-span-error/instrument.mjs

@@ -6,4 +6,7 @@ Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   tracesSampleRate: 1.0,
   transport: loggingTransport,
+  // This suite drives the raw OpenTelemetry tracer (`client.tracer.startActiveSpan`), which only
+  // produces spans when Sentry owns the tracer provider.
+  skipOpenTelemetrySetup: false,
 });

packages/cloudflare/src/baseSdk.ts

@@ -96,6 +96,9 @@ export function initWithDefaultIntegrations(
     stackParser: stackParserFromStackParserOptions(options.stackParser || defaultStackParser),
     integrations: getIntegrationsToSetup(options),
     transport: options.transport || makeCloudflareTransport,
+    // Like most Node-based SDKs, Cloudflare defaults to running without a Sentry OpenTelemetry tracer
+    // provider. Scope isolation is handled by the entrypoint wrappers' AsyncLocalStorage strategy.
+    skipOpenTelemetrySetup: options.skipOpenTelemetrySetup ?? true,
     flushLock,
   };
 
@@ -109,14 +112,9 @@ export function initWithDefaultIntegrations(
   }
   /*! rollup-include-development-only-end */
 
-  /**
-   * The Cloudflare SDK is not OpenTelemetry native, however, we set up some OpenTelemetry compatibility
-   * via a custom trace provider.
-   * This ensures that any spans emitted via `@opentelemetry/api` will be captured by Sentry.
-   * HOWEVER, big caveat: This does not handle custom context handling, it will always work off the current scope.
-   * This should be good enough for many, but not all integrations.
-   */
-  if (!options.skipOpenTelemetrySetup) {
+  // Opt-in only: when `skipOpenTelemetrySetup` is `false`, set up a custom trace provider so spans
+  // emitted via `@opentelemetry/api` are captured by Sentry. See the option's docs for the caveats.
+  if (!clientOptions.skipOpenTelemetrySetup) {
     setupOpenTelemetryTracer();
   }
 

packages/cloudflare/src/client.ts

@@ -175,15 +175,15 @@ interface BaseCloudflareOptions {
   enableDedupe?: boolean;
 
   /**
-   * The Cloudflare SDK is not OpenTelemetry native, however, we set up some OpenTelemetry compatibility
-   * via a custom trace provider.
-   * This ensures that any spans emitted via `@opentelemetry/api` will be captured by Sentry.
-   * HOWEVER, big caveat: This does not handle custom context handling, it will always work off the current scope.
-   * This should be good enough for many, but not all integrations.
+   * The Cloudflare SDK is not OpenTelemetry native. By default (`true`) it does not set up a tracer
+   * provider; spans are emitted via the SDK's own instrumentation and scopes are isolated with
+   * AsyncLocalStorage.
    *
-   * If you want to opt-out of setting up the OpenTelemetry compatibility tracer, set this to `true`.
+   * Set this to `false` to opt into the OpenTelemetry compatibility tracer, which captures spans
+   * emitted via `@opentelemetry/api`. Big caveat: it does not handle custom context, always working
+   * off the current scope. This is good enough for many, but not all, integrations.
    *
-   * @default false
+   * @default true
    */
   skipOpenTelemetrySetup?: boolean;
 

packages/cloudflare/test/opentelemetry.test.ts

@@ -48,6 +48,7 @@ describe('opentelemetry compatibility', () => {
       dsn: 'https://username@domain/123',
       tracesSampleRate: 1,
       traceLifecycle: 'static',
+      skipOpenTelemetrySetup: false,
       beforeSendTransaction: event => {
         transactionEvents.push(event);
         return null;
@@ -109,6 +110,7 @@ describe('opentelemetry compatibility', () => {
       dsn: 'https://username@domain/123',
       tracesSampleRate: 1,
       traceLifecycle: 'static',
+      skipOpenTelemetrySetup: false,
       beforeSendTransaction: event => {
         transactionEvents.push(event);
         return null;
@@ -153,6 +155,7 @@ describe('opentelemetry compatibility', () => {
       dsn: 'https://username@domain/123',
       tracesSampleRate: 1,
       traceLifecycle: 'static',
+      skipOpenTelemetrySetup: false,
       beforeSendTransaction: event => {
         transactionEvents.push(event);
         return null;
@@ -181,6 +184,7 @@ describe('opentelemetry compatibility', () => {
       dsn: 'https://username@domain/123',
       tracesSampleRate: 1,
       traceLifecycle: 'static',
+      skipOpenTelemetrySetup: false,
       beforeSendTransaction: event => {
         transactionEvents.push(event);
         return null;

packages/nextjs/src/server/index.ts

@@ -146,6 +146,9 @@ export function init(options: NodeOptions): NodeClient | undefined {
     environment: options.environment || process.env.SENTRY_ENVIRONMENT || getVercelEnv(false) || process.env.NODE_ENV,
     release: process.env._sentryRelease || globalWithInjectedValues._sentryRelease,
     defaultIntegrations: customDefaultIntegrations,
+    // Next.js emits its own OpenTelemetry spans, so it defaults to registering the Sentry tracer
+    // provider (unlike most Node-based SDKs). A user-provided value still overrides this via `...options`.
+    skipOpenTelemetrySetup: false,
     ...options,
     // Override runtime to 'cloudflare' when running on OpenNext/Cloudflare
     ...cloudflareConfig,

packages/node-native/src/event-loop-block-integration.ts

@@ -79,7 +79,11 @@ function startPolling(
 ): IntegrationInternal | undefined {
   if (client.asyncLocalStorageLookup) {
     const { asyncLocalStorage, contextSymbol } = client.asyncLocalStorageLookup;
-    registerThread({ asyncLocalStorage, stateLookup: ['_currentContext', contextSymbol] });
+    // With the OpenTelemetry context strategy, scopes live under `contextSymbol` on the OTel context
+    // (`store._currentContext[contextSymbol]`). The pure AsyncLocalStorage strategy omits it because
+    // its store already is the `{ scope, isolationScope }` object, so no traversal is needed.
+    const stateLookup = contextSymbol ? ['_currentContext', contextSymbol] : [];
+    registerThread({ asyncLocalStorage, stateLookup });
   } else {
     registerThread();
   }

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

@@ -32,7 +32,7 @@ interface HttpOptions {
    * This will ensure that the default HttpInstrumentation from OpenTelemetry is not setup,
    * only the Sentry-specific instrumentation for request isolation is applied.
    *
-   * If `skipOpenTelemetrySetup: true` is configured, this defaults to `false`, otherwise it defaults to `true`.
+   * Defaults to `true` when tracing is enabled.
    */
   spans?: boolean;
 
@@ -55,8 +55,8 @@ interface HttpOptions {
    * Whether to inject trace propagation headers (sentry-trace, baggage, traceparent) into outgoing HTTP requests.
    *
    * When set to `false`, Sentry will not inject any trace propagation headers, but will still create breadcrumbs
-   * (if `breadcrumbs` is enabled). This is useful when `skipOpenTelemetrySetup: true` is configured and you want
-   * to avoid duplicate trace headers being injected by both Sentry and OpenTelemetry's HttpInstrumentation.
+   * (if `breadcrumbs` is enabled). This is useful when you run your own OpenTelemetry `HttpInstrumentation` and
+   * want to avoid duplicate trace headers being injected by both Sentry and OpenTelemetry.
    *
    * @default `true`
    */

packages/node/src/integrations/node-fetch/index.ts

@@ -24,7 +24,7 @@ const _nativeNodeFetchIntegration = ((options: NodeFetchOptions = {}) => {
 export const nativeNodeFetchIntegration = defineIntegration(_nativeNodeFetchIntegration);
 
 function _shouldInstrumentSpans(options: NodeFetchOptions, clientOptions: Partial<NodeClientOptions> = {}): boolean {
-  // If `spans` is passed in, it takes precedence
-  // Else, we by default emit spans, unless `skipOpenTelemetrySetup` is set to `true` or spans are not enabled
-  return options.spans ?? (!clientOptions.skipOpenTelemetrySetup && hasSpansEnabled(clientOptions));
+  // If `spans` is passed in, it takes precedence. Otherwise emit spans whenever tracing is enabled;
+  // fetch instrumentation is channel-based and does not depend on a Sentry OpenTelemetry tracer provider.
+  return options.spans ?? hasSpansEnabled(clientOptions);
 }

packages/node/src/integrations/node-fetch/types.ts

@@ -106,7 +106,7 @@ export interface NodeFetchOptions extends UndiciInstrumentationConfig {
    * If set to false, do not emit any spans.
    * Breadcrumbs and trace propagation for outgoing fetch requests are still applied.
    *
-   * If `skipOpenTelemetrySetup: true` is configured, this defaults to `false`, otherwise it defaults to `true`.
+   * Defaults to `true` when tracing is enabled.
    */
   spans?: boolean;
 

packages/node/src/sdk/index.ts

@@ -16,6 +16,7 @@ import {
   stackParserFromStackParserOptions,
 } from '@sentry/core';
 import { setOpenTelemetryContextAsyncContextStrategy, setupEventContextTrace } from '@sentry/opentelemetry';
+import { setAsyncLocalStorageAsyncContextStrategy } from '@sentry/server-utils';
 import { isMainThread, parentPort } from 'node:worker_threads';
 import { detectOrchestrionSetup } from '@sentry/server-utils/orchestrion';
 import { registerDiagnosticsChannelInjection } from '@sentry/server-utils/orchestrion/register';
@@ -40,7 +41,7 @@ import { getEntryPointType } from '../utils/entry-point';
 import { getSpotlightConfig } from '../utils/spotlight';
 import { defaultStackParser, getSentryRelease } from './api';
 import { NodeClient } from './client';
-import { initOpenTelemetry } from './initOtel';
+import { initOpenTelemetry, setupSpanDataBackfill } from './initOtel';
 
 /**
  * Get the base default integrations shared by all Node SDK default-integration sets.
@@ -171,7 +172,18 @@ function _init(
 
   const clientOptions = getClientOptions({ ...options, defaultIntegrations }, getDefaultIntegrationsImpl);
 
-  const asyncLocalStorageLookup = setOpenTelemetryContextAsyncContextStrategy();
+  // When Sentry does not own an OpenTelemetry tracer provider, scope isolation runs on a pure
+  // AsyncLocalStorage strategy instead of the OpenTelemetry context strategy. Instrumentation still
+  // emits spans via core `startSpan`; there is just no OTel provider or propagator behind them.
+  let asyncLocalStorageLookup: ReturnType<typeof setOpenTelemetryContextAsyncContextStrategy> | undefined;
+  if (clientOptions.skipOpenTelemetrySetup) {
+    // The ALS store already is the `{ scope, isolationScope }` object, so no `contextSymbol` is needed
+    // to reach it (unlike the OTel context strategy, where it is nested under the OTel context).
+    const asyncLocalStorage = setAsyncLocalStorageAsyncContextStrategy();
+    asyncLocalStorageLookup = { asyncLocalStorage };
+  } else {
+    asyncLocalStorageLookup = setOpenTelemetryContextAsyncContextStrategy();
+  }
 
   const scope = getCurrentScope();
   scope.update(clientOptions.initialScope);
@@ -202,8 +214,6 @@ function _init(
 
   updateScopeFromEnvVariables();
 
-  setupEventContextTrace(client);
-
   // Ensure we flush events when vercel functions are ended
   // See: https://vercel.com/docs/functions/functions-api-reference#sigterm-signal
   if (process.env.VERCEL) {
@@ -213,8 +223,16 @@ function _init(
     });
   }
 
-  // Add Node SDK specific OpenTelemetry setup
+  // Channel-based instrumentation emits spans via core `startSpan` in every mode, so always backfill
+  // the Sentry-convention span data (e.g. `sentry.op`) the OTel provider pipeline would otherwise
+  // derive. It is idempotent, so it is a no-op for spans the provider already enriches.
+  setupSpanDataBackfill(client);
+
+  // Add Node SDK specific OpenTelemetry setup. `setupEventContextTrace` reads the active span from the
+  // OpenTelemetry context, so it only belongs here: without a Sentry tracer provider a foreign OTel
+  // span could otherwise override the Sentry trace on error events.
   if (!clientOptions.skipOpenTelemetrySetup) {
+    setupEventContextTrace(client);
     initOpenTelemetry(client);
   }
 
@@ -249,6 +267,9 @@ function getClientOptions(
     tracesSampleRate,
     spotlight,
     traceLifecycle,
+    // Most Node-based SDKs default to running without a Sentry OpenTelemetry tracer provider. SDKs
+    // that need OTel spans surfaced in Sentry (nextjs, sveltekit) opt back in by passing `false`.
+    skipOpenTelemetrySetup: options.skipOpenTelemetrySetup ?? true,
     debug: envToBool(options.debug ?? process.env.SENTRY_DEBUG),
   };