fix(node): Bound the Vercel keep-alive wait and skip it on Bun

- Wait at most 2 seconds for both the response to close and the root span to end, so a
  response that never emits `close` cannot hold the function open.
- Unref the timer and type the request-context global the same way `vercelWaitUntil` does.
- Bun does not publish `http.server.response.finish`, so the keep-alive suite is Node-only.

Co-authored-by: Claude <claude@anthropic.com>

Author: sergical

dev-packages/bun-integration-tests/node-suites/excludes.ts

@@ -2,14 +2,15 @@
 // fails on Bun is skipped with `test.skipIf` on `RUNTIME` in the Node suite, not listed here.
 
 // Node-only features: ANR and native thread watchdogs, child processes, the AWS Lambda Node runtime,
-// and `node:sqlite`, which `flue` needs.
+// `node:sqlite`, which `flue` needs, and the Vercel keep-alive, which needs `http.server.response.finish`.
 const NODE_ONLY = [
   'suites/anr/test.ts',
   'suites/aws-serverless/**',
   'suites/breadcrumbs/**',
   'suites/child-process/test.ts',
   'suites/thread-blocked-native/test.ts',
   'suites/tracing/flue/test.ts',
+  'suites/vercel/keep-alive/test.ts',
 ];
 
 // Bun does not publish `http.server.request.start`, so `@sentry/node` creates no `http.server`

packages/node/src/sdk/vercel.ts

@@ -1,16 +1,17 @@
 import type { Client, Span } from '@sentry/core';
 import { getActiveSpan, getRootSpan, GLOBAL_OBJ } from '@sentry/core';
 import type { HttpServerResponse } from '@sentry/core/server';
+import { _INTERNAL_safeUnref } from '@sentry/core/server';
 import { subscribeDiagnosticsChannel } from '@sentry/server-utils';
 
 // On Vercel, `http.server.request.start` fires without the request context, while this channel fires with it.
 const HTTP_ON_SERVER_RESPONSE_FINISH = 'http.server.response.finish';
 
 // Some frameworks end the request's root span shortly after the response closes.
-const ROOT_SPAN_END_TIMEOUT_MS = 2000;
+const REQUEST_END_TIMEOUT_MS = 2000;
 
-interface VercelRequestContext {
-  waitUntil?: (task: Promise<unknown>) => void;
+interface VercelRequestContextGlobal {
+  get?(): { waitUntil?: (task: Promise<unknown>) => void } | undefined;
 }
 
 /**
@@ -19,7 +20,7 @@ interface VercelRequestContext {
  * Vercel can suspend a function as soon as the response is sent, so buffered events, spans, logs and metrics
  * (and the timers that flush them) arrive late or never. When a response
  * finishes, we register one `waitUntil` that waits for the response to close and the request's root span to
- * end, and then flushes the client.
+ * end (2 seconds at most), and then flushes the client.
  */
 export function setupVercelKeepAlive(client: Client): void {
   // Ensure we flush events when vercel functions are ended
@@ -31,9 +32,10 @@ export function setupVercelKeepAlive(client: Client): void {
 
   subscribeDiagnosticsChannel(HTTP_ON_SERVER_RESPONSE_FINISH, message => {
     const { response } = message as { response?: HttpServerResponse };
-    const requestContext = (
-      GLOBAL_OBJ as unknown as Record<symbol, { get?(): VercelRequestContext | undefined } | undefined>
-    )[Symbol.for('@vercel/request-context')]?.get?.();
+    const requestContextGlobal: VercelRequestContextGlobal | undefined =
+      // @ts-expect-error Vercel sets this global, so `GLOBAL_OBJ` does not type it
+      GLOBAL_OBJ[Symbol.for('@vercel/request-context')];
+    const requestContext = requestContextGlobal?.get?.();
     if (!response || !requestContext?.waitUntil) {
       return;
     }
@@ -42,30 +44,43 @@ export function setupVercelKeepAlive(client: Client): void {
     const rootSpan = activeSpan && getRootSpan(activeSpan);
 
     requestContext.waitUntil(
-      new Promise<void>(resolve => response.once('close', resolve))
-        .then(() => rootSpan && waitForSpanEnd(client, rootSpan, ROOT_SPAN_END_TIMEOUT_MS))
-        .then(() => client.flush(2000)),
+      waitForRequestEnd(client, response, rootSpan, REQUEST_END_TIMEOUT_MS).then(() => client.flush(2000)),
     );
   });
 }
 
-function waitForSpanEnd(client: Client, span: Span, timeout: number): Promise<void> {
-  // Ended and unsampled spans are not recording.
-  if (!span.isRecording()) {
-    return Promise.resolve();
-  }
-
+function waitForRequestEnd(
+  client: Client,
+  response: HttpServerResponse,
+  rootSpan: Span | undefined,
+  timeout: number,
+): Promise<void> {
   return new Promise(resolve => {
+    let responseClosed = false;
+    // Ended and unsampled spans are not recording.
+    let rootSpanEnded = !rootSpan?.isRecording();
+
     const done = (): void => {
       clearTimeout(timer);
       unsubscribe();
       resolve();
     };
-    const timer = setTimeout(done, timeout);
-    const unsubscribe = client.on('spanEnd', endedSpan => {
-      if (endedSpan === span) {
+    const doneIfRequestEnded = (): void => {
+      if (responseClosed && rootSpanEnded) {
         done();
       }
+    };
+
+    const timer = _INTERNAL_safeUnref(setTimeout(done, timeout));
+    const unsubscribe = client.on('spanEnd', span => {
+      if (span === rootSpan) {
+        rootSpanEnded = true;
+        doneIfRequestEnded();
+      }
+    });
+    response.once('close', () => {
+      responseClosed = true;
+      doneIfRequestEnded();
     });
   });
 }

packages/node/test/sdk/vercel.test.ts

@@ -127,6 +127,19 @@ describe('setupVercelKeepAlive', () => {
     expect(client.flush).toHaveBeenCalledTimes(1);
   });
 
+  it('flushes after 2 seconds when the response does not close', async () => {
+    const client = createClient();
+    setupVercelKeepAlive(client as unknown as Client);
+
+    finishResponse();
+
+    await vi.advanceTimersByTimeAsync(1999);
+    expect(client.flush).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(1);
+    expect(client.flush).toHaveBeenCalledTimes(1);
+  });
+
   it('does nothing without a request context', () => {
     (globalThis as any)[REQUEST_CONTEXT] = undefined;
     setupVercelKeepAlive(createClient() as unknown as Client);