rewrite pipeline to just always use spanJSonV2 because thanks OTel

Author: Lms24

.vscode/settings.json

@@ -28,5 +28,6 @@
   "editor.defaultFormatter": "esbenp.prettier-vscode",
   "[typescript]": {
     "editor.defaultFormatter": "esbenp.prettier-vscode"
-  }
+  },
+  "angular.enable-strict-mode-prompt": false
 }

packages/browser/src/integrations/httpcontext.ts

@@ -1,7 +1,7 @@
 import {
   defineIntegration,
   httpHeadersToSpanAttributes,
-  safeSetSpanAttributes,
+  safeSetSpanJSONAttributes,
   SEMANTIC_ATTRIBUTE_URL_FULL,
 } from '@sentry/core';
 import { getHttpRequestData, WINDOW } from '../helpers';
@@ -21,19 +21,19 @@ export const httpContextIntegration = defineIntegration(() => {
       }
 
       if (client.getOptions().traceLifecycle === 'stream') {
-        client.on('processSpan', (span, { readOnlySpan }) => {
-          if (readOnlySpan.is_segment) {
+        client.on('processSpan', spanJSON => {
+          if (spanJSON.is_segment) {
             const { url, headers } = getHttpRequestData();
 
             const attributeHeaders = httpHeadersToSpanAttributes(headers);
 
-            safeSetSpanAttributes(
-              span,
+            safeSetSpanJSONAttributes(
+              spanJSON,
               {
                 [SEMANTIC_ATTRIBUTE_URL_FULL]: url,
                 ...attributeHeaders,
               },
-              readOnlySpan.attributes,
+              spanJSON.attributes,
             );
           }
         });

packages/browser/src/integrations/spanstreaming.ts

@@ -1,14 +1,12 @@
-import type { Client, IntegrationFn, Span, SpanV2JSON } from '@sentry/core';
+import type { Client, IntegrationFn, Span, SpanV2JSON, SpanV2JSONWithSegmentRef } from '@sentry/core';
 import {
   captureSpan,
   createSpanV2Envelope,
   debug,
   defineIntegration,
   getDynamicSamplingContextFromSpan,
-  INTERNAL_getSegmentSpan,
   isV2BeforeSendSpanCallback,
   showSpanDropWarning,
-  spanToV2JSON,
 } from '@sentry/core';
 import { DEBUG_BUILD } from '../debug-build';
 
@@ -35,7 +33,7 @@ export const spanStreamingIntegration = defineIntegration(((userOptions?: Partia
   };
 
   // key: traceId-segmentSpanId
-  const spanTreeMap = new Map<string, Set<Span>>();
+  const spanTreeMap = new Map<string, Set<SpanV2JSONWithSegmentRef>>();
 
   return {
     name: 'SpanStreaming',
@@ -57,13 +55,13 @@ export const spanStreamingIntegration = defineIntegration(((userOptions?: Partia
         return;
       }
 
-      client.on('enqueueSpan', span => {
-        const spanTreeMapKey = getSpanTreeMapKey(span);
+      client.on('enqueueSpan', spanJSON => {
+        const spanTreeMapKey = getSpanTreeMapKey(spanJSON as SpanV2JSONWithSegmentRef);
         const spanBuffer = spanTreeMap.get(spanTreeMapKey);
         if (spanBuffer) {
-          spanBuffer.add(span);
+          spanBuffer.add(spanJSON as SpanV2JSONWithSegmentRef);
         } else {
-          spanTreeMap.set(spanTreeMapKey, new Set([span]));
+          spanTreeMap.set(spanTreeMapKey, new Set([spanJSON as SpanV2JSONWithSegmentRef]));
         }
       });
 
@@ -87,37 +85,42 @@ export const spanStreamingIntegration = defineIntegration(((userOptions?: Partia
 
 interface SpanProcessingOptions {
   client: Client;
-  spanTreeMap: Map<string, Set<Span>>;
+  spanTreeMap: Map<string, Set<SpanV2JSONWithSegmentRef>>;
   batchLimit: number;
   beforeSendSpan: ((span: SpanV2JSON) => SpanV2JSON) | undefined;
 }
 
 /**
  * Just the traceid alone isn't enough because there can be multiple span trees with the same traceid.
  */
-function getSpanTreeMapKey(span: Span): string {
-  return `${span.spanContext().traceId}-${INTERNAL_getSegmentSpan(span).spanContext().spanId}`;
+function getSpanTreeMapKey(spanJSON: SpanV2JSONWithSegmentRef): string {
+  return `${spanJSON.trace_id}-${spanJSON._segmentSpan?.spanContext().spanId || spanJSON.span_id}`;
 }
 
 function sendSegment(
   segmentSpan: Span,
   { client, spanTreeMap, batchLimit, beforeSendSpan }: SpanProcessingOptions,
 ): void {
   const traceId = segmentSpan.spanContext().traceId;
-  const spanTreeMapKey = getSpanTreeMapKey(segmentSpan);
+  const segmentSpanId = segmentSpan.spanContext().spanId;
+  const spanTreeMapKey = `${traceId}-${segmentSpanId}`;
   const spansOfTrace = spanTreeMap.get(spanTreeMapKey);
 
   if (!spansOfTrace?.size) {
     spanTreeMap.delete(spanTreeMapKey);
     return;
   }
 
-  const finalSpans = Array.from(spansOfTrace).map(span => {
-    const spanJson = spanToV2JSON(span);
+  // Apply beforeSendSpan callback and clean up segment span references
+  const finalSpans = Array.from(spansOfTrace).map(spanJSON => {
+    // Remove the segment span reference before processing
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { _segmentSpan, ...cleanSpanJSON } = spanJSON;
+
     if (beforeSendSpan) {
-      return applyBeforeSendSpanCallback(spanJson, beforeSendSpan);
+      return applyBeforeSendSpanCallback(cleanSpanJSON, beforeSendSpan);
     }
-    return spanJson;
+    return cleanSpanJSON;
   });
 
   const batches: SpanV2JSON[][] = [];
@@ -127,6 +130,7 @@ function sendSegment(
 
   DEBUG_BUILD && debug.log(`Sending trace ${traceId} in ${batches.length} batch${batches.length === 1 ? '' : 'es'}`);
 
+  // Compute DSC from the segment span (passed as parameter)
   const dsc = getDynamicSamplingContextFromSpan(segmentSpan);
 
   for (const batch of batches) {

packages/core/src/client.ts

@@ -618,13 +618,13 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
    */
   public on(hook: 'afterSegmentSpanEnd', callback: (span: Span) => void): () => void;
   /**
-   * Register a callback for when the span is ready to be enqueued into the span buffer.
+   * Register a callback for when the span JSON is ready to be enqueued into the span buffer.
    */
-  public on(hook: 'enqueueSpan', callback: (span: Span) => void): () => void;
+  public on(hook: 'enqueueSpan', callback: (spanJSON: SpanV2JSON) => void): () => void;
   /**
-   * Register a callback for when a span is processed, to add some attributes to the span.
+   * Register a callback for when a span JSON is processed, to add some attributes to the span JSON.
    */
-  public on(hook: 'processSpan', callback: (span: Span, hint: { readOnlySpan: SpanV2JSON }) => void): () => void;
+  public on(hook: 'processSpan', callback: (spanJSON: SpanV2JSON, hint: { readOnlySpan: Span }) => void): () => void;
 
   /**
    * Register a callback for when an idle span is allowed to auto-finish.
@@ -901,12 +901,12 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
   // Hooks reserved for Span-First span processing:
   /** Fire a hook after the `spanEnd` hook  */
   public emit(hook: 'afterSpanEnd', span: Span): void;
-  /** Fire a hook after a span is processed, to add some attributes to the span. */
-  public emit(hook: 'processSpan', span: Span, hint: { readOnlySpan: SpanV2JSON }): void;
+  /** Fire a hook after a span is processed, to add some attributes to the span JSON. */
+  public emit(hook: 'processSpan', spanJSON: SpanV2JSON, hint: { readOnlySpan: Span }): void;
   /** Fire a hook after the `segmentSpanEnd` hook is fired. */
   public emit(hook: 'afterSegmentSpanEnd', span: Span): void;
   /** Fire a hook after a span ready to be enqueued into the span buffer. */
-  public emit(hook: 'enqueueSpan', span: Span): void;
+  public emit(hook: 'enqueueSpan', spanJSON: SpanV2JSON): void;
 
   /**
    * Fire a hook indicating that an idle span is allowed to auto finish.

packages/core/src/index.ts

@@ -90,7 +90,8 @@ export {
   showSpanDropWarning,
 } from './utils/spanUtils';
 export { captureSpan } from './spans/captureSpan';
-export { safeSetSpanAttributes } from './spans/spanFirstUtils';
+export type { SpanV2JSONWithSegmentRef } from './spans/captureSpan';
+export { safeSetSpanAttributes, safeSetSpanJSONAttributes } from './spans/spanFirstUtils';
 export { attributesFromObject } from './utils/attributes';
 export { _setSpanForScope as _INTERNAL_setSpanForScope } from './utils/spanOnScope';
 export { parseSampleRate } from './utils/parseSampleRate';

packages/core/src/spans/captureSpan.ts

@@ -20,17 +20,32 @@ import type { Span, SpanV2JSON } from '../types-hoist/span';
 import { mergeScopeData } from '../utils/applyScopeDataToEvent';
 import { debug } from '../utils/debug-logger';
 import { INTERNAL_getSegmentSpan, spanToV2JSON } from '../utils/spanUtils';
-import { safeSetSpanAttributes } from './spanFirstUtils';
+import { safeSetSpanJSONAttributes } from './spanFirstUtils';
 
 /**
- * Captures a span and returns it to the caller, to be enqueued for sending.
+ * A SpanV2JSON with an attached reference to the segment span.
+ * This reference is used to compute dynamic sampling context before sending.
+ * The reference MUST be removed before sending the span envelope.
  */
-export function captureSpan(span: Span, client = getClient()): Span | void {
+export interface SpanV2JSONWithSegmentRef extends SpanV2JSON {
+  _segmentSpan: Span;
+}
+
+/**
+ * Captures a span and returns a JSON representation to be enqueued for sending.
+ *
+ * IMPORTANT: This function converts the span to JSON immediately to avoid writing
+ * to an already-ended OTel span instance (which is blocked by the OTel Span class).
+ */
+export function captureSpan(span: Span, client = getClient()): SpanV2JSONWithSegmentRef | void {
   if (!client) {
     DEBUG_BUILD && debug.warn('No client available to capture span.');
     return;
   }
 
+  // Convert to JSON FIRST - we cannot write to an already-ended span
+  const spanJSON = spanToV2JSON(span) as SpanV2JSONWithSegmentRef;
+
   const segmentSpan = INTERNAL_getSegmentSpan(span);
   const serializedSegmentSpan = spanToV2JSON(segmentSpan);
 
@@ -39,44 +54,39 @@ export function captureSpan(span: Span, client = getClient()): Span | void {
 
   const originalAttributes = serializedSegmentSpan.attributes ?? {};
 
-  applyCommonSpanAttributes(span, serializedSegmentSpan, client, finalScopeData, originalAttributes);
+  applyCommonSpanAttributes(spanJSON, serializedSegmentSpan, client, finalScopeData, originalAttributes);
 
   if (span === segmentSpan) {
-    applyScopeToSegmentSpan(span, finalScopeData, originalAttributes);
+    applyScopeToSegmentSpan(spanJSON, finalScopeData, originalAttributes);
   }
 
-  // Allow integrations to add additional data to span. Pass in a serialized
-  // span to avoid having to potentially serialize the span in every integration
-  // (for improved performance).
-  client.emit('processSpan', span, { readOnlySpan: spanToV2JSON(span) });
-
-  // Wondering where we apply the beforeSendSpan callback?
-  // We apply it directly before sending the span,
-  // so whenever the buffer this span gets enqueued in is being flushed.
-  // Why? Because we have to enqueue the span instance itself, not a JSON object.
-  // We could temporarily convert to JSON here but this means that we'd then again
-  // have to mutate the `span` instance (doesn't work for every kind of object mutation)
-  // or construct a fully new span object. The latter is risky because users (or we) could hold
-  // references to the original span instance.
-  client.emit('enqueueSpan', span);
-
-  return span;
+  // Attach segment span reference for DSC generation at send time
+  spanJSON._segmentSpan = segmentSpan;
+
+  // Allow integrations to add additional data to the span JSON
+  client.emit('processSpan', spanJSON, { readOnlySpan: span });
+
+  // Enqueue the JSON representation for sending
+  // Note: We now enqueue JSON instead of the span instance to avoid mutating ended spans
+  client.emit('enqueueSpan', spanJSON);
+
+  return spanJSON;
 }
 
 function applyScopeToSegmentSpan(
-  segmentSpan: Span,
+  segmentSpanJSON: SpanV2JSON,
   scopeData: ScopeData,
   originalAttributes: SerializedAttributes,
 ): void {
   // TODO: Apply all scope data from auto instrumentation (contexts, request) to segment span
   const { attributes } = scopeData;
   if (attributes) {
-    safeSetSpanAttributes(segmentSpan, attributes, originalAttributes);
+    safeSetSpanJSONAttributes(segmentSpanJSON, attributes, originalAttributes);
   }
 }
 
 function applyCommonSpanAttributes(
-  span: Span,
+  spanJSON: SpanV2JSON,
   serializedSegmentSpan: SpanV2JSON,
   client: Client,
   scopeData: ScopeData,
@@ -86,8 +96,8 @@ function applyCommonSpanAttributes(
   const { release, environment, sendDefaultPii } = client.getOptions();
 
   // avoid overwriting any previously set attributes (from users or potentially our SDK instrumentation)
-  safeSetSpanAttributes(
-    span,
+  safeSetSpanJSONAttributes(
+    spanJSON,
     {
       [SEMANTIC_ATTRIBUTE_SENTRY_RELEASE]: release,
       [SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT]: environment,

packages/core/src/spans/spanFirstUtils.ts

@@ -1,7 +1,8 @@
 import type { RawAttributes } from '../attributes';
 import { isAttributeObject } from '../attributes';
 import type { SerializedAttributes } from '../types-hoist/attributes';
-import type { Span } from '../types-hoist/span';
+import type { Span, SpanV2JSON } from '../types-hoist/span';
+import { attributeValueToSerializedAttribute } from '../utils/attributes';
 
 /**
  * Only set a span attribute if it is not already set.
@@ -18,6 +19,26 @@ export function safeSetSpanAttributes(
   });
 }
 
+/**
+ * Only set a span JSON attribute if it is not already set.
+ * This is used to safely set attributes on JSON objects without mutating already-ended span instances.
+ */
+export function safeSetSpanJSONAttributes(
+  spanJSON: SpanV2JSON,
+  newAttributes: RawAttributes<Record<string, unknown>>,
+  originalAttributeKeys: SerializedAttributes | undefined,
+): void {
+  if (!spanJSON.attributes) {
+    spanJSON.attributes = {};
+  }
+
+  Object.keys(newAttributes).forEach(key => {
+    if (!originalAttributeKeys?.[key]) {
+      setAttributeOnSpanJSONWithMaybeUnit(spanJSON, key, newAttributes[key]);
+    }
+  });
+}
+
 function setAttributeOnSpanWithMaybeUnit(span: Span, attributeKey: string, attributeValue: unknown): void {
   if (isAttributeObject(attributeValue)) {
     const { value, unit } = attributeValue;
@@ -34,6 +55,35 @@ function setAttributeOnSpanWithMaybeUnit(span: Span, attributeKey: string, attri
   }
 }
 
+function setAttributeOnSpanJSONWithMaybeUnit(
+  spanJSON: SpanV2JSON,
+  attributeKey: string,
+  attributeValue: unknown,
+): void {
+  // Ensure attributes object exists (it's initialized in safeSetSpanJSONAttributes)
+  if (!spanJSON.attributes) {
+    return;
+  }
+
+  if (isAttributeObject(attributeValue)) {
+    const { value, unit } = attributeValue;
+
+    if (isSupportedSerializableType(value)) {
+      spanJSON.attributes[attributeKey] = attributeValueToSerializedAttribute(value);
+    }
+
+    if (unit) {
+      spanJSON.attributes[`${attributeKey}.unit`] = attributeValueToSerializedAttribute(unit);
+    }
+  } else if (isSupportedSerializableType(attributeValue)) {
+    spanJSON.attributes[attributeKey] = attributeValueToSerializedAttribute(attributeValue);
+  }
+}
+
 function isSupportedAttributeType(value: unknown): value is Parameters<Span['setAttribute']>[1] {
   return ['string', 'number', 'boolean'].includes(typeof value) || Array.isArray(value);
 }
+
+function isSupportedSerializableType(value: unknown): boolean {
+  return ['string', 'number', 'boolean'].includes(typeof value) || Array.isArray(value);
+}

packages/node-core/src/index.ts

@@ -136,6 +136,7 @@ export {
   wrapMcpServerWithSentry,
   featureFlagsIntegration,
   metrics,
+  withStreamSpan,
 } from '@sentry/core';
 
 export type {

packages/node/src/index.ts

@@ -191,4 +191,5 @@ export {
   cron,
   NODE_VERSION,
   validateOpenTelemetrySetup,
+  withStreamSpan,
 } from '@sentry/node-core';