feat: populate span with additional attrs

Author: logaretm

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

@@ -13,13 +13,20 @@ import {
 import type { Database, PreparedStatement } from 'db0';
 // eslint-disable-next-line import/no-extraneous-dependencies
 import { defineNitroPlugin, useDatabase } from 'nitropack/runtime';
+import type { DatabaseConnectionConfig as DatabaseConfig } from 'nitropack/types';
 // @ts-expect-error - This is a virtual module
-import { databaseInstances } from '#sentry/database-config.mjs';
+import { databaseConfig } from '#sentry/database-config.mjs';
+import { getDatabaseSpanData } from '../utils/database';
 
 type MaybeInstrumentedDatabase = Database & {
   __sentry_instrumented__?: boolean;
 };
 
+interface DatabaseSpanData {
+  [key: string]: string | undefined;
+  'db.system.name': string;
+}
+
 /**
  * Keeps track of prepared statements that have been patched.
  */
@@ -35,12 +42,14 @@ const SENTRY_ORIGIN = 'auto.db.nuxt';
  */
 export default defineNitroPlugin(() => {
   try {
+    const _databaseConfig = databaseConfig as Record<string, 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);
+      instrumentDatabase(db, _databaseConfig[instance]);
     }
 
     debug.log('[Nitro Database Plugin]: Databases instrumented.');
@@ -55,17 +64,25 @@ export default defineNitroPlugin(() => {
   }
 });
 
-function instrumentDatabase(db: MaybeInstrumentedDatabase): void {
+/**
+ * Instruments a database instance with Sentry.
+ */
+function instrumentDatabase(db: MaybeInstrumentedDatabase, config?: DatabaseConfig): void {
   if (db.__sentry_instrumented__) {
     debug.log('[Nitro Database Plugin]: Database already instrumented. Skipping...');
     return;
   }
 
+  const metadata: DatabaseSpanData = {
+    'db.system.name': config?.connector ?? db.dialect,
+    ...getDatabaseSpanData(config),
+  };
+
   db.prepare = new Proxy(db.prepare, {
     apply(target, thisArg, args: Parameters<typeof db.prepare>) {
       const [query] = args;
 
-      return instrumentPreparedStatement(target.apply(thisArg, args), query, db.dialect);
+      return instrumentPreparedStatement(target.apply(thisArg, args), query, metadata);
     },
   });
 
@@ -75,7 +92,7 @@ function instrumentDatabase(db: MaybeInstrumentedDatabase): void {
   db.sql = new Proxy(db.sql, {
     apply(target, thisArg, args: Parameters<typeof db.sql>) {
       const query = args[0]?.[0] ?? '';
-      const opts = createStartSpanOptions(query, db.dialect);
+      const opts = createStartSpanOptions(query, metadata);
 
       return startSpan(
         opts,
@@ -87,7 +104,7 @@ function instrumentDatabase(db: MaybeInstrumentedDatabase): void {
   db.exec = new Proxy(db.exec, {
     apply(target, thisArg, args: Parameters<typeof db.exec>) {
       return startSpan(
-        createStartSpanOptions(args[0], db.dialect),
+        createStartSpanOptions(args[0], metadata),
         handleSpanStart(() => target.apply(thisArg, args), { query: args[0] }),
       );
     },
@@ -102,16 +119,20 @@ function instrumentDatabase(db: MaybeInstrumentedDatabase): void {
  * This is meant to be used as a top-level call, under the hood it calls `instrumentPreparedStatementQueries`
  * to patch the query methods. The reason for this abstraction is to ensure that the `bind` method is also patched.
  */
-function instrumentPreparedStatement(statement: PreparedStatement, query: string, dialect: string): PreparedStatement {
+function instrumentPreparedStatement(
+  statement: PreparedStatement,
+  query: string,
+  data: DatabaseSpanData,
+): PreparedStatement {
   // statement.bind() returns a new instance of D1PreparedStatement, so we have to patch it as well.
   // eslint-disable-next-line @typescript-eslint/unbound-method
   statement.bind = new Proxy(statement.bind, {
     apply(target, thisArg, args: Parameters<typeof statement.bind>) {
-      return instrumentPreparedStatementQueries(target.apply(thisArg, args), query, dialect);
+      return instrumentPreparedStatementQueries(target.apply(thisArg, args), query, data);
     },
   });
 
-  return instrumentPreparedStatementQueries(statement, query, dialect);
+  return instrumentPreparedStatementQueries(statement, query, data);
 }
 
 /**
@@ -120,7 +141,7 @@ function instrumentPreparedStatement(statement: PreparedStatement, query: string
 function instrumentPreparedStatementQueries(
   statement: PreparedStatement,
   query: string,
-  dialect: string,
+  data: DatabaseSpanData,
 ): PreparedStatement {
   if (patchedStatement.has(statement)) {
     return statement;
@@ -130,7 +151,7 @@ function instrumentPreparedStatementQueries(
   statement.get = new Proxy(statement.get, {
     apply(target, thisArg, args: Parameters<typeof statement.get>) {
       return startSpan(
-        createStartSpanOptions(query, dialect),
+        createStartSpanOptions(query, data),
         handleSpanStart(() => target.apply(thisArg, args), { query }),
       );
     },
@@ -140,7 +161,7 @@ function instrumentPreparedStatementQueries(
   statement.run = new Proxy(statement.run, {
     apply(target, thisArg, args: Parameters<typeof statement.run>) {
       return startSpan(
-        createStartSpanOptions(query, dialect),
+        createStartSpanOptions(query, data),
         handleSpanStart(() => target.apply(thisArg, args), { query }),
       );
     },
@@ -150,7 +171,7 @@ function instrumentPreparedStatementQueries(
   statement.all = new Proxy(statement.all, {
     apply(target, thisArg, args: Parameters<typeof statement.all>) {
       return startSpan(
-        createStartSpanOptions(query, dialect),
+        createStartSpanOptions(query, data),
         handleSpanStart(() => target.apply(thisArg, args), { query }),
       );
     },
@@ -203,14 +224,14 @@ function createBreadcrumb(query: string): void {
 /**
  * Creates a start span options object.
  */
-function createStartSpanOptions(query: string, dialect: string): StartSpanOptions {
+function createStartSpanOptions(query: string, data: DatabaseSpanData): StartSpanOptions {
   return {
     name: query,
     attributes: {
-      'db.system.name': dialect,
       'db.query.text': query,
       [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: SENTRY_ORIGIN,
       [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'db.query',
+      ...data,
     },
   };
 }

packages/nuxt/src/runtime/utils/database.ts

@@ -0,0 +1,46 @@
+import type { ConnectorName } from 'db0';
+import type { DatabaseConnectionConfig as DatabaseConfig } from 'nitropack/types';
+
+interface DatabaseSpanData {
+  [key: string]: string | number | undefined;
+}
+
+/**
+ * Extracts span attributes from the database configuration.
+ */
+export function getDatabaseSpanData(config?: DatabaseConfig): Partial<DatabaseSpanData> {
+  try {
+    if (!config?.connector) {
+      // Default to SQLite if no connector is configured
+      return {
+        'db.namespace': 'db.sqlite',
+      };
+    }
+
+    if (config.connector === 'postgresql' || config.connector === 'mysql2') {
+      return {
+        'server.address': config.options?.host,
+        'server.port': config.options?.port,
+      };
+    }
+
+    if (config.connector === 'pglite') {
+      return {
+        'db.namespace': config.options?.dataDir,
+      };
+    }
+
+    if ((['better-sqlite3', 'bun', 'sqlite', 'sqlite3'] as ConnectorName[]).includes(config.connector)) {
+      return {
+        // DB is the default file name in nitro for sqlite-like connectors
+        'db.namespace': `${config.options?.name ?? 'db'}.sqlite`,
+      };
+    }
+
+    return {};
+  } catch {
+    // This is a best effort to get some attributes, so it is not an absolute must
+    // Since the user can configure invalid options, we should not fail the whole instrumentation.
+    return {};
+  }
+}

packages/nuxt/src/vite/databaseConfig.ts

@@ -21,15 +21,16 @@ export function addDatabaseInstrumentation(nitro: NitroConfig): void {
   /**
    * This is a different option than the one in `experimental.database`, this configures multiple database instances.
    * keys represent database names to be passed to `useDatabase(name?)`.
+   * We also use the config to populate database span attributes.
    * https://nitro.build/guide/database#configuration
    */
-  const databaseInstances = Object.keys(nitro.database || { default: {} });
+  const databaseConfig = nitro.database || { default: {} };
 
   // Create a virtual module to pass this data to runtime
   addServerTemplate({
     filename: '#sentry/database-config.mjs',
     getContents: () => {
-      return `export const databaseInstances = ${JSON.stringify(databaseInstances)};`;
+      return `export const databaseConfig = ${JSON.stringify(databaseConfig)};`;
     },
   });