@sentry/nuxt 10.45.0 → 10.47.0

package/build/module/runtime/plugins/database.server.d.ts

@@ -1,5 +1,5 @@
 /**
- * Creates a Nitro plugin that instruments the database calls.
+ * Nitro plugin that instruments database calls for Nuxt v5+ (Nitro v3+)
  */
 declare const _default: () => void;
 export default _default;

package/build/module/runtime/plugins/database.server.js

@@ -1,150 +1,6 @@
-import {
-  addBreadcrumb,
-  captureException,
-  debug,
-  flushIfServerless,
-  SEMANTIC_ATTRIBUTE_SENTRY_OP,
-  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
-  SPAN_STATUS_ERROR,
-  startSpan
-} from "@sentry/core";
-import { useDatabase } from "nitropack/runtime";
+import { useDatabase } from "nitro/database";
 import { databaseConfig } from "#sentry/database-config.mjs";
-import { getDatabaseSpanData } from "../utils/database-span-data.js";
-const patchedStatement = /* @__PURE__ */ new WeakSet();
-const SENTRY_ORIGIN = "auto.db.nuxt";
+import { createDatabasePlugin } from "../utils/instrumentDatabase.js";
 export default () => {
-  try {
-    const _databaseConfig = databaseConfig;
-    const databaseInstances = Object.keys(databaseConfig);
-    debug.log("[Nitro Database Plugin]: Instrumenting databases...");
-    for (const instance of databaseInstances) {
-      debug.log("[Nitro Database Plugin]: Instrumenting database instance:", instance);
-      const db = useDatabase(instance);
-      instrumentDatabase(db, _databaseConfig[instance]);
-    }
-    debug.log("[Nitro Database Plugin]: Databases instrumented.");
-  } catch (error) {
-    if (error instanceof Error && /Cannot access 'instances'/.test(error.message)) {
-      debug.log("[Nitro Database Plugin]: Database instrumentation skipped during build time.");
-      return;
-    }
-    debug.error("[Nitro Database Plugin]: Failed to instrument database:", error);
-  }
+  createDatabasePlugin(useDatabase, databaseConfig);
 };
-function instrumentDatabase(db, config) {
-  if (db.__sentry_instrumented__) {
-    debug.log("[Nitro Database Plugin]: Database already instrumented. Skipping...");
-    return;
-  }
-  const metadata = {
-    "db.system.name": config?.connector ?? db.dialect,
-    ...getDatabaseSpanData(config)
-  };
-  db.prepare = new Proxy(db.prepare, {
-    apply(target, thisArg, args) {
-      const [query] = args;
-      return instrumentPreparedStatement(target.apply(thisArg, args), query, metadata);
-    }
-  });
-  db.sql = new Proxy(db.sql, {
-    apply(target, thisArg, args) {
-      const query = args[0]?.[0] ?? "";
-      const opts = createStartSpanOptions(query, metadata);
-      return startSpan(
-        opts,
-        handleSpanStart(() => target.apply(thisArg, args))
-      );
-    }
-  });
-  db.exec = new Proxy(db.exec, {
-    apply(target, thisArg, args) {
-      return startSpan(
-        createStartSpanOptions(args[0], metadata),
-        handleSpanStart(() => target.apply(thisArg, args), { query: args[0] })
-      );
-    }
-  });
-  db.__sentry_instrumented__ = true;
-}
-function instrumentPreparedStatement(statement, query, data) {
-  statement.bind = new Proxy(statement.bind, {
-    apply(target, thisArg, args) {
-      return instrumentPreparedStatementQueries(target.apply(thisArg, args), query, data);
-    }
-  });
-  return instrumentPreparedStatementQueries(statement, query, data);
-}
-function instrumentPreparedStatementQueries(statement, query, data) {
-  if (patchedStatement.has(statement)) {
-    return statement;
-  }
-  statement.get = new Proxy(statement.get, {
-    apply(target, thisArg, args) {
-      return startSpan(
-        createStartSpanOptions(query, data),
-        handleSpanStart(() => target.apply(thisArg, args), { query })
-      );
-    }
-  });
-  statement.run = new Proxy(statement.run, {
-    apply(target, thisArg, args) {
-      return startSpan(
-        createStartSpanOptions(query, data),
-        handleSpanStart(() => target.apply(thisArg, args), { query })
-      );
-    }
-  });
-  statement.all = new Proxy(statement.all, {
-    apply(target, thisArg, args) {
-      return startSpan(
-        createStartSpanOptions(query, data),
-        handleSpanStart(() => target.apply(thisArg, args), { query })
-      );
-    }
-  });
-  patchedStatement.add(statement);
-  return statement;
-}
-function handleSpanStart(fn, breadcrumbOpts) {
-  return async (span) => {
-    try {
-      const result = await fn();
-      if (breadcrumbOpts) {
-        createBreadcrumb(breadcrumbOpts.query);
-      }
-      return result;
-    } catch (error) {
-      span.setStatus({ code: SPAN_STATUS_ERROR, message: "internal_error" });
-      captureException(error, {
-        mechanism: {
-          handled: false,
-          type: SENTRY_ORIGIN
-        }
-      });
-      throw error;
-    } finally {
-      await flushIfServerless();
-    }
-  };
-}
-function createBreadcrumb(query) {
-  addBreadcrumb({
-    category: "query",
-    message: query,
-    data: {
-      "db.query.text": query
-    }
-  });
-}
-function createStartSpanOptions(query, data) {
-  return {
-    name: query,
-    attributes: {
-      "db.query.text": query,
-      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: SENTRY_ORIGIN,
-      [SEMANTIC_ATTRIBUTE_SENTRY_OP]: "db.query",
-      ...data
-    }
-  };
-}

