feat(opentelemetry): Do not use SentrySpan & Transaction classes

Instead, we build the transaction event manually in the span exporter now.

We also ensure to emit `spanStart` & `spanEnd` hooks now in the span processor.

Author: mydea

packages/core/src/index.ts

@@ -91,6 +91,7 @@ export {
   spanIsSampled,
   spanToTraceContext,
   getSpanDescendants,
+  getStatusMessage,
 } from './utils/spanUtils';
 export { getRootSpan } from './utils/getRootSpan';
 export { applySdkMetadata } from './utils/sdkMetadata';

packages/node-experimental/test/integration/transactions.test.ts

@@ -15,7 +15,11 @@ describe('Integration | Transactions', () => {
   });
 
   it('correctly creates transaction & spans', async () => {
-    const beforeSendTransaction = jest.fn(() => null);
+    const transactions: TransactionEvent[] = [];
+    const beforeSendTransaction = jest.fn(event => {
+      transactions.push(event);
+      return null;
+    });
 
     mockSdkInit({ enableTracing: true, beforeSendTransaction });
 
@@ -58,86 +62,74 @@ describe('Integration | Transactions', () => {
 
     await client.flush();
 
-    expect(beforeSendTransaction).toHaveBeenCalledTimes(1);
-    expect(beforeSendTransaction).toHaveBeenLastCalledWith(
-      expect.objectContaining({
-        breadcrumbs: [
-          { message: 'test breadcrumb 1', timestamp: 123456 },
-          { message: 'test breadcrumb 2', timestamp: 123456 },
-          { message: 'test breadcrumb 3', timestamp: 123456 },
-        ],
-        contexts: {
-          otel: {
-            attributes: {
-              'test.outer': 'test value',
-              'sentry.op': 'test op',
-              'sentry.origin': 'auto.test',
-              'sentry.source': 'task',
-            },
-            resource: {
-              'service.name': 'node',
-              'service.namespace': 'sentry',
-              'service.version': expect.any(String),
-              'telemetry.sdk.language': 'nodejs',
-              'telemetry.sdk.name': 'opentelemetry',
-              'telemetry.sdk.version': expect.any(String),
-            },
-          },
-          runtime: { name: 'node', version: expect.any(String) },
-          trace: {
-            data: {
-              'otel.kind': 'INTERNAL',
-              'sentry.op': 'test op',
-              'sentry.origin': 'auto.test',
-              'sentry.source': 'task',
-              'sentry.sample_rate': 1,
-              'test.outer': 'test value',
-            },
-            op: 'test op',
-            span_id: expect.any(String),
-            status: 'ok',
-            trace_id: expect.any(String),
-            origin: 'auto.test',
-          },
-        },
-        environment: 'production',
-        event_id: expect.any(String),
-        platform: 'node',
-        sdkProcessingMetadata: expect.objectContaining({
-          dynamicSamplingContext: expect.objectContaining({
-            environment: 'production',
-            public_key: expect.any(String),
-            sample_rate: '1',
-            sampled: 'true',
-            trace_id: expect.any(String),
-            transaction: 'test name',
-          }),
-          sampleRate: 1,
-          spanMetadata: expect.any(Object),
-          requestPath: 'test-path',
-        }),
-        server_name: expect.any(String),
-        // spans are circular (they have a reference to the transaction), which leads to jest choking on this
-        // instead we compare them in detail below
-        spans: [expect.any(Object), expect.any(Object)],
-        start_timestamp: expect.any(Number),
-        tags: {
-          'outer.tag': 'test value',
-          'test.tag': 'test value',
-        },
-        timestamp: expect.any(Number),
-        transaction: 'test name',
-        transaction_info: { source: 'task' },
-        type: 'transaction',
-      }),
-      {
-        event_id: expect.any(String),
+    expect(transactions).toHaveLength(1);
+    const transaction = transactions[0];
+
+    expect(transaction.breadcrumbs).toEqual([
+      { message: 'test breadcrumb 1', timestamp: 123456 },
+      { message: 'test breadcrumb 2', timestamp: 123456 },
+      { message: 'test breadcrumb 3', timestamp: 123456 },
+    ]);
+
+    expect(transaction.contexts?.otel).toEqual({
+      attributes: {
+        'test.outer': 'test value',
+        'sentry.op': 'test op',
+        'sentry.origin': 'auto.test',
+        'sentry.source': 'task',
       },
-    );
+      resource: {
+        'service.name': 'node',
+        'service.namespace': 'sentry',
+        'service.version': expect.any(String),
+        'telemetry.sdk.language': 'nodejs',
+        'telemetry.sdk.name': 'opentelemetry',
+        'telemetry.sdk.version': expect.any(String),
+      },
+    });
 
-    // Checking the spans here, as they are circular to the transaction...
-    const runArgs = beforeSendTransaction.mock.calls[0] as unknown as [TransactionEvent, unknown];
-    const spans = runArgs[0].spans || [];
+    expect(transaction.contexts?.trace).toEqual({
+      data: {
+        'otel.kind': 'INTERNAL',
+        'sentry.op': 'test op',
+        'sentry.origin': 'auto.test',
+        'sentry.source': 'task',
+        'sentry.sample_rate': 1,
+        'test.outer': 'test value',
+      },
+      op: 'test op',
+      span_id: expect.any(String),
+      status: 'ok',
+      trace_id: expect.any(String),
+      origin: 'auto.test',
+    });
+
+    expect(transaction.sdkProcessingMetadata?.sampleRate).toEqual(1);
+    expect(transaction.sdkProcessingMetadata?.requestPath).toEqual('test-path');
+    expect(transaction.sdkProcessingMetadata?.dynamicSamplingContext).toEqual({
+      environment: 'production',
+      public_key: expect.any(String),
+      sample_rate: '1',
+      sampled: 'true',
+      trace_id: expect.any(String),
+      transaction: 'test name',
+    });
+
+    expect(transaction.environment).toEqual('production');
+    expect(transaction.event_id).toEqual(expect.any(String));
+    expect(transaction.start_timestamp).toEqual(expect.any(Number));
+    expect(transaction.timestamp).toEqual(expect.any(Number));
+    expect(transaction.transaction).toEqual('test name');
+
+    expect(transaction.tags).toEqual({
+      'outer.tag': 'test value',
+      'test.tag': 'test value',
+    });
+    expect(transaction.transaction_info).toEqual({ source: 'task' });
+    expect(transaction.type).toEqual('transaction');
+
+    expect(transaction.spans).toHaveLength(2);
+    const spans = transaction.spans || [];
 
     // note: Currently, spans do not have any context/span added to them
     // This is the same behavior as for the "regular" SDKs