fix(core): Prevent infinite recursion when console is instrumented twice

packages/core/src/instrument/console.ts

@@ -51,16 +51,31 @@ export function _INTERNAL_resetConsoleInstrumentationOptions(): void {
  _filter.clear();
 }
 
-function instrumentConsole(): void {
+// The console levels *this* copy of the SDK has already wrapped. A copy must wrap each level at
+// most once: re-wrapping overwrites `originalConsoleMethods[level]` with a function that itself
+// reads `originalConsoleMethods[level]`, so calling through to the "original" (here and in
+// `consoleSandbox`) re-enters a wrapper indefinitely, ending in a `RangeError: Maximum call stack
+// size exceeded`. This can happen e.g. in React Native when instrumentation state is re-initialized
+// while the console stays wrapped. See getsentry/sentry-react-native SDK-CRASHES-REACT-NATIVE-5HZ.
+// We intentionally track this per copy rather than checking for the shared `__sentry_original__`
+// marker: a *different* SDK copy's wrapper (e.g. separate CDN bundles that each inline
+// `@sentry/core`) is safe to wrap since its call chain resolves down to the native method, and
+// skipping it would silently drop that copy's console handlers (breadcrumbs, `captureConsole`).
+const instrumentedLevels = new Set<ConsoleLevel>();
+
+/** Only exported for tests. */
+export function instrumentConsole(): void {
  if (!('console' in GLOBAL_OBJ)) {
  return;
  }
 
  CONSOLE_LEVELS.forEach(function (level: ConsoleLevel): void {
- if (!(level in GLOBAL_OBJ.console)) {
+ if (instrumentedLevels.has(level) || !(level in GLOBAL_OBJ.console)) {
  return;
  }
 
+ instrumentedLevels.add(level);
+
  fill(GLOBAL_OBJ.console, level, function (originalConsoleMethod: () => any): Function {
  originalConsoleMethods[level] = originalConsoleMethod;
 

packages/core/test/lib/instrument/console.test.ts

@@ -1,31 +1,53 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import {
- _INTERNAL_resetConsoleInstrumentationOptions,
- addConsoleInstrumentationFilter,
- addConsoleInstrumentationHandler,
-} from '../../../src/instrument/console';
+import { CONSOLE_LEVELS } from '../../../src/utils/debug-logger';
 import { GLOBAL_OBJ } from '../../../src/utils/worldwide';
-import { debug, originalConsoleMethods } from '../../../src/utils/debug-logger';
-import { resetInstrumentationHandlers } from '../../../src/instrument/handlers';
+
+// Capture the pristine console methods once, before any instrumentation wraps them. Each test gets a
+// fresh copy of the instrumentation modules (and therefore fresh module-scoped state such as
+// `instrumentedLevels`) via `vi.resetModules()`, but the global console object is shared across the
+// module registry, so we must also restore it between tests - otherwise a fresh `instrumentConsole()`
+// would wrap an already-wrapped method.
+const nativeConsoleMethods = Object.fromEntries(
+ CONSOLE_LEVELS.map(level => [level, GLOBAL_OBJ.console[level]]),
+) as Record<string, unknown>;
+
+function restoreNativeConsole(): void {
+ for (const level of CONSOLE_LEVELS) {
+ GLOBAL_OBJ.console[level] = nativeConsoleMethods[level] as (typeof GLOBAL_OBJ.console)[typeof level];
+ }
+}
+
+// Re-import the instrumentation modules so each test gets fresh module-scoped state (e.g.
+// `instrumentedLevels`). `vi.resetModules()` does not reset the shared global console, so we also
+// restore the native methods first, ensuring a fresh `instrumentConsole()` never wraps an
+// already-wrapped method.
+async function loadInstrumentationModules() {
+ vi.resetModules();
+ restoreNativeConsole();
+ return {
+ consoleModule: await import('../../../src/instrument/console'),
+ debugLoggerModule: await import('../../../src/utils/debug-logger'),
+ };
+}
 
 describe('addConsoleInstrumentationHandler', () => {
- let _originalConsoleMethods: typeof originalConsoleMethods = {};
+ let consoleModule: Awaited<ReturnType<typeof loadInstrumentationModules>>['consoleModule'];
+ let debugLoggerModule: Awaited<ReturnType<typeof loadInstrumentationModules>>['debugLoggerModule'];
+
+ beforeEach(async () => {
+ ({ consoleModule, debugLoggerModule } = await loadInstrumentationModules());
+ });
 
  afterEach(() => {
- Object.assign(originalConsoleMethods, _originalConsoleMethods);
- resetInstrumentationHandlers();
+ restoreNativeConsole();
  vi.restoreAllMocks();
  });
 
  // This cannot be done in beforeEach, as the first invocation of `addConsoleInstrumentationHandler` will overwrite the original console methods.
  // Due to `fill` being called
  // So instead, we need to call this each time after calling `addConsoleInstrumentationHandler`
  function mockConsoleMethods() {
- // Re-store this with the current implementation
- Object.assign(_originalConsoleMethods, originalConsoleMethods);
-
- // Overwrite with mock console methods
- Object.assign(originalConsoleMethods, {
+ Object.assign(debugLoggerModule.originalConsoleMethods, {
  log: vi.fn(),
  warn: vi.fn(),
  error: vi.fn(),
@@ -38,72 +60,92 @@ describe('addConsoleInstrumentationHandler', () => {
  'calls registered handler when console.%s is called',
  level => {
  const handler = vi.fn();
- addConsoleInstrumentationHandler(handler);
+consoleModule.addConsoleInstrumentationHandler(handler);
  mockConsoleMethods();
 
  GLOBAL_OBJ.console[level]('test message');
 
  expect(handler).toHaveBeenCalledWith(expect.objectContaining({ args: ['test message'], level }));
- expect(originalConsoleMethods[level]).toHaveBeenCalledWith('test message');
+ expect(debugLoggerModule.originalConsoleMethods[level]).toHaveBeenCalledWith('test message');
  },
  );
 
  it('calls through to the underlying console method without throwing', () => {
- addConsoleInstrumentationHandler(vi.fn());
+consoleModule.addConsoleInstrumentationHandler(vi.fn());
  mockConsoleMethods();
  expect(() => GLOBAL_OBJ.console.log('hello')).not.toThrow();
  });
 
- describe('filter', () => {
- afterEach(() => {
- _INTERNAL_resetConsoleInstrumentationOptions();
- });
+ it('does not recurse infinitely when the same SDK copy re-instruments an already-wrapped console', () => {
+ // Re-running `instrumentConsole()` within the same copy of `@sentry/core` (e.g. instrumentation
+ // state re-initialized in React Native while the console stays wrapped) must not re-wrap our own
+ // wrapper. Otherwise the second pass stores that wrapper into `originalConsoleMethods[level]`,
+ // which the wrapper reads on every call, so calling through to the "original" re-enters the
+ // wrapper forever -> `RangeError: Maximum call stack size exceeded`.
+ const handler = vi.fn();
+ consoleModule.addConsoleInstrumentationHandler(handler);
+ mockConsoleMethods();
+
+ const wrapperAfterFirstPass = GLOBAL_OBJ.console.error;
+
+ // Force a second instrumentation pass on the same copy to mimic re-initialized state.
+ consoleModule.instrumentConsole();
+
+ // The second pass must be a no-op: our own wrapper is left in place (identity unchanged),
+ // so `originalConsoleMethods[level]` keeps pointing at the real method rather than a wrapper.
+ expect(GLOBAL_OBJ.console.error).toBe(wrapperAfterFirstPass);
 
+ expect(() => GLOBAL_OBJ.console.error('boom')).not.toThrow();
+ expect(handler).toHaveBeenCalledWith(expect.objectContaining({ args: ['boom'], level: 'error' }));
+ expect(debugLoggerModule.originalConsoleMethods.error).toHaveBeenCalledWith('boom');
+ });
+
+ describe('filter', () => {
  describe('when debug is disabled', () => {
  beforeEach(() => {
- vi.spyOn(debug, 'isEnabled').mockImplementation(() => false);
+ vi.spyOn(debugLoggerModule.debug, 'isEnabled').mockImplementation(() => false);
  });
 
  it('filters out messages that match the filter', () => {
  const handler = vi.fn();
- addConsoleInstrumentationHandler(handler);
- addConsoleInstrumentationFilter(['test message']);
+consoleModule.addConsoleInstrumentationHandler(handler);
+consoleModule.addConsoleInstrumentationFilter(['test message']);
  mockConsoleMethods();
 
  GLOBAL_OBJ.console.log('test message');
 
- expect(originalConsoleMethods.log).not.toHaveBeenCalledWith('test message');
+ expect(debugLoggerModule.originalConsoleMethods.log).not.toHaveBeenCalledWith('test message');
  expect(handler).not.toHaveBeenCalled();
  });
 
  it('does not filter out messages that do not match the filter', () => {
  const handler = vi.fn();
- addConsoleInstrumentationHandler(handler);
- addConsoleInstrumentationFilter(['test message']);
+consoleModule.addConsoleInstrumentationHandler(handler);
+consoleModule.addConsoleInstrumentationFilter(['test message']);
  mockConsoleMethods();
 
  GLOBAL_OBJ.console.log('other message');
 
  expect(handler).toHaveBeenCalled();
- expect(originalConsoleMethods.log).toHaveBeenCalledWith('other message');
+ expect(debugLoggerModule.originalConsoleMethods.log).toHaveBeenCalledWith('other message');
  });
  });
 
  describe('when debug is enabled', () => {
  beforeEach(() => {
- vi.spyOn(debug, 'isEnabled').mockImplementation(() => true);
+ vi.spyOn(debugLoggerModule.debug, 'isEnabled').mockImplementation(() => true);
  });
 
  it('logs filtered messages but does not call the handler for them', () => {
  const handler = vi.fn();
- addConsoleInstrumentationHandler(handler);
- addConsoleInstrumentationFilter(['test message']);
+consoleModule.addConsoleInstrumentationHandler(handler);
+consoleModule.addConsoleInstrumentationFilter(['test message']);
  mockConsoleMethods();
 
  GLOBAL_OBJ.console.log('test message');
 
  expect(handler).not.toHaveBeenCalled();
- expect(originalConsoleMethods.log).toHaveBeenCalledWith('test message');
+ expect(debugLoggerModule.originalConsoleMethods.log).toHaveBeenCalledWith('test message');
  });
  });
  });