Buffer with global weakmap and save on spanEnd

Author: aliu39

dev-packages/opentelemetry-v2-tests/test/integration/transactions.test.ts

@@ -548,57 +548,57 @@ describe('Integration | Transactions', () => {
     expect(finishedSpans.length).toBe(0);
   });
 
-it('collects child spans that are finished within 5 minutes their parent span has been sent', async () => {
-  const timeout = 5 * 60 * 1000;
-  const now = Date.now();
-  vi.useFakeTimers();
-  vi.setSystemTime(now);
+  it('collects child spans that are finished within 5 minutes their parent span has been sent', async () => {
+    const timeout = 5 * 60 * 1000;
+    const now = Date.now();
+    vi.useFakeTimers();
+    vi.setSystemTime(now);
 
-  const logs: unknown[] = [];
-  vi.spyOn(logger, 'log').mockImplementation(msg => logs.push(msg));
+    const logs: unknown[] = [];
+    vi.spyOn(logger, 'log').mockImplementation(msg => logs.push(msg));
 
-  const transactions: Event[] = [];
+    const transactions: Event[] = [];
 
-  mockSdkInit({
-    tracesSampleRate: 1,
-    beforeSendTransaction: event => {
-      transactions.push(event);
-      return null;
-    },
-  });
+    mockSdkInit({
+      tracesSampleRate: 1,
+      beforeSendTransaction: event => {
+        transactions.push(event);
+        return null;
+      },
+    });
 
-  const provider = getProvider();
-  const spanProcessor = getSpanProcessor();
+    const provider = getProvider();
+    const spanProcessor = getSpanProcessor();
 
-  const exporter = spanProcessor ? spanProcessor['_exporter'] : undefined;
+    const exporter = spanProcessor ? spanProcessor['_exporter'] : undefined;
 
-  if (!exporter) {
-    throw new Error('No exporter found, aborting test...');
-  }
+    if (!exporter) {
+      throw new Error('No exporter found, aborting test...');
+    }
 
-  startSpanManual({ name: 'test name' }, async span => {
-    const subSpan = startInactiveSpan({ name: 'inner span 1' });
-    subSpan.end();
+    startSpanManual({ name: 'test name' }, async span => {
+      const subSpan = startInactiveSpan({ name: 'inner span 1' });
+      subSpan.end();
 
-    const subSpan2 = startInactiveSpan({ name: 'inner span 2' });
+      const subSpan2 = startInactiveSpan({ name: 'inner span 2' });
 
-    span.end();
+      span.end();
 
-    setTimeout(() => {
-      subSpan2.end();
-    }, timeout - 2);
-  });
+      setTimeout(() => {
+        subSpan2.end();
+      }, timeout - 2);
+    });
 
-  vi.advanceTimersByTime(timeout - 1);
+    vi.advanceTimersByTime(timeout - 1);
 
-  expect(transactions).toHaveLength(2);
-  expect(transactions[0]?.spans).toHaveLength(1);
+    expect(transactions).toHaveLength(2);
+    expect(transactions[0]?.spans).toHaveLength(1);
 
-  const finishedSpans: any = exporter['_finishedSpanBuckets'].flatMap(bucket =>
-    bucket ? Array.from(bucket.spans) : [],
-  );
-  expect(finishedSpans.length).toBe(0);
-});
+    const finishedSpans: any = exporter['_finishedSpanBuckets'].flatMap(bucket =>
+      bucket ? Array.from(bucket.spans) : [],
+    );
+    expect(finishedSpans.length).toBe(0);
+  });
 
   it('discards child spans that are finished after 5 minutes their parent span has been sent', async () => {
     const timeout = 5 * 60 * 1000;

packages/browser/src/integrations/featureFlags/featureFlagsIntegration.ts

@@ -1,6 +1,11 @@
-import type { Client, Event, EventHint, Integration, IntegrationFn } from '@sentry/core';
+import type { Client, Event, EventHint, Integration, IntegrationFn, Span } from '@sentry/core';
 import { defineIntegration } from '@sentry/core';
-import { copyFlagsFromScopeToEvent, insertFlagToScope } from '../../utils/featureFlags';
+import {
+  bufferSpanFeatureFlag,
+  copyFlagsFromScopeToEvent,
+  freezeSpanFeatureFlags,
+  insertFlagToScope,
+} from '../../utils/featureFlags';
 
 export interface FeatureFlagsIntegration extends Integration {
   addFeatureFlag: (name: string, value: unknown) => void;
@@ -35,12 +40,19 @@ export const featureFlagsIntegration = defineIntegration(() => {
   return {
     name: 'FeatureFlags',
 
+    setup(client: Client) {
+      client.on('spanEnd', (span: Span) => {
+        freezeSpanFeatureFlags(span);
+      });
+    },
+
     processEvent(event: Event, _hint: EventHint, _client: Client): Event {
       return copyFlagsFromScopeToEvent(event);
     },
 
     addFeatureFlag(name: string, value: unknown): void {
       insertFlagToScope(name, value);
+      bufferSpanFeatureFlag(name, value);
     },
   };
 }) as IntegrationFn<FeatureFlagsIntegration>;

packages/browser/src/integrations/featureFlags/launchdarkly/integration.ts

@@ -1,6 +1,11 @@
-import type { Client, Event, EventHint, IntegrationFn } from '@sentry/core';
+import type { Client, Event, EventHint, IntegrationFn, Span } from '@sentry/core';
 import { defineIntegration } from '@sentry/core';
-import { copyFlagsFromScopeToEvent, insertFlagToScope } from '../../../utils/featureFlags';
+import {
+  bufferSpanFeatureFlag,
+  copyFlagsFromScopeToEvent,
+  freezeSpanFeatureFlags,
+  insertFlagToScope,
+} from '../../../utils/featureFlags';
 import type { LDContext, LDEvaluationDetail, LDInspectionFlagUsedHandler } from './types';
 
 /**
@@ -22,6 +27,12 @@ export const launchDarklyIntegration = defineIntegration(() => {
   return {
     name: 'LaunchDarkly',
 
+    setup(client: Client) {
+      client.on('spanEnd', (span: Span) => {
+        freezeSpanFeatureFlags(span);
+      });
+    },
+
     processEvent(event: Event, _hint: EventHint, _client: Client): Event {
       return copyFlagsFromScopeToEvent(event);
     },
@@ -46,6 +57,7 @@ export function buildLaunchDarklyFlagUsedHandler(): LDInspectionFlagUsedHandler
      */
     method: (flagKey: string, flagDetail: LDEvaluationDetail, _context: LDContext) => {
       insertFlagToScope(flagKey, flagDetail.value);
+      bufferSpanFeatureFlag(flagKey, flagDetail.value);
     },
   };
 }

packages/browser/src/integrations/featureFlags/openfeature/integration.ts

@@ -5,15 +5,26 @@
  * Add the integration hook to your OpenFeature object.
  *   - OpenFeature.getClient().addHooks(new OpenFeatureIntegrationHook());
  */
-import type { Client, Event, EventHint, IntegrationFn } from '@sentry/core';
+import type { Client, Event, EventHint, IntegrationFn, Span } from '@sentry/core';
 import { defineIntegration } from '@sentry/core';
-import { copyFlagsFromScopeToEvent, insertFlagToScope } from '../../../utils/featureFlags';
+import {
+  bufferSpanFeatureFlag,
+  copyFlagsFromScopeToEvent,
+  freezeSpanFeatureFlags,
+  insertFlagToScope,
+} from '../../../utils/featureFlags';
 import type { EvaluationDetails, HookContext, HookHints, JsonValue, OpenFeatureHook } from './types';
 
 export const openFeatureIntegration = defineIntegration(() => {
   return {
     name: 'OpenFeature',
 
+    setup(client: Client) {
+      client.on('spanEnd', (span: Span) => {
+        freezeSpanFeatureFlags(span);
+      });
+    },
+
     processEvent(event: Event, _hint: EventHint, _client: Client): Event {
       return copyFlagsFromScopeToEvent(event);
     },
@@ -29,12 +40,14 @@ export class OpenFeatureIntegrationHook implements OpenFeatureHook {
    */
   public after(_hookContext: Readonly<HookContext<JsonValue>>, evaluationDetails: EvaluationDetails<JsonValue>): void {
     insertFlagToScope(evaluationDetails.flagKey, evaluationDetails.value);
+    bufferSpanFeatureFlag(evaluationDetails.flagKey, evaluationDetails.value);
   }
 
   /**
    * On error evaluation result.
    */
   public error(hookContext: Readonly<HookContext<JsonValue>>, _error: unknown, _hookHints?: HookHints): void {
     insertFlagToScope(hookContext.flagKey, hookContext.defaultValue);
+    bufferSpanFeatureFlag(hookContext.flagKey, hookContext.defaultValue);
   }
 }

packages/browser/src/integrations/featureFlags/statsig/integration.ts

@@ -1,6 +1,11 @@
-import type { Client, Event, EventHint, IntegrationFn } from '@sentry/core';
+import type { Client, Event, EventHint, IntegrationFn, Span } from '@sentry/core';
 import { defineIntegration } from '@sentry/core';
-import { copyFlagsFromScopeToEvent, insertFlagToScope } from '../../../utils/featureFlags';
+import {
+  bufferSpanFeatureFlag,
+  copyFlagsFromScopeToEvent,
+  freezeSpanFeatureFlags,
+  insertFlagToScope,
+} from '../../../utils/featureFlags';
 import type { FeatureGate, StatsigClient } from './types';
 
 /**
@@ -31,15 +36,20 @@ export const statsigIntegration = defineIntegration(
     return {
       name: 'Statsig',
 
-      processEvent(event: Event, _hint: EventHint, _client: Client): Event {
-        return copyFlagsFromScopeToEvent(event);
-      },
+      setup(client: Client) {
+        client.on('spanEnd', (span: Span) => {
+          freezeSpanFeatureFlags(span);
+        });
 
-      setup() {
         statsigClient.on('gate_evaluation', (event: { gate: FeatureGate }) => {
           insertFlagToScope(event.gate.name, event.gate.value);
+          bufferSpanFeatureFlag(event.gate.name, event.gate.value);
         });
       },
+
+      processEvent(event: Event, _hint: EventHint, _client: Client): Event {
+        return copyFlagsFromScopeToEvent(event);
+      },
     };
   },
 ) satisfies IntegrationFn;

packages/browser/src/integrations/featureFlags/unleash/integration.ts

@@ -1,7 +1,12 @@
-import type { Client, Event, EventHint, IntegrationFn } from '@sentry/core';
+import type { Client, Event, EventHint, IntegrationFn, Span } from '@sentry/core';
 import { defineIntegration, fill, logger } from '@sentry/core';
 import { DEBUG_BUILD } from '../../../debug-build';
-import { copyFlagsFromScopeToEvent, insertFlagToScope } from '../../../utils/featureFlags';
+import {
+  bufferSpanFeatureFlag,
+  copyFlagsFromScopeToEvent,
+  freezeSpanFeatureFlags,
+  insertFlagToScope,
+} from '../../../utils/featureFlags';
 import type { UnleashClient, UnleashClientClass } from './types';
 
 type UnleashIntegrationOptions = {
@@ -35,14 +40,20 @@ export const unleashIntegration = defineIntegration(
     return {
       name: 'Unleash',
 
-      processEvent(event: Event, _hint: EventHint, _client: Client): Event {
-        return copyFlagsFromScopeToEvent(event);
+      setup(client: Client) {
+        client.on('spanEnd', (span: Span) => {
+          freezeSpanFeatureFlags(span);
+        });
       },
 
       setupOnce() {
         const unleashClientPrototype = unleashClientClass.prototype as UnleashClient;
         fill(unleashClientPrototype, 'isEnabled', _wrappedIsEnabled);
       },
+
+      processEvent(event: Event, _hint: EventHint, _client: Client): Event {
+        return copyFlagsFromScopeToEvent(event);
+      },
     };
   },
 ) satisfies IntegrationFn;
@@ -65,6 +76,7 @@ function _wrappedIsEnabled(
 
     if (typeof toggleName === 'string' && typeof result === 'boolean') {
       insertFlagToScope(toggleName, result);
+      bufferSpanFeatureFlag(toggleName, result);
     } else if (DEBUG_BUILD) {
       logger.error(
         `[Feature Flags] UnleashClient.isEnabled does not match expected signature. arg0: ${toggleName} (${typeof toggleName}), result: ${result} (${typeof result})`,

packages/browser/src/utils/featureFlags.ts

@@ -1,5 +1,5 @@
-import type { Event, FeatureFlag } from '@sentry/core';
-import { getCurrentScope, logger } from '@sentry/core';
+import type { Event, FeatureFlag, Span } from '@sentry/core';
+import { getActiveSpan, getCurrentScope, GLOBAL_OBJ, logger } from '@sentry/core';
 import { DEBUG_BUILD } from '../debug-build';
 
 /**
@@ -13,6 +13,13 @@ import { DEBUG_BUILD } from '../debug-build';
  */
 export const FLAG_BUFFER_SIZE = 100;
 
+/**
+ * Max number of flag evaluations to record per span.
+ */
+export const MAX_FLAGS_PER_SPAN = 10;
+
+GLOBAL_OBJ._spanToFlagBufferMap = new WeakMap<Span, FeatureFlag[]>();
+
 /**
  * Copies feature flags that are in current scope context to the event context
  */
@@ -87,3 +94,43 @@ export function insertToFlagBuffer(flags: FeatureFlag[], name: string, value: un
     result: value,
   });
 }
+
+/**
+ * Records a feature flag evaluation for the active span, adding it to a weak map of flag buffers. This is a no-op for non-boolean values.
+ * The keys in each buffer are unique. Once the buffer for a span reaches maxFlagsPerSpan, subsequent flags are dropped.
+ *
+ * @param name             Name of the feature flag.
+ * @param value            Value of the feature flag. Non-boolean values are ignored.
+ * @param maxFlagsPerSpan  Max number of flags a buffer should store. Default value should always be used in production.
+ */
+export function bufferSpanFeatureFlag(
+  name: string,
+  value: unknown,
+  maxFlagsPerSpan: number = MAX_FLAGS_PER_SPAN,
+): void {
+  const spanFlagMap = GLOBAL_OBJ._spanToFlagBufferMap;
+  if (!spanFlagMap || typeof value !== 'boolean') {
+    return;
+  }
+
+  const span = getActiveSpan();
+  if (span) {
+    const flags = spanFlagMap.get(span) || [];
+    if (!flags.find(flag => flag.flag === name) && flags.length < maxFlagsPerSpan) {
+      flags.push({ flag: name, result: value });
+    }
+    spanFlagMap.set(span, flags);
+  }
+}
+
+/**
+ * Add the buffered feature flags for a span to the span attributes. Call this on span end.
+ *
+ * @param span         Span to add flags to.
+ */
+export function freezeSpanFeatureFlags(span: Span): void {
+  const flags = GLOBAL_OBJ._spanToFlagBufferMap?.get(span);
+  if (flags) {
+    span.setAttributes(Object.fromEntries(flags.map(flag => [`flag.evaluation.${flag.flag}`, flag.result])));
+  }
+}

packages/core/src/utils-hoist/worldwide.ts

@@ -14,7 +14,9 @@
 
 import type { Carrier } from '../carrier';
 import type { Client } from '../client';
+import type { FeatureFlag } from '../featureFlags';
 import type { SerializedLog } from '../types-hoist/log';
+import type { Span } from '../types-hoist/span';
 import type { SdkSource } from './env';
 
 /** Internal global with common properties and Sentry extensions  */
@@ -56,6 +58,10 @@ export type InternalGlobal = {
    */
   _sentryModuleMetadata?: Record<string, any>;
   _sentryEsmLoaderHookRegistered?: boolean;
+  /**
+   * A map of spans to feature flag buffers. Populated by feature flag integrations.
+   */
+  _spanToFlagBufferMap?: WeakMap<Span, FeatureFlag[]>;
 } & Carrier;
 
 /** Get's the global object for the current JavaScript runtime */