revert vercel-specific functionality

Author: s1gr1d

packages/nextjs/src/common/captureRequestError.ts

@@ -1,5 +1,6 @@
 import type { RequestEventData } from '@sentry/core';
-import { captureException, flushIfServerless, headersToDict, withScope } from '@sentry/core';
+import { captureException, headersToDict, vercelWaitUntil, withScope } from '@sentry/core';
+import { flushSafelyWithTimeout } from './utils/responseEnd';
 
 type RequestInfo = {
   path: string;
@@ -40,6 +41,6 @@ export function captureRequestError(error: unknown, request: RequestInfo, errorC
       },
     });
 
-    flushIfServerless().catch(() => /* no-op */ {});
+    vercelWaitUntil(flushSafelyWithTimeout());
   });
 }

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

@@ -1,5 +1,6 @@
-import { captureException, flushIfServerless, httpRequestToRequestData, withScope } from '@sentry/core';
+import { captureException, httpRequestToRequestData, vercelWaitUntil, withScope } from '@sentry/core';
 import type { NextPageContext } from 'next';
+import { flushSafelyWithTimeout } from '../utils/responseEnd';
 
 type ContextOrProps = {
   req?: NextPageContext['req'];
@@ -53,5 +54,5 @@ export async function captureUnderscoreErrorException(contextOrProps: ContextOrP
     });
   });
 
-  flushIfServerless().catch(() => /* no-op */ {});
+  vercelWaitUntil(flushSafelyWithTimeout());
 }

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

@@ -2,7 +2,6 @@ import {
   captureException,
   continueTrace,
   debug,
-  flushIfServerless,
   getActiveSpan,
   httpRequestToRequestData,
   isString,
@@ -11,6 +10,7 @@ import {
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
   setHttpStatus,
   startSpanManual,
+  vercelWaitUntil,
   withIsolationScope,
 } from '@sentry/core';
 import type { NextApiRequest } from 'next';
@@ -95,7 +95,7 @@ export function wrapApiHandlerWithSentry(apiHandler: NextApiHandler, parameteriz
                     apply(target, thisArg, argArray) {
                       setHttpStatus(span, res.statusCode);
                       span.end();
-                      flushIfServerless().catch(() => /* no-op */ {});
+                      vercelWaitUntil(flushSafelyWithTimeout());
                       return target.apply(thisArg, argArray);
                     },
                   });

packages/nextjs/src/common/withServerActionInstrumentation.ts

@@ -3,16 +3,17 @@ import {
   captureException,
   continueTrace,
   debug,
-  flushIfServerless,
   getActiveSpan,
   getClient,
   getIsolationScope,
   handleCallbackErrors,
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
   SPAN_STATUS_ERROR,
   startSpan,
+  vercelWaitUntil,
   withIsolationScope,
 } from '@sentry/core';
+import { flushSafelyWithTimeout } from '../common/utils/responseEnd';
 import { DEBUG_BUILD } from './debug-build';
 import { isNotFoundNavigationError, isRedirectNavigationError } from './nextNavigationErrorUtils';
 
@@ -151,7 +152,7 @@ async function withServerActionInstrumentationImplementation<A extends (...args:
             },
           );
         } finally {
-          flushIfServerless().catch(() => /* no-op */ {});
+          vercelWaitUntil(flushSafelyWithTimeout());
         }
       },
     );

packages/nextjs/src/common/wrapMiddlewareWithSentry.ts

@@ -1,7 +1,6 @@
 import type { TransactionSource } from '@sentry/core';
 import {
   captureException,
-  flushIfServerless,
   getActiveSpan,
   getCurrentScope,
   getRootSpan,
@@ -10,9 +9,11 @@ import {
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
   setCapturedScopesOnSpan,
   startSpan,
+  vercelWaitUntil,
   winterCGRequestToRequestData,
   withIsolationScope,
 } from '@sentry/core';
+import { flushSafelyWithTimeout } from '../common/utils/responseEnd';
 import type { EdgeRouteHandler } from '../edge/types';
 
 /**
@@ -107,7 +108,7 @@ export function wrapMiddlewareWithSentry<H extends EdgeRouteHandler>(
                 });
               },
               () => {
-                flushIfServerless().catch(() => /* no-op */ {});
+                vercelWaitUntil(flushSafelyWithTimeout());
               },
             );
           },

packages/nextjs/src/common/wrapServerComponentWithSentry.ts

