Merge branch 'develop' into dependabot/npm_and_yarn/ts-node-10.9.2

Author: chargome

package.json

@@ -129,7 +129,7 @@
     "madge": "8.0.0",
     "nodemon": "^3.1.10",
     "npm-run-all2": "^6.2.0",
-    "prettier": "^3.6.2",
+    "prettier": "^3.8.1",
     "prettier-plugin-astro": "^0.14.1",
     "rimraf": "^5.0.10",
     "rollup": "^4.35.0",

packages/browser/src/integrations/spotlight.ts

@@ -80,9 +80,9 @@ export const spotlightBrowserIntegration = defineIntegration(_spotlightIntegrati
 export function isSpotlightInteraction(event: Event): boolean {
   return Boolean(
     event.type === 'transaction' &&
-      event.spans &&
-      event.contexts?.trace &&
-      event.contexts.trace.op === 'ui.action.click' &&
-      event.spans.some(({ description }) => description?.includes('#sentry-spotlight')),
+    event.spans &&
+    event.contexts?.trace &&
+    event.contexts.trace.op === 'ui.action.click' &&
+    event.spans.some(({ description }) => description?.includes('#sentry-spotlight')),
   );
 }

packages/core/src/types-hoist/feedback/index.ts

@@ -15,10 +15,7 @@ export type { FeedbackEvent, UserFeedback, SendFeedback, SendFeedbackParams };
  * The integration's internal `options` member where every value should be set
  */
 export interface FeedbackInternalOptions
-  extends FeedbackGeneralConfiguration,
-    FeedbackThemeConfiguration,
-    FeedbackTextConfiguration,
-    FeedbackCallbacks {}
+  extends FeedbackGeneralConfiguration, FeedbackThemeConfiguration, FeedbackTextConfiguration, FeedbackCallbacks {}
 
 type Hooks = unknown;
 type HTMLElement = unknown;

packages/core/src/types-hoist/options.ts

@@ -616,8 +616,10 @@ export interface ClientOptions<TO extends BaseTransportOptions = BaseTransportOp
 }
 
 /** Base configuration options for every SDK. */
