feat: initial db instrumentation

Author: logaretm

packages/nuxt/src/module.ts

@@ -10,6 +10,7 @@ import { consoleSandbox } from '@sentry/core';
 import * as path from 'path';
 import type { SentryNuxtModuleOptions } from './common/types';
 import { addDynamicImportEntryFileWrapper, addSentryTopImport, addServerConfigToBuild } from './vite/addServerConfig';
+import { addDatabaseInstrumentation } from './vite/databaseConfig';
 import { addMiddlewareImports, addMiddlewareInstrumentation } from './vite/middlewareConfig';
 import { setupSourceMaps } from './vite/sourceMaps';
 import { addOTelCommonJSImportAlias, findDefaultSdkInitFile } from './vite/utils';
@@ -126,6 +127,8 @@ export default defineNuxtModule<ModuleOptions>({
     // Preps the the middleware instrumentation module.
     if (serverConfigFile) {
       addMiddlewareImports();
+
+      addDatabaseInstrumentation(nuxt);
     }
 
     nuxt.hooks.hook('nitro:init', nitro => {

packages/nuxt/src/runtime/plugins/database.server.ts

@@ -0,0 +1,78 @@
+import {
+  type SpanAttributes,
+  captureException,
+  debug,
+  flushIfServerless,
+  SEMANTIC_ATTRIBUTE_SENTRY_OP,
+  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
+  SPAN_STATUS_ERROR,
+  SPAN_STATUS_OK,
+  startSpan,
+} from '@sentry/core';
+import type { Database } from 'db0';
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { defineNitroPlugin, useDatabase } from 'nitropack/runtime';
+
+/**
+ * Creates a Nitro plugin that instruments the database calls.
+ */
+export default defineNitroPlugin(() => {
+  const db = useDatabase();
+
+  debug.log('@sentry/nuxt: Instrumenting database...');
+
+  instrumentDatabase(db);
+
+  debug.log('@sentry/nuxt: Database instrumented.');
+});
+
+function instrumentDatabase(db: Database): void {
+  db.sql = new Proxy(db.sql, {
+    apply(target, thisArg, args: Parameters<typeof db.sql>) {
+      const query = args[0]?.[0];
+      const attributes = getSpanAttributes(db, query);
+
+      return startSpan(
+        {
+          name: query || 'db.query',
+          attributes,
+        },
+        async span => {
+          try {
+            const result = await target.apply(thisArg, args);
+            span.setStatus({ code: SPAN_STATUS_OK });
+
+            return result;
+          } catch (error) {
+            span.setStatus({ code: SPAN_STATUS_ERROR, message: 'internal_error' });
+            captureException(error, {
+              mechanism: {
+                handled: false,
+                type: attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN],
+              },
+            });
+
+            // Re-throw the error to be handled by the caller
+            throw error;
+          } finally {
+            await flushIfServerless();
+          }
+        },
+      );
+    },
+  });
+}
+
+function getSpanAttributes(db: Database, query?: string): SpanAttributes {
+  const attributes: SpanAttributes = {
+    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.db.nuxt',
+    [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'db',
+    'db.system': db.dialect,
+  };
+
+  if (query) {
+    attributes['db.query'] = query;
+  }
+
+  return attributes;
+}

packages/nuxt/src/vite/databaseConfig.ts

@@ -0,0 +1,19 @@
+import { addServerPlugin, createResolver } from '@nuxt/kit';
+import { consoleSandbox } from '@sentry/core';
+import type { Nuxt } from 'nuxt/schema';
+
+/**
+ * Sets up the database instrumentation.
+ */
+export function addDatabaseInstrumentation(nuxt: Nuxt): void {
+  if (!nuxt.options.nitro?.database) {
+    consoleSandbox(() => {
+      // eslint-disable-next-line no-console
+      console.log('[Sentry] No database configuration found. Skipping database instrumentation.');
+    });
+
+    return;
+  }
+
+  addServerPlugin(createResolver(import.meta.url).resolve('./runtime/plugins/database.server'));
+}