fix: bring back the previous behavior for compatability

Author: logaretm

packages/nextjs/src/config/webpack.ts

@@ -22,6 +22,7 @@ import type {
   WebpackEntryProperty,
 } from './types';
 import { getNextjsVersion } from './util';
+import type { VercelCronsConfigResult } from './withSentryConfig/getFinalConfigObjectUtils';
 
 // Next.js runs webpack 3 times, once for the client, the server, and for edge. Because we don't want to print certain
 // warnings 3 times, we keep track of them here.
@@ -46,15 +47,15 @@ export function constructWebpackConfigFunction({
   routeManifest,
   nextJsVersion,
   useRunAfterProductionCompileHook,
-  vercelCronsConfig,
+  vercelCronsConfigResult,
 }: {
   userNextConfig: NextConfigObject;
   userSentryOptions: SentryBuildOptions;
   releaseName: string | undefined;
   routeManifest: RouteManifest | undefined;
   nextJsVersion: string | undefined;
   useRunAfterProductionCompileHook: boolean | undefined;
-  vercelCronsConfig: VercelCronsConfig;
+  vercelCronsConfigResult: VercelCronsConfigResult;
 }): WebpackConfigFunction {
   // Will be called by nextjs and passed its default webpack configuration and context data about the build (whether
   // we're building server or client, whether we're in dev, what version of webpack we're using, etc). Note that
@@ -99,6 +100,13 @@ export function constructWebpackConfigFunction({
     // `newConfig.module.rules` is required, so we don't have to keep asserting its existence
     const newConfig = setUpModuleRules(rawNewConfig);
 
+    // Determine which cron config to use based on strategy
+    // - 'spans': injected as global for span-based detection (App Router + Pages Router)
+    // - 'wrapper': passed to wrapping loader for Pages Router API handler wrapping
+    const { strategy: cronsStrategy, config: cronsConfig } = vercelCronsConfigResult;
+    const vercelCronsConfigForGlobal = cronsStrategy === 'spans' ? cronsConfig : undefined;
+    const vercelCronsConfigForWrapper = cronsStrategy === 'wrapper' ? cronsConfig : undefined;
+
     // Add a loader which will inject code that sets global values
     addValueInjectionLoader({
       newConfig,
@@ -108,7 +116,7 @@ export function constructWebpackConfigFunction({
       releaseName,
       routeManifest,
       nextJsVersion,
-      vercelCronsConfig,
+      vercelCronsConfig: vercelCronsConfigForGlobal,
     });
 
     addOtelWarningIgnoreRule(newConfig);
@@ -249,7 +257,7 @@ export function constructWebpackConfigFunction({
             loader: path.resolve(__dirname, 'loaders', 'wrappingLoader.js'),
             options: {
               ...staticWrappingLoaderOptions,
-              vercelCronsConfig,
+              vercelCronsConfig: vercelCronsConfigForWrapper,
               wrappingTargetKind: 'api-route',
             },
           },

packages/nextjs/src/config/withSentryConfig/getFinalConfigObject.ts

@@ -45,7 +45,7 @@ export function getFinalConfigObject(
   }
 
   const routeManifest = maybeCreateRouteManifest(incomingUserNextConfigObject, userSentryOptions);
-  const vercelCronsConfig = maybeGetVercelCronsConfig(userSentryOptions);
+  const vercelCronsConfigResult = maybeGetVercelCronsConfig(userSentryOptions);
   setUpBuildTimeVariables(incomingUserNextConfigObject, userSentryOptions, releaseName);
 
   const nextJsVersion = getNextjsVersion();
@@ -65,7 +65,7 @@ export function getFinalConfigObject(
     routeManifest,
     nextJsVersion,
     bundlerInfo,
-    vercelCronsConfig,
+    vercelCronsConfigResult,
   );
 
   const shouldUseRunAfterProductionCompileHook = resolveUseRunAfterProductionCompileHookOption(
@@ -96,7 +96,7 @@ export function getFinalConfigObject(
       nextJsVersion,
       shouldUseRunAfterProductionCompileHook,
       bundlerInfo,
-      vercelCronsConfig,
+      vercelCronsConfigResult,
     }),
     ...getTurbopackPatch(bundlerInfo, turboPackConfig),
   };

packages/nextjs/src/config/withSentryConfig/getFinalConfigObjectBundlerUtils.ts

@@ -1,11 +1,11 @@
-import type { VercelCronsConfig } from '../../common/types';
 import { handleRunAfterProductionCompile } from '../handleRunAfterProductionCompile';
 import type { RouteManifest } from '../manifest/types';
 import { constructTurbopackConfig } from '../turbopack';
 import type { NextConfigObject, SentryBuildOptions, TurbopackOptions } from '../types';
 import { detectActiveBundler, supportsProductionCompileHook } from '../util';
 import { constructWebpackConfigFunction } from '../webpack';
 import { DEFAULT_SERVER_EXTERNAL_PACKAGES } from './constants';
+import type { VercelCronsConfigResult } from './getFinalConfigObjectUtils';
 
 /**
  * Information about the active bundler and feature support based on Next.js version.
@@ -71,12 +71,15 @@ export function maybeConstructTurbopackConfig(
   routeManifest: RouteManifest | undefined,
   nextJsVersion: string | undefined,
   bundlerInfo: BundlerInfo,
-  vercelCronsConfig: VercelCronsConfig,
+  vercelCronsConfigResult: VercelCronsConfigResult,
 ): TurbopackOptions | undefined {
   if (!bundlerInfo.isTurbopack) {
     return undefined;
   }
 
+  // Only pass crons config if the span-based approach is enabled
+  const vercelCronsConfig = vercelCronsConfigResult.strategy === 'spans' ? vercelCronsConfigResult.config : undefined;
+
   return constructTurbopackConfig({
     userNextConfig: incomingUserNextConfigObject,
     userSentryOptions,
@@ -254,7 +257,7 @@ export function getWebpackPatch({
   nextJsVersion,
   shouldUseRunAfterProductionCompileHook,
   bundlerInfo,
-  vercelCronsConfig,
+  vercelCronsConfigResult,
 }: {
   incomingUserNextConfigObject: NextConfigObject;
   userSentryOptions: SentryBuildOptions;
@@ -263,7 +266,7 @@ export function getWebpackPatch({
   nextJsVersion: string | undefined;
   shouldUseRunAfterProductionCompileHook: boolean;
   bundlerInfo: BundlerInfo;
-  vercelCronsConfig: VercelCronsConfig;
+  vercelCronsConfigResult: VercelCronsConfigResult;
 }): Partial<NextConfigObject> {
   if (!bundlerInfo.isWebpack || userSentryOptions.webpack?.disableSentryConfig) {
     return {};
@@ -277,7 +280,7 @@ export function getWebpackPatch({
       routeManifest,
       nextJsVersion,
       useRunAfterProductionCompileHook: shouldUseRunAfterProductionCompileHook,
-      vercelCronsConfig,
+      vercelCronsConfigResult,
     }),
   };
 }

packages/nextjs/src/config/withSentryConfig/getFinalConfigObjectUtils.ts

@@ -252,37 +252,92 @@ export function getNextMajor(nextJsVersion: string | undefined): number | undefi
 }
 
 /**
- * Reads and returns the Vercel crons configuration from vercel.json.
- * Returns undefined if not running on Vercel, if the option is disabled,
- * or if vercel.json doesn't exist or doesn't contain crons.
+ * Reads the Vercel crons configuration from vercel.json.
+ * Returns undefined if vercel.json doesn't exist or doesn't contain crons.
  */
-export function maybeGetVercelCronsConfig(userSentryOptions: SentryBuildOptions): VercelCronsConfig {
-  // Only read crons config if running on Vercel and the experimental option is enabled
-  if (!process.env.VERCEL || !userSentryOptions._experimental?.vercelCronsMonitoring) {
-    return undefined;
-  }
-
+function readVercelCronsConfig(): VercelCronsConfig {
   try {
     const vercelJsonPath = path.join(process.cwd(), 'vercel.json');
     const vercelJsonContents = fs.readFileSync(vercelJsonPath, 'utf8');
     // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     const cronsConfig = JSON.parse(vercelJsonContents).crons as VercelCronsConfig;
 
     if (cronsConfig && Array.isArray(cronsConfig) && cronsConfig.length > 0) {
-      debug.log(
-        "[@sentry/nextjs] Creating Sentry cron monitors for your Vercel Cron Jobs. You can disable this feature by setting the 'automaticVercelMonitors' option to false in your Next.js config.",
-      );
       return cronsConfig;
     }
-
     return undefined;
   } catch (e) {
     if ((e as { code: string }).code === 'ENOENT') {
-      // noop if file does not exist
       return undefined;
     }
-    // log but noop
     debug.error('[@sentry/nextjs] Failed to read vercel.json for automatic cron job monitoring instrumentation', e);
     return undefined;
   }
 }
+
+/** Strategy for Vercel cron monitoring instrumentation */
+export type VercelCronsStrategy = 'spans' | 'wrapper';
+
+export type VercelCronsConfigResult = {
+  /** The crons configuration from vercel.json, if available */
+  config: VercelCronsConfig;
+  /**
+   * The instrumentation strategy to use:
+   * - `spans`: New span-based approach (works for both App Router and Pages Router)
+   * - `wrapper`: Old wrapper-based approach (Pages Router only)
+   * - `undefined`: No cron monitoring enabled
+   */
+  strategy: VercelCronsStrategy | undefined;
+};
+
+/**
+ * Reads and returns the Vercel crons configuration from vercel.json along with
+ * information about which instrumentation approach to use.
+ *
+ * - `_experimental.vercelCronsMonitoring`: New span-based approach (works for both App Router and Pages Router)
+ * - `automaticVercelMonitors`: Old wrapper-based approach (Pages Router only)
+ *
+ * If both are enabled, the new approach is preferred and a warning is logged.
+ */
+export function maybeGetVercelCronsConfig(userSentryOptions: SentryBuildOptions): VercelCronsConfigResult {
+  const result: VercelCronsConfigResult = { config: undefined, strategy: undefined };
+
+  if (!process.env.VERCEL) {
+    return result;
+  }
+
+  const experimentalEnabled = userSentryOptions._experimental?.vercelCronsMonitoring === true;
+  const legacyEnabled = userSentryOptions.webpack?.automaticVercelMonitors === true;
+
+  if (!experimentalEnabled && !legacyEnabled) {
+    return result;
+  }
+
+  const config = readVercelCronsConfig();
+  if (!config) {
+    return result;
+  }
+
+  result.config = config;
+
+  if (experimentalEnabled && legacyEnabled) {
+    debug.warn(
+      "[@sentry/nextjs] Both '_experimental.vercelCronsMonitoring' and 'webpack.automaticVercelMonitors' are enabled. " +
+        "Using the new span-based approach from '_experimental.vercelCronsMonitoring'. " +
+        "You can remove 'webpack.automaticVercelMonitors' from your config.",
+    );
+    result.strategy = 'spans';
+  } else if (experimentalEnabled) {
+    debug.log(
+      '[@sentry/nextjs] Creating Sentry cron monitors for your Vercel Cron Jobs using span-based instrumentation.',
+    );
+    result.strategy = 'spans';
+  } else {
+    debug.log(
+      "[@sentry/nextjs] Creating Sentry cron monitors for your Vercel Cron Jobs. You can disable this feature by setting the 'automaticVercelMonitors' option to false in your Next.js config.",
+    );
+    result.strategy = 'wrapper';
+  }
+
+  return result;
+}

packages/nextjs/src/server/vercelCronsMonitoring.ts

@@ -36,7 +36,9 @@ export function maybeStartCronCheckIn(span: Span, route: string | undefined): vo
     return;
   }
 
-  // Get headers from the isolation scope
+  // The strategy here is to check if the request is a Vercel cron
+  // request by checking the user agent, vercel always sets the user agent to 'vercel-cron/1.0'
+
   const headers = getIsolationScope().getScopeData().sdkProcessingMetadata?.normalizedRequest?.headers as
     | Record<string, string | string[] | undefined>
     | undefined;
@@ -45,41 +47,30 @@ export function maybeStartCronCheckIn(span: Span, route: string | undefined): vo
     return;
   }
 
-  // Check if this is a Vercel cron request
   const userAgent = Array.isArray(headers['user-agent']) ? headers['user-agent'][0] : headers['user-agent'];
-
   if (!userAgent?.includes('vercel-cron')) {
     return;
   }
 
-  // Find matching cron configuration
   const matchedCron = vercelCronsConfig.find(cron => cron.path === route);
-
   if (!matchedCron?.path || !matchedCron.schedule) {
     return;
   }
 
   const monitorSlug = matchedCron.path;
   const startTime = _INTERNAL_safeDateNow() / 1000;
 
-  // Start the check-in
   const checkInId = captureCheckIn(
+    { monitorSlug, status: 'in_progress' },
     {
-      monitorSlug,
-      status: 'in_progress',
-    },
-    {
-      maxRuntime: 60 * 12, // 12 hours - high arbitrary number since we don't know the actual duration
-      schedule: {
-        type: 'crontab',
-        value: matchedCron.schedule,
-      },
+      maxRuntime: 60 * 12,
+      schedule: { type: 'crontab', value: matchedCron.schedule },
     },
   );
 
   DEBUG_BUILD && debug.log(`[Cron] Started check-in for "${monitorSlug}" with ID "${checkInId}"`);
 
-  // Store check-in data on the span for completion later
+  // Store marking attributes on the span so we can complete the check-in later
   span.setAttribute(ATTR_SENTRY_CRON_CHECK_IN_ID, checkInId);
   span.setAttribute(ATTR_SENTRY_CRON_MONITOR_SLUG, monitorSlug);
   span.setAttribute(ATTR_SENTRY_CRON_START_TIME, startTime);
@@ -91,7 +82,6 @@ export function maybeStartCronCheckIn(span: Span, route: string | undefined): vo
  */
 export function maybeCompleteCronCheckIn(span: Span): void {
   const spanData = spanToJSON(span).data;
-
   const checkInId = spanData?.[ATTR_SENTRY_CRON_CHECK_IN_ID];
   const monitorSlug = spanData?.[ATTR_SENTRY_CRON_MONITOR_SLUG];
   const startTime = spanData?.[ATTR_SENTRY_CRON_START_TIME];
@@ -102,10 +92,6 @@ export function maybeCompleteCronCheckIn(span: Span): void {
 
   const duration = _INTERNAL_safeDateNow() / 1000 - startTime;
   const spanStatus = spanToJSON(span).status;
-
-  // Determine check-in status based on span status
-  // Only mark as error if span status is explicitly 'error', otherwise treat as success
-  // Span status can be 'ok', 'error', or undefined (unset) - undefined means success
   const checkInStatus = spanStatus === 'error' ? 'error' : 'ok';
 
   captureCheckIn({
@@ -115,7 +101,7 @@ export function maybeCompleteCronCheckIn(span: Span): void {
     duration,
   });
 
-  // Clean up the cron attributes from the span
+  // Cleanup marking attributes so they don't pollute user span data
   span.setAttribute(ATTR_SENTRY_CRON_CHECK_IN_ID, undefined);
   span.setAttribute(ATTR_SENTRY_CRON_MONITOR_SLUG, undefined);
   span.setAttribute(ATTR_SENTRY_CRON_START_TIME, undefined);