move gb integration to core

Author: madhuchavva

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

@@ -1,12 +1,6 @@
-import type { Client, Event, EventHint, IntegrationFn } from '@sentry/core';
-import {
-  _INTERNAL_addFeatureFlagToActiveSpan,
-  _INTERNAL_copyFlagsFromScopeToEvent,
-  _INTERNAL_insertFlagToScope,
-  defineIntegration,
-  fill,
-} from '@sentry/core';
-import type { GrowthBook, GrowthBookClass } from './types';
+import type { IntegrationFn } from '@sentry/core';
+import * as SentryCore from '@sentry/core';
+import type { GrowthBookClass } from './types';
 
 /**
  * Sentry integration for capturing feature flag evaluations from GrowthBook.
@@ -28,43 +22,7 @@ import type { GrowthBook, GrowthBookClass } from './types';
  * Sentry.captureException(new Error('something went wrong'));
  * ```
  */
-export const growthbookIntegration = defineIntegration(({ growthbookClass }: { growthbookClass: GrowthBookClass }) => {
-  return {
-    name: 'GrowthBook',
+const _coreAny = SentryCore as unknown as Record<string, any>;
 
-    setupOnce() {
-      const proto = growthbookClass.prototype as GrowthBook;
-      fill(proto, 'isOn', _wrapBooleanReturningMethod);
-      fill(proto, 'getFeatureValue', _wrapBooleanReturningMethod);
-      // Also capture evalFeature when present. Not all versions have it, so guard.
-      if (typeof (proto as unknown as Record<string, unknown>).evalFeature === 'function') {
-        fill(proto as any, 'evalFeature', _wrapBooleanReturningMethod as any);
-      }
-    },
-
-    processEvent(event: Event, _hint: EventHint, _client: Client): Event {
-      return _INTERNAL_copyFlagsFromScopeToEvent(event);
-    },
-  };
-}) satisfies IntegrationFn;
-
-function _wrapBooleanReturningMethod(
-  original: (this: GrowthBook, ...args: unknown[]) => unknown,
-): (this: GrowthBook, ...args: unknown[]) => unknown {
-  return function (this: GrowthBook, ...args: unknown[]): unknown {
-    const flagName = args[0];
-    const result = original.apply(this, args);
-    // Capture any JSON-serializable result (booleans, strings, numbers, null, plain objects/arrays).
-    // Skip functions/symbols/undefined.
-    if (
-      typeof flagName === 'string' &&
-      typeof result !== 'undefined' &&
-      typeof result !== 'function' &&
-      typeof result !== 'symbol'
-    ) {
-      _INTERNAL_insertFlagToScope(flagName, result);
-      _INTERNAL_addFeatureFlagToActiveSpan(flagName, result);
-    }
-    return result;
-  };
-}
+export const growthbookIntegration = (({ growthbookClass }: { growthbookClass: GrowthBookClass }) =>
+  _coreAny.growthbookIntegration({ growthbookClass })) satisfies IntegrationFn;

packages/browser/src/integrations/featureFlags/growthbook/types.ts

@@ -1,6 +1,6 @@
 export interface GrowthBook {
-  isOn(this: GrowthBook, featureKey: string): boolean;
-  getFeatureValue(this: GrowthBook, featureKey: string, defaultValue: unknown): unknown;
+  isOn(this: GrowthBook, featureKey: string, ...rest: unknown[]): boolean;
+  getFeatureValue(this: GrowthBook, featureKey: string, defaultValue: unknown, ...rest: unknown[]): unknown;
 }
 
 // We only depend on the surface we wrap; constructor args are irrelevant here.

packages/core/src/index.ts

@@ -111,6 +111,7 @@ export { zodErrorsIntegration } from './integrations/zoderrors';
 export { thirdPartyErrorFilterIntegration } from './integrations/third-party-errors-filter';
 export { consoleIntegration } from './integrations/console';
 export { featureFlagsIntegration, type FeatureFlagsIntegration } from './integrations/featureFlags';
+export { growthbookIntegration } from './integrations/featureFlags';
 
 export { profiler } from './profiling';
 export { instrumentFetchRequest } from './fetch';

packages/core/src/integrations/featureFlags/growthbook.ts

