@sentry/nuxt 10.70.0 → 11.0.0-alpha.1

package/build/module/common/types.d.ts

@@ -1,7 +1,7 @@
 import type { BuildTimeOptionsBase } from '@sentry/core';
 import type { init as initNode } from '@sentry/node';
-import type { SentryRollupPluginOptions } from '@sentry/rollup-plugin';
-import type { SentryVitePluginOptions } from '@sentry/vite-plugin';
+import type { SentryRollupPluginOptions } from '@sentry/bundler-plugins/rollup';
+import type { SentryVitePluginOptions } from '@sentry/bundler-plugins/vite';
 import type { init as initVue } from '@sentry/vue';
 export type SentryNuxtClientOptions = Omit<Parameters<typeof initVue>[0] & object, 'app'>;
 export type SentryNuxtServerOptions = Parameters<typeof initNode>[0] & {
@@ -18,144 +18,6 @@ export type SentryNuxtServerOptions = Parameters<typeof initNode>[0] & {
      */
     enableNitroErrorHandler?: boolean;
 };
-type SourceMapsOptions = {
-    /**
-     * Suppresses all logs.
-     *
-     * @default false
-     * @deprecated Use option `silent` instead of `sourceMapsUploadOptions.silent`
-     */
-    silent?: boolean;
-    /**
-     * When an error occurs during release creation or sourcemaps upload, the plugin will call this function.
-     *
-     * By default, the plugin will simply throw an error, thereby stopping the bundling process.
-     * If an `errorHandler` callback is provided, compilation will continue, unless an error is
-     * thrown in the provided callback.
-     *
-     * To allow compilation to continue but still emit a warning, set this option to the following:
-     *
-     * ```js
-     * (err) => {
-     *   console.warn(err);
-     * }
-     * ```
-     *
-     * @deprecated Use option `errorHandler` instead of `sourceMapsUploadOptions.errorHandler`
-     */
-    errorHandler?: (err: Error) => void;
-    /**
-     * Options related to managing the Sentry releases for a build.
-     *
-     * More info: https://docs.sentry.io/product/releases/
-     *
-     * @deprecated Use option `release` instead of `sourceMapsUploadOptions.release`
-     */
-    release?: {
-        /**
-         * Unique identifier for the release you want to create.
-         *
-         * This value can also be specified via the `SENTRY_RELEASE` environment variable.
-         *
-         * Defaults to automatically detecting a value for your environment.
-         * This includes values for Cordova, Heroku, AWS CodeBuild, CircleCI, Xcode, and Gradle, and otherwise uses the git `HEAD`'s commit SHA.
-         * (the latter requires access to git CLI and for the root directory to be a valid repository)
-         *
-         * If you didn't provide a value and the plugin can't automatically detect one, no release will be created.
-         *
-         * @deprecated Use `release.name` instead of `sourceMapsUploadOptions.release.name`
-         */
-        name?: string;
-    };
-    /**
-     * If this flag is `true`, and an auth token is detected, the Sentry SDK will
-     * automatically generate and upload source maps to Sentry during a production build.
-     *
-     * @default true
-     * @deprecated Use option `sourcemaps.disable` instead of `sourceMapsUploadOptions.enabled`
-     */
-    enabled?: boolean;
-    /**
-     * The auth token to use when uploading source maps to Sentry.
-     *
-     * Instead of specifying this option, you can also set the `SENTRY_AUTH_TOKEN` environment variable.
-     *
-     * To create an auth token, follow this guide:
-     * @see https://docs.sentry.io/product/accounts/auth-tokens/#organization-auth-tokens
-     * @deprecated Use option `authToken` instead of `sourceMapsUploadOptions.authToken`
-     */
-    authToken?: string;
-    /**
-     * The organization slug of your Sentry organization.
-     * Instead of specifying this option, you can also set the `SENTRY_ORG` environment variable.
-     * @deprecated Use option `org` instead of `sourceMapsUploadOptions.org`
-     */
-    org?: string;
-    /**
-     * The URL of your Sentry instance if you're using self-hosted Sentry.
-     *
-     * @default https://sentry.io by default the plugin will point towards the Sentry SaaS URL
-     * @deprecated Use `sentryUrl` instead of `sourceMapsUploadOptions.url`
-     */
-    url?: string;
-    /**
-     * The project slug of your Sentry project.
-     * Instead of specifying this option, you can also set the `SENTRY_PROJECT` environment variable.
-     *
-     * @deprecated Use option `project` instead of `sourceMapsUploadOptions.project`
-     */
-    project?: string;
-    /**
-     * If this flag is `true`, the Sentry plugin will collect some telemetry data and send it to Sentry.
-     * It will not collect any sensitive or user-specific data.
-     *
-     * @default true
-     * @deprecated Use option `telemetry` instead of `sourceMapsUploadOptions.telemetry`
-     */
-    telemetry?: boolean;
-    /**
-     * Options related to sourcemaps
-     *
-     * @deprecated Use option `sourcemaps` instead of `sourceMapsUploadOptions.sourcemaps`
-     */
-    sourcemaps?: {
-        /**
-         * A glob or an array of globs that specify the build artifacts and source maps that will be uploaded to Sentry.
-         *
-         * If this option is not specified, sensible defaults based on your adapter and nuxt.config.js
-         * setup will be used. Use this option to override these defaults, for instance if you have a
-         * customized build setup that diverges from Nuxt's defaults.
-         *
-         * The globbing patterns must follow the implementation of the `glob` package.
-         * @see https://www.npmjs.com/package/glob#glob-primer
-         *
-         * @deprecated Use option `sourcemaps.assets` instead of `sourceMapsUploadOptions.sourcemaps.assets`
-         */
-        assets?: string | Array<string>;
-        /**
-         * A glob or an array of globs that specifies which build artifacts should not be uploaded to Sentry.
-         *
-         * @default [] - By default no files are ignored. Thus, all files matching the `assets` glob
-         * or the default value for `assets` are uploaded.
-         *
-         * The globbing patterns follow the implementation of the glob package. (https://www.npmjs.com/package/glob)
-         *
-         * @deprecated Use option `sourcemaps.ignore` instead of `sourceMapsUploadOptions.sourcemaps.ignore`
-         */
-        ignore?: string | Array<string>;
-        /**
-         * A glob or an array of globs that specifies the build artifacts that should be deleted after the artifact
-         * upload to Sentry has been completed.
-         *
-         * @default [] - By default no files are deleted.
-         *
-         * The globbing patterns follow the implementation of the glob package. (https://www.npmjs.com/package/glob)
-         *
-         * @deprecated Use option `sourcemaps.filesToDeleteAfterUpload` instead of `sourceMapsUploadOptions.sourcemaps.filesToDeleteAfterUpload`
-         */
-        filesToDeleteAfterUpload?: string | Array<string>;
-    };
-};
 /**
  *  Build options for the Sentry module. These options are used during build-time by the Sentry SDK.
  */
@@ -166,32 +28,6 @@ export type SentryNuxtModuleOptions = BuildTimeOptionsBase & {
      * @default true
      */
     enabled?: boolean;
-    /**
-     * Experimental build-time options that may change or be removed without notice.
-     */
-    _experimental?: {
-        /**
-         * Enables build-time diagnostics-channel instrumentation for supported dependencies bundled into the Nitro server.
-         *
-         * 1. Call `Sentry.experimentalUseDiagnosticsChannelInjection()` just before `Sentry.init()`
-         * 2. Remove `--import ./.output/server/sentry.server.config.mjs` from your `start`script
-         * 3. Add `sentry.autoInjectServerSentry: 'top-level-import'` in `nuxt.config.ts` so Sentry's server configuration is automatically imported
-         *
-         * @default false
-         * @experimental May change or be removed in any release.
-         */
-        useDiagnosticsChannelInjection?: boolean;
-    };
-    /**
-     * Options for the Sentry Vite plugin to customize the source maps upload process.
-     *
-     * These options are always read from the `sentry` module options in the `nuxt.config.(js|ts).
-     * Do not define them in the `sentry.client.config.(js|ts)` or `sentry.server.config.(js|ts)` files.
-     *
-     * @deprecated  This option was deprecated as it adds unnecessary nesting.
-     *              Put the options one level higher to the root-level of the `sentry` module options.
-     */
-    sourceMapsUploadOptions?: SourceMapsOptions;
     /**
      *
      * Enables (partial) server tracing by automatically injecting Sentry for environments where modifying the node option `--import` is not possible.
@@ -249,11 +85,10 @@ export type SentryNuxtModuleOptions = BuildTimeOptionsBase & {
      */
     experimental_entrypointWrappedFunctions?: string[];
     /**
-     * Options to be passed directly to the Sentry Rollup Plugin (`@sentry/rollup-plugin`) and Sentry Vite Plugin (`@sentry/vite-plugin`) that ship with the Sentry Nuxt SDK.
+     * Options to be passed directly to the Sentry Rollup Plugin (`@sentry/bundler-plugins/rollup`) and Sentry Vite Plugin (`@sentry/bundler-plugins/vite`) that ship with the Sentry Nuxt SDK.
      * You can use this option to override any options the SDK passes to the Vite (for Nuxt) and Rollup (for Nitro) plugin.
      *
      * Please note that this option is unstable and may change in a breaking way in any release.
      */
     unstable_sentryBundlerPluginOptions?: SentryRollupPluginOptions & SentryVitePluginOptions;
 };
-export {};

package/build/module/module.json

@@ -4,5 +4,5 @@
   "compatibility": {
     "nuxt": ">=3.7.0"
   },
-  "version": "10.70.0"
+  "version": "11.0.0-alpha.1"
 }

