rewrite to captureSpan

Author: Lms24

packages/browser/src/integrations/spanstreaming.ts

@@ -1,27 +1,12 @@
-import type { Client, IntegrationFn, Scope, ScopeData, Span, SpanAttributes, SpanV2JSON } from '@sentry/core';
+import type { Client, IntegrationFn, Span, SpanV2JSON } from '@sentry/core';
 import {
+  captureSpan,
   createSpanV2Envelope,
   debug,
   defineIntegration,
-  getCapturedScopesOnSpan,
   getDynamicSamplingContextFromSpan,
-  getGlobalScope,
   INTERNAL_getSegmentSpan,
   isV2BeforeSendSpanCallback,
-  mergeScopeData,
-  reparentChildSpans,
-  SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME,
-  SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT,
-  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,
-  shouldIgnoreSpan,
   showSpanDropWarning,
   spanToV2JSON,
 } from '@sentry/core';
@@ -72,7 +57,7 @@ export const spanStreamingIntegration = defineIntegration(((userOptions?: Partia
         return;
       }
 
-      client.on('spanEnd', span => {
+      client.on('enqueueSpan', span => {
         const spanTreeMapKey = getSpanTreeMapKey(span);
         const spanBuffer = spanTreeMap.get(spanTreeMapKey);
         if (spanBuffer) {
@@ -82,10 +67,14 @@ export const spanStreamingIntegration = defineIntegration(((userOptions?: Partia
         }
       });
 
+      client.on('afterSpanEnd', span => {
+        captureSpan(span, client);
+      });
+
       // For now, we send all spans on local segment (root) span end.
       // TODO: This will change once we have more concrete ideas about a universal SDK data buffer.
-      client.on('segmentSpanEnd', segmentSpan => {
-        processAndSendSpans(segmentSpan, {
+      client.on('afterSegmentSpanEnd', segmentSpan => {
+        sendSegment(segmentSpan, {
           spanTreeMap: spanTreeMap,
           client,
           batchLimit: options.batchLimit,
@@ -110,7 +99,7 @@ function getSpanTreeMapKey(span: Span): string {
   return `${span.spanContext().traceId}-${INTERNAL_getSegmentSpan(span).spanContext().spanId}`;
 }
 
-function processAndSendSpans(
+function sendSegment(
   segmentSpan: Span,
   { client, spanTreeMap, batchLimit, beforeSendSpan }: SpanProcessingOptions,
 ): void {
@@ -123,54 +112,17 @@ function processAndSendSpans(
     return;
   }
 
-  const segmentSpanJson = spanToV2JSON(segmentSpan);
-
-  for (const span of spansOfTrace) {
-    applyCommonSpanAttributes(span, segmentSpanJson, client);
-  }
-
-  const { ignoreSpans } = client.getOptions();
-
-  // 1. Check if the entire span tree is ignored by ignoreSpans
-  if (ignoreSpans?.length && shouldIgnoreSpan(segmentSpanJson, ignoreSpans)) {
-    client.recordDroppedEvent('before_send', 'span', spansOfTrace.size);
-    spanTreeMap.delete(spanTreeMapKey);
-    return;
-  }
-
-  const serializedSpans = Array.from(spansOfTrace ?? []).map(s => {
-    const serialized = spanToV2JSON(s);
-    // remove internal span attributes we don't need to send.
-    delete serialized.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME];
-    return serialized;
-  });
-
-  const processedSpans = [];
-  let ignoredSpanCount = 0;
-
-  for (const span of serializedSpans) {
-    // 2. Check if child spans should be ignored
-    const isChildSpan = span.span_id !== segmentSpan.spanContext().spanId;
-    if (ignoreSpans?.length && isChildSpan && shouldIgnoreSpan(span, ignoreSpans)) {
-      reparentChildSpans(serializedSpans, span);
-      ignoredSpanCount++;
-      // drop this span by not adding it to the processedSpans array
-      continue;
+  const finalSpans = Array.from(spansOfTrace).map(span => {
+    const spanJson = spanToV2JSON(span);
+    if (beforeSendSpan) {
+      return applyBeforeSendSpanCallback(spanJson, beforeSendSpan);
     }
-
-    // 3. Apply beforeSendSpan callback
-    // TODO: validate beforeSendSpan result/pass in a copy and merge afterwards
-    const processedSpan = beforeSendSpan ? applyBeforeSendSpanCallback(span, beforeSendSpan) : span;
-    processedSpans.push(processedSpan);
-  }
-
-  if (ignoredSpanCount) {
-    client.recordDroppedEvent('before_send', 'span', ignoredSpanCount);
-  }
+    return spanJson;
+  });
 
   const batches: SpanV2JSON[][] = [];
-  for (let i = 0; i < processedSpans.length; i += batchLimit) {
-    batches.push(processedSpans.slice(i, i + batchLimit));
+  for (let i = 0; i < finalSpans.length; i += batchLimit) {
+    batches.push(finalSpans.slice(i, i + batchLimit));
   }
 
   DEBUG_BUILD && debug.log(`Sending trace ${traceId} in ${batches.length} batch${batches.length === 1 ? '' : 'es'}`);
@@ -190,35 +142,6 @@ function processAndSendSpans(
   spanTreeMap.delete(spanTreeMapKey);
 }
 
-function applyCommonSpanAttributes(span: Span, serializedSegmentSpan: SpanV2JSON, client: Client): void {
-  const sdk = client.getSdkMetadata();
-  const { release, environment, sendDefaultPii } = client.getOptions();
-
-  const { isolationScope: spanIsolationScope, scope: spanScope } = getCapturedScopesOnSpan(span);
-
-  const originalAttributeKeys = Object.keys(spanToV2JSON(span).attributes ?? {});
-
-  const finalScopeData = getFinalScopeData(spanIsolationScope, spanScope);
-
-  // avoid overwriting any previously set attributes (from users or potentially our SDK instrumentation)
-  setAttributesIfNotPresent(span, originalAttributeKeys, {
-    [SEMANTIC_ATTRIBUTE_SENTRY_RELEASE]: release,
-    [SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT]: environment,
-    [SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME]: serializedSegmentSpan.name,
-    [SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_ID]: serializedSegmentSpan.span_id,
-    [SEMANTIC_ATTRIBUTE_SENTRY_SDK_NAME]: sdk?.sdk?.name,
-    [SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION]: sdk?.sdk?.version,
-    ...(sendDefaultPii
-      ? {
-          [SEMANTIC_ATTRIBUTE_USER_ID]: finalScopeData.user?.id,
-          [SEMANTIC_ATTRIBUTE_USER_EMAIL]: finalScopeData.user?.email,
-          [SEMANTIC_ATTRIBUTE_USER_IP_ADDRESS]: finalScopeData.user?.ip_address ?? undefined,
-          [SEMANTIC_ATTRIBUTE_USER_USERNAME]: finalScopeData.user?.username,
-        }
-      : {}),
-  });
-}
-
 function applyBeforeSendSpanCallback(span: SpanV2JSON, beforeSendSpan: (span: SpanV2JSON) => SpanV2JSON): SpanV2JSON {
   const modifedSpan = beforeSendSpan(span);
   if (!modifedSpan) {
@@ -227,23 +150,3 @@ function applyBeforeSendSpanCallback(span: SpanV2JSON, beforeSendSpan: (span: Sp
   }
   return modifedSpan;
 }
-
-function setAttributesIfNotPresent(span: Span, originalAttributeKeys: string[], newAttributes: SpanAttributes): void {
-  Object.keys(newAttributes).forEach(key => {
-    if (!originalAttributeKeys.includes(key)) {
-      span.setAttribute(key, newAttributes[key]);
-    }
-  });
-}
-
-// TODO: Extract this to a helper in core. It's used in multiple places.
-function getFinalScopeData(isolationScope: Scope | undefined, scope: Scope | undefined): ScopeData {
-  const finalScopeData = getGlobalScope().getScopeData();
-  if (isolationScope) {
-    mergeScopeData(finalScopeData, isolationScope.getScopeData());
-  }
-  if (scope) {
-    mergeScopeData(finalScopeData, scope.getScopeData());
-  }
-  return finalScopeData;
-}

packages/core/src/client.ts

@@ -608,13 +608,19 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
    */
   public on(hook: 'spanEnd', callback: (span: Span) => void): () => void;
 
+  // Hooks reserved for Span-First span processing:
   /**
    * Register a callback for after a span is ended.
-   * NOTE: The span cannot be mutated anymore in this callback.
-   * Receives the span as argument.
-   * @returns {() => void} A function that, when executed, removes the registered callback.
    */
-  public on(hook: 'segmentSpanEnd', callback: (span: Span) => void): () => void;
+  public on(hook: 'afterSpanEnd', callback: (span: Span) => void): () => void;
+  /**
+   * Register a callback for after a segment span is ended.
+   */
+  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.
+   */
+  public on(hook: 'enqueueSpan', callback: (span: Span) => void): () => void;
 
   /**
    * Register a callback for when an idle span is allowed to auto-finish.
@@ -888,8 +894,13 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
   /** Fire a hook whenever a span ends. */
   public emit(hook: 'spanEnd', span: Span): void;
 
-  /** Fire a hook whenever a segment span ends. */
-  public emit(hook: 'segmentSpanEnd', span: Span): void;
+  // 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 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;
 
   /**
    * Fire a hook indicating that an idle span is allowed to auto finish.

packages/core/src/index.ts

@@ -89,6 +89,7 @@ export {
   spanToV2JSON,
   showSpanDropWarning,
 } from './utils/spanUtils';
+export { captureSpan } from './spans/captureSpan';
 export { attributesFromObject } from './utils/attributes';
 export { _setSpanForScope as _INTERNAL_setSpanForScope } from './utils/spanOnScope';
 export { parseSampleRate } from './utils/parseSampleRate';

packages/core/src/tracing/sentrySpan.ts

@@ -316,6 +316,7 @@ export class SentrySpan implements Span {
     const client = getClient();
     if (client) {
       client.emit('spanEnd', this);
+      client.emit('afterSpanEnd', this);
     }
 
     // A segment span is basically the root span of a local span tree.
@@ -341,7 +342,7 @@ export class SentrySpan implements Span {
       return;
     } else if (client?.getOptions().traceLifecycle === 'stream') {
       // TODO (spans): Remove standalone span custom logic in favor of sending simple v2 web vital spans
-      client?.emit('segmentSpanEnd', this);
+      client?.emit('afterSegmentSpanEnd', this);
       return;
     }
 

packages/core/src/tracing/trace.ts

@@ -491,6 +491,7 @@ function _startChildSpan(parentSpan: Span, scope: Scope, spanArguments: SentrySp
     // If it has an endTimestamp, it's already ended
     if (spanArguments.endTimestamp) {
       client.emit('spanEnd', childSpan);
+      client.emit('afterSpanEnd', childSpan);
     }
   }
 

packages/core/src/types-hoist/options.ts

@@ -1,3 +1,4 @@
+import { RawAttributes } from '../attributes';
 import type { CaptureContext } from '../scope';
 import type { Breadcrumb, BreadcrumbHint } from './breadcrumb';
 import type { ErrorEvent, EventHint, TransactionEvent } from './event';

packages/opentelemetry/src/spanProcessor.ts

@@ -56,6 +56,7 @@ function onSpanEnd(span: Span): void {
 
   const client = getClient();
   client?.emit('spanEnd', span);
+  client?.emit('afterSpanEnd', span);
 }
 
 /**