fix(sveltekit): Ensure server errors from streamed responses are sent (#17044)

Make sure we use of Cloudflare's `waitUntil` function which
fortunately is available within the error handler hook. This fixes
error reporting for streamed server responses on Clourdlfare,
 where the returned promise rejects after the initial response was sent.

Author: Lms24

packages/sveltekit/src/server-common/handleError.ts

@@ -1,4 +1,4 @@
-import { captureException, consoleSandbox } from '@sentry/core';
+import { captureException, consoleSandbox, flush } from '@sentry/core';
 import type { HandleServerError } from '@sveltejs/kit';
 import { flushIfServerless } from '../server-common/utils';
 
@@ -42,7 +42,23 @@ export function handleErrorWithSentry(handleError: HandleServerError = defaultEr
       },
     });
 
-    await flushIfServerless();
+    const platform = input.event.platform as {
+      context?: {
+        waitUntil?: (p: Promise<void>) => void;
+      };
+    };
+
+    // Cloudflare workers have a `waitUntil` method that we can use to flush the event queue
+    // We already call this in `wrapRequestHandler` from `sentryHandleInitCloudflare`
+    // However, `handleError` can be invoked when wrapRequestHandler already finished
+    // (e.g. when responses are streamed / returning promises from load functions)
+    const cloudflareWaitUntil = platform?.context?.waitUntil;
+    if (typeof cloudflareWaitUntil === 'function') {
+      const waitUntil = cloudflareWaitUntil.bind(platform.context);
+      waitUntil(flush(2000));
+    } else {
+      await flushIfServerless();
+    }
 
     // We're extra cautious with SafeHandleServerErrorInput - this type is not compatible with HandleServerErrorInput
     // @ts-expect-error - we're still passing the same object, just with a different (backwards-compatible) type

packages/sveltekit/test/server-common/handleError.test.ts

@@ -91,5 +91,29 @@ describe('handleError', () => {
       // Check that the default handler wasn't invoked
       expect(consoleErrorSpy).toHaveBeenCalledTimes(0);
     });
+
+    it('calls waitUntil if available', async () => {
+      const wrappedHandleError = handleErrorWithSentry();
+      const mockError = new Error('test');
+      const waitUntilSpy = vi.fn();
+
+      await wrappedHandleError({
+        error: mockError,
+        event: {
+          ...requestEvent,
+          platform: {
+            context: {
+              waitUntil: waitUntilSpy,
+            },
+          },
+        },
+        status: 500,
+        message: 'Internal Error',
+      });
+
+      expect(waitUntilSpy).toHaveBeenCalledTimes(1);
+      // flush() returns a promise, this is what we expect here
+      expect(waitUntilSpy).toHaveBeenCalledWith(expect.any(Promise));
+    });
   });
 });