package/build/module/module.mjs

@@ -5,8 +5,8 @@ import { existsSync } from 'node:fs';
 import * as fs from 'fs';
 import { INSTRUMENTED_MODULE_NAMES } from '@sentry/server-utils/orchestrion/config';
 import { sentryOrchestrionPlugin } from '@sentry/server-utils/orchestrion/rollup';
-import { sentryRollupPlugin } from '@sentry/rollup-plugin';
-import { sentryVitePlugin } from '@sentry/vite-plugin';
+import { sentryRollupPlugin } from '@sentry/bundler-plugins/rollup';
+import { sentryVitePlugin } from '@sentry/bundler-plugins/vite';
 
 async function getNitroMajorVersion() {
   try {
@@ -230,9 +230,6 @@ function wrapEntryWithDynamicImport({
       if (source.includes(`/${SERVER_CONFIG_FILENAME}`)) {
         return { id: source, moduleSideEffects: true };
       }
-      if (source === "import-in-the-middle/hook.mjs") {
-        return { id: source, moduleSideEffects: true, external: true };
-      }
       if (options.isEntry && source.includes(".mjs") && !source.includes(`.mjs${SENTRY_WRAPPED_ENTRY}`)) {
         const resolution = await this.resolve(source, importer, options);
         if (!resolution || resolution?.external) return resolution;
@@ -256,7 +253,6 @@ function wrapEntryWithDynamicImport({
           // Regular `import` of the Sentry config
           `import ${JSON.stringify(resolvedSentryConfigPath)};
 import(${JSON.stringify(entryId)});
-import 'import-in-the-middle/hook.mjs';
 ${reExportedFunctions}
 `
         );
@@ -362,18 +358,25 @@ ${originalCode.replace(/defineEventHandler\(/g, "defineInstrumentedEventHandler(
 }
 
 const IORedisDependencies = ["standard-as-callback"];
-function setupOrchestrion(nuxt) {
+function setupOrchestrion(nuxt, hasServerConfig, buildTimeInstrumentation) {
+  if (buildTimeInstrumentation === false) {
+    return;
+  }
   nuxt.hook("nitro:config", (nitroConfig) => {
     if (nuxt.options?._prepare) {
       return;
     }
+    const isCloudflare = !!nitroConfig.preset?.replace(/-/g, "_").startsWith("cloudflare");
+    if (!hasServerConfig && !isCloudflare) {
+      return;
+    }
     nitroConfig.rollupConfig ?? (nitroConfig.rollupConfig = {});
     if (nitroConfig.rollupConfig.plugins === null || nitroConfig.rollupConfig.plugins === void 0) {
       nitroConfig.rollupConfig.plugins = [];
     } else if (!Array.isArray(nitroConfig.rollupConfig.plugins)) {
       nitroConfig.rollupConfig.plugins = [nitroConfig.rollupConfig.plugins];
     }
-    nitroConfig.rollupConfig.plugins.push(sentryOrchestrionPlugin());
+    nitroConfig.rollupConfig.plugins.push(sentryOrchestrionPlugin({}));
     const externals = nitroConfig.externals || (nitroConfig.externals = {});
     const inline = externals.inline;
     const existingInline = Array.isArray(inline) ? inline : inline ? [inline] : [];
@@ -409,11 +412,7 @@ function validateSourceMapsOptionsPlugin(options) {
 
 function setupSourceMaps(moduleOptions, nuxt, addVitePlugin) {
   const isDebug = moduleOptions.debug;
-  const sourceMapsUploadOptions = moduleOptions.sourceMapsUploadOptions || {};
-  const sourceMapsEnabled = moduleOptions.sourcemaps?.disable === true ? false : moduleOptions.sourcemaps?.disable === false ? true : (
-    // eslint-disable-next-line typescript/no-deprecated
-    sourceMapsUploadOptions.enabled ?? true
-  );
+  const sourceMapsEnabled = moduleOptions.sourcemaps?.disable !== true;
   const shouldDeleteFilesFallback = { client: true, server: true };
   nuxt.hook("modules:done", () => {
     if (sourceMapsEnabled && !nuxt.options.dev && !nuxt.options?._prepare) {
@@ -422,8 +421,7 @@ function setupSourceMaps(moduleOptions, nuxt, addVitePlugin) {
       shouldDeleteFilesFallback.server = previousSourceMapSettings.server === "unset";
       if (isDebug && (shouldDeleteFilesFallback.client || shouldDeleteFilesFallback.server)) {
         const enabledDeleteFallbacks = shouldDeleteFilesFallback.client && shouldDeleteFilesFallback.server ? "client-side and server-side" : shouldDeleteFilesFallback.server ? "server-side" : "client-side";
-        if (!moduleOptions.sourcemaps?.filesToDeleteAfterUpload && // eslint-disable-next-line typescript/no-deprecated
-        !sourceMapsUploadOptions.sourcemaps?.filesToDeleteAfterUpload) {
+        if (!moduleOptions.sourcemaps?.filesToDeleteAfterUpload) {
           console.log(
             `[Sentry] We enabled \`'hidden'\` source maps for your ${enabledDeleteFallbacks} build. Source map files will be automatically deleted after uploading them to Sentry.`
           );
@@ -468,44 +466,23 @@ function normalizePath(path) {
   return path.replace(/^(\.\.\/)+/, "./");
 }
 function getPluginOptions(moduleOptions, shouldDeleteFilesFallback) {
-  const sourceMapsUploadOptions = moduleOptions.sourceMapsUploadOptions || {};
-  const shouldDeleteFilesAfterUpload = shouldDeleteFilesFallback?.client || shouldDeleteFilesFallback?.server;
-  const fallbackFilesToDelete = [
-    ...shouldDeleteFilesFallback?.client ? [".*/**/public/**/*.map"] : [],
-    ...shouldDeleteFilesFallback?.server ? [".*/**/server/**/*.map", ".*/**/output/**/*.map", ".*/**/function/**/*.map"] : []
-  ];
   const sourcemapsOptions = moduleOptions.sourcemaps || {};
-  const deprecatedSourcemapsOptions = sourceMapsUploadOptions.sourcemaps || {};
-  const filesToDeleteAfterUpload = sourcemapsOptions.filesToDeleteAfterUpload ?? // eslint-disable-next-line typescript/no-deprecated
-  deprecatedSourcemapsOptions.filesToDeleteAfterUpload;
-  if (typeof filesToDeleteAfterUpload === "undefined" && shouldDeleteFilesAfterUpload && moduleOptions.debug) {
-    console.log(
-      `[Sentry] Setting \`sentry.sourceMapsUploadOptions.sourcemaps.filesToDeleteAfterUpload: [${fallbackFilesToDelete.map((path) => `"${path}"`).join(", ")}]\` to delete generated source maps after they were uploaded to Sentry.`
-    );
-  }
+  const filesToDeleteAfterUpload = resolveFilesToDeleteAfterUpload(moduleOptions, shouldDeleteFilesFallback);
   return {
     applicationKey: moduleOptions.applicationKey,
-    // eslint-disable-next-line typescript/no-deprecated
-    org: moduleOptions.org ?? sourceMapsUploadOptions.org ?? process.env.SENTRY_ORG,
-    // eslint-disable-next-line typescript/no-deprecated
-    project: moduleOptions.project ?? sourceMapsUploadOptions.project ?? process.env.SENTRY_PROJECT,
-    // eslint-disable-next-line typescript/no-deprecated
-    authToken: moduleOptions.authToken ?? sourceMapsUploadOptions.authToken ?? process.env.SENTRY_AUTH_TOKEN,
-    // eslint-disable-next-line typescript/no-deprecated
-    telemetry: moduleOptions.telemetry ?? sourceMapsUploadOptions.telemetry ?? true,
-    // eslint-disable-next-line typescript/no-deprecated
-    url: moduleOptions.sentryUrl ?? sourceMapsUploadOptions.url ?? process.env.SENTRY_URL,
+    org: moduleOptions.org ?? process.env.SENTRY_ORG,
+    project: moduleOptions.project ?? process.env.SENTRY_PROJECT,
+    authToken: moduleOptions.authToken ?? process.env.SENTRY_AUTH_TOKEN,
+    telemetry: moduleOptions.telemetry ?? true,
+    url: moduleOptions.sentryUrl ?? process.env.SENTRY_URL,
     headers: moduleOptions.headers,
     debug: moduleOptions.debug ?? false,
-    // eslint-disable-next-line typescript/no-deprecated
-    silent: moduleOptions.silent ?? sourceMapsUploadOptions.silent ?? false,
-    // eslint-disable-next-line typescript/no-deprecated
-    errorHandler: moduleOptions.errorHandler ?? sourceMapsUploadOptions.errorHandler,
+    silent: moduleOptions.silent ?? false,
+    errorHandler: moduleOptions.errorHandler,
     bundleSizeOptimizations: moduleOptions.bundleSizeOptimizations,
     // todo: test if this can be overridden by the user
     release: {
-      // eslint-disable-next-line typescript/no-deprecated
-      name: moduleOptions.release?.name ?? sourceMapsUploadOptions.release?.name,
+      name: moduleOptions.release?.name,
       // Support all release options from BuildTimeOptionsBase
       ...moduleOptions.release,
       ...moduleOptions?.unstable_sentryBundlerPluginOptions?.release
@@ -521,16 +498,28 @@ function getPluginOptions(moduleOptions, shouldDeleteFilesFallback) {
       // The server/client files are in different places depending on the nitro preset (e.g. '.output/server' or '.netlify/functions-internal/server')
       // We cannot determine automatically how the build folder looks like (depends on the preset), so we have to accept that source maps are uploaded multiple times (with the vitePlugin for Nuxt and the rollupPlugin for Nitro).
       // If we could know where the server/client assets are located, we could do something like this (based on the Nitro preset): isNitro ? ['./.output/server/**/*'] : ['./.output/public/**/*'],
-      // eslint-disable-next-line typescript/no-deprecated
-      assets: sourcemapsOptions.assets ?? deprecatedSourcemapsOptions.assets ?? void 0,
-      // eslint-disable-next-line typescript/no-deprecated
-      ignore: sourcemapsOptions.ignore ?? deprecatedSourcemapsOptions.ignore ?? void 0,
-      filesToDeleteAfterUpload: filesToDeleteAfterUpload ? filesToDeleteAfterUpload : shouldDeleteFilesFallback?.server || shouldDeleteFilesFallback?.client ? fallbackFilesToDelete : void 0,
+      assets: sourcemapsOptions.assets ?? void 0,
+      ignore: sourcemapsOptions.ignore ?? void 0,
+      filesToDeleteAfterUpload,
       rewriteSources: sourcemapsOptions.rewriteSources ?? normalizePath,
       ...moduleOptions?.unstable_sentryBundlerPluginOptions?.sourcemaps
     }
   };
 }
+function resolveFilesToDeleteAfterUpload(moduleOptions, shouldDeleteFilesFallback) {
+  const shouldDeleteFilesAfterUpload = shouldDeleteFilesFallback?.client || shouldDeleteFilesFallback?.server;
+  const fallbackFilesToDelete = [
+    ...shouldDeleteFilesFallback?.client ? [".*/**/public/**/*.map"] : [],
+    ...shouldDeleteFilesFallback?.server ? [".*/**/server/**/*.map", ".*/**/output/**/*.map", ".*/**/function/**/*.map"] : []
+  ];
+  const filesToDeleteAfterUpload = moduleOptions.sourcemaps?.filesToDeleteAfterUpload;
+  if (typeof filesToDeleteAfterUpload === "undefined" && shouldDeleteFilesAfterUpload && moduleOptions.debug) {
+    console.log(
+      `[Sentry] Setting \`sentry.sourcemaps.filesToDeleteAfterUpload: [${fallbackFilesToDelete.map((path) => `"${path}"`).join(", ")}]\` to delete generated source maps after they were uploaded to Sentry.`
+    );
+  }
+  return filesToDeleteAfterUpload ? filesToDeleteAfterUpload : shouldDeleteFilesAfterUpload ? fallbackFilesToDelete : void 0;
+}
 function extractNuxtSourceMapSetting(nuxt, runtime) {
   if (!runtime) {
     return void 0;
@@ -718,10 +707,8 @@ var module$1 = defineNuxtModule({
     const isNitroV3 = await getNitroMajorVersion() >= 3;
     const nuxtMajor = parseInt(nuxt._version?.split(".")[0] ?? "3", 10);
     const isMinNuxtV4 = nuxtMajor >= 4;
+    setupOrchestrion(nuxt, !!serverConfigFile, moduleOptions.buildTimeInstrumentation);
     if (serverConfigFile) {
-      if (moduleOptions._experimental?.useDiagnosticsChannelInjection) {
-        setupOrchestrion(nuxt);
-      }
       if (isNitroV3) {
         addServerPlugin(moduleDirResolver.resolve("./runtime/plugins/handler.server"));
         addServerPlugin(moduleDirResolver.resolve("./runtime/plugins/update-route-name.server"));

package/build/module/runtime/hooks/updateRouteBeforeResponse.js

@@ -1,4 +1,5 @@
-import { getActiveSpan, getRootSpan, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, isObjectLike, debug } from '@sentry/core';
+import { getActiveSpan, getRootSpan, isObjectLike, debug } from '@sentry/core';
+import { setHttpServerSpanRouteAttribute } from '@sentry/server-utils';
 
 function getMatchedRoutePath(event) {
   const matchedRoute = event.context.matchedRoute;
@@ -14,6 +15,7 @@ function updateRouteBeforeResponse(event) {
     if (matchedRoutePath === "/**") {
       return;
     }
+    setHttpServerSpanRouteAttribute(matchedRoutePath);
     const activeSpan = getActiveSpan();
     if (!activeSpan) {
       return;
@@ -22,10 +24,6 @@ function updateRouteBeforeResponse(event) {
     if (!rootSpan) {
       return;
     }
-    rootSpan.setAttributes({
-      [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: "route",
-      "http.route": matchedRoutePath
-    });
     const params = event.context?.params;
     if (isObjectLike(params)) {
       Object.entries(params).forEach(([key, value]) => {

package/build/module/runtime/hooks/wrapMiddlewareHandler.js

@@ -1,4 +1,6 @@
-import { debug, httpHeadersToSpanAttributes, getClient, startSpan, SPAN_STATUS_OK, SPAN_STATUS_ERROR, captureException, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, flushIfServerless, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, SEMANTIC_ATTRIBUTE_SENTRY_OP } from '@sentry/core';
+import { SENTRY_OP } from '@sentry/conventions/attributes';
+import { WEB_SERVER_MIDDLEWARE_SPAN_OP } from '@sentry/conventions/op';
+import { debug, getClient, httpHeadersToSpanAttributes, startSpan, SPAN_STATUS_OK, SPAN_STATUS_ERROR, captureException, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, flushIfServerless, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '@sentry/core';
 
 function wrapMiddlewareHandlerWithSentry(handler, fileName) {
   if (!isEventHandlerObject(handler)) {
@@ -72,7 +74,7 @@ function normalizeHandlers(handlers, normalizer) {
 }
 function getSpanAttributes(event, middlewareName, hookName, index) {
   const attributes = {
-    [SEMANTIC_ATTRIBUTE_SENTRY_OP]: "middleware.nuxt",
+    [SENTRY_OP]: WEB_SERVER_MIDDLEWARE_SPAN_OP,
     [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: "custom",
     [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.middleware.nuxt",
     "nuxt.middleware.name": middlewareName,
@@ -94,8 +96,10 @@ function getSpanAttributes(event, middlewareName, hookName, index) {
   if (!Object.keys(headers).length && eventH3v2?.req?.headers instanceof Headers) {
     headers = Object.fromEntries(eventH3v2?.req.headers.entries());
   }
-  const headerAttributes = httpHeadersToSpanAttributes(headers, getClient()?.getDataCollectionOptions() ?? false);
-  Object.assign(attributes, headerAttributes);
+  const client = getClient();
+  if (client) {
+    Object.assign(attributes, httpHeadersToSpanAttributes(headers, client.getDataCollectionOptions()));
+  }
   return attributes;
 }
 function isEventHandlerObject(handler) {

package/build/module/runtime/plugins/route-detector-legacy.server.js

@@ -1,6 +1,7 @@
-import { debug, getActiveSpan, getRootSpan, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '@sentry/core';
+import { debug } from '@sentry/core';
 import { defineNuxtPlugin } from 'nuxt/app';
 import { extractParametrizedRouteFromContext } from '../utils/route-extraction.js';
+import { setHttpServerSpanRouteAttribute } from '@sentry/server-utils';
 
 var routeDetectorLegacy_server = defineNuxtPlugin((nuxtApp) => {
   nuxtApp.hooks.hook("app:rendered", async (renderContext) => {
@@ -22,17 +23,8 @@ var routeDetectorLegacy_server = defineNuxtPlugin((nuxtApp) => {
     if (routeInfo === null) {
       return;
     }
-    const activeSpan = getActiveSpan();
-    if (activeSpan && routeInfo.parametrizedRoute) {
-      const rootSpan = getRootSpan(activeSpan);
-      if (!rootSpan) {
-        return;
-      }
-      debug.log("Matched parametrized server route:", routeInfo.parametrizedRoute);
-      rootSpan.setAttributes({
-        [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: "route",
-        "http.route": routeInfo.parametrizedRoute
-      });
+    if (routeInfo.parametrizedRoute) {
+      setHttpServerSpanRouteAttribute(routeInfo.parametrizedRoute);
     }
   });
 });

package/build/module/runtime/plugins/route-detector.server.js

@@ -1,6 +1,7 @@
-import { debug, getActiveSpan, getRootSpan, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '@sentry/core';
+import { debug } from '@sentry/core';
 import { defineNuxtPlugin } from 'nuxt/app';
 import { extractParametrizedRouteFromContext } from '../utils/route-extraction.js';
+import { setHttpServerSpanRouteAttribute } from '@sentry/server-utils';
 
 var routeDetector_server = defineNuxtPlugin((nuxtApp) => {
   nuxtApp.hooks.hook("app:rendered", async (renderContext) => {
@@ -22,18 +23,7 @@ var routeDetector_server = defineNuxtPlugin((nuxtApp) => {
     if (routeInfo === null) {
       return;
     }
-    const activeSpan = getActiveSpan();
-    if (activeSpan && routeInfo.parametrizedRoute) {
-      const rootSpan = getRootSpan(activeSpan);
-      if (!rootSpan) {
-        return;
-      }
-      debug.log("Matched parametrized server route:", routeInfo.parametrizedRoute);
-      rootSpan.setAttributes({
-        [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: "route",
-        "http.route": routeInfo.parametrizedRoute
-      });
-    }
+    setHttpServerSpanRouteAttribute(routeInfo.parametrizedRoute);
   });
 });
 

package/build/module/runtime/plugins/sentry-cloudflare.server.js

@@ -1,4 +1,5 @@
-import { setAsyncLocalStorageAsyncContextStrategy, wrapRequestHandler } from '@sentry/cloudflare';
+import { setAsyncLocalStorageAsyncContextStrategy, getDefaultIntegrations } from '@sentry/cloudflare';
+import { wrapRequestHandler } from '@sentry/cloudflare/request';
 import { debug, getIsolationScope, getDefaultIsolationScope, getTraceData } from '@sentry/core';
 import { sentryCaptureErrorHook } from '../hooks/captureErrorHook.js';
 import { updateRouteBeforeResponse } from '../hooks/updateRouteBeforeResponse.js';
@@ -25,7 +26,9 @@ const sentryCloudflareNitroPlugin = (optionsOrFn) => (nitroApp) => {
           cf: getCfProperties(event)
         });
         const requestHandlerOptions = {
-          options: cloudflareOptions,
+          // `wrapRequestHandler` only sets up the integrations that work without `nodejs_compat`.
+          // Nitro's Cloudflare presets require the flag anyway, so opt into the full set.
+          options: { defaultIntegrations: getDefaultIntegrations(cloudflareOptions), ...cloudflareOptions },
           request,
           context: getCloudflareProperties(event).context
         };

package/build/module/runtime/plugins/sentry.client.js

@@ -30,7 +30,8 @@ var sentry_client = defineNuxtPlugin({
     });
     nuxtApp.hook("app:error", (error) => {
       if (isNuxtError(error)) {
-        if (error?.statusCode && error.statusCode >= 300 && error.statusCode < 500) {
+        const statusCode = error?.status || error?.statusCode;
+        if (statusCode && statusCode >= 300 && statusCode < 500) {
           return;
         }
       }

package/build/module/runtime/utils/instrumentStorage.js

@@ -1,6 +1,20 @@
-import { debug, startSpan, SPAN_STATUS_OK, SEMANTIC_ATTRIBUTE_CACHE_HIT, SPAN_STATUS_ERROR, captureException, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, flushIfServerless, SEMANTIC_ATTRIBUTE_CACHE_KEY, SEMANTIC_ATTRIBUTE_SENTRY_OP, isObjectLike } from '@sentry/core';
+import { SENTRY_OP } from '@sentry/conventions/attributes';
+import { DATABASE_CACHE_REMOVE_SPAN_OP, DATABASE_CACHE_PUT_SPAN_OP, DATABASE_CACHE_GET_SPAN_OP } from '@sentry/conventions/op';
+import { debug, startSpan, SPAN_STATUS_OK, SEMANTIC_ATTRIBUTE_CACHE_HIT, SPAN_STATUS_ERROR, captureException, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, flushIfServerless, SEMANTIC_ATTRIBUTE_CACHE_KEY, isObjectLike } from '@sentry/core';
 
-const CACHE_HIT_METHODS = /* @__PURE__ */ new Set(["hasItem", "getItem", "getItemRaw"]);
+const CACHE_HIT_METHODS = /* @__PURE__ */ new Set(["hasItem", "getItem", "getItemRaw", "getItems"]);
+const METHOD_SPAN_OPS = {
+  hasItem: DATABASE_CACHE_GET_SPAN_OP,
+  getItem: DATABASE_CACHE_GET_SPAN_OP,
+  getItemRaw: DATABASE_CACHE_GET_SPAN_OP,
+  getItems: DATABASE_CACHE_GET_SPAN_OP,
+  getKeys: DATABASE_CACHE_GET_SPAN_OP,
+  setItem: DATABASE_CACHE_PUT_SPAN_OP,
+  setItemRaw: DATABASE_CACHE_PUT_SPAN_OP,
+  setItems: DATABASE_CACHE_PUT_SPAN_OP,
+  removeItem: DATABASE_CACHE_REMOVE_SPAN_OP,
+  clear: DATABASE_CACHE_REMOVE_SPAN_OP
+};
 async function createStoragePlugin(useStorage, userStorageMounts) {
   const storage = useStorage();
   const userMounts = new Set(userStorageMounts.map((m) => `${m}:`));
@@ -54,7 +68,7 @@ function createMethodWrapper(original, methodName, driver, mountBase) {
           const result = await target.apply(thisArg, args);
           span.setStatus({ code: SPAN_STATUS_OK });
           if (CACHE_HIT_METHODS.has(methodName)) {
-            span.setAttribute(SEMANTIC_ATTRIBUTE_CACHE_HIT, isCacheHit(args[0], result));
+            span.setAttribute(SEMANTIC_ATTRIBUTE_CACHE_HIT, resolveCacheHit(methodName, args[0], result));
           }
           return result;
         } catch (error) {
@@ -86,13 +100,10 @@ function wrapStorageMount(storage) {
   mountWithInstrumentation.__sentry_instrumented__ = true;
   return mountWithInstrumentation;
 }
-function normalizeMethodName(methodName) {
-  return methodName.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-}
 function createSpanStartOptions(methodName, driver, mountBase, args) {
   const keys = getCacheKeys(args?.[0], mountBase);
   const attributes = {
-    [SEMANTIC_ATTRIBUTE_SENTRY_OP]: `cache.${normalizeMethodName(methodName)}`,
+    [SENTRY_OP]: METHOD_SPAN_OPS[methodName],
     [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.cache.nuxt",
     [SEMANTIC_ATTRIBUTE_CACHE_KEY]: keys.length > 1 ? keys : keys[0],
     "db.operation.name": methodName,
@@ -120,6 +131,15 @@ function normalizeKey(key, prefix) {
   return `${prefix}${key == null ? "" : String(key)}`;
 }
 const CACHED_FN_HANDLERS_RE = /^nitro:(functions|handlers):/i;
+function resolveCacheHit(methodName, key, result) {
+  if (methodName === "hasItem") {
+    return Boolean(result);
+  }
+  if (methodName === "getItems") {
+    return Array.isArray(result) && result.some((item) => isObjectLike(item) && item.value != null);
+  }
+  return isCacheHit(key, result);
+}
 function isCacheHit(key, value) {
   try {
     const isEmpty = value == null;

package/build/module/vite/addServerConfig.d.ts

@@ -16,7 +16,7 @@ export declare function addSentryTopImport(moduleOptions: SentryNuxtModuleOption
  * This function modifies the Rollup configuration to include a plugin that wraps the entry file with a dynamic import (`import()`)
  * and adds the Sentry server config with the static `import` declaration.
  *
- * With this, the Sentry server config can be loaded before all other modules of the application (which is needed for import-in-the-middle).
+ * With this, the Sentry server config can be loaded before all other modules of the application.
  * See: https://nodejs.org/api/module.html#enabling
  */
 export declare function addDynamicImportEntryFileWrapper(nitro: Nitro, serverConfigFile: string, moduleOptions: Omit<SentryNuxtModuleOptions, 'experimental_entrypointWrappedFunctions'> & Required<Pick<SentryNuxtModuleOptions, 'experimental_entrypointWrappedFunctions'>>): void;

package/build/module/vite/orchestrion.d.ts

@@ -2,5 +2,10 @@ import type { Nuxt } from '@nuxt/schema';
 /**
  * Configures Nitro to bundle and transform dependencies that publish tracing
  * events through diagnostics channels.
+ *
+ * `hasServerConfig` reflects whether a `sentry.server.config` file was found. On Node the SDK is
+ * initialized from that file, so orchestrion only makes sense when it exists. On Cloudflare the SDK
+ * is initialized through `sentryCloudflareNitroPlugin` instead (no server config file), so the
+ * transform must still run there — detected via the Nitro preset.
  */
-export declare function setupOrchestrion(nuxt: Nuxt): void;
+export declare function setupOrchestrion(nuxt: Nuxt, hasServerConfig: boolean, buildTimeInstrumentation?: boolean): void;

package/build/module/vite/sourceMaps.d.ts

@@ -1,6 +1,6 @@
 import type { Nuxt } from '@nuxt/schema';
-import { type SentryRollupPluginOptions } from '@sentry/rollup-plugin';
-import { type SentryVitePluginOptions } from '@sentry/vite-plugin';
+import { type SentryRollupPluginOptions } from '@sentry/bundler-plugins/rollup';
+import { type SentryVitePluginOptions } from '@sentry/bundler-plugins/vite';
 import type { NitroConfig } from 'nitropack';
 import type { Plugin } from 'vite';
 import type { SentryNuxtModuleOptions } from '../common/types';