feat(node): Wire up SentryTracerProvider

dev-packages/e2e-tests/test-applications/node-connect/tests/transactions.test.ts

@@ -54,41 +54,44 @@ test('Sends an API route transaction', async ({ baseURL }) => {
     origin: 'auto.http.otel.http',
   });
 
+  const manualSpanExpectation = {
+    data: {
+      'sentry.origin': 'manual',
+    },
+    description: 'test-span',
+    parent_span_id: expect.stringMatching(/[a-f0-9]{16}/),
+    span_id: expect.stringMatching(/[a-f0-9]{16}/),
+    start_timestamp: expect.any(Number),
+    status: 'ok',
+    timestamp: expect.any(Number),
+    trace_id: expect.stringMatching(/[a-f0-9]{32}/),
+    origin: 'manual',
+  };
+
+  const connectSpanExpectation = {
+    data: {
+      'sentry.origin': 'auto.http.otel.connect',
+      'sentry.op': 'request_handler.connect',
+      'http.route': '/test-transaction',
+      'connect.type': 'request_handler',
+      'connect.name': '/test-transaction',
+    },
+    op: 'request_handler.connect',
+    description: '/test-transaction',
+    parent_span_id: expect.stringMatching(/[a-f0-9]{16}/),
+    span_id: expect.stringMatching(/[a-f0-9]{16}/),
+    start_timestamp: expect.any(Number),
+    status: 'ok',
+    timestamp: expect.any(Number),
+    trace_id: expect.stringMatching(/[a-f0-9]{32}/),
+    origin: 'auto.http.otel.connect',
+  };
+
   expect(transactionEvent).toEqual(
     expect.objectContaining({
-      spans: [
-        {
-          data: {
-            'sentry.origin': 'manual',
-          },
-          description: 'test-span',
-          parent_span_id: expect.stringMatching(/[a-f0-9]{16}/),
-          span_id: expect.stringMatching(/[a-f0-9]{16}/),
-          start_timestamp: expect.any(Number),
-          status: 'ok',
-          timestamp: expect.any(Number),
-          trace_id: expect.stringMatching(/[a-f0-9]{32}/),
-          origin: 'manual',
-        },
-        {
-          data: {
-            'sentry.origin': 'auto.http.otel.connect',
-            'sentry.op': 'request_handler.connect',
-            'http.route': '/test-transaction',
-            'connect.type': 'request_handler',
-            'connect.name': '/test-transaction',
-          },
-          op: 'request_handler.connect',
-          description: '/test-transaction',
-          parent_span_id: expect.stringMatching(/[a-f0-9]{16}/),
-          span_id: expect.stringMatching(/[a-f0-9]{16}/),
-          start_timestamp: expect.any(Number),
-          status: 'ok',
-          timestamp: expect.any(Number),
-          trace_id: expect.stringMatching(/[a-f0-9]{32}/),
-          origin: 'auto.http.otel.connect',
-        },
-      ],
+      // The SentryTracerProvider serializes native child spans in start/tree order, so the
+      // Connect handler span appears before the manual span created inside it.
+      spans: [connectSpanExpectation, manualSpanExpectation],
       transaction: 'GET /test-transaction',
       type: 'transaction',
       transaction_info: {

dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage-streamed/test.ts

@@ -2,6 +2,7 @@ import {
   SDK_VERSION,
   SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT,
   SEMANTIC_ATTRIBUTE_SENTRY_OP,
+  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   SEMANTIC_ATTRIBUTE_SENTRY_RELEASE,
   SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE,
   SEMANTIC_ATTRIBUTE_SENTRY_SDK_INTEGRATIONS,
@@ -63,6 +64,7 @@ test('sends a streamed span envelope with correct spans for a manually started s
             [SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME]: { type: 'string', value: 'test-span' },
             [SEMANTIC_ATTRIBUTE_SENTRY_RELEASE]: { type: 'string', value: '1.0.0' },
             [SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT]: { type: 'string', value: 'production' },
+            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: { type: 'string', value: 'manual' },
             [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: { type: 'string', value: 'custom' },
             'sentry.span.source': { type: 'string', value: 'custom' },
           },
@@ -86,6 +88,7 @@ test('sends a streamed span envelope with correct spans for a manually started s
             [SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME]: { type: 'string', value: 'test-span' },
             [SEMANTIC_ATTRIBUTE_SENTRY_RELEASE]: { type: 'string', value: '1.0.0' },
             [SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT]: { type: 'string', value: 'production' },
+            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: { type: 'string', value: 'manual' },
             [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: { type: 'string', value: 'custom' },
             'sentry.span.source': { type: 'string', value: 'custom' },
           },
@@ -122,6 +125,7 @@ test('sends a streamed span envelope with correct spans for a manually started s
             [SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME]: { type: 'string', value: 'test-span' },
             [SEMANTIC_ATTRIBUTE_SENTRY_RELEASE]: { type: 'string', value: '1.0.0' },
             [SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT]: { type: 'string', value: 'production' },
+            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: { type: 'string', value: 'manual' },
             [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: { type: 'string', value: 'custom' },
             'sentry.span.source': { type: 'string', value: 'custom' },
           },
@@ -148,6 +152,7 @@ test('sends a streamed span envelope with correct spans for a manually started s
           [SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME]: { type: 'string', value: 'test-span' },
           [SEMANTIC_ATTRIBUTE_SENTRY_RELEASE]: { type: 'string', value: '1.0.0' },
           [SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT]: { type: 'string', value: 'production' },
+          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: { type: 'string', value: 'manual' },
           [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: { type: 'string', value: 'custom' },
           'sentry.span.source': { type: 'string', value: 'custom' },
           'process.runtime.engine.name': { type: 'string', value: 'v8' },

dev-packages/node-integration-tests/suites/public-api/startSpan/updateName-method-streamed/test.ts

@@ -15,7 +15,9 @@ test('updates the span name when calling `span.updateName` (streamed)', async ()
             name: 'new name',
             is_segment: true,
             attributes: {
-              [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: { type: 'string', value: 'url' },
+              // `updateName` marks the name as explicitly chosen, so the source becomes `custom`,
+              // overriding the `url` source set at span start (a stale `url` no longer describes the name).
+              [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: { type: 'string', value: 'custom' },
             },
           },
         ],

dev-packages/node-integration-tests/suites/public-api/startSpan/updateName-method/test.ts

@@ -7,16 +7,18 @@ afterAll(() => {
 });
 
 test('updates the span name when calling `span.updateName`', async () => {
-  createRunner(__dirname, 'scenario.ts')
+  await createRunner(__dirname, 'scenario.ts')
     .expect({
       transaction: {
         transaction: 'new name',
-        transaction_info: { source: 'url' },
+        // `updateName` marks the name as explicitly chosen, so the source becomes `custom`,
+        // overriding the `url` source set at span start (a stale `url` no longer describes the name).
+        transaction_info: { source: 'custom' },
         contexts: {
           trace: {
             span_id: expect.any(String),
             trace_id: expect.any(String),
-            data: { [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'url' },
+            data: { [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'custom' },
           },
         },
       },

dev-packages/node-integration-tests/suites/tracing/langgraph/test.ts

@@ -356,89 +356,96 @@ describe('LangGraph integration', () => {
     },
   );
 
-  // createReactAgent tests
-  const EXPECTED_TRANSACTION_REACT_AGENT = {
-    transaction: 'main',
-    spans: [
-      expect.objectContaining({
-        data: expect.objectContaining({
-          [GEN_AI_OPERATION_NAME_ATTRIBUTE]: 'invoke_agent',
-          [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'gen_ai.invoke_agent',
-          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ai.langgraph',
-          [GEN_AI_AGENT_NAME_ATTRIBUTE]: 'helpful_assistant',
-          [GEN_AI_PIPELINE_NAME_ATTRIBUTE]: 'helpful_assistant',
-        }),
-        description: 'invoke_agent helpful_assistant',
-        op: 'gen_ai.invoke_agent',
-        origin: 'auto.ai.langgraph',
-        status: 'ok',
-      }),
-      expect.objectContaining({ op: 'http.client' }),
-      expect.objectContaining({
-        data: expect.objectContaining({
-          [GEN_AI_AGENT_NAME_ATTRIBUTE]: 'helpful_assistant',
-        }),
-        op: 'gen_ai.chat',
-      }),
-    ],
-  };
-
+  // createReactAgent tests.
+  // Spans are asserted order-independently: the span-array order is not a protocol guarantee (Sentry
+  // rebuilds the tree from `parent_span_id`), and the provider emits tree order while the OTel exporter
+  // emits finish order (the `http.client` that the chat span wraps finishes before the chat span itself).
   createEsmAndCjsTests(__dirname, 'agent-scenario.mjs', 'instrument-agent.mjs', (createRunner, test) => {
     test('should instrument createReactAgent with agent and chat spans', { timeout: 30000 }, async () => {
       await createRunner()
         .ignore('event')
-        .expect({ transaction: EXPECTED_TRANSACTION_REACT_AGENT })
+        .expect({
+          transaction: event => {
+            const spans = event.spans ?? [];
+            expect(event.transaction).toBe('main');
+            expect(spans).toHaveLength(3);
+            expect(spans).toContainEqual(
+              expect.objectContaining({
+                data: expect.objectContaining({
+                  [GEN_AI_OPERATION_NAME_ATTRIBUTE]: 'invoke_agent',
+                  [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'gen_ai.invoke_agent',
+                  [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ai.langgraph',
+                  [GEN_AI_AGENT_NAME_ATTRIBUTE]: 'helpful_assistant',
+                  [GEN_AI_PIPELINE_NAME_ATTRIBUTE]: 'helpful_assistant',
+                }),
+                description: 'invoke_agent helpful_assistant',
+                op: 'gen_ai.invoke_agent',
+                origin: 'auto.ai.langgraph',
+                status: 'ok',
+              }),
+            );
+            expect(spans).toContainEqual(expect.objectContaining({ op: 'http.client' }));
+            expect(spans).toContainEqual(
+              expect.objectContaining({
+                data: expect.objectContaining({ [GEN_AI_AGENT_NAME_ATTRIBUTE]: 'helpful_assistant' }),
+                op: 'gen_ai.chat',
+              }),
+            );
+          },
+        })
         .start()
         .completed();
     });
   });
 
-  // createReactAgent with tools - verifies tool execution spans
-  const EXPECTED_TRANSACTION_REACT_AGENT_TOOLS = {
-    transaction: 'main',
-    spans: [
-      expect.objectContaining({
-        data: expect.objectContaining({
-          [GEN_AI_OPERATION_NAME_ATTRIBUTE]: 'invoke_agent',
-          [GEN_AI_AGENT_NAME_ATTRIBUTE]: 'math_assistant',
-        }),
-        op: 'gen_ai.invoke_agent',
-        status: 'ok',
-      }),
-      expect.objectContaining({ op: 'http.client' }),
-      expect.objectContaining({ op: 'gen_ai.chat' }),
-      expect.objectContaining({
-        data: expect.objectContaining({
-          [GEN_AI_OPERATION_NAME_ATTRIBUTE]: 'execute_tool',
-          [GEN_AI_TOOL_NAME_ATTRIBUTE]: 'add',
-          'gen_ai.tool.type': 'function',
-        }),
-        description: 'execute_tool add',
-        op: 'gen_ai.execute_tool',
-        status: 'ok',
-      }),
-      expect.objectContaining({ op: 'http.client' }),
-      expect.objectContaining({ op: 'gen_ai.chat' }),
-      expect.objectContaining({
-        data: expect.objectContaining({
-          [GEN_AI_OPERATION_NAME_ATTRIBUTE]: 'execute_tool',
-          [GEN_AI_TOOL_NAME_ATTRIBUTE]: 'multiply',
-          'gen_ai.tool.type': 'function',
-        }),
-        description: 'execute_tool multiply',
-        op: 'gen_ai.execute_tool',
-        status: 'ok',
-      }),
-      expect.objectContaining({ op: 'http.client' }),
-      expect.objectContaining({ op: 'gen_ai.chat' }),
-    ],
-  };
-
+  // createReactAgent with tools - verifies tool execution spans (asserted order-independently, see above).
   createEsmAndCjsTests(__dirname, 'agent-tools-scenario.mjs', 'instrument-agent.mjs', (createRunner, test) => {
     test('should create tool execution spans for createReactAgent with tools', { timeout: 30000 }, async () => {
       await createRunner()
         .ignore('event')
-        .expect({ transaction: EXPECTED_TRANSACTION_REACT_AGENT_TOOLS })
+        .expect({
+          transaction: event => {
+            const spans = event.spans ?? [];
+            expect(event.transaction).toBe('main');
+            expect(spans).toHaveLength(9);
+            expect(spans).toContainEqual(
+              expect.objectContaining({
+                data: expect.objectContaining({
+                  [GEN_AI_OPERATION_NAME_ATTRIBUTE]: 'invoke_agent',
+                  [GEN_AI_AGENT_NAME_ATTRIBUTE]: 'math_assistant',
+                }),
+                op: 'gen_ai.invoke_agent',
+                status: 'ok',
+              }),
+            );
+            expect(spans).toContainEqual(
+              expect.objectContaining({
+                data: expect.objectContaining({
+                  [GEN_AI_OPERATION_NAME_ATTRIBUTE]: 'execute_tool',
+                  [GEN_AI_TOOL_NAME_ATTRIBUTE]: 'add',
+                  'gen_ai.tool.type': 'function',
+                }),
+                description: 'execute_tool add',
+                op: 'gen_ai.execute_tool',
+                status: 'ok',
+              }),
+            );
+            expect(spans).toContainEqual(
+              expect.objectContaining({
+                data: expect.objectContaining({
+                  [GEN_AI_OPERATION_NAME_ATTRIBUTE]: 'execute_tool',
+                  [GEN_AI_TOOL_NAME_ATTRIBUTE]: 'multiply',
+                  'gen_ai.tool.type': 'function',
+                }),
+                description: 'execute_tool multiply',
+                op: 'gen_ai.execute_tool',
+                status: 'ok',
+              }),
+            );
+            expect(spans.filter(span => span.op === 'http.client')).toHaveLength(3);
+            expect(spans.filter(span => span.op === 'gen_ai.chat')).toHaveLength(3);
+          },
+        })
         .start()
         .completed();
     });

dev-packages/node-integration-tests/suites/tracing/mysql-streamed/test.ts

@@ -52,6 +52,13 @@ describe('mysql auto instrumentation (streamed)', () => {
         type: 'string',
         value: 'db',
       },
+      // The `mysql` (v1) instrumentation sets no explicit span origin, so these spans carry the
+      // default `manual` origin. The streamed-span path writes it as a first-class attribute (the
+      // non-streamed/SDK path omits the `manual` default, which is why this wasn't asserted before).
+      'sentry.origin': {
+        type: 'string',
+        value: 'manual',
+      },
       'sentry.release': {
         type: 'string',
         value: '1.0',

dev-packages/node-integration-tests/suites/tracing/no-parent-span-client-report/scenario-fetch.mjs

@@ -0,0 +1 @@
+fetch('http://localhost:9999/external').catch(() => {});

dev-packages/node-integration-tests/suites/tracing/no-parent-span-client-report/test.ts

@@ -7,7 +7,28 @@ describe('no_parent_span client report', () => {
   });
 
   createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
-    test('records no_parent_span outcome for http.client span without a local parent', async () => {
+    test('records no_parent_span outcome for an outgoing http request without a local parent', async () => {
+      const runner = createRunner()
+        .unignore('client_report')
+        .expect({
+          client_report: report => {
+            expect(report.discarded_events).toEqual([
+              {
+                category: 'span',
+                quantity: 1,
+                reason: 'no_parent_span',
+              },
+            ]);
+          },
+        })
+        .start();
+
+      await runner.completed();
+    });
+  });
+
+  createEsmAndCjsTests(__dirname, 'scenario-fetch.mjs', 'instrument.mjs', (createRunner, test) => {
+    test('records no_parent_span outcome for an outgoing fetch request without a local parent', async () => {
       const runner = createRunner()
         .unignore('client_report')
         .expect({

dev-packages/node-integration-tests/suites/tracing/postgres-streamed/test.ts

@@ -73,8 +73,10 @@ const COMMON_DB_ATTRIBUTES = {
 
 /**
  * Builds the expected strict shape of a streamed postgres db span.
- * The `pg.connect` span has neither a `db.statement` nor a `sentry.origin`,
- * whereas query spans carry both.
+ * Query spans carry a `db.statement` and the `auto.db.otel.postgres` origin. The `pg.connect` span
+ * has no `db.statement`, and since the pg instrumentation sets no origin on it, it carries the
+ * default `manual` origin (written as an attribute on the streamed-span path; the non-streamed/SDK
+ * path omits the `manual` default).
  */
 function expectedDbSpan({ name, statement }: { name: string; statement?: string }): unknown {
   const attributes: Record<string, unknown> = { ...COMMON_DB_ATTRIBUTES };
@@ -88,6 +90,11 @@ function expectedDbSpan({ name, statement }: { name: string; statement?: string
       type: 'string',
       value: 'auto.db.otel.postgres',
     };
+  } else {
+    attributes['sentry.origin'] = {
+      type: 'string',
+      value: 'manual',
+    };
   }
 
   return {