Merge branch 'develop' into sig/inline-nitro-utils

Author: s1gr1d

dev-packages/browser-integration-tests/suites/integrations/captureConsole/test.ts

@@ -30,6 +30,7 @@ sentryTest('it captures console messages correctly', async ({ getLocalTestUrl, p
       extra: {
         arguments: ['console log'],
       },
+      message: 'console log',
     }),
   );
   expect(logEvent?.exception).toBeUndefined();
@@ -40,6 +41,7 @@ sentryTest('it captures console messages correctly', async ({ getLocalTestUrl, p
       extra: {
         arguments: ['console warn'],
       },
+      message: 'console warn',
     }),
   );
   expect(warnEvent?.exception).toBeUndefined();
@@ -50,6 +52,7 @@ sentryTest('it captures console messages correctly', async ({ getLocalTestUrl, p
       extra: {
         arguments: ['console info'],
       },
+      message: 'console info',
     }),
   );
   expect(infoEvent?.exception).toBeUndefined();
@@ -60,6 +63,7 @@ sentryTest('it captures console messages correctly', async ({ getLocalTestUrl, p
       extra: {
         arguments: ['console error'],
       },
+      message: 'console error',
     }),
   );
   expect(errorEvent?.exception).toBeUndefined();
@@ -70,6 +74,7 @@ sentryTest('it captures console messages correctly', async ({ getLocalTestUrl, p
       extra: {
         arguments: ['console trace'],
       },
+      message: 'console trace',
     }),
   );
   expect(traceEvent?.exception).toBeUndefined();
@@ -90,6 +95,11 @@ sentryTest('it captures console messages correctly', async ({ getLocalTestUrl, p
     }),
   );
   expect(errorWithErrorEvent?.exception?.values?.[0].value).toBe('console error with error object');
