add test, some refactoring and fixes

Author: s1gr1d

dev-packages/e2e-tests/test-applications/astro-5/src/pages/user-page/settings.astro

@@ -0,0 +1,7 @@
+---
+import Layout from '../../layouts/Layout.astro';
+---
+
+<Layout>
+  <h1>User Settings</h1>
+</Layout>

dev-packages/e2e-tests/test-applications/astro-5/tests/tracing.dynamic.test.ts

@@ -312,3 +312,55 @@ test.describe('nested SSR routes (client, server, server request)', () => {
     });
   });
 });
+
+// Case for `user-page/[id]` vs. `user-page/settings` static routes
+test.describe('parametrized vs static paths', () => {
+  test('should use static route name for static route in parametrized path', async ({ page }) => {
+    const clientPageloadTxnPromise = waitForTransaction('astro-5', txnEvent => {
+      return txnEvent?.transaction?.startsWith('/user-page/') ?? false;
+    });
+
+    const serverPageRequestTxnPromise = waitForTransaction('astro-5', txnEvent => {
+      return txnEvent?.transaction?.startsWith('GET /user-page/') ?? false;
+    });
+
+    await page.goto('/user-page/settings');
+
+    const clientPageloadTxn = await clientPageloadTxnPromise;
+    const serverPageRequestTxn = await serverPageRequestTxnPromise;
+
+    expect(clientPageloadTxn).toMatchObject({
+      transaction: '/user-page/settings', // todo: parametrize to '/catchAll/[...path]'
+      transaction_info: { source: 'url' },
+      contexts: {
+        trace: {
+          op: 'pageload',
+          origin: 'auto.pageload.browser',
+          data: {
+            'sentry.op': 'pageload',
+            'sentry.origin': 'auto.pageload.browser',
+            'sentry.source': 'url',
+          },
+        },
+      },
+    });
+
+    expect(serverPageRequestTxn).toMatchObject({
+      transaction: 'GET /user-page/settings',
+      transaction_info: { source: 'route' },
+      contexts: {
+        trace: {
+          op: 'http.server',
+          origin: 'auto.http.astro',
+          data: {
+            'sentry.op': 'http.server',
+            'sentry.origin': 'auto.http.astro',
+            'sentry.source': 'route',
+            url: expect.stringContaining('/user-page/settings'),
+          },
+        },
+      },
+      request: { url: expect.stringContaining('/user-page/settings') },
+    });
+  });
+});

packages/astro/src/integration/index.ts