package/build/module/runtime/plugins/handler-legacy.server.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (nitroApp: import("nitropack").NitroApp) => void;
+export default _default;

package/build/module/runtime/plugins/handler-legacy.server.js

@@ -0,0 +1,4 @@
+import { patchEventHandler } from "../utils/patchEventHandler.js";
+export default (nitroApp) => {
+  nitroApp.h3App.handler = patchEventHandler(nitroApp.h3App.handler);
+};

package/build/module/runtime/plugins/handler.server.d.ts

@@ -0,0 +1,6 @@
+import type { NitroApp } from 'nitro/types';
+/**
+ * This plugin patches the h3 event handler for Nuxt v5+ (Nitro v3+).
+ */
+declare const _default: (nitroApp: NitroApp) => void;
+export default _default;

package/build/module/runtime/plugins/handler.server.js

@@ -0,0 +1,6 @@
+import { patchEventHandler } from "../utils/patchEventHandler.js";
+export default (nitroApp) => {
+  if (nitroApp?.h3?.handler) {
+    nitroApp.h3.handler = patchEventHandler(nitroApp.h3.handler);
+  }
+};

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

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

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

@@ -0,0 +1,37 @@
+import { debug, getActiveSpan, getRootSpan, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from "@sentry/core";
+import { defineNuxtPlugin } from "nuxt/app";
+import { extractParametrizedRouteFromContext } from "../utils/route-extraction.js";
+export default defineNuxtPlugin((nuxtApp) => {
+  nuxtApp.hooks.hook("app:rendered", async (renderContext) => {
+    let buildTimePagesData;
+    try {
+      const { default: importedPagesData } = await import("#build/sentry--nuxt-pages-data.mjs");
+      buildTimePagesData = importedPagesData || [];
+      debug.log("Imported build-time pages data:", buildTimePagesData);
+    } catch (error) {
+      buildTimePagesData = [];
+      debug.warn("Failed to import build-time pages data:", error);
+    }
+    const ssrContext = renderContext.ssrContext;
+    const routeInfo = extractParametrizedRouteFromContext(
+      ssrContext?.modules,
+      ssrContext?.url || ssrContext?.event._path,
+      buildTimePagesData
+    );
+    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
+      });
+    }
+  });
+});

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

