CLOSED - add node support for generic featureFlagsIntegration and move utils to core

dev-packages/browser-integration-tests/suites/integrations/featureFlags/constants.ts

@@ -1,3 +1,3 @@
-// Corresponds to constants in featureFlags.ts, in browser utils.
+// Corresponds to constants in featureFlags.ts, in @sentry/core utils.
 export const FLAG_BUFFER_SIZE = 100;
 export const MAX_FLAGS_PER_SPAN = 10;

dev-packages/node-integration-tests/suites/featureFlags/featureFlagsIntegration/onError/basic/scenario.ts

@@ -0,0 +1,20 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+const FLAG_BUFFER_SIZE = 100;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  sampleRate: 1.0,
+  transport: loggingTransport,
+  integrations: [Sentry.featureFlagsIntegration()],
+});
+
+const flagsIntegration = Sentry.getClient()?.getIntegrationByName<Sentry.FeatureFlagsIntegration>('FeatureFlags');
+for (let i = 1; i <= FLAG_BUFFER_SIZE; i++) {
+  flagsIntegration?.addFeatureFlag(`feat${i}`, false);
+}
+flagsIntegration?.addFeatureFlag(`feat${FLAG_BUFFER_SIZE + 1}`, true); // eviction
+flagsIntegration?.addFeatureFlag('feat3', true); // update
+
+throw new Error('Test error');

dev-packages/node-integration-tests/suites/featureFlags/featureFlagsIntegration/onError/basic/test.ts

@@ -0,0 +1,32 @@
+import { afterAll, test } from 'vitest';
+import { cleanupChildProcesses, createRunner } from '../../../../../utils/runner';
+
+const FLAG_BUFFER_SIZE = 100;
+
+afterAll(() => {
+  cleanupChildProcesses();
+});
+
+test('Flags captured on error with eviction, update, and no async tasks', async () => {
+  // Based on scenario.ts.
+  const expectedFlags = [{ flag: 'feat2', result: false }];
+  for (let i = 4; i <= FLAG_BUFFER_SIZE; i++) {
+    expectedFlags.push({ flag: `feat${i}`, result: false });
+  }
+  expectedFlags.push({ flag: `feat${FLAG_BUFFER_SIZE + 1}`, result: true });
+  expectedFlags.push({ flag: 'feat3', result: true });
+
+  await createRunner(__dirname, 'scenario.ts')
+    .expect({
+      event: {
+        exception: { values: [{ type: 'Error', value: 'Test error' }] },
+        contexts: {
+          flags: {
+            values: expectedFlags,
+          },
+        },
+      },
+    })
+    .start()
+    .completed();
+});

dev-packages/node-integration-tests/suites/featureFlags/featureFlagsIntegration/onError/withScope/scenario.ts

@@ -0,0 +1,22 @@
+import type { Scope } from '@sentry/node';
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  sampleRate: 1.0,
+  transport: loggingTransport,
+  integrations: [Sentry.featureFlagsIntegration()],
+});
+
+const flagsIntegration = Sentry.getClient()?.getIntegrationByName<Sentry.FeatureFlagsIntegration>('FeatureFlags');
+flagsIntegration?.addFeatureFlag('shared', true);
+
+Sentry.withScope((_scope: Scope) => {
+  flagsIntegration?.addFeatureFlag('forked', true);
+  flagsIntegration?.addFeatureFlag('shared', false);
+  Sentry.captureException(new Error('Error in forked scope'));
+});
+
+flagsIntegration?.addFeatureFlag('main', true);
+throw new Error('Error in main scope');

dev-packages/node-integration-tests/suites/featureFlags/featureFlagsIntegration/onError/withScope/test.ts

@@ -0,0 +1,38 @@
+import { afterAll, test } from 'vitest';
+import { cleanupChildProcesses, createRunner } from '../../../../../utils/runner';
+
+afterAll(() => {
+  cleanupChildProcesses();
+});
+
+test('Flags captured on error are isolated by current scope', async () => {
+  await createRunner(__dirname, 'scenario.ts')
+    .expect({
+      event: {
+        exception: { values: [{ type: 'Error', value: 'Error in forked scope' }] },
+        contexts: {
+          flags: {
+            values: [
+              { flag: 'forked', result: true },
+              { flag: 'shared', result: false },
+            ],
+          },
+        },
+      },
+    })
+    .expect({
+      event: {
+        exception: { values: [{ type: 'Error', value: 'Error in main scope' }] },
+        contexts: {
+          flags: {
+            values: [
+              { flag: 'shared', result: true },
+              { flag: 'main', result: true },
+            ],
+          },
+        },
+      },
+    })
+    .start()
+    .completed();
+});

