apply scope contexts, extras, request data attributes

Author: Lms24

packages/browser/src/integrations/spanstreaming.ts

@@ -1,20 +1,24 @@
-import type { Client, IntegrationFn, Span, SpanAttributes, SpanAttributeValue, SpanV2JSON } from '@sentry/core';
+import type { Client, IntegrationFn, Scope, ScopeData, Span, SpanAttributes, SpanV2JSON } from '@sentry/core';
 import {
+  attributesFromObject,
   createSpanV2Envelope,
   debug,
   defineIntegration,
   getCapturedScopesOnSpan,
   getDynamicSamplingContextFromSpan,
   getGlobalScope,
   getRootSpan as getSegmentSpan,
+  httpHeadersToSpanAttributes,
   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_NAME,
+  SEMANTIC_ATTRIBUTE_URL_FULL,
   SEMANTIC_ATTRIBUTE_USER_EMAIL,
   SEMANTIC_ATTRIBUTE_USER_ID,
   SEMANTIC_ATTRIBUTE_USER_IP_ADDRESS,
@@ -24,6 +28,7 @@ import {
   spanToV2JSON,
 } from '@sentry/core';
 import { DEBUG_BUILD } from '../debug-build';
+import { getHttpRequestData } from '../helpers';
 
 export interface SpanStreamingOptions {
   batchLimit: number;
@@ -40,11 +45,11 @@ export const spanStreamingIntegration = defineIntegration(((userOptions?: Partia
   }
 
   const options: SpanStreamingOptions = {
+    ...userOptions,
     batchLimit:
       userOptions?.batchLimit && userOptions.batchLimit <= 1000 && userOptions.batchLimit >= 1
         ? userOptions.batchLimit
         : 1000,
-    ...userOptions,
   };
 
   // key: traceId-segmentSpanId
@@ -59,14 +64,14 @@ export const spanStreamingIntegration = defineIntegration(((userOptions?: Partia
       const initialMessage = 'spanStreamingIntegration requires';
       const fallbackMsg = 'Falling back to static trace lifecycle.';
 
-      if (clientOptions.traceLifecycle !== 'streamed') {
-        DEBUG_BUILD && debug.warn(`${initialMessage} \`traceLifecycle\` to be set to "streamed"! ${fallbackMsg}`);
+      if (clientOptions.traceLifecycle !== 'stream') {
+        DEBUG_BUILD && debug.warn(`${initialMessage} \`traceLifecycle\` to be set to "stream"! ${fallbackMsg}`);
         return;
       }
 
       if (beforeSendSpan && !isV2BeforeSendSpanCallback(beforeSendSpan)) {
-        DEBUG_BUILD &&
-          debug.warn(`${initialMessage} a beforeSendSpan callback using \`makeV2Callback\`! ${fallbackMsg}`);
+        client.getOptions().traceLifecycle = 'static';
+        debug.warn(`${initialMessage} a beforeSendSpan callback using \`makeV2Callback\`! ${fallbackMsg}`);
         return;
       }
 
@@ -82,16 +87,14 @@ export const spanStreamingIntegration = defineIntegration(((userOptions?: Partia
 
       // 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, {
-            spanTreeMap: spanTreeMap,
-            client,
-            batchLimit: options.batchLimit,
-            beforeSendSpan,
-          }),
-      );
+      client.on('segmentSpanEnd', segmentSpan => {
+        processAndSendSpans(segmentSpan, {
+          spanTreeMap: spanTreeMap,
+          client,
+          batchLimit: options.batchLimit,
+          beforeSendSpan,
+        });
+      });
     },
   };
 }) satisfies IntegrationFn);
@@ -122,12 +125,15 @@ function processAndSendSpans(
     spanTreeMap.delete(spanTreeMapKey);
     return;
   }
+
   const segmentSpanJson = spanToV2JSON(segmentSpan);
 
   for (const span of spansOfTrace) {
     applyCommonSpanAttributes(span, segmentSpanJson, client);
   }
 
+  applyScopeToSegmentSpan(segmentSpan, segmentSpanJson, client);
+
   // TODO: Apply scope data and contexts to segment span
 
   const { ignoreSpans } = client.getOptions();
@@ -139,7 +145,12 @@ function processAndSendSpans(
     return;
   }
 
-  const serializedSpans = Array.from(spansOfTrace ?? []).map(spanToV2JSON);
+  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;
@@ -168,7 +179,7 @@ function processAndSendSpans(
     batches.push(processedSpans.slice(i, i + batchLimit));
   }
 
-  DEBUG_BUILD && debug.log(`Sending trace ${traceId} in ${batches.length} batche${batches.length === 1 ? '' : 's'}`);
+  DEBUG_BUILD && debug.log(`Sending trace ${traceId} in ${batches.length} batch${batches.length === 1 ? '' : 'es'}`);
 
   const dsc = getDynamicSamplingContextFromSpan(segmentSpan);
 
@@ -193,14 +204,7 @@ function applyCommonSpanAttributes(span: Span, serializedSegmentSpan: SpanV2JSON
 
   const originalAttributeKeys = Object.keys(spanToV2JSON(span).attributes ?? {});
 
-  // TODO: Extract this scope data merge to a helper in core. It's used in multiple places.
-  const finalScopeData = getGlobalScope().getScopeData();
-  if (spanIsolationScope) {
-    mergeScopeData(finalScopeData, spanIsolationScope.getScopeData());
-  }
-  if (spanScope) {
-    mergeScopeData(finalScopeData, spanScope.getScopeData());
-  }
+  const finalScopeData = getFinalScopeData(spanIsolationScope, spanScope);
 
   // avoid overwriting any previously set attributes (from users or potentially our SDK instrumentation)
   setAttributesIfNotPresent(span, originalAttributeKeys, {
@@ -220,6 +224,35 @@ function applyCommonSpanAttributes(span: Span, serializedSegmentSpan: SpanV2JSON
   });
 }
 
+/**
+ * Adds span attributes frome
+ */
+function applyScopeToSegmentSpan(segmentSpan: Span, serializedSegmentSpan: SpanV2JSON, client: Client): void {
+  const { isolationScope, scope } = getCapturedScopesOnSpan(segmentSpan);
+  const finalScopeData = getFinalScopeData(isolationScope, scope);
+
+  const browserRequestData = getHttpRequestData();
+
+  const tags = finalScopeData.tags ?? {};
+
+  let contextAttributes = {};
+  Object.keys(finalScopeData.contexts).forEach(key => {
+    if (finalScopeData.contexts[key]) {
+      contextAttributes = { ...contextAttributes, ...attributesFromObject(finalScopeData.contexts[key]) };
+    }
+  });
+
+  const extraAttributes = attributesFromObject(finalScopeData.extra);
+
+  setAttributesIfNotPresent(segmentSpan, Object.keys(serializedSegmentSpan.attributes ?? {}), {
+    [SEMANTIC_ATTRIBUTE_URL_FULL]: browserRequestData.url,
+    ...httpHeadersToSpanAttributes(browserRequestData.headers, client.getOptions().sendDefaultPii ?? false),
+    ...tags,
+    ...contextAttributes,
+    ...extraAttributes,
+  });
+}
+
 function applyBeforeSendSpanCallback(span: SpanV2JSON, beforeSendSpan: (span: SpanV2JSON) => SpanV2JSON): SpanV2JSON {
   const modifedSpan = beforeSendSpan(span);
   if (!modifedSpan) {
@@ -236,3 +269,15 @@ function setAttributesIfNotPresent(span: Span, originalAttributeKeys: string[],
     }
   });
 }
+
+// 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/index.ts

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

packages/core/src/tracing/sentrySpan.ts

@@ -328,8 +328,6 @@ export class SentrySpan implements Span {
       return;
     }
 
-    client?.emit('segmentSpanEnd', this);
-
     // if this is a standalone span, we send it immediately
     if (this._isStandaloneSpan) {
       if (this._sampled) {
@@ -342,8 +340,9 @@ export class SentrySpan implements Span {
         }
       }
       return;
-    } else if (client?.getOptions()._experiments?._INTERNAL_spanStreaming) {
-      // nothing to do here; the spanStreaming integration will listen to the respective client hook.
+    } 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);
       return;
     }
 

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

@@ -390,7 +390,7 @@ export interface ClientOptions<TO extends BaseTransportOptions = BaseTransportOp
    *
    * @default 'static'
    */
-  traceLifecycle?: 'static' | 'streamed';
+  traceLifecycle?: 'static' | 'stream';
 
   /**
    * The organization ID for your Sentry project.

packages/core/src/utils/attributes.ts

@@ -1,4 +1,8 @@
+import { normalize } from '..';
 import type { SerializedAttribute } from '../types-hoist/attributes';
+import { Primitive } from '../types-hoist/misc';
+import type { SpanAttributes, SpanAttributeValue } from '../types-hoist/span';
+import { isPrimitive } from './is';
 
 /**
  * Converts an attribute value to a serialized attribute value object, containing
@@ -47,3 +51,50 @@ export function attributeValueToSerializedAttribute(value: unknown): SerializedA
     }
   }
 }
+
+/**
+ * Given an object that might contain keys with primitive, array, or object values,
+ * return a SpanAttributes object that flattens the object into a single level.
+ * - Nested keys are separated by '.'.
+ * - arrays are stringified (TODO: might change, depending on how we support array attributes)
+ * - objects are flattened
+ * - primitives are added directly
+ * - nullish values are ignored
+ * - maxDepth is the maximum depth to flatten the object to
+ *
+ * @param obj - The object to flatten into span attributes
+ * @returns The span attribute object
+ */
+export function attributesFromObject(obj: Record<string, unknown>, maxDepth = 3): SpanAttributes {
+  const result: Record<string, number | string | boolean | undefined> = {};
+
+  function primitiveOrToString(current: unknown): number | boolean | string {
+    if (typeof current === 'number' || typeof current === 'boolean' || typeof current === 'string') {
+      return current;
+    }
+    return String(current);
+  }
+
+  function flatten(current: unknown, prefix: string, depth: number): void {
+    if (current == null) {
+      return;
+    } else if (depth >= maxDepth) {
+      result[prefix] = primitiveOrToString(current);
+      return;
+    } else if (Array.isArray(current)) {
+      result[prefix] = JSON.stringify(current);
+    } else if (typeof current === 'number' || typeof current === 'string' || typeof current === 'boolean') {
+      result[prefix] = current;
+    } else if (typeof current === 'object' && current !== null && !Array.isArray(current) && depth < maxDepth) {
+      for (const [key, value] of Object.entries(current as Record<string, unknown>)) {
+        flatten(value, prefix ? `${prefix}.${key}` : key, depth + 1);
+      }
+    }
+  }
+
+  const normalizedObj = normalize(obj, maxDepth);
+
+  flatten(normalizedObj, '', 0);
+
+  return result;
+}

packages/core/test/lib/utils/attributes.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, it } from 'vitest';
+import { attributesFromObject } from '../../../src/utils/attributes';
+
+describe('attributesFromObject', () => {
+  it('flattens an object', () => {
+    const context = {
+      a: 1,
+      b: { c: { d: 2 } },
+    };
+
+    const result = attributesFromObject(context);
+
+    expect(result).toEqual({
+      a: 1,
+      'b.c.d': 2,
+    });
+  });
+
+  it('flattens an object with a max depth', () => {
+    const context = {
+      a: 1,
+      b: { c: { d: 2 } },
+    };
+
+    const result = attributesFromObject(context, 2);
+
+    expect(result).toEqual({
+      a: 1,
+      'b.c': '[Object]',
+    });
+  });
+
+  it('flattens an object an array', () => {
+    const context = {
+      a: 1,
+      b: { c: { d: 2 } },
+      integrations: ['foo', 'bar'],
+    };
+
+    const result = attributesFromObject(context);
+
+    expect(result).toEqual({
+      a: 1,
+      'b.c.d': 2,
+      integrations: '["foo","bar"]',
+    });
+  });
+
+  it('handles a circular object', () => {
+    const context = {
+      a: 1,
+      b: { c: { d: 2 } },
+    };
+    context.b.c.e = context.b;
+
+    const result = attributesFromObject(context, 5);
+
+    expect(result).toEqual({
+      a: 1,
+      'b.c.d': 2,
+      'b.c.e': '[Circular ~]',
+    });
+  });
+
+  it('handles a circular object in an array', () => {
+    const context = {
+      a: 1,
+      b: { c: { d: 2 } },
+      integrations: ['foo', 'bar'],
+    };
+
+    // @ts-expect-error - this is fine
+    context.integrations[0] = context.integrations;
+
+    const result = attributesFromObject(context, 5);
+
+    expect(result).toEqual({
+      a: 1,
+      'b.c.d': 2,
+      integrations: '["[Circular ~]","bar"]',
+    });
+  });
+
+  it('handles objects in arrays', () => {
+    const context = {
+      a: 1,
+      b: { c: { d: 2 } },
+      integrations: [{ name: 'foo' }, { name: 'bar' }],
+    };
+
+    const result = attributesFromObject(context);
+
+    expect(result).toEqual({
+      a: 1,
+      'b.c.d': 2,
+      integrations: '[{"name":"foo"},{"name":"bar"}]',
+    });
+  });
+});