ref: Avoid using global singleton for logger

Author: mydea

packages/hub/test/scope.test.ts

@@ -9,6 +9,7 @@ describe('Scope', () => {
   afterEach(() => {
     jest.resetAllMocks();
     jest.useRealTimers();
+    GLOBAL_OBJ.__SENTRY__ = GLOBAL_OBJ.__SENTRY__ || {};
     GLOBAL_OBJ.__SENTRY__.globalEventProcessors = undefined;
   });
 

packages/integrations/test/captureconsole.test.ts

@@ -1,7 +1,13 @@
 /* eslint-disable @typescript-eslint/unbound-method */
 import type { Event, Hub, Integration } from '@sentry/types';
 import type { ConsoleLevel } from '@sentry/utils';
-import { addInstrumentationHandler, CONSOLE_LEVELS, GLOBAL_OBJ, originalConsoleMethods } from '@sentry/utils';
+import {
+  addInstrumentationHandler,
+  CONSOLE_LEVELS,
+  GLOBAL_OBJ,
+  originalConsoleMethods,
+  resetInstrumentationHandlers,
+} from '@sentry/utils';
 
 import { CaptureConsole } from '../src/captureconsole';
 
@@ -54,6 +60,8 @@ describe('CaptureConsole setup', () => {
     CONSOLE_LEVELS.forEach(key => {
       originalConsoleMethods[key] = _originalConsoleMethods[key];
     });
+
+    resetInstrumentationHandlers();
   });
 
   describe('monkeypatching', () => {

packages/replay/test/mocks/resetSdkMock.ts

@@ -1,3 +1,6 @@
+import type { EventProcessor } from '@sentry/types';
+import { getGlobalSingleton, resetInstrumentationHandlers } from '@sentry/utils';
+
 import type { Replay as ReplayIntegration } from '../../src';
 import type { ReplayContainer } from '../../src/replay';
 import type { RecordMock } from './../index';
@@ -17,9 +20,11 @@ export async function resetSdkMock({ replayOptions, sentryOptions, autoStart }:
   jest.setSystemTime(new Date(BASE_TIMESTAMP));
   jest.clearAllMocks();
   jest.resetModules();
-  // NOTE: The listeners added to `addInstrumentationHandler` are leaking
-  // @ts-ignore Don't know if there's a cleaner way to clean up old event processors
-  globalThis.__SENTRY__.globalEventProcessors = [];
+
+  // Clear all handlers that have been registered
+  resetInstrumentationHandlers();
+  getGlobalSingleton<EventProcessor[]>('globalEventProcessors', () => []).length = 0;
+
   const SentryUtils = await import('@sentry/utils');
   jest.spyOn(SentryUtils, 'addInstrumentationHandler').mockImplementation((type, handler: (args: any) => any) => {
     if (type === 'dom') {

packages/utils/src/instrument.ts

@@ -94,6 +94,16 @@ export function addInstrumentationHandler(type: InstrumentHandlerType, callback:
   instrument(type);
 }
 
+/**
+ * Reset all instrumentation handlers.
+ * This can be used by tests to ensure we have a clean slate of instrumentation handlers.
+ */
+export function resetInstrumentationHandlers(): void {
+  Object.keys(handlers).forEach(key => {
+    handlers[key as InstrumentHandlerType] = undefined;
+  });
+}
+
 /** JSDoc */
 function triggerHandlers(type: InstrumentHandlerType, data: any): void {
   if (!type || !handlers[type]) {

packages/utils/src/logger.ts

@@ -1,6 +1,5 @@
-import type { WrappedFunction } from '@sentry/types';
-
-import { getGlobalSingleton, GLOBAL_OBJ } from './worldwide';
+import { originalConsoleMethods } from './instrument';
+import { GLOBAL_OBJ } from './worldwide';
 
 /** Prefix for logging strings */
 const PREFIX = 'Sentry Logger ';
@@ -9,7 +8,7 @@ export const CONSOLE_LEVELS = ['debug', 'info', 'warn', 'error', 'log', 'assert'
 export type ConsoleLevel = (typeof CONSOLE_LEVELS)[number];
 
 type LoggerMethod = (...args: unknown[]) => void;
-type LoggerConsoleMethods = Record<(typeof CONSOLE_LEVELS)[number], LoggerMethod>;
+type LoggerConsoleMethods = Record<ConsoleLevel, LoggerMethod>;
 
 /** JSDoc */
 interface Logger extends LoggerConsoleMethods {
@@ -28,26 +27,24 @@ export function consoleSandbox<T>(callback: () => T): T {
     return callback();
   }
 
-  const originalConsole = GLOBAL_OBJ.console as Console & Record<string, unknown>;
-  const wrappedLevels: Partial<LoggerConsoleMethods> = {};
+  const console = GLOBAL_OBJ.console as Console;
+  const wrappedFuncs: Partial<LoggerConsoleMethods> = {};
+
+  const wrappedLevels = Object.keys(originalConsoleMethods) as ConsoleLevel[];
 
   // Restore all wrapped console methods
-  CONSOLE_LEVELS.forEach(level => {
-    // TODO(v7): Remove this check as it's only needed for Node 6
-    const originalWrappedFunc =
-      originalConsole[level] && (originalConsole[level] as WrappedFunction).__sentry_original__;
-    if (level in originalConsole && originalWrappedFunc) {
-      wrappedLevels[level] = originalConsole[level] as LoggerConsoleMethods[typeof level];
-      originalConsole[level] = originalWrappedFunc as Console[typeof level];
-    }
+  wrappedLevels.forEach(level => {
+    const originalConsoleMethod = originalConsoleMethods[level] as LoggerMethod;
+    wrappedFuncs[level] = console[level] as LoggerMethod | undefined;
+    console[level] = originalConsoleMethod;
   });
 
   try {
     return callback();
   } finally {
     // Revert restoration to wrapped state
-    Object.keys(wrappedLevels).forEach(level => {
-      originalConsole[level] = wrappedLevels[level as (typeof CONSOLE_LEVELS)[number]];
+    wrappedLevels.forEach(level => {
+      console[level] = wrappedFuncs[level] as LoggerMethod;
     });
   }
 }
@@ -83,12 +80,4 @@ function makeLogger(): Logger {
   return logger as Logger;
 }
 
-// Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used
-let logger: Logger;
-if (__DEBUG_BUILD__) {
-  logger = getGlobalSingleton('logger', makeLogger);
-} else {
-  logger = makeLogger();
-}
-
-export { logger };
+export const logger = makeLogger();