dev-packages/node-integration-tests/suites/featureFlags/featureFlagsIntegration/onSpan/scenario.ts

@@ -0,0 +1,28 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+const MAX_FLAGS_PER_SPAN = 10;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  sampleRate: 1.0,
+  // // disable attaching headers to /test/* endpoints
+  // tracePropagationTargets: [/^(?!.*test).*$/],
+  tracesSampleRate: 1.0,
+  transport: loggingTransport,
+  integrations: [Sentry.featureFlagsIntegration()],
+});
+
+const flagsIntegration = Sentry.getClient()?.getIntegrationByName<Sentry.FeatureFlagsIntegration>('FeatureFlags');
+
+Sentry.startSpan({ name: 'test-root-span' }, () => {
+  Sentry.startSpan({ name: 'test-span' }, () => {
+    Sentry.startSpan({ name: 'test-nested-span' }, () => {
+      for (let i = 1; i <= MAX_FLAGS_PER_SPAN; i++) {
+        flagsIntegration?.addFeatureFlag(`feat${i}`, false);
+      }
+      flagsIntegration?.addFeatureFlag(`feat${MAX_FLAGS_PER_SPAN + 1}`, true); // dropped flag
+      flagsIntegration?.addFeatureFlag('feat3', true); // update
+    });
+  });
+});

dev-packages/node-integration-tests/suites/featureFlags/featureFlagsIntegration/onSpan/test.ts

@@ -0,0 +1,34 @@
+import { afterAll, expect, test } from 'vitest';
+import { cleanupChildProcesses, createRunner } from '../../../../utils/runner';
+
+const MAX_FLAGS_PER_SPAN = 10;
+
+afterAll(() => {
+  cleanupChildProcesses();
+});
+
+test('Flags captured on span attributes with max limit', async () => {
+  // Based on scenario.ts.
+  const expectedFlags: Record<string, boolean> = {};
+  for (let i = 1; i <= MAX_FLAGS_PER_SPAN; i++) {
+    expectedFlags[`flag.evaluation.feat${i}`] = i === 3;
+  }
+
+  await createRunner(__dirname, 'scenario.ts')
+    .expect({
+      transaction: {
+        spans: [
+          expect.objectContaining({
+            description: 'test-span',
+            data: expect.objectContaining({}),
+          }),
+          expect.objectContaining({
+            description: 'test-nested-span',
+            data: expect.objectContaining(expectedFlags),
+          }),
+        ],
+      },
+    })
+    .start()
+    .completed();
+});

packages/astro/src/index.server.ts

@@ -135,6 +135,8 @@ export {
   consoleLoggingIntegration,
   wrapMcpServerWithSentry,
   NODE_VERSION,
+  featureFlagsIntegration,
+  type FeatureFlagsIntegration,
 } from '@sentry/node';
 
 export { init } from './server/sdk';

packages/aws-serverless/src/index.ts

