Remove SDK-side enrichment and redundant op/origin backfill

Author: andreiborza

packages/core/src/tracing/spans/spanJsonToStreamedSpan.ts

@@ -1,32 +1,11 @@
 import type { RawAttributes } from '../../attributes';
-import type { Client } from '../../client';
-import {
-  SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT,
-  SEMANTIC_ATTRIBUTE_SENTRY_OP,
-  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
-  SEMANTIC_ATTRIBUTE_SENTRY_RELEASE,
-  SEMANTIC_ATTRIBUTE_SENTRY_SDK_NAME,
-  SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION,
-  SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_ID,
-  SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME,
-  SEMANTIC_ATTRIBUTE_USER_EMAIL,
-  SEMANTIC_ATTRIBUTE_USER_ID,
-  SEMANTIC_ATTRIBUTE_USER_IP_ADDRESS,
-  SEMANTIC_ATTRIBUTE_USER_USERNAME,
-} from '../../semanticAttributes';
-import type { Event } from '../../types-hoist/event';
 import type { SerializedStreamedSpan, SpanJSON, StreamedSpanJSON } from '../../types-hoist/span';
 import { streamedSpanJsonToSerializedSpan } from '../../utils/spanUtils';
-import { safeSetSpanJSONAttributes } from './captureSpan';
 
 /**
  * Converts a v1 SpanJSON (from a legacy transaction) to a serialized v2 StreamedSpan.
  */
