fix(sveltekit,astro,remix): Keep answering tunnel requests in the SDK's own request hook

Where no runtime hook answers tunnel requests, like on Vercel Edge, the request hook these SDKs already run is the only place left to answer them. It's one call, and where a runtime hook exists it answers first.

Author: logaretm

packages/astro/src/server/middleware.ts

@@ -26,7 +26,10 @@ import {
   filterCollectedUrl,
   filterCollectedUrlQuery,
 } from '@sentry/core';
-import { flushIfServerless } from '@sentry/core/server';
+import {
+  flushIfServerless,
+  _INTERNAL_handleServedTunnelRequest as handleServedTunnelRequest,
+} from '@sentry/core/server';
 import {
   captureException,
   continueTrace,
@@ -87,6 +90,11 @@ export const handleRequest: (options?: MiddlewareOptions) => MiddlewareHandler =
       return next();
     }
 
+    const tunnelResponse = handleServedTunnelRequest(ctx.request);
+    if (tunnelResponse) {
+      return tunnelResponse;
+    }
+
     const isDynamicPageRequest = checkIsDynamicPageRequest(ctx);
 
     // For static (prerendered) routes, we only want to inject the parametrized route meta tags

packages/astro/test/server/middleware.test.ts

@@ -2,6 +2,7 @@ import { HTTP_REQUEST_METHOD, SENTRY_SEGMENT_NAME_SOURCE, URL_FULL, URL_PATH } f
 import type { Client, Span } from '@sentry/core';
 
 import * as SentryCore from '@sentry/core';
+import * as SentryCoreServer from '@sentry/core/server';
 import * as SentryNode from '@sentry/node';
 import type { APIContext } from 'astro';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
@@ -33,6 +34,27 @@ const STATIC_REQUEST_CONTEXT = {
   url: new URL('https://myDomain.io/users/'),
 };
 
