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

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.

I update the `node-otel-without-tracing` e2e tests to reflect that no
Sentry spans leak into the OTLP endpoint, as well as trying this out
locally with an express app and Jaeger.

**Before** the fix, Sentry span leaks:
<img width="2608" height="1578" alt="Screenshot 2025-11-24 at 20 35 21"
src="https://github.com/user-attachments/assets/45284aac-b9c1-423d-b199-c1c9273d1980"
/>
<img width="2608" height="1578" alt="Screenshot 2025-11-24 at 20 34 53"
src="https://github.com/user-attachments/assets/ff1929e6-a195-4e4e-a45b-5bddf49a1c25"
/>
<hr>

**After** the fix, no Sentry span leakage
<img width="2608" height="1578" alt="Screenshot 2025-11-24 at 20 28 22"
src="https://github.com/user-attachments/assets/e6584c01-30ef-40f2-87bf-33ac1d81e302"
/>
<img width="2608" height="1578" alt="Screenshot 2025-11-24 at 20 28 32"
src="https://github.com/user-attachments/assets/4388bb01-9f7b-48ab-8bb4-c7129075c89c"
/>

Closes: #17826

Author: andreiborza

dev-packages/e2e-tests/test-applications/node-otel-without-tracing/package.json

@@ -11,6 +11,7 @@
     "test:assert": "pnpm test"
   },
   "dependencies": {
+    "@opentelemetry/api": "1.9.0",
     "@opentelemetry/sdk-trace-node": "2.2.0",
     "@opentelemetry/exporter-trace-otlp-http": "0.208.0",
     "@opentelemetry/instrumentation-undici": "0.13.2",

dev-packages/e2e-tests/test-applications/node-otel-without-tracing/src/app.ts

@@ -2,6 +2,7 @@ import './instrument';
 
 // Other imports below
 import * as Sentry from '@sentry/node';
+import { trace, type Span } from '@opentelemetry/api';
 import express from 'express';
 
 const app = express();
@@ -29,6 +30,23 @@ app.get('/test-transaction', function (req, res) {
   });
 });
 