-export interface CoreOptions<TO extends BaseTransportOptions = BaseTransportOptions>
-  extends Omit<Partial<ClientOptions<TO>>, 'integrations' | 'transport' | 'stackParser'> {
+export interface CoreOptions<TO extends BaseTransportOptions = BaseTransportOptions> extends Omit<
+  Partial<ClientOptions<TO>>,
+  'integrations' | 'transport' | 'stackParser'
+> {
   /**
    * If this is set to false, default integrations will not be added, otherwise this will internally be set to the
    * recommended default integrations.

packages/core/src/utils/flushIfServerless.ts

@@ -36,7 +36,7 @@ async function flushWithTimeout(timeout: number): Promise<void> {
  */
 export async function flushIfServerless(
   params: // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  | { timeout?: number; cloudflareWaitUntil?: (task: Promise<any>) => void }
+    | { timeout?: number; cloudflareWaitUntil?: (task: Promise<any>) => void }
     | { timeout?: number; cloudflareCtx?: MinimalCloudflareContext } = {},
 ): Promise<void> {
   const { timeout = 2000 } = params;

packages/feedback/src/core/types.ts

@@ -5,8 +5,10 @@ import type { FeedbackInternalOptions } from '@sentry/core';
  *
  * This is the config that gets passed into the integration constructor
  */
-export interface OptionalFeedbackConfiguration
-  extends Omit<Partial<FeedbackInternalOptions>, 'themeLight' | 'themeDark'> {
+export interface OptionalFeedbackConfiguration extends Omit<
+  Partial<FeedbackInternalOptions>,
+  'themeLight' | 'themeDark'
+> {
   themeLight?: Partial<FeedbackInternalOptions['themeLight']>;
   themeDark?: Partial<FeedbackInternalOptions['themeLight']>;
 }

packages/nextjs/src/common/pages-router-instrumentation/_error.ts

@@ -13,15 +13,18 @@ type ContextOrProps = {
 /**
  * Capture the exception passed by nextjs to the `_error` page, adding context data as appropriate.
  *
+ * This will not capture the exception if the status code is < 500 or if the pathname is not provided and will thus not return an event ID.
+ *
  * @param contextOrProps The data passed to either `getInitialProps` or `render` by nextjs
+ * @returns The Sentry event ID, or `undefined` if no event was captured
  */
-export async function captureUnderscoreErrorException(contextOrProps: ContextOrProps): Promise<void> {
+export async function captureUnderscoreErrorException(contextOrProps: ContextOrProps): Promise<string | undefined> {
   const { req, res, err } = contextOrProps;
 
   // 404s (and other 400-y friends) can trigger `_error`, but we don't want to send them to Sentry
   const statusCode = res?.statusCode || contextOrProps.statusCode;
   if (statusCode && statusCode < 500) {
-    return Promise.resolve();
+    return;
   }
 
   // In previous versions of the suggested `_error.js` page in which this function is meant to be used, there was a
@@ -32,18 +35,18 @@ export async function captureUnderscoreErrorException(contextOrProps: ContextOrP
   // twice, we just bail if we sense we're in that now-extraneous second call. (We can tell which function we're in
   // because Nextjs passes `pathname` to `getInitialProps` but not to `render`.)
   if (!contextOrProps.pathname) {
-    return Promise.resolve();
+    return;
   }
 
-  withScope(scope => {
+  const eventId = withScope(scope => {
     if (req) {
       const normalizedRequest = httpRequestToRequestData(req);
       scope.setSDKProcessingMetadata({ normalizedRequest });
     }
 
     // If third-party libraries (or users themselves) throw something falsy, we want to capture it as a message (which
     // is what passing a string to `captureException` will wind up doing)
-    captureException(err || `_error.js called with falsy error (${err})`, {
+    return captureException(err || `_error.js called with falsy error (${err})`, {
       mechanism: {
         type: 'auto.function.nextjs.underscore_error',
         handled: false,
@@ -55,4 +58,6 @@ export async function captureUnderscoreErrorException(contextOrProps: ContextOrP
   });
 
   waitUntil(flushSafelyWithTimeout());
+
+  return eventId;
 }

packages/nextjs/test/common/pages-router-instrumentation/captureUnderscoreErrorException.test.ts

@@ -0,0 +1,117 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { captureUnderscoreErrorException } from '../../../src/common/pages-router-instrumentation/_error';
+
+const mockCaptureException = vi.fn(() => 'test-event-id');
+const mockWithScope = vi.fn((callback: (scope: any) => any) => {
+  const mockScope = {
+    setSDKProcessingMetadata: vi.fn(),
+  };
+  return callback(mockScope);
+});
+
+vi.mock('@sentry/core', async () => {
+  const actual = await vi.importActual('@sentry/core');
+  return {
+    ...actual,
+    captureException: (...args: unknown[]) => mockCaptureException(...args),
+    withScope: (callback: (scope: any) => any) => mockWithScope(callback),
+    httpRequestToRequestData: vi.fn(() => ({ url: 'http://test.com' })),
+  };
+});
+
+vi.mock('../../../src/common/utils/responseEnd', () => ({
+  flushSafelyWithTimeout: vi.fn(() => Promise.resolve()),
+  waitUntil: vi.fn(),
+}));
+
+describe('captureUnderscoreErrorException', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return the event ID when capturing an exception', async () => {
+    const error = new Error('Test error');
+    const result = await captureUnderscoreErrorException({
+      err: error,
+      pathname: '/test',
+      res: { statusCode: 500 } as any,
+    });
+
+    expect(result).toBe('test-event-id');
+    expect(mockCaptureException).toHaveBeenCalledWith(error, {
+      mechanism: {
+        type: 'auto.function.nextjs.underscore_error',
+        handled: false,
+        data: {
+          function: '_error.getInitialProps',
+        },
+      },
+    });
+  });
+
+  it('should return undefined for 4xx status codes', async () => {
+    const result = await captureUnderscoreErrorException({
+      err: new Error('Not found'),
+      pathname: '/test',
+      res: { statusCode: 404 } as any,
+    });
+
+    expect(result).toBeUndefined();
+    expect(mockCaptureException).not.toHaveBeenCalled();
+  });
+
+  it('should return undefined when pathname is not provided (render call)', async () => {
+    const result = await captureUnderscoreErrorException({
+      err: new Error('Test error'),
+      res: { statusCode: 500 } as any,
+    });
+
+    expect(result).toBeUndefined();
+    expect(mockCaptureException).not.toHaveBeenCalled();
+  });
+
+  it('should capture falsy errors as messages', async () => {
+    const result = await captureUnderscoreErrorException({
+      err: undefined,
+      pathname: '/test',
+      res: { statusCode: 500 } as any,
+    });
+
+    expect(result).toBe('test-event-id');
+    expect(mockCaptureException).toHaveBeenCalledWith('_error.js called with falsy error (undefined)', {
+      mechanism: {
+        type: 'auto.function.nextjs.underscore_error',
+        handled: false,
+        data: {
+          function: '_error.getInitialProps',
+        },
+      },
+    });
+  });
+
+  it('should use statusCode from contextOrProps when res is not available', async () => {
+    const result = await captureUnderscoreErrorException({
+      err: new Error('Test error'),
+      pathname: '/test',
+      statusCode: 500,
+    });
+
+    expect(result).toBe('test-event-id');
+    expect(mockCaptureException).toHaveBeenCalled();
+  });
+
+  it('should return undefined when statusCode from contextOrProps is 4xx', async () => {
+    const result = await captureUnderscoreErrorException({
+      err: new Error('Bad request'),
+      pathname: '/test',
+      statusCode: 400,
+    });
+
+    expect(result).toBeUndefined();
+    expect(mockCaptureException).not.toHaveBeenCalled();
+  });
+});

packages/react/test/reactrouter-compat-utils/instrumentation.test.tsx

@@ -1114,9 +1114,8 @@ describe('tryUpdateSpanNameBeforeEnd - source upgrade logic', () => {
       const { handleNavigation } = await import('../../src/reactrouter-compat-utils/instrumentation');
       const { startBrowserTracingNavigationSpan } = await import('@sentry/browser');
       const { spanToJSON } = await import('@sentry/core');
-      const { transactionNameHasWildcard, resolveRouteNameAndSource } = await import(
-        '../../src/reactrouter-compat-utils/utils'
-      );
+      const { transactionNameHasWildcard, resolveRouteNameAndSource } =
+        await import('../../src/reactrouter-compat-utils/utils');
 
       const location: Location = {
         pathname: '/users/123',

packages/replay-internal/src/types/replay.ts

@@ -321,7 +321,8 @@ export interface ReplayIntegrationPrivacyOptions {
 }
 
 export interface ReplayConfiguration
-  extends ReplayIntegrationPrivacyOptions,
+  extends
+    ReplayIntegrationPrivacyOptions,
     OptionalReplayPluginOptions,
     Pick<RecordingOptions, 'maskAllText' | 'maskAllInputs'> {}