+describe('sentryMiddleware with the managed tunnel', () => {
+  it('answers tunnel requests without calling the rest of the middleware chain', async () => {
+    const getClientSpy = vi.spyOn(SentryNode, 'getClient').mockReturnValue({} as Client);
+    const tunnelResponse = new Response('forwarded');
+    const matcherSpy = vi
+      .spyOn(SentryCoreServer, '_INTERNAL_handleServedTunnelRequest')
+      .mockReturnValue(Promise.resolve(tunnelResponse));
+    const next = vi.fn();
+    const request = new Request('https://myDomain.io/abc123', { method: 'POST' });
+
+    const response = await handleRequest()({ ...DYNAMIC_REQUEST_CONTEXT, request } as unknown as APIContext, next);
+
+    expect(response).toBe(tunnelResponse);
+    expect(matcherSpy).toHaveBeenCalledWith(request);
+    expect(next).not.toHaveBeenCalled();
+
+    getClientSpy.mockRestore();
+    matcherSpy.mockRestore();
+  });
+});
+
 describe('sentryMiddleware', () => {
   const startSpanSpy = vi.spyOn(SentryNode, 'startSpan');
 

packages/remix/src/v3/server/middleware.ts

@@ -10,6 +10,7 @@ import {
   updateSpanName,
   winterCGRequestToRequestData,
 } from '@sentry/core';
+import { _INTERNAL_handleServedTunnelRequest as handleServedTunnelRequest } from '@sentry/core/server';
 
 import { formatRouteTiming } from '../routeTiming';
 import type { MatcherLike, MiddlewareLike, NextFunctionLike, RequestContextLike } from '../types';
@@ -25,6 +26,11 @@ import { resolveRoutePattern } from './route';
  */
 export function sentryRemixMiddleware(matcher: MatcherLike): MiddlewareLike {
   return async function sentryMiddleware(context: RequestContextLike, next: NextFunctionLike): Promise<Response> {
+    const tunnelResponse = handleServedTunnelRequest(context.request);
+    if (tunnelResponse) {
+      return tunnelResponse;
+    }
+
     const isolationScope = getIsolationScope();
     isolationScope.setSDKProcessingMetadata({ normalizedRequest: winterCGRequestToRequestData(context.request) });
 

packages/remix/test/v3/middleware.test.ts

@@ -40,6 +40,19 @@ describe('sentryRemixMiddleware', () => {
     handleServedTunnelRequest.mockReturnValue(undefined);
   });
 
+  it('answers tunnel requests before route matching and the rest of the chain', async () => {
+    const tunnelResponse = new Response('forwarded');
+    handleServedTunnelRequest.mockReturnValue(Promise.resolve(tunnelResponse));
+    const next = vi.fn();
+    const context = contextFor('http://x/abc123');
+
+    const response = await sentryRemixMiddleware(matcherFor('/'))(context, next);
+
+    expect(response).toBe(tunnelResponse);
+    expect(handleServedTunnelRequest).toHaveBeenCalledWith(context.request);
+    expect(next).not.toHaveBeenCalled();
+  });
+
   it('propagates the trace to HTML responses through Server-Timing, ahead of the route', async () => {
     getTraceData.mockReturnValue({ 'sentry-trace': 'abc-def-1', baggage: 'sentry-trace_id=abc' });
     const middleware = sentryRemixMiddleware(matcherFor('/users/:id'));

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

@@ -19,7 +19,11 @@ import {
   withIsolationScope,
   filterCollectedUrl,
 } from '@sentry/core';
-import { flushIfServerless, _INTERNAL_setTunnelDefaults as setTunnelDefaults } from '@sentry/core/server';
+import {
+  flushIfServerless,
+  _INTERNAL_handleServedTunnelRequest as handleServedTunnelRequest,
+  _INTERNAL_setTunnelDefaults as setTunnelDefaults,
+} from '@sentry/core/server';
 import { getTunnelBasePath } from '../common/tunnel';
 import type { Handle, ResolveOptions } from './handleTypes';
 import { DEBUG_BUILD } from '../common/debug-build';
@@ -297,6 +301,11 @@ export function sentryHandle(handlerOptions?: SentryHandleOptions): Handle {
   };
 
   const sentryRequestHandler: Handle = input => {
+    const tunnelResponse = handleServedTunnelRequest(input.event.request);
+    if (tunnelResponse) {
+      return tunnelResponse;
+    }
+
     const backwardsForwardsCompatibleEvent = input.event as typeof input.event & BackwardsForwardsCompatibleEvent;
 
     // Escape hatch to suppress request isolation and trace continuation (see initCloudflareSentryHandle)

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

@@ -4,6 +4,7 @@ import { getCapturedScopesOnSpan, getRootSpan, getSpanDescendants, spanIsSampled
 import * as SentryCore from '@sentry/core';
 import { NodeClient, serveTunnelIntegration, setCurrentClient } from '@sentry/node';
 import { _INTERNAL_resetTunnelDefaults } from '@sentry/core/server';
+import { TUNNEL_BASE_PATH_GLOBAL } from '../../src/common/tunnel';
 import type { Handle } from '../../src/server-common/handleTypes';
 import { redirect } from '@sveltejs/kit';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
@@ -145,6 +146,16 @@ describe('sentryHandle with span streaming', () => {
 describe('sentryHandle with the managed tunnel', () => {
   const DSN = 'https://public@o1.ingest.sentry.io/1337';
 
+  function makeTunnelRequest(path: string): Request {
+    const body = SentryCore.serializeEnvelope(SentryCore.createEnvelope({ dsn: DSN }, [])) as string;
+
+    return new Request(`http://localhost:3000${path}`, {
+      method: 'POST',
+      body,
+      headers: { 'content-length': String(body.length) },
+    });
+  }
+
   beforeEach(() => {
     vi.stubGlobal(
       'fetch',
@@ -160,6 +171,36 @@ describe('sentryHandle with the managed tunnel', () => {
     _INTERNAL_resetTunnelDefaults();
   });
 
+  it('answers tunnel requests without resolving the route', async () => {
+    const mockResolve = vi.fn();
+
+    const response = await sentryHandle()({
+      event: mockEvent({ request: makeTunnelRequest(SentryCore.getTunnelPath(DSN)!), route: { id: null } }),
+      resolve: mockResolve,
+    });
+
+    expect(await response.text()).toBe('forwarded');
+    expect(mockResolve).not.toHaveBeenCalled();
+  });
+
+  it('serves the tunnel under the base path `sentrySvelteKit()` set before the handle was created', async () => {
+    vi.stubGlobal(TUNNEL_BASE_PATH_GLOBAL, '/app');
+    const mockResolve = vi.fn(() => Promise.resolve(new Response('app')));
+    const handle = sentryHandle();
+
+    const underBasePath = await handle({
+      event: mockEvent({ request: makeTunnelRequest(`/app${SentryCore.getTunnelPath(DSN)!}`), route: { id: null } }),
+      resolve: mockResolve,
+    });
+    const atRoot = await handle({
+      event: mockEvent({ request: makeTunnelRequest(SentryCore.getTunnelPath(DSN)!), route: { id: null } }),
+      resolve: mockResolve,
+    });
+
+    expect(await underBasePath.text()).toBe('forwarded');
+    expect(await atRoot.text()).toBe('app');
+  });
+
   it('resolves every other request', async () => {
     const mockResolve = vi.fn(() => Promise.resolve(new Response('app')));