fix: Mark ISR pages for client side to ignore meta trace contents

Author: logaretm

packages/nextjs/src/client/routing/appRouterRoutingInstrumentation.ts

@@ -7,6 +7,7 @@ import {
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
 } from '@sentry/core';
 import { startBrowserTracingNavigationSpan, startBrowserTracingPageLoadSpan, WINDOW } from '@sentry/react';
+import type { RouteManifest } from '../../config/manifest/types';
 import { maybeParameterizeRoute } from './parameterization';
 
 export const INCOMPLETE_APP_ROUTER_INSTRUMENTATION_TRANSACTION_NAME = 'incomplete-app-router-transaction';
@@ -33,20 +34,66 @@ let navigationRoutingMode: 'router-patch' | 'transition-start-hook' = 'router-pa
 
 const currentRouterPatchingNavigationSpanRef: NavigationSpanRef = { current: undefined };
 
+/**
+ * Check if the current route is an ISR/SSG page by looking it up in the route manifest
+ */
+function isIsrSsgRoute(pathname: string): boolean {
+  const globalWithManifest = GLOBAL_OBJ as typeof GLOBAL_OBJ & {
+    _sentryRouteManifest?: string | RouteManifest;
+  };
+
+  const manifestData = globalWithManifest._sentryRouteManifest;
+  if (!manifestData) {
+    return false;
+  }
+
+  let manifest: RouteManifest;
+  if (typeof manifestData === 'string') {
+    try {
+      manifest = JSON.parse(manifestData);
+    } catch {
+      return false;
+    }
+  } else {
+    manifest = manifestData;
+  }
+
+  if (!manifest.isrRoutes || manifest.isrRoutes.length === 0) {
+    return false;
+  }
+
+  // Check if the pathname matches any ISR route
+  // For dynamic routes, we need to match the parameterized pattern
+  const parameterizedPath = maybeParameterizeRoute(pathname);
+  const pathToCheck = parameterizedPath || pathname;
+
+  return manifest.isrRoutes.includes(pathToCheck);
+}
+
 /** Instruments the Next.js app router for pageloads. */
 export function appRouterInstrumentPageLoad(client: Client): void {
   const parameterizedPathname = maybeParameterizeRoute(WINDOW.location.pathname);
   const origin = browserPerformanceTimeOrigin();
-  startBrowserTracingPageLoadSpan(client, {
-    name: parameterizedPathname ?? WINDOW.location.pathname,
-    // pageload should always start at timeOrigin (and needs to be in s, not ms)
-    startTime: origin ? origin / 1000 : undefined,
-    attributes: {
-      [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'pageload',
-      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.pageload.nextjs.app_router_instrumentation',
-      [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: parameterizedPathname ? 'route' : 'url',
+
+  // Check if this is an ISR/SSG page
+  // if so, don't use cached trace meta tags to prevent using cached trace data
+  const isIsrSsgPage = isIsrSsgRoute(WINDOW.location.pathname);
+
+  startBrowserTracingPageLoadSpan(
+    client,
+    {
+      name: parameterizedPathname ?? WINDOW.location.pathname,
+      // pageload should always start at timeOrigin (and needs to be in s, not ms)
+      startTime: origin ? origin / 1000 : undefined,
+      attributes: {
+        [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'pageload',
+        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.pageload.nextjs.app_router_instrumentation',
+        [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: parameterizedPathname ? 'route' : 'url',
+      },
     },
-  });
+    // For ISR/SSG pages, pass empty trace data to prevent using cached meta tags
+    isIsrSsgPage ? { sentryTrace: undefined, baggage: undefined } : undefined,
+  );
 }
 
 interface NavigationSpanRef {

packages/nextjs/src/client/routing/parameterization.ts

@@ -96,6 +96,7 @@ function getManifest(): RouteManifest | null {
   let manifest: RouteManifest = {
     staticRoutes: [],
     dynamicRoutes: [],
+    isrRoutes: [],
   };
 
   // Shallow check if the manifest is actually what we expect it to be

packages/nextjs/src/config/manifest/createRouteManifest.ts

@@ -115,23 +115,46 @@ function hasOptionalPrefix(paramNames: string[]): boolean {
   return firstParam === 'locale' || firstParam === 'lang' || firstParam === 'language';
 }
 
+/**
+ * Check if a page file exports generateStaticParams (ISR/SSG indicator)
+ */
+function checkForGenerateStaticParams(pageFilePath: string): boolean {
+  try {
+    const content = fs.readFileSync(pageFilePath, 'utf8');
+    // check for generateStaticParams export
+    // the regex covers `export function generateStaticParams`, `export async function generateStaticParams`, `export const generateStaticParams`
+    return /export\s+(async\s+)?function\s+generateStaticParams|export\s+const\s+generateStaticParams/.test(content);
+  } catch {
+    return false;
+  }
+}
+
 function scanAppDirectory(
   dir: string,
   basePath: string = '',
   includeRouteGroups: boolean = false,
-): { dynamicRoutes: RouteInfo[]; staticRoutes: RouteInfo[] } {
+): { dynamicRoutes: RouteInfo[]; staticRoutes: RouteInfo[]; isrRoutes: string[] } {
   const dynamicRoutes: RouteInfo[] = [];
   const staticRoutes: RouteInfo[] = [];
+  const isrRoutes: string[] = [];
 
   try {
     const entries = fs.readdirSync(dir, { withFileTypes: true });
-    const pageFile = entries.some(entry => isPageFile(entry.name));
+    const pageFile = entries.find(entry => isPageFile(entry.name));
 
     if (pageFile) {
       // Conditionally normalize the path based on includeRouteGroups option
       const routePath = includeRouteGroups ? basePath || '/' : normalizeRoutePath(basePath || '/');
       const isDynamic = routePath.includes(':');
 
+      // Check if this page has generateStaticParams (ISR/SSG indicator)
+      const pageFilePath = path.join(dir, pageFile.name);
+      const hasGenerateStaticParams = checkForGenerateStaticParams(pageFilePath);
+
+      if (hasGenerateStaticParams) {
+        isrRoutes.push(routePath);
+      }
+
       if (isDynamic) {
         const { regex, paramNames, hasOptionalPrefix } = buildRegexForDynamicRoute(routePath);
         dynamicRoutes.push({
@@ -172,14 +195,15 @@ function scanAppDirectory(
 
         dynamicRoutes.push(...subRoutes.dynamicRoutes);
         staticRoutes.push(...subRoutes.staticRoutes);
+        isrRoutes.push(...subRoutes.isrRoutes);
       }
     }
   } catch (error) {
     // eslint-disable-next-line no-console
     console.warn('Error building route manifest:', error);
   }
 
-  return { dynamicRoutes, staticRoutes };
+  return { dynamicRoutes, staticRoutes, isrRoutes };
 }
 
 /**
@@ -204,6 +228,7 @@ export function createRouteManifest(options?: CreateRouteManifestOptions): Route
 
   if (!targetDir) {
     return {
+      isrRoutes: [],
       dynamicRoutes: [],
       staticRoutes: [],
     };
@@ -214,11 +239,16 @@ export function createRouteManifest(options?: CreateRouteManifestOptions): Route
     return manifestCache;
   }
 
-  const { dynamicRoutes, staticRoutes } = scanAppDirectory(targetDir, options?.basePath, options?.includeRouteGroups);
+  const { dynamicRoutes, staticRoutes, isrRoutes } = scanAppDirectory(
+    targetDir,
+    options?.basePath,
+    options?.includeRouteGroups,
+  );
 
   const manifest: RouteManifest = {
     dynamicRoutes,
     staticRoutes,
+    isrRoutes,
   };
 
   // set cache

packages/nextjs/src/config/manifest/types.ts

@@ -34,4 +34,9 @@ export type RouteManifest = {
    * List of all static routes
    */
   staticRoutes: RouteInfo[];
+
+  /**
+   * List of ISR/SSG routes (routes with generateStaticParams)
+   */
+  isrRoutes: string[];
 };