@@ -1,7 +1,6 @@
 import type { RequestEventData } from '@sentry/core';
 import {
   captureException,
-  flushIfServerless,
   getActiveSpan,
   getCapturedScopesOnSpan,
   getClient,
@@ -16,12 +15,14 @@ import {
   SPAN_STATUS_OK,
   spanToJSON,
   startSpanManual,
+  vercelWaitUntil,
   winterCGHeadersToDict,
   withIsolationScope,
   withScope,
 } from '@sentry/core';
 import { isNotFoundNavigationError, isRedirectNavigationError } from '../common/nextNavigationErrorUtils';
 import type { ServerComponentContext } from '../common/types';
+import { flushSafelyWithTimeout } from '../common/utils/responseEnd';
 import { TRANSACTION_ATTR_SENTRY_TRACE_BACKFILL } from './span-attributes-with-logic-attached';
 import { commonObjectToIsolationScope, commonObjectToPropagationContext } from './utils/tracingUtils';
 import { getSanitizedRequestUrl } from './utils/urls';
@@ -136,7 +137,7 @@ export function wrapServerComponentWithSentry<F extends (...args: any[]) => any>
                 },
                 () => {
                   span.end();
-                  flushIfServerless().catch(() => /* no-op */ {});
+                  vercelWaitUntil(flushSafelyWithTimeout());
                 },
               );
             },

packages/nextjs/src/edge/index.ts

@@ -1,6 +1,5 @@
 import {
   applySdkMetadata,
-  flushIfServerless,
   getGlobalScope,
   getRootSpan,
   GLOBAL_OBJ,
@@ -10,10 +9,12 @@ import {
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
   spanToJSON,
   stripUrlQueryAndFragment,
+  vercelWaitUntil,
 } from '@sentry/core';
 import type { VercelEdgeOptions } from '@sentry/vercel-edge';
 import { getDefaultIntegrations, init as vercelEdgeInit } from '@sentry/vercel-edge';
 import { isBuild } from '../common/utils/isBuild';
+import { flushSafelyWithTimeout } from '../common/utils/responseEnd';
 import { distDirRewriteFramesIntegration } from './distDirRewriteFramesIntegration';
 
 export * from '@sentry/vercel-edge';
@@ -89,7 +90,7 @@ export function init(options: VercelEdgeOptions = {}): void {
 
   client?.on('spanEnd', span => {
     if (span === getRootSpan(span)) {
-      flushIfServerless().catch(() => /* no-op */ {});
+      vercelWaitUntil(flushSafelyWithTimeout());
     }
   });
 

packages/nextjs/src/edge/wrapApiHandlerWithSentry.ts

@@ -1,6 +1,5 @@
 import {
   captureException,
-  flushIfServerless,
   getActiveSpan,
   getCurrentScope,
   getRootSpan,
@@ -10,9 +9,11 @@ import {
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
   setCapturedScopesOnSpan,
   startSpan,
+  vercelWaitUntil,
   winterCGRequestToRequestData,
   withIsolationScope,
 } from '@sentry/core';
+import { flushSafelyWithTimeout } from '../common/utils/responseEnd';
 import type { EdgeRouteHandler } from './types';
 
 /**
@@ -87,7 +88,7 @@ export function wrapApiHandlerWithSentry<H extends EdgeRouteHandler>(
                 });
               },
               () => {
-                flushIfServerless().catch(() => /* no-op */ {});
+                vercelWaitUntil(flushSafelyWithTimeout());
               },
             );
           },

packages/nuxt/src/server/sdk.ts

@@ -1,6 +1,6 @@
 import * as path from 'node:path';
 import type { Client, EventProcessor, Integration } from '@sentry/core';
-import { applySdkMetadata, debug, flushIfServerless, getGlobalScope } from '@sentry/core';
+import { applySdkMetadata, debug, flush, getGlobalScope, vercelWaitUntil } from '@sentry/core';
 import {
   type NodeOptions,
   getDefaultIntegrations as getDefaultNodeIntegrations,
@@ -84,9 +84,22 @@ function getNuxtDefaultIntegrations(options: NodeOptions): Integration[] {
       instrumentation: {
         responseHook: () => {
           // Makes it possible to end the tracing span before closing the Vercel lambda (https://vercel.com/docs/functions/functions-api-reference#waituntil)
-          flushIfServerless().catch(() => /* no-op */ {});
+          vercelWaitUntil(flushSafelyWithTimeout());
         },
       },
     }),
   ];
 }
+
+/**
+ * Flushes pending Sentry events with a 2-second timeout and in a way that cannot create unhandled promise rejections.
+ */
+async function flushSafelyWithTimeout(): Promise<void> {
+  try {
+    DEBUG_BUILD && debug.log('Flushing events...');
+    await flush(2000);
+    DEBUG_BUILD && debug.log('Done flushing events');
+  } catch (e) {
+    DEBUG_BUILD && debug.log('Error while flushing events:\n', e);
+  }
+}