-export function spanJsonToSerializedStreamedSpan(
-  span: SpanJSON,
-  transactionEvent: Event,
-  client: Client,
-): SerializedStreamedSpan {
+export function spanJsonToSerializedStreamedSpan(span: SpanJSON): SerializedStreamedSpan {
   const streamedSpan: StreamedSpanJSON = {
     trace_id: span.trace_id,
     span_id: span.span_id,
@@ -40,33 +19,6 @@ export function spanJsonToSerializedStreamedSpan(
     links: span.links,
   };
 
-  // Fold op and origin into attributes
-  safeSetSpanJSONAttributes(streamedSpan, {
-    [SEMANTIC_ATTRIBUTE_SENTRY_OP]: span.op,
-    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: span.origin,
-  });
-
-  // Enrich from transaction event context (same pattern as captureSpan.ts applyCommonSpanAttributes)
-  const sdk = client.getSdkMetadata();
-  const { release, environment, sendDefaultPii } = client.getOptions();
-
-  safeSetSpanJSONAttributes(streamedSpan, {
-    [SEMANTIC_ATTRIBUTE_SENTRY_RELEASE]: transactionEvent.release || release,
-    [SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT]: transactionEvent.environment || environment,
-    [SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME]: transactionEvent.transaction,
-    [SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_ID]: transactionEvent.contexts?.trace?.span_id,
-    [SEMANTIC_ATTRIBUTE_SENTRY_SDK_NAME]: sdk?.sdk?.name,
-    [SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION]: sdk?.sdk?.version,
-    ...(sendDefaultPii
-      ? {
-          [SEMANTIC_ATTRIBUTE_USER_ID]: transactionEvent.user?.id,
-          [SEMANTIC_ATTRIBUTE_USER_EMAIL]: transactionEvent.user?.email,
-          [SEMANTIC_ATTRIBUTE_USER_IP_ADDRESS]: transactionEvent.user?.ip_address,
-          [SEMANTIC_ATTRIBUTE_USER_USERNAME]: transactionEvent.user?.username,
-        }
-      : {}),
-  });
-
   return streamedSpanJsonToSerializedSpan(streamedSpan);
 }
 

packages/core/test/lib/tracing/spans/spanJsonToStreamedSpan.test.ts

@@ -1,22 +1,6 @@
 import { describe, expect, it } from 'vitest';
-import {
-  SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT,
-  SEMANTIC_ATTRIBUTE_SENTRY_OP,
-  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
-  SEMANTIC_ATTRIBUTE_SENTRY_RELEASE,
-  SEMANTIC_ATTRIBUTE_SENTRY_SDK_NAME,
-  SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION,
-  SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_ID,
-  SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME,
-  SEMANTIC_ATTRIBUTE_USER_EMAIL,
-  SEMANTIC_ATTRIBUTE_USER_ID,
-  SEMANTIC_ATTRIBUTE_USER_IP_ADDRESS,
-  SEMANTIC_ATTRIBUTE_USER_USERNAME,
-} from '../../../../src';
-import type { Event } from '../../../../src/types-hoist/event';
 import type { SpanJSON } from '../../../../src/types-hoist/span';
 import { spanJsonToSerializedStreamedSpan } from '../../../../src/tracing/spans/spanJsonToStreamedSpan';
-import { getDefaultTestClientOptions, TestClient } from '../../../mocks/client';
 
 function makeSpanJSON(overrides: Partial<SpanJSON> = {}): SpanJSON {
   return {
@@ -28,31 +12,6 @@ function makeSpanJSON(overrides: Partial<SpanJSON> = {}): SpanJSON {
   };
 }
 
-function makeTransactionEvent(overrides: Partial<Event> = {}): Event {
-  return {
-    type: 'transaction',
-    transaction: 'GET /api/chat',
-    release: '1.0.0',
-    environment: 'production',
-    contexts: {
-      trace: {
-        span_id: 'root0000deadbeef',
-        trace_id: '00112233445566778899aabbccddeeff',
-      },
-    },
-    ...overrides,
-  };
-}
-
-function makeClient(options: Partial<Parameters<typeof getDefaultTestClientOptions>[0]> = {}): TestClient {
-  return new TestClient(
-    getDefaultTestClientOptions({
-      dsn: 'https://dsn@ingest.f00.f00/1',
-      ...options,
-    }),
-  );
-}
-
 describe('spanJsonToSerializedStreamedSpan', () => {
   it('maps basic SpanJSON fields to StreamedSpan fields', () => {
     const span = makeSpanJSON({
@@ -64,7 +23,7 @@ describe('spanJsonToSerializedStreamedSpan', () => {
       parent_span_id: 'parent00deadbeef',
     });
 
-    const result = spanJsonToSerializedStreamedSpan(span, makeTransactionEvent(), makeClient());
+    const result = spanJsonToSerializedStreamedSpan(span);
 
     expect(result.name).toBe('chat gpt-4');
     expect(result.start_timestamp).toBe(1000);
@@ -77,14 +36,12 @@ describe('spanJsonToSerializedStreamedSpan', () => {
   });
 
   it('uses empty string for name when description is undefined', () => {
-    const span = makeSpanJSON({ description: undefined });
-    const result = spanJsonToSerializedStreamedSpan(span, makeTransactionEvent(), makeClient());
+    const result = spanJsonToSerializedStreamedSpan(makeSpanJSON({ description: undefined }));
     expect(result.name).toBe('');
   });
 
   it('uses start_timestamp as end_timestamp when timestamp is undefined', () => {
-    const span = makeSpanJSON({ timestamp: undefined });
-    const result = spanJsonToSerializedStreamedSpan(span, makeTransactionEvent(), makeClient());
+    const result = spanJsonToSerializedStreamedSpan(makeSpanJSON({ timestamp: undefined }));
     expect(result.end_timestamp).toBe(1000);
   });
 
@@ -99,24 +56,11 @@ describe('spanJsonToSerializedStreamedSpan', () => {
     ];
 
     for (const [v1Status, expected] of cases) {
-      const span = makeSpanJSON({ status: v1Status });
-      const result = spanJsonToSerializedStreamedSpan(span, makeTransactionEvent(), makeClient());
+      const result = spanJsonToSerializedStreamedSpan(makeSpanJSON({ status: v1Status }));
       expect(result.status).toBe(expected);
     }
   });
 
-  it('folds op and origin into attributes', () => {
-    const span = makeSpanJSON({
-      op: 'gen_ai.chat',
-      origin: 'auto.ai.openai',
-    });
-
-    const result = spanJsonToSerializedStreamedSpan(span, makeTransactionEvent(), makeClient());
-
-    expect(result.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_OP]).toEqual({ type: 'string', value: 'gen_ai.chat' });
-    expect(result.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]).toEqual({ type: 'string', value: 'auto.ai.openai' });
-  });
-
   it('preserves existing span data attributes', () => {
     const span = makeSpanJSON({
       data: {
@@ -127,111 +71,20 @@ describe('spanJsonToSerializedStreamedSpan', () => {
       },
     });
 
-    const result = spanJsonToSerializedStreamedSpan(span, makeTransactionEvent(), makeClient());
+    const result = spanJsonToSerializedStreamedSpan(span);
 
     expect(result.attributes?.['gen_ai.system']).toEqual({ type: 'string', value: 'openai' });
     expect(result.attributes?.['gen_ai.request.model']).toEqual({ type: 'string', value: 'gpt-4' });
     expect(result.attributes?.['gen_ai.usage.input_tokens']).toEqual({ type: 'integer', value: 100 });
     expect(result.attributes?.['gen_ai.usage.output_tokens']).toEqual({ type: 'integer', value: 50 });
   });
 
-  it('enriches with transaction event context', () => {
-    const span = makeSpanJSON();
-    const event = makeTransactionEvent({
-      release: '2.0.0',
-      environment: 'staging',
-      transaction: 'POST /api/generate',
-      contexts: { trace: { span_id: 'segment0deadbeef' } },
-    });
-
-    const result = spanJsonToSerializedStreamedSpan(span, event, makeClient());
-
-    expect(result.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_RELEASE]).toEqual({ type: 'string', value: '2.0.0' });
-    expect(result.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT]).toEqual({ type: 'string', value: 'staging' });
-    expect(result.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME]).toEqual({
-      type: 'string',
-      value: 'POST /api/generate',
-    });
-    expect(result.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_ID]).toEqual({
-      type: 'string',
-      value: 'segment0deadbeef',
-    });
-  });
-
-  it('enriches with SDK metadata', () => {
-    const client = makeClient();
-    client.getOptions()._metadata = { sdk: { name: 'sentry.javascript.node', version: '9.0.0' } };
-
-    const span = makeSpanJSON();
-    const result = spanJsonToSerializedStreamedSpan(span, makeTransactionEvent(), client);
-
-    expect(result.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_SDK_NAME]).toEqual({
-      type: 'string',
-      value: 'sentry.javascript.node',
-    });
-    expect(result.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION]).toEqual({ type: 'string', value: '9.0.0' });
-  });
-
-  it('adds user attributes when sendDefaultPii is true', () => {
-    const client = makeClient({ sendDefaultPii: true });
-    const event = makeTransactionEvent({
-      user: { id: 'u123', email: 'a@b.com', ip_address: '1.2.3.4', username: 'alice' },
-    });
-
-    const span = makeSpanJSON();
-    const result = spanJsonToSerializedStreamedSpan(span, event, client);
-
-    expect(result.attributes?.[SEMANTIC_ATTRIBUTE_USER_ID]).toEqual({ type: 'string', value: 'u123' });
-    expect(result.attributes?.[SEMANTIC_ATTRIBUTE_USER_EMAIL]).toEqual({ type: 'string', value: 'a@b.com' });
-    expect(result.attributes?.[SEMANTIC_ATTRIBUTE_USER_IP_ADDRESS]).toEqual({ type: 'string', value: '1.2.3.4' });
-    expect(result.attributes?.[SEMANTIC_ATTRIBUTE_USER_USERNAME]).toEqual({ type: 'string', value: 'alice' });
-  });
-
-  it('does not add user attributes when sendDefaultPii is false', () => {
-    const client = makeClient({ sendDefaultPii: false });
-    const event = makeTransactionEvent({
-      user: { id: 'u123', email: 'a@b.com' },
-    });
-
-    const span = makeSpanJSON();
-    const result = spanJsonToSerializedStreamedSpan(span, event, client);
-
-    expect(result.attributes?.[SEMANTIC_ATTRIBUTE_USER_ID]).toBeUndefined();
-    expect(result.attributes?.[SEMANTIC_ATTRIBUTE_USER_EMAIL]).toBeUndefined();
-  });
-
-  it('does not overwrite pre-existing span data attributes with enrichment', () => {
-    const span = makeSpanJSON({
-      data: {
-        [SEMANTIC_ATTRIBUTE_SENTRY_RELEASE]: 'span-level-release',
-        [SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT]: 'span-level-env',
-      },
-    });
-
-    const event = makeTransactionEvent({
-      release: 'event-level-release',
-      environment: 'event-level-env',
-    });
-
-    const result = spanJsonToSerializedStreamedSpan(span, event, makeClient());
-
-    // Span-level values should win
-    expect(result.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_RELEASE]).toEqual({
-      type: 'string',
-      value: 'span-level-release',
-    });
-    expect(result.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT]).toEqual({
-      type: 'string',
-      value: 'span-level-env',
-    });
-  });
-
   it('carries over links', () => {
     const span = makeSpanJSON({
       links: [{ trace_id: 'aabb', span_id: 'ccdd', sampled: true, attributes: { foo: 'bar' } }],
     });
 
-    const result = spanJsonToSerializedStreamedSpan(span, makeTransactionEvent(), makeClient());
+    const result = spanJsonToSerializedStreamedSpan(span);
 
     expect(result.links).toEqual([
       { trace_id: 'aabb', span_id: 'ccdd', sampled: true, attributes: { foo: { type: 'string', value: 'bar' } } },