adjust tests for new paradigm

Author: mydea

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

@@ -8,14 +8,15 @@ Sentry.pinoIntegration.untrackLogger(ignoredLogger);
 
 ignoredLogger.info('this will not be tracked');
 
-Sentry.withIsolationScope(() => {
+// Each operation runs in its own trace, so logs emitted within them carry distinct trace ids.
+Sentry.startNewTrace(() => {
   Sentry.startSpan({ name: 'startup' }, () => {
     logger.info({ user: 'user-id', something: { more: 3, complex: 'nope' } }, 'hello world');
   });
 });
 
 setTimeout(() => {
-  Sentry.withIsolationScope(() => {
+  Sentry.startNewTrace(() => {
     Sentry.startSpan({ name: 'later' }, () => {
       const child = logger.child({ module: 'authentication' });
       child.error(new Error('oh no'));

dev-packages/node-integration-tests/suites/public-api/bindScopeToEmitter/test.ts

@@ -34,7 +34,9 @@ test('bindScopeToEmitter preserves the active span for listeners firing in a dif
   expect(childBound?.parent_span_id).toBe(parentSpanId);
   expect(childBound?.trace_id).toBe(parentTraceId);
 
-  // The unbound emitter's listener ran without the parent active -> its own, separate trace.
+  // The unbound emitter's listener ran without the parent active -> its own root transaction,
+  // not nested under the parent span. It still shares the isolation scope's propagation context
+  // trace, matching the core SDK behavior for root spans.
   expect(childUnbound?.spans).toEqual([]);
-  expect(childUnbound?.contexts?.trace?.trace_id).not.toBe(parentTraceId);
+  expect(childUnbound?.contexts?.trace?.parent_span_id).toBeUndefined();
 });

dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-root-spans-streamed/test.ts

@@ -6,25 +6,24 @@ afterAll(() => {
 });
 
 test('sends manually started streamed parallel root spans in root context', async () => {
-  expect.assertions(7);
+  expect.assertions(6);
 
   await createRunner(__dirname, 'scenario.ts')
-    .expect({ span: { items: [{ name: 'test_span_1' }] } })
     .expect({
       span: spanContainer => {
         expect(spanContainer).toBeDefined();
-        const traceId = spanContainer.items[0]!.trace_id;
-        expect(traceId).toMatch(/^[0-9a-f]{32}$/);
 
-        // It ignores propagation context of the root context
-        expect(traceId).not.toBe('12345678901234567890123456789012');
-        expect(spanContainer.items[0]!.parent_span_id).toBeUndefined();
+        const span1 = spanContainer.items.find(item => item.name === 'test_span_1');
+        const span2 = spanContainer.items.find(item => item.name === 'test_span_2');
+        expect(span1).toBeDefined();
+        expect(span2).toBeDefined();
 
-        // Different trace ID than the first span
-        const trace1Id = spanContainer.items[0]!.attributes.spanIdTraceId?.value;
-        expect(trace1Id).toMatch(/^[0-9a-f]{32}$/);
+        // Both root spans continue the scope's propagation context, matching the core SDK behavior.
+        expect(span1!.trace_id).toBe('12345678901234567890123456789012');
+        expect(span1!.parent_span_id).toBe('1234567890123456');
 
-        expect(trace1Id).not.toBe(traceId);
+        // Same trace ID for both spans
+        expect(span2!.trace_id).toBe(span1!.trace_id);
       },
     })
     .start()

dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-root-spans/test.ts

@@ -6,24 +6,23 @@ afterAll(() => {
 });
 
 test('should send manually started parallel root spans in root context', async () => {
-  expect.assertions(7);
+  expect.assertions(6);
 
   await createRunner(__dirname, 'scenario.ts')
     .expect({ transaction: { transaction: 'test_span_1' } })
     .expect({
       transaction: transaction => {
         expect(transaction).toBeDefined();
         const traceId = transaction.contexts?.trace?.trace_id;
-        expect(traceId).toBeDefined();
 
-        // It ignores propagation context of the root context
-        expect(traceId).not.toBe('12345678901234567890123456789012');
-        expect(transaction.contexts?.trace?.parent_span_id).toBeUndefined();
+        // Both root spans continue the scope's propagation context, matching the core SDK behavior.
+        expect(traceId).toBe('12345678901234567890123456789012');
+        expect(transaction.contexts?.trace?.parent_span_id).toBe('1234567890123456');
 
-        // Different trace ID than the first span
+        // Same trace ID as the first span
         const trace1Id = transaction.contexts?.trace?.data?.spanIdTraceId;
-        expect(trace1Id).toBeDefined();
-        expect(trace1Id).not.toBe(traceId);
+        expect(trace1Id).toBe('12345678901234567890123456789012');
+        expect(trace1Id).toBe(traceId);
       },
     })
     .start()

dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-streamed/test.ts

@@ -9,19 +9,20 @@ test('sends manually started streamed parallel root spans outside of root contex
   expect.assertions(6);
 
   await createRunner(__dirname, 'scenario.ts')
-    .expect({ span: { items: [{ name: 'test_span_1' }] } })
     .expect({
       span: spanContainer => {
         expect(spanContainer).toBeDefined();
-        const traceId = spanContainer.items[0]!.trace_id;
-        expect(traceId).toMatch(/^[0-9a-f]{32}$/);
-        expect(spanContainer.items[0]!.parent_span_id).toBeUndefined();
 
-        const trace1Id = spanContainer.items[0]!.attributes.spanIdTraceId?.value;
-        expect(trace1Id).toMatch(/^[0-9a-f]{32}$/);
+        const span1 = spanContainer.items.find(item => item.name === 'test_span_1');
+        const span2 = spanContainer.items.find(item => item.name === 'test_span_2');
+        expect(span1).toBeDefined();
+        expect(span2).toBeDefined();
 
-        // Different trace ID as the first span
-        expect(trace1Id).not.toBe(traceId);
+        expect(span1!.trace_id).toMatch(/^[0-9a-f]{32}$/);
+        expect(span1!.parent_span_id).toBeUndefined();
+
+        // Same trace ID for both spans - both root spans share the scope's propagation context
+        expect(span2!.trace_id).toBe(span1!.trace_id);
       },
     })
     .start()

dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-with-parentSpanId-streamed/test.ts

@@ -9,19 +9,22 @@ test('sends manually started streamed parallel root spans outside of root contex
   expect.assertions(6);
 
   await createRunner(__dirname, 'scenario.ts')
-    .expect({ span: { items: [{ name: 'test_span_1' }] } })
     .expect({
       span: spanContainer => {
         expect(spanContainer).toBeDefined();
-        const traceId = spanContainer.items[0]!.trace_id;
-        expect(traceId).toMatch(/^[0-9a-f]{32}$/);
-        expect(spanContainer.items[0]!.parent_span_id).toBeUndefined();
 
-        const trace1Id = spanContainer.items[0]!.attributes.spanIdTraceId?.value;
-        expect(trace1Id).toMatch(/^[0-9a-f]{32}$/);
+        const span1 = spanContainer.items.find(item => item.name === 'test_span_1');
+        const span2 = spanContainer.items.find(item => item.name === 'test_span_2');
+        expect(span1).toBeDefined();
+        expect(span2).toBeDefined();
 
-        // Different trace ID as the first span
-        expect(trace1Id).not.toBe(traceId);
+        // Both root spans continue the scope's propagation context, including the parentSpanId,
+        // matching the core SDK behavior.
+        expect(span1!.trace_id).toBe('12345678901234567890123456789012');
+        expect(span1!.parent_span_id).toBe('1234567890123456');
+
+        // Same trace ID for both spans
+        expect(span2!.trace_id).toBe(span1!.trace_id);
       },
     })
     .start()

dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-with-parentSpanId/test.ts

@@ -12,14 +12,15 @@ test('should send manually started parallel root spans outside of root context w
       transaction: transaction => {
         expect(transaction).toBeDefined();
         const traceId = transaction.contexts?.trace?.trace_id;
-        expect(traceId).toBeDefined();
-        expect(transaction.contexts?.trace?.parent_span_id).toBeUndefined();
 
-        const trace1Id = transaction.contexts?.trace?.data?.spanIdTraceId;
-        expect(trace1Id).toBeDefined();
+        // Both root spans continue the scope's propagation context, including the parentSpanId,
+        // matching the core SDK behavior.
+        expect(traceId).toBe('12345678901234567890123456789012');
+        expect(transaction.contexts?.trace?.parent_span_id).toBe('1234567890123456');
 
-        // Different trace ID as the first span
-        expect(trace1Id).not.toBe(traceId);
+        // Same trace ID as the first span
+        const trace1Id = transaction.contexts?.trace?.data?.spanIdTraceId;
+        expect(trace1Id).toBe(traceId);
       },
     })
     .start()

dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope/test.ts

@@ -20,8 +20,8 @@ test('should send manually started parallel root spans outside of root context',
         const trace1Id = transaction.contexts?.trace?.data?.spanIdTraceId;
         expect(trace1Id).toBeDefined();
 
-        // Different trace ID as the first span
-        expect(trace1Id).not.toBe(traceId);
+        // Same trace ID as the first span - both root spans share the scope's propagation context
+        expect(trace1Id).toBe(traceId);
       },
     })
     .start()