fix(astro): Run the server init before the middleware so the tunnel works on a cold server

Author: logaretm

dev-packages/e2e-tests/test-applications/astro-7/package.json

@@ -19,6 +19,7 @@
   "dependencies": {
     "@astrojs/node": "^11.1.4",
     "@playwright/test": "~1.63.0",
+    "@sentry/conventions": "0.27.0",
     "@sentry-internal/test-utils": "link:../../../test-utils",
     "@sentry/astro": "file:../../packed/sentry-astro-packed.tgz",
     "astro": "^7.2.8",

dev-packages/e2e-tests/test-applications/astro-7/tests/tunnel.test.ts

@@ -1,19 +1,29 @@
+import { URL_PATH } from '@sentry/conventions/attributes';
+import { HTTP_SERVER } from '@sentry/conventions/op';
 import { expect, test } from '@playwright/test';
 import { getSpanOp, waitForStreamedSpan } from '@sentry-internal/test-utils';
 
 test.skip(!process.env.PUBLIC_E2E_TEST_TUNNEL, 'Only runs in the tunnel variant');
 
+const DSN = 'http://public@localhost:3031/1337';
 const TUNNEL_PATH = /^\/docs\/[a-z0-9]{1,7}\/$/;
 
 test('answers the managed tunnel under the base path before the app middleware', async ({ page }) => {
+  // The first request this server sees, so no SSR page has run `Sentry.init` yet.
+  const coldTunnelResponse = await page.request.post('/docs/qpo967/', {
+    headers: { 'content-type': 'application/x-sentry-envelope' },
+    data: `${JSON.stringify({ dsn: DSN })}\n`,
+  });
+  expect(coldTunnelResponse.status()).toBe(200);
+
   // The variant's auth middleware rejects every other POST.
   expect((await page.request.post('/docs/anything/', { data: 'x' })).status()).toBe(401);
 
   const tunnelServerSpanPromise = waitForStreamedSpan(
     'astro-7',
     span =>
-      getSpanOp(span) === 'http.server' &&
-      /\/docs\/[a-z0-9]{1,7}\/?$/.test(String(span.attributes['url.path']?.value ?? '')),
+      getSpanOp(span) === HTTP_SERVER &&
+      /\/docs\/[a-z0-9]{1,7}\/?$/.test(String(span.attributes[URL_PATH]?.value ?? '')),
   );
   const tunnelResponsePromise = page.waitForResponse(
     response => response.request().method() === 'POST' && TUNNEL_PATH.test(new URL(response.url()).pathname),
@@ -30,8 +40,7 @@ test('answers the managed tunnel under the base path before the app middleware',
   const anchorSpanPromise = waitForStreamedSpan(
     'astro-7',
     span =>
-      getSpanOp(span) === 'http.server' &&
-      String(span.attributes['url.path']?.value ?? '').startsWith('/docs/test-ssr'),
+      getSpanOp(span) === HTTP_SERVER && String(span.attributes[URL_PATH]?.value ?? '').startsWith('/docs/test-ssr'),
   );
   await page.request.get('/docs/test-ssr/');
 

packages/astro/src/integration/index.ts

@@ -7,6 +7,7 @@ import { createRequire } from 'module';
 import * as path from 'path';
 import type { VitePlugin } from './cloudflare';
 import { sentryCloudflareNodeWarningPlugin, sentryCloudflareVitePlugin } from './cloudflare';
+import { makeSentryMiddlewareVitePlugin, SENTRY_MIDDLEWARE_MODULE } from './middleware/virtual';
 import { buildClientSnippet, buildSdkInitFileImportSnippet, buildServerSnippet } from './snippets';
 import { getAstroTunnelOptions, makeTunnelOptionsVitePlugin, TUNNEL_OPTIONS_IMPORT } from './tunnel';
 import type { SentryOptions } from './types';
@@ -181,18 +182,23 @@ export const sentryAstro = (options: SentryOptions = {}): AstroIntegration => {
           }
         }
 
+        let serverInitSnippet = '';
         if (sdkEnabled.server) {
           const pathToServerInit = serverInitPath ? path.resolve(serverInitPath) : findDefaultSdkInitFile('server');
 
           if (pathToServerInit) {
             debug && logger.info(`Using ${pathToServerInit} for server init.`);
-            // Always inject the server config via `injectScript('page-ssr')`.
-            // This ensures Sentry.init() runs in dev mode (where the Vite plugin doesn't fire)
-            // and also serves as the fallback for non-Cloudflare adapters in production.
-            injectScript('page-ssr', tunnelOptionsImport + buildSdkInitFileImportSnippet(pathToServerInit));
+            serverInitSnippet = tunnelOptionsImport + buildSdkInitFileImportSnippet(pathToServerInit);
           } else if (!usesCloudflareVitePlugin) {
             debug && logger.info('Using default server init.');
-            injectScript('page-ssr', tunnelOptionsImport + buildServerSnippet(options || {}));
+            serverInitSnippet = tunnelOptionsImport + buildServerSnippet(options || {});
+          }
+
+          // Always inject the server config via `injectScript('page-ssr')`.
+          // This ensures Sentry.init() runs in dev mode (where the Vite plugin doesn't fire)
+          // and also serves as the fallback for non-Cloudflare adapters in production.
+          if (serverInitSnippet) {
+            injectScript('page-ssr', serverInitSnippet);
           }
 
           if (isCloudflareWorkers && command !== 'dev') {
@@ -239,9 +245,10 @@ export const sentryAstro = (options: SentryOptions = {}): AstroIntegration => {
         const shouldAddMiddleware = sdkEnabled.server && autoInstrumentation?.requestHandler !== false;
 
         if (isSSR && shouldAddMiddleware) {
+          updateConfig({ vite: { plugins: [makeSentryMiddlewareVitePlugin(serverInitSnippet)] } });
           addMiddleware({
             order: 'pre',
-            entrypoint: '@sentry/astro/middleware',
+            entrypoint: SENTRY_MIDDLEWARE_MODULE,
           });
         }
       },

packages/astro/src/integration/middleware/virtual.ts

@@ -0,0 +1,22 @@
+import type { VitePlugin } from '../cloudflare';
+
+/**
+ * The middleware entrypoint the integration registers instead of `@sentry/astro/middleware`.
+ */
+export const SENTRY_MIDDLEWARE_MODULE = 'virtual:@sentry/astro/middleware';
+const RESOLVED_SENTRY_MIDDLEWARE_MODULE = `\0${SENTRY_MIDDLEWARE_MODULE}`;
+
+/**
+ * Serves the Sentry middleware behind the server init. `page-ssr` scripts only run once an SSR page loads, so without
+ * this a request that renders no page, like a tunnel request on a cold serverless instance, would find no client.
+ */
+export function makeSentryMiddlewareVitePlugin(serverInitSnippet: string): VitePlugin {
+  return {
+    name: 'sentry-astro-middleware',
+    resolveId: id => (id === SENTRY_MIDDLEWARE_MODULE ? RESOLVED_SENTRY_MIDDLEWARE_MODULE : null),
+    load: id =>
+      id === RESOLVED_SENTRY_MIDDLEWARE_MODULE
+        ? `${serverInitSnippet}\nexport { onRequest } from "@sentry/astro/middleware";\n`
+        : null,
+  };
+}

packages/astro/test/integration/index.test.ts

@@ -680,10 +680,33 @@ describe('sentryAstro integration', () => {
     expect(addMiddleware).toHaveBeenCalledTimes(1);
     expect(addMiddleware).toHaveBeenCalledWith({
       order: 'pre',
-      entrypoint: '@sentry/astro/middleware',
+      entrypoint: 'virtual:@sentry/astro/middleware',
     });
   });
 
+  it('runs the server init before the middleware, so requests that render no page find a client', async () => {
+    const integration = sentryAstro({});
+    const updateConfig = vi.fn();
+    const injectScript = vi.fn();
+
+    // @ts-expect-error - the hook exists and we only need to pass what we actually use
+    await integration.hooks['astro:config:setup']({
+      // @ts-expect-error - we only need to pass what we actually use
+      config: { output: 'server' },
+      addMiddleware: vi.fn(),
+      updateConfig,
+      injectScript,
+    });
+
+    const plugin = updateConfig.mock.calls
+      .flatMap(([config]) => config.vite?.plugins ?? [])
+      .find(plugin => plugin.name === 'sentry-astro-middleware');
+    const resolvedId = plugin.resolveId('virtual:@sentry/astro/middleware');
+    const serverInit = injectScript.mock.calls.find(([stage]) => stage === 'page-ssr')?.[1];
+
+    expect(plugin.load(resolvedId)).toBe(`${serverInit}\nexport { onRequest } from "@sentry/astro/middleware";\n`);
+  });
+
   it.each([{ output: 'static' }, { output: undefined }])(
     "doesn't add middleware if in static mode (config %s)",
     async (config: any) => {