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

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: [

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: [

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: [

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: [

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: [

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: [

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: [

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: [