@@ -5,7 +5,7 @@ export default defineNuxtPlugin((nuxtApp) => {
   nuxtApp.hooks.hook("app:rendered", async (renderContext) => {
     let buildTimePagesData;
     try {
-      const { default: importedPagesData } = await import("#build/sentry--nuxt-pages-data.mjs");
+      const { default: importedPagesData } = await import("#sentry/nuxt-pages-data.mjs");
       buildTimePagesData = importedPagesData || [];
       debug.log("Imported build-time pages data:", buildTimePagesData);
     } catch (error) {

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

@@ -1,21 +1,14 @@
-import {
-  debug,
-  flushIfServerless,
-  getDefaultIsolationScope,
-  getIsolationScope,
-  withIsolationScope
-} from "@sentry/core";
+import { debug } from "@sentry/core";
 import { sentryCaptureErrorHook } from "../hooks/captureErrorHook.js";
-import { updateRouteBeforeResponse } from "../hooks/updateRouteBeforeResponse.js";
 import { addSentryTracingMetaTags } from "../utils.js";
 export default (nitroApp) => {
-  nitroApp.h3App.handler = patchEventHandler(nitroApp.h3App.handler);
-  nitroApp.hooks.hook("beforeResponse", updateRouteBeforeResponse);
   nitroApp.hooks.hook("error", sentryCaptureErrorHook);
   nitroApp.hooks.hook("render:html", (html, { event }) => {
-    const headers = event.node.res?.getHeaders() || {};
-    const isPreRenderedPage = Object.keys(headers).includes("x-nitro-prerender");
-    const isSWRCachedPage = event?.context?.cache?.options.swr;
+    const nodeResHeadersH3v1 = event.node?.res?.getHeaders() || {};
+    const isPreRenderedPage = Object.keys(nodeResHeadersH3v1).includes("x-nitro-prerender") || // fix   × typescript-eslint(no-unsafe-member-access): Unsafe member access .res on an `any` value.
+    // oxlint-disable-next-line typescript/no-explicit-any,typescript-oxlint/no-unsafe-member-access
+    !!event.res?.headers?.has?.("x-nitro-prerender");
+    const isSWRCachedPage = event?.context?.cache?.options?.swr;
     if (!isPreRenderedPage && !isSWRCachedPage) {
       addSentryTracingMetaTags(html.head);
     } else {
@@ -26,21 +19,3 @@ export default (nitroApp) => {
     }
   });
 };
-function patchEventHandler(handler) {
-  return new Proxy(handler, {
-    async apply(handlerTarget, handlerThisArg, handlerArgs) {
-      const isolationScope = getIsolationScope();
-      const newIsolationScope = isolationScope === getDefaultIsolationScope() ? isolationScope.clone() : isolationScope;
-      debug.log(
-        `Patched h3 event handler. ${isolationScope === newIsolationScope ? "Using existing" : "Created new"} isolation scope.`
-      );
-      return withIsolationScope(newIsolationScope, async () => {
-        try {
-          return await handlerTarget.apply(handlerThisArg, handlerArgs);
-        } finally {
-          await flushIfServerless();
-        }
-      });
-    }
-  });
-}

package/build/module/runtime/plugins/storage-legacy.server.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Nitro plugin that instruments storage driver calls for Nuxt v3/v4 (Nitro v2)
+ */
+declare const _default: (_nitroApp: import("nitropack").NitroApp) => Promise<void>;
+export default _default;

package/build/module/runtime/plugins/storage-legacy.server.js

@@ -0,0 +1,6 @@
+import { useStorage } from "nitropack/runtime";
+import { userStorageMounts } from "#sentry/storage-config.mjs";
+import { createStoragePlugin } from "../utils/instrumentStorage.js";
+export default async (_nitroApp) => {
+  await createStoragePlugin(useStorage, userStorageMounts);
+};

package/build/module/runtime/plugins/storage.server.d.ts

@@ -1,5 +1,7 @@
 /**
- * Creates a Nitro plugin that instruments the storage driver.
+ * Nitro plugin that instruments storage driver calls for Nuxt v5+ (Nitro v3+)
  */
-declare const _default: (_nitroApp: import("nitropack").NitroApp) => Promise<void>;
+declare const _default: (_nitroApp: import("nitro/types").NitroApp & {
+    hooks: NonNullable<import("nitro/types").NitroApp["hooks"]>;
+}) => Promise<void>;
 export default _default;

package/build/module/runtime/plugins/storage.server.js

@@ -1,171 +1,6 @@
-import {
-  captureException,
-  debug,
-  flushIfServerless,
-  SEMANTIC_ATTRIBUTE_CACHE_HIT,
-  SEMANTIC_ATTRIBUTE_CACHE_KEY,
-  SEMANTIC_ATTRIBUTE_SENTRY_OP,
-  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
-  SPAN_STATUS_ERROR,
-  SPAN_STATUS_OK,
-  startSpan
-} from "@sentry/core";
-import { useStorage } from "nitropack/runtime";
+import { useStorage } from "nitro/storage";
 import { userStorageMounts } from "#sentry/storage-config.mjs";
-const CACHE_HIT_METHODS = /* @__PURE__ */ new Set(["hasItem", "getItem", "getItemRaw"]);
+import { createStoragePlugin } from "../utils/instrumentStorage.js";
 export default async (_nitroApp) => {
-  const storage = useStorage();
-  const userMounts = new Set(userStorageMounts.map((m) => `${m}:`));
-  debug.log("[storage] Starting to instrument storage drivers...");
-  userMounts.add("cache:");
-  userMounts.add("");
-  const mounts = storage.getMounts();
-  for (const mount of mounts) {
-    if (!userMounts.has(mount.base)) {
-      continue;
-    }
-    instrumentDriver(mount.driver, mount.base);
-  }
-  storage.mount = wrapStorageMount(storage);
+  await createStoragePlugin(useStorage, userStorageMounts);
 };
-function instrumentDriver(driver, mountBase) {
-  if (driver.__sentry_instrumented__) {
-    debug.log(`[storage] Driver already instrumented: "${driver.name}". Skipping...`);
-    return driver;
-  }
-  debug.log(`[storage] Instrumenting driver: "${driver.name}" on mount: "${mountBase}"`);
-  const methodsToInstrument = [
-    "hasItem",
-    "getItem",
-    "getItemRaw",
-    "getItems",
-    "setItem",
-    "setItemRaw",
-    "setItems",
-    "removeItem",
-    "getKeys",
-    "clear"
-  ];
-  for (const methodName of methodsToInstrument) {
-    const original = driver[methodName];
-    if (typeof original !== "function") {
-      continue;
-    }
-    driver[methodName] = createMethodWrapper(original, methodName, driver, mountBase);
-  }
-  driver.__sentry_instrumented__ = true;
-  return driver;
-}
-function createMethodWrapper(original, methodName, driver, mountBase) {
-  return new Proxy(original, {
-    async apply(target, thisArg, args) {
-      const options = createSpanStartOptions(methodName, driver, mountBase, args);
-      debug.log(`[storage] Running method: "${methodName}" on driver: "${driver.name ?? "unknown"}"`);
-      return startSpan(options, async (span) => {
-        try {
-          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));
-          }
-          return result;
-        } catch (error) {
-          span.setStatus({ code: SPAN_STATUS_ERROR, message: "internal_error" });
-          captureException(error, {
-            mechanism: {
-              handled: false,
-              type: options.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]
-            }
-          });
-          throw error;
-        } finally {
-          await flushIfServerless();
-        }
-      });
-    }
-  });
-}
-function wrapStorageMount(storage) {
-  const original = storage.mount;
-  if (original.__sentry_instrumented__) {
-    return original;
-  }
-  function mountWithInstrumentation(base, driver) {
-    debug.log(`[storage] Instrumenting mount: "${base}"`);
-    const instrumentedDriver = instrumentDriver(driver, base);
-    return original(base, instrumentedDriver);
-  }
-  mountWithInstrumentation.__sentry_instrumented__ = true;
-  return mountWithInstrumentation;
-}
-function normalizeMethodName(methodName) {
-  return methodName.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-}
-function isEmptyValue(value) {
-  return value === null || value === void 0;
-}
-function createSpanStartOptions(methodName, driver, mountBase, args) {
-  const keys = getCacheKeys(args?.[0], mountBase);
-  const attributes = {
-    [SEMANTIC_ATTRIBUTE_SENTRY_OP]: `cache.${normalizeMethodName(methodName)}`,
-    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.cache.nuxt",
-    [SEMANTIC_ATTRIBUTE_CACHE_KEY]: keys.length > 1 ? keys : keys[0],
-    "db.operation.name": methodName,
-    "db.collection.name": mountBase.replace(/:$/, ""),
-    "db.system.name": driver.name ?? "unknown"
-  };
-  return {
-    name: keys.join(", "),
-    attributes
-  };
-}
-function getCacheKeys(key, prefix) {
-  if (Array.isArray(key)) {
-    return key.map((k) => normalizeKey(k, prefix));
-  }
-  return [normalizeKey(key, prefix)];
-}
-function normalizeKey(key, prefix) {
-  if (typeof key === "string") {
-    return `${prefix}${key}`;
-  }
-  if (typeof key === "object" && key !== null && "key" in key) {
-    return `${prefix}${key.key}`;
-  }
-  return `${prefix}${isEmptyValue(key) ? "" : String(key)}`;
-}
-const CACHED_FN_HANDLERS_RE = /^nitro:(functions|handlers):/i;
-function isCacheHit(key, value) {
-  try {
-    const isEmpty = isEmptyValue(value);
-    if (isEmpty || !CACHED_FN_HANDLERS_RE.test(key)) {
-      return !isEmpty;
-    }
-    return validateCacheEntry(key, JSON.parse(String(value)));
-  } catch {
-    return false;
-  }
-}
-function validateCacheEntry(key, entry) {
-  if (isEmptyValue(entry.value)) {
-    return false;
-  }
-  if (Date.now() > (entry.expires || 0)) {
-    return false;
-  }
-  if (isResponseCacheEntry(key, entry)) {
-    if (entry.value.status >= 400) {
-      return false;
-    }
-    if (entry.value.body === void 0) {
-      return false;
-    }
-    if (entry.value.headers.etag === "undefined" || entry.value.headers["last-modified"] === "undefined") {
-      return false;
-    }
-  }
-  return true;
-}
-function isResponseCacheEntry(key, _) {
-  return key.startsWith("nitro:handlers:");
-}

package/build/module/runtime/plugins/update-route-name-legacy.server.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (nitroApp: import("nitropack").NitroApp) => void;
+export default _default;

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

@@ -0,0 +1,4 @@
+import { updateRouteBeforeResponse } from "../hooks/updateRouteBeforeResponse.js";
+export default (nitroApp) => {
+  nitroApp.hooks.hook("beforeResponse", updateRouteBeforeResponse);
+};

package/build/module/runtime/plugins/update-route-name.server.d.ts

@@ -0,0 +1,4 @@
+declare const _default: (nitroApp: import("nitro/types").NitroApp & {
+    hooks: NonNullable<import("nitro/types").NitroApp["hooks"]>;
+}) => void;
+export default _default;

package/build/module/runtime/plugins/update-route-name.server.js

@@ -0,0 +1,4 @@
+import { updateRouteBeforeResponse } from "../hooks/updateRouteBeforeResponse.js";
+export default (nitroApp) => {
+  nitroApp.hooks.hook("response", (_response, event) => updateRouteBeforeResponse(event));
+};

package/build/module/runtime/utils/database-span-data.d.ts

@@ -1,8 +1,22 @@
-import type { DatabaseConnectionConfig as DatabaseConfig } from 'nitropack/types';
+import type { ConnectorName } from 'db0';
 export interface DatabaseSpanData {
     [key: string]: string | number | undefined;
 }
+/**
+ * A minimal database connection configuration type compatible with both nitropack (Nitro v2) and nitro (Nitro v3+).
+ * Mirrors the shape of `DatabaseConnectionConfig` from both packages.
+ */
+export interface DatabaseConnectionConfig {
+    connector?: ConnectorName;
+    options?: {
+        host?: string;
+        port?: number;
+        dataDir?: string;
+        name?: string;
+        [key: string]: unknown;
+    };
+}
 /**
  * Extracts span attributes from the database configuration.
  */
-export declare function getDatabaseSpanData(config?: DatabaseConfig): Partial<DatabaseSpanData>;
+export declare function getDatabaseSpanData(config?: DatabaseConnectionConfig): Partial<DatabaseSpanData>;

package/build/module/runtime/utils/instrumentDatabase.d.ts

@@ -0,0 +1,9 @@
+import type { Database } from 'db0';
+import { type DatabaseConnectionConfig } from './database-span-data.js';
+/**
+ * Creates the Nitro database plugin setup by instrumenting the configured database instances.
+ *
+ * Called from the version-specific plugin entry points (database.server.ts / database-legacy.server.ts)
+ * which supply the correct `useDatabase` import for their respective Nitro version.
+ */
+export declare function createDatabasePlugin(useDatabase: (name: string) => Database, databaseConfig: Record<string, DatabaseConnectionConfig>): void;