@@ -121,6 +121,8 @@ export {
   consoleLoggingIntegration,
   wrapMcpServerWithSentry,
   NODE_VERSION,
+  featureFlagsIntegration,
+  type FeatureFlagsIntegration,
 } from '@sentry/node';
 
 export {

packages/browser/src/index.ts

@@ -61,13 +61,13 @@ export {
   instrumentSupabaseClient,
   zodErrorsIntegration,
   thirdPartyErrorFilterIntegration,
+  featureFlagsIntegration,
 } from '@sentry/core';
-export type { Span } from '@sentry/core';
+export type { Span, FeatureFlagsIntegration } from '@sentry/core';
 export { makeBrowserOfflineTransport } from './transports/offline';
 export { browserProfilingIntegration } from './profiling/integration';
 export { spotlightBrowserIntegration } from './integrations/spotlight';
 export { browserSessionIntegration } from './integrations/browsersession';
-export { featureFlagsIntegration, type FeatureFlagsIntegration } from './integrations/featureFlags';
 export { launchDarklyIntegration, buildLaunchDarklyFlagUsedHandler } from './integrations/featureFlags/launchdarkly';
 export { openFeatureIntegration, OpenFeatureIntegrationHook } from './integrations/featureFlags/openfeature';
 export { unleashIntegration } from './integrations/featureFlags/unleash';

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

@@ -1,11 +1,11 @@
 import type { Client, Event, EventHint, IntegrationFn, Span } from '@sentry/core';
-import { defineIntegration } from '@sentry/core';
 import {
-  bufferSpanFeatureFlag,
-  copyFlagsFromScopeToEvent,
-  freezeSpanFeatureFlags,
-  insertFlagToScope,
-} from '../../../utils/featureFlags';
+  _INTERNAL_bufferSpanFeatureFlag,
+  _INTERNAL_copyFlagsFromScopeToEvent,
+  _INTERNAL_freezeSpanFeatureFlags,
+  _INTERNAL_insertFlagToScope,
+  defineIntegration,
+} from '@sentry/core';
 import type { LDContext, LDEvaluationDetail, LDInspectionFlagUsedHandler } from './types';
 
 /**
@@ -29,12 +29,12 @@ export const launchDarklyIntegration = defineIntegration(() => {
 
     setup(client: Client) {
       client.on('spanEnd', (span: Span) => {
-        freezeSpanFeatureFlags(span);
+        _INTERNAL_freezeSpanFeatureFlags(span);
       });
     },
 
     processEvent(event: Event, _hint: EventHint, _client: Client): Event {
-      return copyFlagsFromScopeToEvent(event);
+      return _INTERNAL_copyFlagsFromScopeToEvent(event);
     },
   };
 }) satisfies IntegrationFn;
@@ -56,8 +56,8 @@ export function buildLaunchDarklyFlagUsedHandler(): LDInspectionFlagUsedHandler
      * Handle a flag evaluation by storing its name and value on the current scope.
      */
     method: (flagKey: string, flagDetail: LDEvaluationDetail, _context: LDContext) => {
-      insertFlagToScope(flagKey, flagDetail.value);
-      bufferSpanFeatureFlag(flagKey, flagDetail.value);
+      _INTERNAL_insertFlagToScope(flagKey, flagDetail.value);
+      _INTERNAL_bufferSpanFeatureFlag(flagKey, flagDetail.value);
     },
   };
 }

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

@@ -14,13 +14,13 @@
  * ```
  */
 import type { Client, Event, EventHint, IntegrationFn, Span } from '@sentry/core';
-import { defineIntegration } from '@sentry/core';
 import {
-  bufferSpanFeatureFlag,
-  copyFlagsFromScopeToEvent,
-  freezeSpanFeatureFlags,
-  insertFlagToScope,
-} from '../../../utils/featureFlags';
+  _INTERNAL_bufferSpanFeatureFlag,
+  _INTERNAL_copyFlagsFromScopeToEvent,
+  _INTERNAL_freezeSpanFeatureFlags,
+  _INTERNAL_insertFlagToScope,
+  defineIntegration,
+} from '@sentry/core';
 import type { EvaluationDetails, HookContext, HookHints, JsonValue, OpenFeatureHook } from './types';
 
 export const openFeatureIntegration = defineIntegration(() => {
@@ -29,12 +29,12 @@ export const openFeatureIntegration = defineIntegration(() => {
 
     setup(client: Client) {
       client.on('spanEnd', (span: Span) => {
-        freezeSpanFeatureFlags(span);
+        _INTERNAL_freezeSpanFeatureFlags(span);
       });
     },
 
     processEvent(event: Event, _hint: EventHint, _client: Client): Event {
-      return copyFlagsFromScopeToEvent(event);
+      return _INTERNAL_copyFlagsFromScopeToEvent(event);
     },
   };
 }) satisfies IntegrationFn;
@@ -47,15 +47,15 @@ export class OpenFeatureIntegrationHook implements OpenFeatureHook {
    * Successful evaluation result.
    */
   public after(_hookContext: Readonly<HookContext<JsonValue>>, evaluationDetails: EvaluationDetails<JsonValue>): void {
-    insertFlagToScope(evaluationDetails.flagKey, evaluationDetails.value);
-    bufferSpanFeatureFlag(evaluationDetails.flagKey, evaluationDetails.value);
+    _INTERNAL_insertFlagToScope(evaluationDetails.flagKey, evaluationDetails.value);
+    _INTERNAL_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);
+    _INTERNAL_insertFlagToScope(hookContext.flagKey, hookContext.defaultValue);
+    _INTERNAL_bufferSpanFeatureFlag(hookContext.flagKey, hookContext.defaultValue);
   }
 }

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

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