split insertToFlagBuffer into 2 functions (insertFlagToScope and insertToFlagBuffer)

Author: billyvg

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

@@ -2,7 +2,7 @@ import type { Client, Event, EventHint, IntegrationFn } from '@sentry/types';
 import type { LDContext, LDEvaluationDetail, LDInspectionFlagUsedHandler } from './types';
 
 import { defineIntegration } from '@sentry/core';
-import { copyFlagsFromScopeToEvent, insertToFlagBuffer } from '../../../utils/featureFlags';
+import { copyFlagsFromScopeToEvent, insertFlagToScope } from '../../../utils/featureFlags';
 
 /**
  * Sentry integration for capturing feature flags from LaunchDarkly.
@@ -46,7 +46,7 @@ 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) => {
-      insertToFlagBuffer(flagKey, flagDetail.value);
+      insertFlagToScope(flagKey, flagDetail.value);
     },
   };
 }

packages/browser/src/utils/featureFlags.ts

@@ -29,8 +29,9 @@ export function copyFlagsFromScopeToEvent(event: Event): Event {
 }
 
 /**
- * Insert into a FeatureFlag array while maintaining ordered LRU properties. Not
- * thread-safe. After inserting:
+ * Creates a feature flags values array in current context if it does not exist
+ * and inserts the flag into a FeatureFlag array while maintaining ordered LRU
+ * properties. Not thread-safe. After inserting:
  * - `flags` is sorted in order of recency, with the newest flag at the end.
  * - No other flags with the same name exist in `flags`.
  * - The length of `flags` does not exceed `maxSize`. The oldest flag is evicted
@@ -39,19 +40,25 @@ export function copyFlagsFromScopeToEvent(event: Event): Event {
  * @param name     Name of the feature flag to insert.
  * @param value    Value of the feature flag.
  * @param maxSize  Max number of flags the buffer should store. It's recommended
- *   to keep this consistent across insertions. Default is DEFAULT_MAX_SIZE
+ *   to keep this consistent across insertions. Default is FLAG_BUFFER_SIZE
  */
-export function insertToFlagBuffer(name: string, value: unknown, maxSize: number = FLAG_BUFFER_SIZE): void {
-  // Currently only accepts boolean values
-  if (typeof value !== 'boolean') {
-    return;
-  }
-
+export function insertFlagToScope(name: string, value: unknown, maxSize: number = FLAG_BUFFER_SIZE): void {
   const scopeContexts = getCurrentScope().getScopeData().contexts;
   if (!scopeContexts.flags) {
     scopeContexts.flags = { values: [] };
   }
   const flags = scopeContexts.flags.values as FeatureFlag[];
+  insertToFlagBuffer(flags, name, value, maxSize);
+}
+
+/**
+ * Exported for tests
+ */
+export function insertToFlagBuffer(flags: FeatureFlag[], name: string, value: unknown, maxSize: number): void {
+  // Currently only accepts boolean values
+  if (typeof value !== 'boolean') {
+    return;
+  }
 
   if (flags.length > maxSize) {
     DEBUG_BUILD && logger.error(`[Feature Flags] insertToFlagBuffer called on a buffer larger than maxSize=${maxSize}`);

packages/browser/test/utils/featureFlags.test.ts

@@ -1,9 +1,27 @@
+import { getCurrentScope } from '@sentry/core';
 import type { FeatureFlag } from '@sentry/types';
 import { logger } from '@sentry/utils';
 import { vi } from 'vitest';
-import { insertToFlagBuffer } from '../../src/utils/featureFlags';
+import { insertFlagToScope, insertToFlagBuffer } from '../../src/utils/featureFlags';
 
 describe('flags', () => {
+  describe('insertFlagToScope()', () => {
+    it('adds flags to the current scope context', () => {
+      const maxSize = 3;
+      insertFlagToScope('feat1', true, maxSize);
+      insertFlagToScope('feat2', true, maxSize);
+      insertFlagToScope('feat3', true, maxSize);
+      insertFlagToScope('feat4', true, maxSize);
+
+      const scope = getCurrentScope();
+      expect(scope.getScopeData().contexts.flags?.values).toEqual([
+        { flag: 'feat2', result: true },
+        { flag: 'feat3', result: true },
+        { flag: 'feat4', result: true },
+      ]);
+    });
+  });
+
   describe('insertToFlagBuffer()', () => {
     const loggerSpy = vi.spyOn(logger, 'error');
 
@@ -54,6 +72,15 @@ describe('flags', () => {
       ]);
     });
 
+    it('does not accept non-boolean values', () => {
+      const buffer: FeatureFlag[] = [];
+      const maxSize = 1000;
+      insertToFlagBuffer(buffer, 'feat1', 1, maxSize);
+      insertToFlagBuffer(buffer, 'feat2', 'string', maxSize);
+
+      expect(buffer).toEqual([]);
+    });
+
     it('logs error and is a no-op when buffer is larger than maxSize', () => {
       const buffer: FeatureFlag[] = [
         { flag: 'feat1', result: true },