Import utils from core with _INTERNAL_ prefix

aliu39 · aliu39 · commit 6381f91c743c · 2025-06-10T11:46:24.000-07:00
diff --git a/packages/browser/src/integrations/featureFlags/launchdarkly/integration.ts b/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';
+  defineIntegration,
+  _INTERNAL_bufferSpanFeatureFlag,
+  _INTERNAL_copyFlagsFromScopeToEvent,
+  _INTERNAL_freezeSpanFeatureFlags,
+  _INTERNAL_insertFlagToScope,
+} 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);
     },
   };
 }
diff --git a/packages/browser/src/integrations/featureFlags/openfeature/integration.ts b/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';
+  defineIntegration,
+  _INTERNAL_bufferSpanFeatureFlag,
+  _INTERNAL_copyFlagsFromScopeToEvent,
+  _INTERNAL_freezeSpanFeatureFlags,
+  _INTERNAL_insertFlagToScope,
+} 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);
   }
 }
diff --git a/packages/browser/src/integrations/featureFlags/statsig/integration.ts b/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';
+  defineIntegration,
+  _INTERNAL_bufferSpanFeatureFlag,
+  _INTERNAL_copyFlagsFromScopeToEvent,
+  _INTERNAL_freezeSpanFeatureFlags,
+  _INTERNAL_insertFlagToScope,
+} 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);
       },
     };
   },
diff --git a/packages/browser/src/integrations/featureFlags/unleash/integration.ts b/packages/browser/src/integrations/featureFlags/unleash/integration.ts
@@ -1,12 +1,14 @@
 import type { Client, Event, EventHint, IntegrationFn, Span } from '@sentry/core';
-import { defineIntegration, fill, logger } from '@sentry/core';
 import { DEBUG_BUILD } from '../../../debug-build';
 import {
-  bufferSpanFeatureFlag,
-  copyFlagsFromScopeToEvent,
-  freezeSpanFeatureFlags,
-  insertFlagToScope,
-} from '../../../utils/featureFlags';
+  defineIntegration,
+  fill,
+  logger,
+  _INTERNAL_bufferSpanFeatureFlag,
+  _INTERNAL_copyFlagsFromScopeToEvent,
+  _INTERNAL_freezeSpanFeatureFlags,
+  _INTERNAL_insertFlagToScope,
+} from '@sentry/core';
 import type { UnleashClient, UnleashClientClass } from './types';
 
 type UnleashIntegrationOptions = {
@@ -42,7 +44,7 @@ export const unleashIntegration = defineIntegration(
 
       setup(client: Client) {
         client.on('spanEnd', (span: Span) => {
-          freezeSpanFeatureFlags(span);
+          _INTERNAL_freezeSpanFeatureFlags(span);
         });
       },
 
@@ -52,7 +54,7 @@ export const unleashIntegration = defineIntegration(
       },
 
       processEvent(event: Event, _hint: EventHint, _client: Client): Event {
-        return copyFlagsFromScopeToEvent(event);
+        return _INTERNAL_copyFlagsFromScopeToEvent(event);
       },
     };
   },
