fix: esnure random path is preserved through env

Author: logaretm

packages/nextjs/src/config/turbopack/constructTurbopackConfig.ts

@@ -34,9 +34,17 @@ export function constructTurbopackConfig({
     ...(shouldEnableNativeDebugIds ? { debugIds: true } : {}),
   };
 
+  const tunnelPath =
+    userSentryOptions.tunnelRoute !== undefined &&
+    userNextConfig.output !== 'export' &&
+    typeof userSentryOptions.tunnelRoute === 'string'
+      ? `${userNextConfig.basePath ?? ''}${userSentryOptions.tunnelRoute}`
+      : undefined;
+
   const valueInjectionRules = generateValueInjectionRules({
     routeManifest,
     nextJsVersion,
+    tunnelPath,
   });
 
   for (const { matcher, rule } of valueInjectionRules) {

packages/nextjs/src/config/turbopack/generateValueInjectionRules.ts

@@ -8,9 +8,11 @@ import type { JSONValue, TurbopackMatcherWithRule } from '../types';
 export function generateValueInjectionRules({
   routeManifest,
   nextJsVersion,
+  tunnelPath,
 }: {
   routeManifest?: RouteManifest;
   nextJsVersion?: string;
+  tunnelPath?: string;
 }): TurbopackMatcherWithRule[] {
   const rules: TurbopackMatcherWithRule[] = [];
   const isomorphicValues: Record<string, JSONValue> = {};
@@ -26,6 +28,11 @@ export function generateValueInjectionRules({
     clientValues._sentryRouteManifest = JSON.stringify(routeManifest);
   }
 
+  // Inject tunnel route path for both client and server
+  if (tunnelPath) {
+    isomorphicValues._sentryRewritesTunnelPath = tunnelPath;
+  }
+
   if (Object.keys(isomorphicValues).length > 0) {
     clientValues = { ...clientValues, ...isomorphicValues };
     serverValues = { ...serverValues, ...isomorphicValues };

packages/nextjs/src/config/withSentryConfig.ts

@@ -23,6 +23,7 @@ import {
   supportsProductionCompileHook,
 } from './util';
 import { constructWebpackConfigFunction } from './webpack';
+import { isBuild } from '../common/utils/isBuild';
 
 let showedExportModeTunnelWarning = false;
 let showedExperimentalBuildModeWarning = false;
@@ -121,11 +122,10 @@ function getFinalConfigObject(
         );
       }
     } else {
-      const resolvedTunnelRoute =
-        userSentryOptions.tunnelRoute === true ? generateRandomTunnelRoute() : userSentryOptions.tunnelRoute;
-
       // Update the global options object to use the resolved value everywhere
+      const resolvedTunnelRoute = resolveTunnelRoute(userSentryOptions.tunnelRoute);
       userSentryOptions.tunnelRoute = resolvedTunnelRoute || undefined;
+
       setUpTunnelRewriteRules(incomingUserNextConfigObject, resolvedTunnelRoute);
     }
   }
@@ -550,3 +550,26 @@ function getInstrumentationClientFileContents(): string | void {
     }
   }
 }
+
+/**
+ * Resolves the tunnel route based on the user's configuration and the environment.
+ * @param tunnelRoute - The user-provided tunnel route option
+ */
+function resolveTunnelRoute(tunnelRoute: string | true): string {
+  if (process.env.__SENTRY_TUNNEL_ROUTE__) {
+    // Reuse cached value from previous build (server/client)
+    return process.env.__SENTRY_TUNNEL_ROUTE__;
+  }
+
+  const resolvedTunnelRoute = typeof tunnelRoute === 'string' ? tunnelRoute : generateRandomTunnelRoute();
+
+  // Cache for subsequent builds (only during build time)
+  // Turbopack runs the config twice, so we need a shared context to avoid generating a new tunnel route for each build.
+  // env works well here
+  // https://linear.app/getsentry/issue/JS-549/adblock-plus-blocking-requests-to-sentry-and-monitoring-tunnel
+  if (resolvedTunnelRoute) {
+    process.env.__SENTRY_TUNNEL_ROUTE__ = resolvedTunnelRoute;
+  }
+
+  return resolvedTunnelRoute;
+}