+app.get('/test-only-if-parent', function (req, res) {
+  // Remove the HTTP span from the context to simulate no parent span
+  Sentry.withActiveSpan(null, () => {
+    // This should NOT create a span because onlyIfParent is true and there's no parent
+    Sentry.startSpan({ name: 'test-only-if-parent', onlyIfParent: true }, () => {
+      // This custom OTel span SHOULD be created and exported
+      // This tests that custom OTel spans aren't suppressed when onlyIfParent triggers
+      const customTracer = trace.getTracer('custom-tracer');
+      customTracer.startActiveSpan('custom-span-with-only-if-parent', (span: Span) => {
+        span.end();
+      });
+    });
+
+    res.send({});
+  });
+});
+
 app.get('/test-error', async function (req, res) {
   const exceptionId = Sentry.captureException(new Error('This is an error'));
 
@@ -44,6 +62,16 @@ app.get('/test-exception/:id', function (req, _res) {
   throw new Error(`This is an exception with id ${id}`);
 });
 
+app.get('/test-logs/:id', function (req, res) {
+  const id = req.params.id;
+
+  Sentry.startSpan({ name: `log-operation-${id}` }, () => {
+    Sentry.logger.info(`test-log-${id}`, { requestId: id });
+  });
+
+  res.send({ ok: true, id });
+});
+
 Sentry.setupExpressErrorHandler(app);
 
 app.use(function onError(err: unknown, req: any, res: any, next: any) {

dev-packages/e2e-tests/test-applications/node-otel-without-tracing/src/instrument.ts

@@ -17,6 +17,7 @@ Sentry.init({
   // Tracing is completely disabled
   // Custom OTEL setup
   skipOpenTelemetrySetup: true,
+  enableLogs: true,
 });
 
 // Create and configure NodeTracerProvider

dev-packages/e2e-tests/test-applications/node-otel-without-tracing/tests/logs.test.ts

@@ -0,0 +1,42 @@
+import { expect, test } from '@playwright/test';
+import { waitForEnvelopeItem } from '@sentry-internal/test-utils';
+
+test('Logs from different requests have different trace IDs', async ({ baseURL }) => {
+  const logEnvelopePromise1 = waitForEnvelopeItem('node-otel-without-tracing', async envelopeItem => {
+    const [itemHeader, itemPayload] = envelopeItem;
+    if (itemHeader.type === 'log') {
+      const logItems = itemPayload as { items: Array<{ body: string; trace_id?: string }> };
+      return logItems.items.some(item => item.body === 'test-log-1');
+    }
+    return false;
+  });
+
+  const logEnvelopePromise2 = waitForEnvelopeItem('node-otel-without-tracing', async envelopeItem => {
+    const [itemHeader, itemPayload] = envelopeItem;
+    if (itemHeader.type === 'log') {
+      const logItems = itemPayload as { items: Array<{ body: string; trace_id?: string }> };
+      return logItems.items.some(item => item.body === 'test-log-2');
+    }
+    return false;
+  });
+
+  // Make two requests to different routes (each Express route is an isolation scope)
+  await fetch(`${baseURL}/test-logs/1`);
+  await fetch(`${baseURL}/test-logs/2`);
+
+  const logEnvelope1 = await logEnvelopePromise1;
+  const logEnvelope2 = await logEnvelopePromise2;
+
+  const logPayload1 = logEnvelope1[1] as { items: Array<{ body: string; trace_id?: string }> };
+  const logPayload2 = logEnvelope2[1] as { items: Array<{ body: string; trace_id?: string }> };
+
+  const log1 = logPayload1.items.find(item => item.body === 'test-log-1');
+  const log2 = logPayload2.items.find(item => item.body === 'test-log-2');
+
+  const traceId1 = log1?.trace_id;
+  const traceId2 = log2?.trace_id;
+
+  expect(traceId1).toMatch(/[a-f0-9]{32}/);
+  expect(traceId2).toMatch(/[a-f0-9]{32}/);
+  expect(traceId1).not.toBe(traceId2);
+});

dev-packages/e2e-tests/test-applications/node-otel-without-tracing/tests/transactions.test.ts

@@ -34,10 +34,10 @@ test('Sends an API route transaction to OTLP', async ({ baseURL }) => {
   const scopeSpans = json.resourceSpans?.[0]?.scopeSpans;
   expect(scopeSpans).toBeDefined();
 
-  // Http server span & undici client spans are emitted,
-  // as well as the spans emitted via `Sentry.startSpan()`
-  // But our default node-fetch spans are not emitted
-  expect(scopeSpans.length).toEqual(3);
+  // Http server span & undici client spans are emitted.
+  // Sentry.startSpan() spans are NOT emitted (non-recording when tracing is disabled).
+  // Our default node-fetch spans are also not emitted.
+  expect(scopeSpans.length).toEqual(2);
 
   const httpScopes = scopeSpans?.filter(scopeSpan => scopeSpan.scope.name === '@opentelemetry/instrumentation-http');
   const undiciScopes = scopeSpans?.filter(
@@ -47,43 +47,8 @@ test('Sends an API route transaction to OTLP', async ({ baseURL }) => {
 
   expect(httpScopes.length).toBe(1);
 
-  expect(startSpanScopes.length).toBe(1);
-  expect(startSpanScopes[0].spans.length).toBe(2);
-  expect(startSpanScopes[0].spans).toEqual([
-    {
-      traceId: expect.any(String),
-      spanId: expect.any(String),
-      parentSpanId: expect.any(String),
-      name: 'test-span',
-      kind: 1,
-      startTimeUnixNano: expect.any(String),
-      endTimeUnixNano: expect.any(String),
-      attributes: [],
-      droppedAttributesCount: 0,
-      events: [],
-      droppedEventsCount: 0,
-      status: { code: 0 },
-      links: [],
-      droppedLinksCount: 0,
-      flags: expect.any(Number),
-    },
-    {
-      traceId: expect.any(String),
-      spanId: expect.any(String),
-      name: 'test-transaction',
-      kind: 1,
-      startTimeUnixNano: expect.any(String),
-      endTimeUnixNano: expect.any(String),
-      attributes: [{ key: 'sentry.op', value: { stringValue: 'e2e-test' } }],
-      droppedAttributesCount: 0,
-      events: [],
-      droppedEventsCount: 0,
-      status: { code: 0 },
-      links: [],
-      droppedLinksCount: 0,
-      flags: expect.any(Number),
-    },
-  ]);
+  // Sentry spans should not be exported when tracing is disabled
+  expect(startSpanScopes.length).toBe(0);
 
   // Undici spans are emitted correctly
   expect(undiciScopes.length).toBe(1);
@@ -164,3 +129,58 @@ test('Sends an API route transaction to OTLP', async ({ baseURL }) => {
     },
   ]);
 });
+
+test('Custom OTel spans work with onlyIfParent when no parent exists', async ({ baseURL }) => {
+  waitForTransaction('node-otel-without-tracing', transactionEvent => {
+    throw new Error('THIS SHOULD NEVER HAPPEN!');
+  });
+
+  // Ensure we send data to the OTLP endpoint
+  const otelPromise = waitForPlainRequest('node-otel-without-tracing-otel', data => {
+    const json = JSON.parse(data) as any;
+
+    const scopeSpans = json.resourceSpans?.[0]?.scopeSpans;
+
+    // Look for the custom span from our custom-tracer
+    const customScope = scopeSpans?.find(scopeSpan => scopeSpan.scope.name === 'custom-tracer');
+
+    return customScope && customScope.spans.some(span => span.name === 'custom-span-with-only-if-parent');
+  });
+
+  fetch(`${baseURL}/test-only-if-parent`);
+
+  const otelData = await otelPromise;
+
+  expect(otelData).toBeDefined();
+
+  const json = JSON.parse(otelData);
+  expect(json.resourceSpans.length).toBe(1);
+
+  const scopeSpans = json.resourceSpans?.[0]?.scopeSpans;
+  expect(scopeSpans).toBeDefined();
+
+  // Should have HTTP instrumentation span but NO Sentry span
+  const httpScopes = scopeSpans?.filter(scopeSpan => scopeSpan.scope.name === '@opentelemetry/instrumentation-http');
+  const sentryScopes = scopeSpans?.filter(scopeSpan => scopeSpan.scope.name === '@sentry/node');
+  const customScopes = scopeSpans?.filter(scopeSpan => scopeSpan.scope.name === 'custom-tracer');
+
+  // HTTP span exists (from the incoming request)
+  expect(httpScopes.length).toBe(1);
+
+  // Sentry span should NOT exist (onlyIfParent + no parent = suppressed)
+  expect(sentryScopes.length).toBe(0);
+
+  // Custom OTel span SHOULD exist (this is what we're testing - the fix ensures this works)
+  expect(customScopes.length).toBe(1);
+  expect(customScopes[0].spans.length).toBe(1);
+  expect(customScopes[0].spans[0]).toMatchObject({
+    name: 'custom-span-with-only-if-parent',
+    kind: 1,
+    status: { code: 0 },
+  });
+
+  // Verify the custom span is recording (not suppressed)
+  const customSpan = customScopes[0].spans[0];
+  expect(customSpan.spanId).not.toBe('0000000000000000');
+  expect(customSpan.traceId).not.toBe('00000000000000000000000000000000');
+});

dev-packages/node-integration-tests/suites/pino/instrument-auto-off.mjs

@@ -3,6 +3,7 @@ import * as Sentry from '@sentry/node';
 Sentry.init({
   dsn: process.env.SENTRY_DSN,
   release: '1.0',
+  tracesSampleRate: 1.0,
   enableLogs: true,
   integrations: [Sentry.pinoIntegration({ autoInstrument: false })],
 });

dev-packages/node-integration-tests/suites/pino/instrument.mjs

@@ -3,6 +3,7 @@ import * as Sentry from '@sentry/node';
 Sentry.init({
   dsn: process.env.SENTRY_DSN,
   release: '1.0',
+  tracesSampleRate: 1.0,
   enableLogs: true,
   integrations: [Sentry.pinoIntegration({ error: { levels: ['error', 'fatal'] } })],
 });

dev-packages/node-integration-tests/suites/pino/test.ts

@@ -11,6 +11,7 @@ conditionalTest({ min: 20 })('Pino integration', () => {
       .withMockSentryServer()
       .withInstrument(instrumentPath)
       .ignore('event')
+      .ignore('transaction')
       .expect({
         log: log => {
           const traceId1 = log.items?.[0]?.trace_id;
@@ -28,6 +29,7 @@ conditionalTest({ min: 20 })('Pino integration', () => {
     await createRunner(__dirname, 'scenario.mjs')
       .withMockSentryServer()
       .withInstrument(instrumentPath)
+      .ignore('transaction')
       .expect({
         event: {
           exception: {
@@ -105,6 +107,7 @@ conditionalTest({ min: 20 })('Pino integration', () => {
     await createRunner(__dirname, 'scenario-next.mjs')
       .withMockSentryServer()
       .withInstrument(instrumentPath)
+      .ignore('transaction')
       .expect({
         event: {
           exception: {
@@ -182,6 +185,7 @@ conditionalTest({ min: 20 })('Pino integration', () => {
     await createRunner(__dirname, 'scenario-track.mjs')
       .withMockSentryServer()
       .withInstrument(instrumentPath)
+      .ignore('transaction')
       .expect({
         log: {
           items: [