fix(core): Preserve mutated top-level SpanJSON fields in v1 to v2 conversion

v1 SpanJSON mirrors op/origin/profile_id/exclusive_time as top-level fields
alongside their attributes. A static `beforeSendSpan` edits the top-level field,
but the forward converter only copied `data`, so those edits were dropped from
the sent v2 span. Fold the top-level fields back into attributes (top-level wins
over the initially identical attribute), the inverse of `getSpanJSON`.

Author: logaretm

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

@@ -1,12 +1,35 @@
 import type { RawAttributes } from '../../attributes';
+import {
+  SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME,
+  SEMANTIC_ATTRIBUTE_PROFILE_ID,
+  SEMANTIC_ATTRIBUTE_SENTRY_OP,
+  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
+} from '../../semanticAttributes';
 import type { SerializedStreamedSpan, SpanJSON, StreamedSpanJSON } from '../../types/span';
 import { streamedSpanJsonToSerializedSpan } from '../../utils/spanUtils';
 
+// v1 SpanJSON mirrors some attributes as top-level fields (see `SentrySpan.getSpanJSON`). A
+// `beforeSendSpan` callback edits the top-level field, so those edits have to be folded back into
+// attributes, letting the top-level value win over the (initially identical) attribute. This is the
+// inverse of `getSpanJSON` and mirrors how `convertSpanJsonToTransactionEvent` rebuilds `data`.
+const TOP_LEVEL_ATTRIBUTE_FIELDS = [
+  ['op', SEMANTIC_ATTRIBUTE_SENTRY_OP],
+  ['origin', SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN],
+  ['profile_id', SEMANTIC_ATTRIBUTE_PROFILE_ID],
+  ['exclusive_time', SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME],
+] as const;
+
 /**
  * Converts a v1 SpanJSON (from a legacy transaction) to the intermediate v2 {@link StreamedSpanJSON}
  * (raw attributes), before serialization. Use this when a hook needs to mutate the span JSON.
  */
 export function spanJsonToStreamedSpanJSON(span: SpanJSON): StreamedSpanJSON {
+  const attributes = { ...(span.data as RawAttributes<Record<string, unknown>>) };
+
+  for (const [field, attribute] of TOP_LEVEL_ATTRIBUTE_FIELDS) {
+    attributes[attribute] = span[field] ?? attributes[attribute];
+  }
+
   return {
     trace_id: span.trace_id,
     span_id: span.span_id,
@@ -16,7 +39,7 @@ export function spanJsonToStreamedSpanJSON(span: SpanJSON): StreamedSpanJSON {
     end_timestamp: span.timestamp || span.start_timestamp,
     status: !span.status || span.status === 'ok' || span.status === 'cancelled' ? 'ok' : 'error',
     is_segment: false,
-    attributes: { ...(span.data as RawAttributes<Record<string, unknown>>) },
+    attributes,
     links: span.links,
   };
 }

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

@@ -79,6 +79,51 @@ describe('spanJsonToSerializedStreamedSpan', () => {
     expect(result.attributes['gen_ai.usage.output_tokens']).toEqual({ type: 'integer', value: 50 });
   });
 
+  it('maps top-level op/origin into sentry.op/sentry.origin attributes', () => {
+    const span = makeSpanJSON({ op: 'ui.interaction.click', origin: 'auto.http.browser.inp', data: {} });
+
+    const result = spanJsonToSerializedStreamedSpan(span);
+
+    expect(result.attributes['sentry.op']).toEqual({ type: 'string', value: 'ui.interaction.click' });
+    expect(result.attributes['sentry.origin']).toEqual({ type: 'string', value: 'auto.http.browser.inp' });
+  });
+
+  it('lets a mutated top-level op/origin win over the original data attribute', () => {
+    // A `beforeSendSpan` callback mutates the top-level field while the data attribute stays stale.
+    const span = makeSpanJSON({
+      op: 'changed.op',
+      origin: 'changed.origin',
+      data: { 'sentry.op': 'stale.op', 'sentry.origin': 'stale.origin' },
+    });
+
+    const result = spanJsonToSerializedStreamedSpan(span);
+
+    expect(result.attributes['sentry.op']).toEqual({ type: 'string', value: 'changed.op' });
+    expect(result.attributes['sentry.origin']).toEqual({ type: 'string', value: 'changed.origin' });
+  });
+
+  it('keeps the data attribute when there is no top-level op/origin', () => {
+    const span = makeSpanJSON({ op: undefined, origin: undefined, data: { 'sentry.op': 'from.data' } });
+
+    const result = spanJsonToSerializedStreamedSpan(span);
+
+    expect(result.attributes['sentry.op']).toEqual({ type: 'string', value: 'from.data' });
+    expect(result.attributes['sentry.origin']).toBeUndefined();
+  });
+
+  it('maps mutated top-level profile_id/exclusive_time back into attributes', () => {
+    const span = makeSpanJSON({
+      profile_id: 'new-profile',
+      exclusive_time: 42,
+      data: { 'sentry.profile_id': 'stale-profile', 'sentry.exclusive_time': 1 },
+    });
+
+    const result = spanJsonToSerializedStreamedSpan(span);
+
+    expect(result.attributes['sentry.profile_id']).toEqual({ type: 'string', value: 'new-profile' });
+    expect(result.attributes['sentry.exclusive_time']).toEqual({ type: 'integer', value: 42 });
+  });
+
   it('carries over links', () => {
     const span = makeSpanJSON({
       links: [{ trace_id: 'aabb', span_id: 'ccdd', sampled: true, attributes: { foo: 'bar' } }],