wip

Author: Lms24

dev-packages/node-integration-tests/suites/tracing/meta-tags-twp-errors/test.ts

@@ -1,6 +1,5 @@
 import { afterAll, describe, expect, test } from 'vitest';
 import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
-import { run } from 'node:test';
 
 describe('errors in TwP mode have same trace in trace context and getTraceData()', () => {
   afterAll(() => {
@@ -9,16 +8,11 @@ describe('errors in TwP mode have same trace in trace context and getTraceData()
 
   // In a request handler, the spanId is consistent inside of the request
   test('in incoming request', async () => {
-    let firstTraceId: string | undefined;
-
     const runner = createRunner(__dirname, 'server.js')
       .expect({
         event: event => {
           const { contexts } = event;
           const { trace_id, span_id } = contexts?.trace || {};
-          if (!firstTraceId) {
-            firstTraceId = trace_id;
-          }
           expect(trace_id).toMatch(/^[a-f\d]{32}$/);
           expect(span_id).toMatch(/^[a-f\d]{16}$/);
 
@@ -34,15 +28,8 @@ describe('errors in TwP mode have same trace in trace context and getTraceData()
           expect(traceData.metaTags).not.toContain('sentry-sampled=');
         },
       })
-      .expect({
-        event: event => {
-          expect(event.contexts?.trace?.trace_id).toBeDefined();
-          expect(event.contexts?.trace?.trace_id).toBe(firstTraceId);
-        },
-      })
       .start();
     runner.makeRequest('get', '/test');
-    runner.makeRequest('get', '/test');
     await runner.completed();
   });
 

packages/browser/src/integrations/spanstreaming.ts

@@ -6,7 +6,6 @@ import {
   defineIntegration,
   getDynamicSamplingContextFromSpan,
   isV2BeforeSendSpanCallback,
-  showSpanDropWarning,
 } from '@sentry/core';
 import { DEBUG_BUILD } from '../debug-build';
 
@@ -73,10 +72,9 @@ export const spanStreamingIntegration = defineIntegration(((userOptions?: Partia
       // TODO: This will change once we have more concrete ideas about a universal SDK data buffer.
       client.on('afterSegmentSpanEnd', segmentSpan => {
         sendSegment(segmentSpan, {
-          spanTreeMap: spanTreeMap,
+          spanTreeMap,
           client,
           batchLimit: options.batchLimit,
-          beforeSendSpan,
         });
       });
     },
@@ -87,7 +85,6 @@ interface SpanProcessingOptions {
   client: Client;
   spanTreeMap: Map<string, Set<SpanV2JSONWithSegmentRef>>;
   batchLimit: number;
-  beforeSendSpan: ((span: SpanV2JSON) => SpanV2JSON) | undefined;
 }
 
 /**
@@ -97,10 +94,7 @@ 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 {
+function sendSegment(segmentSpan: Span, { client, spanTreeMap, batchLimit }: SpanProcessingOptions): void {
   const traceId = segmentSpan.spanContext().traceId;
   const segmentSpanId = segmentSpan.spanContext().spanId;
   const spanTreeMapKey = `${traceId}-${segmentSpanId}`;
@@ -116,10 +110,6 @@ function sendSegment(
     // Remove the segment span reference before processing
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const { _segmentSpan, ...cleanSpanJSON } = spanJSON;
-
-    if (beforeSendSpan) {
-      return applyBeforeSendSpanCallback(cleanSpanJSON, beforeSendSpan);
-    }
     return cleanSpanJSON;
   });
 
@@ -145,12 +135,3 @@ function sendSegment(
 
   spanTreeMap.delete(spanTreeMapKey);
 }
-
-function applyBeforeSendSpanCallback(span: SpanV2JSON, beforeSendSpan: (span: SpanV2JSON) => SpanV2JSON): SpanV2JSON {
-  const modifedSpan = beforeSendSpan(span);
-  if (!modifedSpan) {
-    showSpanDropWarning();
-    return span;
-  }
-  return modifedSpan;
-}

packages/core/src/client.ts

@@ -31,7 +31,14 @@ import type { RequestEventData } from './types-hoist/request';
 import type { SdkMetadata } from './types-hoist/sdkmetadata';
 import type { Session, SessionAggregates } from './types-hoist/session';
 import type { SeverityLevel } from './types-hoist/severity';
-import type { Span, SpanAttributes, SpanContextData, SpanJSON, SpanV2JSON } from './types-hoist/span';
+import type {
+  Span,
+  SpanAttributes,
+  SpanContextData,
+  SpanJSON,
+  SpanV2JSON,
+  SpanV2JSONWithSegmentRef,
+} from './types-hoist/span';
 import type { StartSpanOptions } from './types-hoist/startSpanOptions';
 import type { Transport, TransportMakeRequestResponse } from './types-hoist/transport';
 import { isV2BeforeSendSpanCallback } from './utils/beforeSendSpan';
@@ -620,7 +627,7 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
   /**
    * Register a callback for when the span JSON is ready to be enqueued into the span buffer.
    */
-  public on(hook: 'enqueueSpan', callback: (spanJSON: SpanV2JSON) => void): () => void;
+  public on(hook: 'enqueueSpan', callback: (spanJSON: SpanV2JSONWithSegmentRef) => void): () => void;
   /**
    * Register a callback for when a span JSON is processed, to add some attributes to the span JSON.
    */
@@ -906,7 +913,7 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
   /** 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', spanJSON: SpanV2JSON): void;
+  public emit(hook: 'enqueueSpan', spanJSON: SpanV2JSONWithSegmentRef): void;
 
   /**
    * Fire a hook indicating that an idle span is allowed to auto finish.

packages/core/src/index.ts

@@ -90,7 +90,6 @@ export {
   showSpanDropWarning,
 } from './utils/spanUtils';
 export { captureSpan } from './spans/captureSpan';
-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';
@@ -450,6 +449,7 @@ export type {
   SpanContextData,
   TraceFlag,
   SpanV2JSON,
+  SpanV2JSONWithSegmentRef,
 } from './types-hoist/span';
 export type { SpanStatus } from './types-hoist/spanStatus';
 export type { Log, LogSeverityLevel } from './types-hoist/log';

packages/core/src/spans/captureSpan.ts

@@ -1,3 +1,4 @@
+import { Attributes, RawAttribute, RawAttributes } from '../attributes';
 import type { Client } from '../client';
 import { getClient, getGlobalScope } from '../currentScopes';
 import { DEBUG_BUILD } from '../debug-build';
@@ -16,35 +17,27 @@ import {
 } from '../semanticAttributes';
 import { getCapturedScopesOnSpan } from '../tracing/utils';
 import type { SerializedAttributes } from '../types-hoist/attributes';
+import { Contexts } from '../types-hoist/context';
 import type { Span, SpanV2JSON } from '../types-hoist/span';
 import { mergeScopeData } from '../utils/applyScopeDataToEvent';
+import { isV2BeforeSendSpanCallback } from '../utils/beforeSendSpan';
 import { debug } from '../utils/debug-logger';
 import { INTERNAL_getSegmentSpan, spanToV2JSON } from '../utils/spanUtils';
-import { safeSetSpanJSONAttributes } from './spanFirstUtils';
-
-/**
- * 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 interface SpanV2JSONWithSegmentRef extends SpanV2JSON {
-  _segmentSpan: Span;
-}
-
+import { applyBeforeSendSpanCallback, safeSetSpanJSONAttributes } from './spanFirstUtils';
 /**
  * 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 {
+export function captureSpan(span: Span, client = getClient()): 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 spanJSON = spanToV2JSON(span);
 
   const segmentSpan = INTERNAL_getSegmentSpan(span);
   const serializedSegmentSpan = spanToV2JSON(segmentSpan);
@@ -60,29 +53,31 @@ export function captureSpan(span: Span, client = getClient()): SpanV2JSONWithSeg
     applyScopeToSegmentSpan(spanJSON, finalScopeData, originalAttributes);
   }
 
-  // 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);
+  const beforeSendSpan = client.getOptions().beforeSendSpan;
+  const processedSpan = isV2BeforeSendSpanCallback(beforeSendSpan)
+    ? applyBeforeSendSpanCallback(spanJSON, beforeSendSpan)
+    : spanJSON;
 
-  return spanJSON;
+  const spanWithRef = {
+    ...processedSpan,
+    _segmentSpan: segmentSpan,
+  };
+
+  client.emit('enqueueSpan', spanWithRef);
 }
 
 function applyScopeToSegmentSpan(
   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) {
-    safeSetSpanJSONAttributes(segmentSpanJSON, attributes, originalAttributes);
-  }
+  // TODO: Apply all scope and request data from auto instrumentation (contexts, request) to segment span
+  const { contexts } = scopeData;
+
+  safeSetSpanJSONAttributes(segmentSpanJSON, contextsToAttributes(contexts), originalAttributes);
 }
 
 function applyCommonSpanAttributes(
@@ -113,6 +108,7 @@ function applyCommonSpanAttributes(
             [SEMANTIC_ATTRIBUTE_USER_USERNAME]: scopeData.user?.username,
           }
         : {}),
+      ...scopeData.attributes,
     },
     originalAttributes,
   );
@@ -129,3 +125,13 @@ function getFinalScopeData(isolationScope: Scope | undefined, scope: Scope | und
   }
   return finalScopeData;
 }
+
+function contextsToAttributes(contexts: Contexts): RawAttributes<Record<string, unknown>> {
+  return {
+    'os.build_id': contexts.os?.build,
+    'os.name': contexts.os?.name,
+    'os.version': contexts.os?.version,
+    // TODO: Add to Sentry SemConv
+    'os.kernel_version': contexts.os?.kernel_version,
+  };
+}

packages/core/src/spans/spanFirstUtils.ts

@@ -3,6 +3,7 @@ import { isAttributeObject } from '../attributes';
 import type { SerializedAttributes } from '../types-hoist/attributes';
 import type { Span, SpanV2JSON } from '../types-hoist/span';
 import { attributeValueToSerializedAttribute } from '../utils/attributes';
+import { showSpanDropWarning } from '../utils/spanUtils';
 
 /**
  * Only set a span attribute if it is not already set.
@@ -55,6 +56,21 @@ function setAttributeOnSpanWithMaybeUnit(span: Span, attributeKey: string, attri
   }
 }
 
+/**
+ * Apply a user-provided beforeSendSpan callback to a span JSON.
+ */
+export function applyBeforeSendSpanCallback(
+  span: SpanV2JSON,
+  beforeSendSpan: (span: SpanV2JSON) => SpanV2JSON,
+): SpanV2JSON {
+  const modifedSpan = beforeSendSpan(span);
+  if (!modifedSpan) {
+    showSpanDropWarning();
+    return span;
+  }
+  return modifedSpan;
+}
+
 function setAttributeOnSpanJSONWithMaybeUnit(
   spanJSON: SpanV2JSON,
   attributeKey: string,

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

@@ -35,6 +35,9 @@ export type SpanAttributes = Partial<{
 /** This type is aligned with the OpenTelemetry TimeInput type. */
 export type SpanTimeInput = HrTime | number | Date;
 
+/**
+ * JSON representation of a v2 span, as it should be sent to Sentry.
+ */
 export interface SpanV2JSON {
   trace_id: string;
   parent_span_id?: string;
@@ -48,6 +51,15 @@ export interface SpanV2JSON {
   links?: SpanLinkJSON<SerializedAttributes>[];
 }
 
+/**
+ * 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 interface SpanV2JSONWithSegmentRef extends SpanV2JSON {
+  _segmentSpan: Span;
+}
+
 export type SerializedSpanContainer = {
   items: Array<SpanV2JSON>;
 };

packages/node-core/src/integrations/context.ts

@@ -15,7 +15,7 @@ import type {
   IntegrationFn,
   OsContext,
 } from '@sentry/core';
-import { defineIntegration } from '@sentry/core';
+import { debug, defineIntegration, getGlobalScope } from '@sentry/core';
 
 export const readFileAsync = promisify(readFile);
 export const readDirAsync = promisify(readdir);
@@ -107,6 +107,31 @@ const _nodeContextIntegration = ((options: ContextOptions = {}) => {
 
   return {
     name: INTEGRATION_NAME,
+    setupOnce() {
+      console.log('xx setupOnce');
+      _getContexts()
+        .then(updatedContext => {
+          const globalScope = getGlobalScope();
+          const previousContexts = globalScope.getScopeData().contexts;
+
+          const contexts = {
+            app: { ...updatedContext.app, ...previousContexts?.app },
+            os: { ...updatedContext.os, ...previousContexts?.os },
+            device: { ...updatedContext.device, ...previousContexts?.device },
+            culture: { ...updatedContext.culture, ...previousContexts?.culture },
+            cloud_resource: { ...updatedContext.cloud_resource, ...previousContexts?.cloud_resource },
+          };
+
+          Object.keys(contexts).forEach(key => {
+            globalScope.setContext(key, contexts[key as keyof Event['contexts']]);
+          });
+
+          console.log('xx set contexts to global scope', contexts);
+        })
+        .catch(() => {
+          debug.warn(`[${INTEGRATION_NAME}] Failed to get contexts from Node`);
+        });
+    },
     // TODO (span-streaming): we probably need to apply this to spans via a hook IF we decide to apply contexts to (segment) spans
     processEvent(event) {
       return addContext(event);