packages/nextjs/test/config/tunnelRouteCaching.test.ts

@@ -0,0 +1,91 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+describe('Tunnel Route Caching (Environment Variable)', () => {
+  let originalNextPhase: string | undefined;
+  let originalTunnelRoute: string | undefined;
+
+  beforeEach(() => {
+    // Save and clear env vars
+    originalNextPhase = process.env.NEXT_PHASE;
+    originalTunnelRoute = process.env.__SENTRY_TUNNEL_ROUTE__;
+    delete process.env.__SENTRY_TUNNEL_ROUTE__;
+  });
+
+  afterEach(() => {
+    // Restore env vars
+    if (originalNextPhase !== undefined) {
+      process.env.NEXT_PHASE = originalNextPhase;
+    } else {
+      delete process.env.NEXT_PHASE;
+    }
+
+    if (originalTunnelRoute !== undefined) {
+      process.env.__SENTRY_TUNNEL_ROUTE__ = originalTunnelRoute;
+    } else {
+      delete process.env.__SENTRY_TUNNEL_ROUTE__;
+    }
+  });
+
+  it('caches tunnel route in environment variable during build phase', () => {
+    process.env.NEXT_PHASE = 'phase-production-build';
+    process.env.__SENTRY_TUNNEL_ROUTE__ = '/cached-route-123';
+
+    // The env var should be accessible
+    expect(process.env.__SENTRY_TUNNEL_ROUTE__).toBe('/cached-route-123');
+  });
+
+  it('environment variable persists across different contexts', () => {
+    process.env.NEXT_PHASE = 'phase-production-build';
+    process.env.__SENTRY_TUNNEL_ROUTE__ = '/test-route-456';
+
+    // Simulate accessing from different module
+    const cachedRoute = process.env.__SENTRY_TUNNEL_ROUTE__;
+
+    expect(cachedRoute).toBe('/test-route-456');
+  });
+
+  it('verifies NEXT_PHASE detection for build time', () => {
+    process.env.NEXT_PHASE = 'phase-production-build';
+
+    const isBuildTime = process.env.NEXT_PHASE === 'phase-production-build';
+
+    expect(isBuildTime).toBe(true);
+  });
+
+  it('verifies NEXT_PHASE detection for non-build time', () => {
+    process.env.NEXT_PHASE = 'phase-development-server';
+
+    const isBuildTime = process.env.NEXT_PHASE === 'phase-production-build';
+
+    expect(isBuildTime).toBe(false);
+  });
+
+  it('handles missing NEXT_PHASE', () => {
+    delete process.env.NEXT_PHASE;
+
+    const isBuildTime = process.env.NEXT_PHASE === 'phase-production-build';
+
+    expect(isBuildTime).toBe(false);
+  });
+});
+
+describe('Random Tunnel Route Generation', () => {
+  it('generates an 8-character alphanumeric string', () => {
+    const randomString = Math.random().toString(36).substring(2, 10);
+    const tunnelRoute = `/${randomString}`;
+
+    // Should be a path with 8 alphanumeric chars
+    expect(tunnelRoute).toMatch(/^\/[a-z0-9]{8}$/);
+  });
+
+  it('generates different values on multiple calls', () => {
+    const route1 = `/${Math.random().toString(36).substring(2, 10)}`;
+    const route2 = `/${Math.random().toString(36).substring(2, 10)}`;
+
+    // Very unlikely to be the same (but not impossible)
+    // This is more of a sanity check
+    expect(route1).toMatch(/^\/[a-z0-9]{8}$/);
+    expect(route2).toMatch(/^\/[a-z0-9]{8}$/);
+  });
+});
+