@@ -0,0 +1,70 @@
+import type { Client } from '../../client';
+import { defineIntegration } from '../../integration';
+import type { Event, EventHint } from '../../types-hoist/event';
+import type { IntegrationFn } from '../../types-hoist/integration';
+import {
+  _INTERNAL_addFeatureFlagToActiveSpan,
+  _INTERNAL_copyFlagsFromScopeToEvent,
+  _INTERNAL_insertFlagToScope,
+} from '../../utils/featureFlags';
+import { fill } from '../../utils/object';
+
+interface GrowthBookLike {
+  isOn(this: GrowthBookLike, featureKey: string, ...rest: unknown[]): boolean;
+  getFeatureValue(this: GrowthBookLike, featureKey: string, defaultValue: unknown, ...rest: unknown[]): unknown;
+}
+
+export type GrowthBookClassLike = new (...args: unknown[]) => GrowthBookLike;
+
+/**
+ * Sentry integration for capturing feature flag evaluations from GrowthBook.
+ *
+ * Only boolean results are captured at this time.
+ */
+export const growthbookIntegration = defineIntegration(
+  ({ growthbookClass }: { growthbookClass: GrowthBookClassLike }) => {
+    return {
+      name: 'GrowthBook',
+
+      setupOnce() {
+        const proto = growthbookClass.prototype as GrowthBookLike;
+
+        // Type guard and wrap isOn
+        if (typeof proto.isOn === 'function') {
+          fill(proto, 'isOn', _wrapAndCaptureBooleanResult);
+        }
+
+        // Type guard and wrap getFeatureValue
+        if (typeof proto.getFeatureValue === 'function') {
+          fill(proto, 'getFeatureValue', _wrapAndCaptureBooleanResult);
+        }
+
+        // Type guard and wrap evalFeature if present
+        const maybeEval = (proto as unknown as Record<string, unknown>).evalFeature;
+        if (typeof maybeEval === 'function') {
+          fill(proto as unknown as Record<string, unknown>, 'evalFeature', _wrapAndCaptureBooleanResult as any);
+        }
+      },
+
+      processEvent(event: Event, _hint: EventHint, _client: Client): Event {
+        return _INTERNAL_copyFlagsFromScopeToEvent(event);
+      },
+    };
+  },
+) satisfies IntegrationFn;
+
+function _wrapAndCaptureBooleanResult(
+  original: (this: GrowthBookLike, ...args: unknown[]) => unknown,
+): (this: GrowthBookLike, ...args: unknown[]) => unknown {
+  return function (this: GrowthBookLike, ...args: unknown[]): unknown {
+    const flagName = args[0];
+    const result = original.apply(this, args);
+
+    if (typeof flagName === 'string' && typeof result === 'boolean') {
+      _INTERNAL_insertFlagToScope(flagName, result);
+      _INTERNAL_addFeatureFlagToActiveSpan(flagName, result);
+    }
+
+    return result;
+  };
+}

packages/core/src/integrations/featureFlags/index.ts

@@ -1 +1,2 @@
 export { featureFlagsIntegration, type FeatureFlagsIntegration } from './featureFlagsIntegration';
+export { growthbookIntegration } from './growthbook';

packages/node/src/integrations/featureFlagShims/growthbook.ts

@@ -1,17 +1,20 @@
-import { consoleSandbox, defineIntegration, isBrowser } from '@sentry/core';
+import {
+  defineIntegration,
+  growthbookIntegration as coreGrowthbookIntegration,
+  isBrowser,
+} from '@sentry/core';
 
 /**
  * Shim for the GrowthBook integration to avoid runtime errors when imported on the server.
  */
-export const growthbookIntegrationShim = defineIntegration((_options?: unknown) => {
-  if (!isBrowser()) {
-    consoleSandbox(() => {
-      // eslint-disable-next-line no-console
-      console.warn('The growthbookIntegration() can only be used in the browser.');
-    });
-  }
+export const growthbookIntegrationShim = defineIntegration(
+  (options: Parameters<typeof coreGrowthbookIntegration>[0]) => {
+    if (!isBrowser()) {
+      // On Node, just return the core integration so Node SDKs can also use it.
+      return coreGrowthbookIntegration(options);
+    }
 
-  return {
-    name: 'GrowthBook',
-  };
-});
+    // In browser, still return the integration to preserve behavior.
+    return coreGrowthbookIntegration(options);
+  },
+);