@@ -12,6 +12,8 @@ const PKG_NAME = '@sentry/astro';
 export const sentryAstro = (options: SentryOptions = {}): AstroIntegration => {
   let sentryServerInitPath: string | undefined;
 
+  let didSaveRouteData = false;
+
   return {
     name: PKG_NAME,
     hooks: {
@@ -171,13 +173,34 @@ export const sentryAstro = (options: SentryOptions = {}): AstroIntegration => {
         }
       },
 
-      // @ts-expect-error - This hook is available in Astro 5
+      // @ts-expect-error - This hook is available in Astro 5+
       'astro:routes:resolved': ({ routes }: { routes: IntegrationResolvedRoute[] }) => {
-        if (!sentryServerInitPath) {
+        if (!sentryServerInitPath || didSaveRouteData) {
           return;
         }
 
-        includeRouteDataToConfigFile(sentryServerInitPath, routes);
+        try {
+          const serverInitContent = readFileSync(sentryServerInitPath, 'utf8');
+
+          const updatedServerInitContent = `${serverInitContent}\nglobalThis["__sentryRouteInfo"] = ${JSON.stringify(
+            routes.map(route => {
+              return {
+                ...route,
+                patternCaseSensitive: joinRouteSegments(route.segments), // Store parametrized routes with correct casing on `globalThis` to be able to use them on the server during runtime
+                patternRegex: route.patternRegex.source, // using `source` to be able to serialize the regex
+              };
+            }),
+            null,
+            2,
+          )};`;
+
+          writeFileSync(sentryServerInitPath, updatedServerInitContent, 'utf8');
+
+          didSaveRouteData = true; // Prevents writing the file multiple times during runtime
+          debug.log('Successfully added route pattern information to Sentry config file:', sentryServerInitPath);
+        } catch (error) {
+          debug.warn(`Failed to write to Sentry config file at ${sentryServerInitPath}:`, error);
+        }
       },
     },
   };
@@ -300,27 +323,3 @@ function joinRouteSegments(segments: RoutePart[][]): string {
 
   return `/${parthArray.join('/')}`;
 }
-
-function includeRouteDataToConfigFile(sentryInitPath: string, routes: IntegrationResolvedRoute[]): void {
-  try {
-    const serverInitContent = readFileSync(sentryInitPath, 'utf8');
-
-    const updatedServerInitContent = `${serverInitContent}\nglobalThis["__sentryRouteInfo"] = ${JSON.stringify(
-      routes.map(route => {
-        return {
-          ...route,
-          patternCaseSensitive: joinRouteSegments(route.segments), // Store parametrized routes with correct casing on `globalThis` to be able to use them on the server during runtime
-          patternRegex: route.patternRegex.source, // using `source` to be able to serialize the regex
-        };
-      }),
-      null,
-      2,
-    )};`;
-
-    writeFileSync(sentryInitPath, updatedServerInitContent, 'utf8');
-
-    debug.log('Successfully added route pattern information to Sentry config file:', sentryInitPath);
-  } catch (error) {
-    debug.warn(`Failed to write to Sentry config file at ${sentryInitPath}:`, error);
-  }
-}

packages/astro/src/integration/types.ts

@@ -1,5 +1,5 @@
 import type { SentryVitePluginOptions } from '@sentry/vite-plugin';
-import type { InjectedRoute, RouteData } from 'astro';
+import type { RouteData } from 'astro';
 
 type SdkInitPaths = {
   /**
@@ -227,12 +227,16 @@ export type SentryOptions = SdkInitPaths &
   } & DeprecatedRuntimeOptions;
 
 /**
- * Inline type for official `IntegrationResolvedRoute` (only available after Astro v5)
+ * Routes inside 'astro:routes:resolved' hook (Astro v5+)
+ *
+ * Inline type for official `IntegrationResolvedRoute`.
  * The type includes more properties, but we only need some of them.
  *
  * @see https://github.com/withastro/astro/blob/04e60119afee668264a2ff6665c19a32150f4c91/packages/astro/src/types/public/integrations.ts#L287
  */
-export type IntegrationResolvedRoute = InjectedRoute & {
+export type IntegrationResolvedRoute = {
+  isPrerendered: RouteData['prerender'];
+  pattern: RouteData['route'];
   patternRegex: RouteData['pattern'];
   segments: RouteData['segments'];
 };

packages/astro/src/server/middleware.ts

@@ -132,14 +132,15 @@ async function instrumentRequest(
       }
 
       try {
+        // `routePattern` is available after Astro 5
         const contextWithRoutePattern = ctx as Parameters<MiddlewareResponseHandler>[0] & { routePattern?: string };
         const rawRoutePattern = contextWithRoutePattern.routePattern;
-
         const foundRoute = storedBuildTimeRoutes?.find(route => route.pattern === rawRoutePattern);
 
-        const interpolatedRoute =
+        const parametrizedRoute =
           foundRoute?.patternCaseSensitive || interpolateRouteFromUrlAndParams(ctx.url.pathname, ctx.params);
-        const source = interpolatedRoute ? 'route' : 'url';
+
+        const source = parametrizedRoute ? 'route' : 'url';
         // storing res in a variable instead of directly returning is necessary to
         // invoke the catch block if next() throws
 
@@ -158,12 +159,12 @@ async function instrumentRequest(
           attributes['http.fragment'] = ctx.url.hash;
         }
 
-        isolationScope?.setTransactionName(`${method} ${interpolatedRoute || ctx.url.pathname}`);
+        isolationScope?.setTransactionName(`${method} ${parametrizedRoute || ctx.url.pathname}`);
 
         const res = await startSpan(
           {
             attributes,
-            name: `${method} ${interpolatedRoute || ctx.url.pathname}`,
+            name: `${method} ${parametrizedRoute || ctx.url.pathname}`,
             op: 'http.server',
           },
           async span => {