+  expect(errorWithErrorEvent?.exception?.values?.[0].mechanism).toEqual({
+    // TODO (v9): Adjust to true after changing the integration's default value
+    handled: false,
+    type: 'console',
+  });
   expect(traceWithErrorEvent).toEqual(
     expect.objectContaining({
       level: 'log',

dev-packages/node-integration-tests/suites/anr/test.ts

@@ -52,6 +52,35 @@ const ANR_EVENT = {
   },
 };
 
+const ANR_EVENT_WITHOUT_STACKTRACE = {
+  // Ensure we have context
+  contexts: {
+    device: {
+      arch: expect.any(String),
+    },
+    app: {
+      app_start_time: expect.any(String),
+    },
+    os: {
+      name: expect.any(String),
+    },
+    culture: {
+      timezone: expect.any(String),
+    },
+  },
+  // and an exception that is our ANR
+  exception: {
+    values: [
+      {
+        type: 'ApplicationNotResponding',
+        value: 'Application Not Responding for at least 100 ms',
+        mechanism: { type: 'ANR' },
+        stacktrace: {},
+      },
+    ],
+  },
+};
+
 const ANR_EVENT_WITH_SCOPE = {
   ...ANR_EVENT,
   user: {
@@ -98,11 +127,11 @@ conditionalTest({ min: 16 })('should report ANR when event loop blocked', () =>
     createRunner(__dirname, 'indefinite.mjs').withMockSentryServer().expect({ event: ANR_EVENT }).start(done);
   });
 
-  test('With --inspect', done => {
+  test("With --inspect the debugger isn't used", done => {
     createRunner(__dirname, 'basic.mjs')
       .withMockSentryServer()
       .withFlags('--inspect')
-      .expect({ event: ANR_EVENT_WITH_SCOPE })
+      .expect({ event: ANR_EVENT_WITHOUT_STACKTRACE })
       .start(done);
   });
 

packages/core/src/integrations/captureconsole.ts

@@ -11,12 +11,24 @@ import { GLOBAL_OBJ } from '../utils-hoist/worldwide';
 
 interface CaptureConsoleOptions {
   levels?: string[];
+
+  // TODO(v9): Flip default value to `true` and adjust JSDoc!
+  /**
+   * By default, Sentry will mark captured console messages as unhandled.
+   * Set this to `true` if you want to mark them as handled instead.
+   *
+   * Note: in v9 of the SDK, this option will default to `true`, meaning the default behavior will change to mark console messages as handled.
+   * @default false
+   */
+  handled?: boolean;
 }
 
 const INTEGRATION_NAME = 'CaptureConsole';
 
 const _captureConsoleIntegration = ((options: CaptureConsoleOptions = {}) => {
   const levels = options.levels || CONSOLE_LEVELS;
+  // TODO(v9): Flip default value to `true`
+  const handled = !!options.handled;
 
   return {
     name: INTEGRATION_NAME,
@@ -30,7 +42,7 @@ const _captureConsoleIntegration = ((options: CaptureConsoleOptions = {}) => {
           return;
         }
 
-        consoleHandler(args, level);
+        consoleHandler(args, level, handled);
       });
     },
   };
@@ -41,7 +53,7 @@ const _captureConsoleIntegration = ((options: CaptureConsoleOptions = {}) => {
  */
 export const captureConsoleIntegration = defineIntegration(_captureConsoleIntegration);
 
-function consoleHandler(args: unknown[], level: string): void {
+function consoleHandler(args: unknown[], level: string, handled: boolean): void {
   const captureContext: CaptureContext = {
     level: severityLevelFromString(level),
     extra: {
@@ -54,7 +66,7 @@ function consoleHandler(args: unknown[], level: string): void {
       event.logger = 'console';
 
       addExceptionMechanism(event, {
-        handled: false,
+        handled,
         type: 'console',
       });
 

packages/core/test/lib/integrations/captureconsole.test.ts

@@ -305,29 +305,78 @@ describe('CaptureConsole setup', () => {
     }).not.toThrow();
   });
 
-  it("marks captured exception's mechanism as unhandled", () => {
-    // const addExceptionMechanismSpy = jest.spyOn(utils, 'addExceptionMechanism');
+  describe('exception mechanism', () => {
+    // TODO (v9): Flip this below after adjusting the default value for `handled` in the integration
+    it("marks captured exception's mechanism as unhandled by default", () => {
+      const captureConsole = captureConsoleIntegration({ levels: ['error'] });
+      captureConsole.setup?.(mockClient);
 
-    const captureConsole = captureConsoleIntegration({ levels: ['error'] });
-    captureConsole.setup?.(mockClient);
+      const someError = new Error('some error');
+      GLOBAL_OBJ.console.error(someError);
 
-    const someError = new Error('some error');
-    GLOBAL_OBJ.console.error(someError);
+      const addedEventProcessor = (mockScope.addEventProcessor as jest.Mock).mock.calls[0][0];
+      const someEvent: Event = {
+        exception: {
+          values: [{}],
+        },
+      };
+      addedEventProcessor(someEvent);
 
-    const addedEventProcessor = (mockScope.addEventProcessor as jest.Mock).mock.calls[0][0];
-    const someEvent: Event = {
-      exception: {
-        values: [{}],
-      },
-    };
-    addedEventProcessor(someEvent);
+      expect(captureException).toHaveBeenCalledTimes(1);
+      expect(mockScope.addEventProcessor).toHaveBeenCalledTimes(1);
 
-    expect(captureException).toHaveBeenCalledTimes(1);
-    expect(mockScope.addEventProcessor).toHaveBeenCalledTimes(1);
+      expect(someEvent.exception?.values?.[0]?.mechanism).toEqual({
+        handled: false,
+        type: 'console',
+      });
+    });
+
+    it("marks captured exception's mechanism as handled if set in the options", () => {
+      const captureConsole = captureConsoleIntegration({ levels: ['error'], handled: true });
+      captureConsole.setup?.(mockClient);
 
-    expect(someEvent.exception?.values?.[0]?.mechanism).toEqual({
-      handled: false,
-      type: 'console',
+      const someError = new Error('some error');
+      GLOBAL_OBJ.console.error(someError);
+
+      const addedEventProcessor = (mockScope.addEventProcessor as jest.Mock).mock.calls[0][0];
+      const someEvent: Event = {
+        exception: {
+          values: [{}],
+        },
+      };
+      addedEventProcessor(someEvent);
+
+      expect(captureException).toHaveBeenCalledTimes(1);
+      expect(mockScope.addEventProcessor).toHaveBeenCalledTimes(1);
+
+      expect(someEvent.exception?.values?.[0]?.mechanism).toEqual({
+        handled: true,
+        type: 'console',
+      });
+    });
+
+    it("marks captured exception's mechanism as unhandled if set in the options", () => {
+      const captureConsole = captureConsoleIntegration({ levels: ['error'], handled: false });
+      captureConsole.setup?.(mockClient);
+
+      const someError = new Error('some error');
+      GLOBAL_OBJ.console.error(someError);
+
+      const addedEventProcessor = (mockScope.addEventProcessor as jest.Mock).mock.calls[0][0];
+      const someEvent: Event = {
+        exception: {
+          values: [{}],
+        },
+      };
+      addedEventProcessor(someEvent);
+
+      expect(captureException).toHaveBeenCalledTimes(1);
+      expect(mockScope.addEventProcessor).toHaveBeenCalledTimes(1);
+
+      expect(someEvent.exception?.values?.[0]?.mechanism).toEqual({
+        handled: false,
+        type: 'console',
+      });
     });
   });
 });

packages/node/src/integrations/anr/index.ts

@@ -14,6 +14,7 @@ import {
 } from '@sentry/core';
 import { NODE_VERSION } from '../../nodeVersion';
 import type { NodeClient } from '../../sdk/client';
+import { isDebuggerEnabled } from '../../utils/debug';
 import type { AnrIntegrationOptions, WorkerStartData } from './common';
 
 const { isPromise } = types;
@@ -98,9 +99,14 @@ const _anrIntegration = ((options: Partial<AnrIntegrationOptions> = {}) => {
         });
       }
     },
-    setup(initClient: NodeClient) {
+    async setup(initClient: NodeClient) {
       client = initClient;
 
+      if (options.captureStackTrace && (await isDebuggerEnabled())) {
+        logger.warn('ANR captureStackTrace has been disabled because the debugger was already enabled');
+        options.captureStackTrace = false;
+      }
+
       // setImmediate is used to ensure that all other integrations have had their setup called first.
       // This allows us to call into all integrations to fetch the full context
       setImmediate(() => this.startWorker());

packages/node/src/integrations/local-variables/local-variables-async.ts

@@ -2,6 +2,7 @@ import { Worker } from 'node:worker_threads';
 import type { Event, EventHint, Exception, IntegrationFn } from '@sentry/core';
 import { defineIntegration, logger } from '@sentry/core';
 import type { NodeClient } from '../../sdk/client';
+import { isDebuggerEnabled } from '../../utils/debug';
 import type { FrameVariables, LocalVariablesIntegrationOptions, LocalVariablesWorkerArgs } from './common';
 import { LOCAL_VARIABLES_KEY, functionNamesMatch } from './common';
 
@@ -101,13 +102,18 @@ export const localVariablesAsyncIntegration = defineIntegration(((
 
   return {
     name: 'LocalVariablesAsync',
-    setup(client: NodeClient) {
+    async setup(client: NodeClient) {
       const clientOptions = client.getOptions();
 
       if (!clientOptions.includeLocalVariables) {
         return;
       }
 
+      if (await isDebuggerEnabled()) {
+        logger.warn('Local variables capture has been disabled because the debugger was already enabled');
+        return;
+      }
+
       const options: LocalVariablesWorkerArgs = {
         ...integrationOptions,
         debug: logger.isEnabled(),

packages/node/src/integrations/local-variables/local-variables-sync.ts

@@ -3,6 +3,7 @@ import type { Event, Exception, IntegrationFn, StackFrame, StackParser } from '@
 import { LRUMap, defineIntegration, getClient, logger } from '@sentry/core';
 import { NODE_MAJOR } from '../../nodeVersion';
 import type { NodeClient } from '../../sdk/client';
+import { isDebuggerEnabled } from '../../utils/debug';
 import type {
   FrameVariables,
   LocalVariablesIntegrationOptions,
@@ -289,7 +290,7 @@ const _localVariablesSyncIntegration = ((
 
   return {
     name: INTEGRATION_NAME,
-    setupOnce() {
+    async setupOnce() {
       const client = getClient<NodeClient>();
       const clientOptions = client?.getOptions();
 
@@ -306,6 +307,11 @@ const _localVariablesSyncIntegration = ((
         return;
       }
 
+      if (await isDebuggerEnabled()) {
+        logger.warn('Local variables capture has been disabled because the debugger was already enabled');
+        return;
+      }
+
       AsyncSession.create(sessionOverride).then(
         session => {
           function handlePaused(

packages/node/src/utils/debug.ts

@@ -0,0 +1,18 @@
+let cachedDebuggerEnabled: boolean | undefined;
+
+/**
+ * Was the debugger enabled when this function was first called?
+ */
+export async function isDebuggerEnabled(): Promise<boolean> {
+  if (cachedDebuggerEnabled === undefined) {
+    try {
+      // Node can be built without inspector support
+      const inspector = await import('node:inspector');
+      cachedDebuggerEnabled = !!inspector.url();
+    } catch (_) {
+      cachedDebuggerEnabled = false;
+    }
+  }
+
+  return cachedDebuggerEnabled;
+}