@@ -75,8 +77,8 @@ function _wrappedIsEnabled(
     const result = original.apply(this, args);
 
     if (typeof toggleName === 'string' && typeof result === 'boolean') {
-      insertFlagToScope(toggleName, result);
-      bufferSpanFeatureFlag(toggleName, result);
+      _INTERNAL_insertFlagToScope(toggleName, result);
+      _INTERNAL_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})`,
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
@@ -125,7 +125,7 @@ export { consoleLoggingIntegration } from './logs/console-integration';
 
 export type { FeatureFlag } from './featureFlags';
 // TODO: ^export from utils?
-// TODO: how to export utils without making public?
+export { _INTERNAL_copyFlagsFromScopeToEvent, _INTERNAL_insertFlagToScope, _INTERNAL_bufferSpanFeatureFlag, _INTERNAL_freezeSpanFeatureFlags } from './utils/featureFlags';
 
 export { applyAggregateErrorsToEvent } from './utils-hoist/aggregate-errors';
 export { getBreadcrumbLogLevelFromHttpStatusCode } from './utils-hoist/breadcrumb-log-level';
diff --git a/packages/core/src/integrations/featureFlags/featureFlagsIntegration.ts b/packages/core/src/integrations/featureFlags/featureFlagsIntegration.ts
@@ -4,10 +4,10 @@ import { type Event, type EventHint } from '../../types-hoist/event';
 import { type Integration, type IntegrationFn } from '../../types-hoist/integration';
 import { type Span } from '../../types-hoist/span';
 import {
-  bufferSpanFeatureFlag,
-  copyFlagsFromScopeToEvent,
-  freezeSpanFeatureFlags,
-  insertFlagToScope,
+  _INTERNAL_bufferSpanFeatureFlag,
+  _INTERNAL_copyFlagsFromScopeToEvent,
+  _INTERNAL_freezeSpanFeatureFlags,
+  _INTERNAL_insertFlagToScope,
 } from '../../utils/featureFlags';
 
 export interface FeatureFlagsIntegration extends Integration {
@@ -44,17 +44,17 @@ export const featureFlagsIntegration = 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);
     },
 
     addFeatureFlag(name: string, value: unknown): void {
-      insertFlagToScope(name, value);
-      bufferSpanFeatureFlag(name, value);
+      _INTERNAL_insertFlagToScope(name, value);
+      _INTERNAL_bufferSpanFeatureFlag(name, value);
     },
   };
 }) as IntegrationFn<FeatureFlagsIntegration>;
diff --git a/packages/core/src/utils/featureFlags.ts b/packages/core/src/utils/featureFlags.ts
@@ -16,12 +16,12 @@ import { getActiveSpan } from './spanUtils';
 /**
  * Max size of the LRU flag buffer stored in Sentry scope and event contexts.
  */
-export const FLAG_BUFFER_SIZE = 100;
+const FLAG_BUFFER_SIZE = 100;
 
 /**
  * Max number of flag evaluations to record per span.
  */
-export const MAX_FLAGS_PER_SPAN = 10;
+const MAX_FLAGS_PER_SPAN = 10;
 
 // Global map of spans to feature flag buffers. Populated by feature flag integrations.
 GLOBAL_OBJ._spanToFlagBufferMap = new WeakMap<Span, FeatureFlag[]>();
@@ -31,7 +31,7 @@ const SPAN_FLAG_ATTRIBUTE_PREFIX = 'flag.evaluation.';
 /**
  * Copies feature flags that are in current scope context to the event context
  */
-export function copyFlagsFromScopeToEvent(event: Event): Event {
+export function _INTERNAL_copyFlagsFromScopeToEvent(event: Event): Event {
   const scope = getCurrentScope();
   const flagContext = scope.getScopeData().contexts.flags;
   const flagBuffer = flagContext ? flagContext.values : [];
@@ -58,13 +58,13 @@ export function copyFlagsFromScopeToEvent(event: Event): Event {
  * @param value    Value of the feature flag.
  * @param maxSize  Max number of flags the buffer should store. Default value should always be used in production.
  */
-export function insertFlagToScope(name: string, value: unknown, maxSize: number = FLAG_BUFFER_SIZE): void {
+export function _INTERNAL_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);
+  _INTERNAL_insertToFlagBuffer(flags, name, value, maxSize);
 }
 
 /**
@@ -80,7 +80,7 @@ export function insertFlagToScope(name: string, value: unknown, maxSize: number
  * @param maxSize    Max number of flags the buffer should store. Default value should always be used in production.
  * @param allowEviction  If true, the oldest flag is evicted when the buffer is full. Otherwise the new flag is dropped.
  */
-export function insertToFlagBuffer(
+export function _INTERNAL_insertToFlagBuffer(
   flags: FeatureFlag[],
   name: string,
   value: unknown,
@@ -128,7 +128,7 @@ export function insertToFlagBuffer(
  * @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(
+export function _INTERNAL_bufferSpanFeatureFlag(
   name: string,
   value: unknown,
   maxFlagsPerSpan: number = MAX_FLAGS_PER_SPAN,
@@ -141,7 +141,7 @@ export function bufferSpanFeatureFlag(
   const span = getActiveSpan();
   if (span) {
     const flags = spanFlagMap.get(span) || [];
-    insertToFlagBuffer(flags, name, value, maxFlagsPerSpan, false);
+    _INTERNAL_insertToFlagBuffer(flags, name, value, maxFlagsPerSpan, false);
     spanFlagMap.set(span, flags);
   }
 }
@@ -151,7 +151,7 @@ export function bufferSpanFeatureFlag(
  *
  * @param span         Span to add flags to.
  */
-export function freezeSpanFeatureFlags(span: Span): void {
+export function _INTERNAL_freezeSpanFeatureFlags(span: Span): void {
   const flags = GLOBAL_OBJ._spanToFlagBufferMap?.get(span);
   if (flags) {
     span.setAttributes(
diff --git a/packages/core/test/lib/utils/featureFlags.test.ts b/packages/core/test/lib/utils/featureFlags.test.ts
