feat: track Prisma and better-sqlite3 (Drizzle) without code changes

Author: thelastbackspace

CHANGELOG.md

@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+- **Prisma without code changes:** `traceperf/auto` and `traceperf run` track every Prisma Client call (`prisma.User.findMany`, raw queries as `prisma.raw.$queryRaw SELECT users`), including clients made with `$extends`. `instrumentPrisma(tp, require('@prisma/client'))` does it by hand. `prismaExtension` steps aside when this is active, so calls are not counted twice.
+- **better-sqlite3, and so Drizzle on SQLite:** `instrumentBetterSqlite3`; auto-detected. Drizzle on pg or mysql2 was already covered through those drivers.
+- N+1 fixes name the Prisma (`include`, `where: { id: { in } }`) and Drizzle (`inArray`) way.
+
 ## [1.4.0] - 2026-11-06
 
 ### Added

README.md

@@ -13,7 +13,7 @@
 - **Honest numbers.** You get total, self and synchronous time for each call. Detailed mode flags calls that blocked the event loop.
 - **Production-ready.** Stats are bounded per label (p50/p95/p99), sampling is built in, and `enabled: false` makes tracking a pass-through costing ~40 ns.
 - **Gets data out.** Chrome/Perfetto traces, OpenTelemetry spans, JSON lines, or your own `onComplete` hook.
-- **Zero-effort coverage.** One line tracks every `fetch`, HTTP request or query, for pg, mysql2, MongoDB/Mongoose, ioredis, Prisma and the AWS SDK.
+- **Zero-effort coverage.** One line tracks every `fetch`, HTTP request or query, for pg, mysql2, MongoDB/Mongoose, ioredis, Prisma, better-sqlite3 (and Drizzle on any of these drivers) and the AWS SDK.
 - **Built for teams.** It feeds Prometheus, catches regressions in CI (`traceperf compare --fail`), shows up in Chrome DevTools, and produces HTML flame-chart reports.
 - **Fits your stack.** Express, Fastify, Hono, Koa, NestJS, Next.js route handlers, decorators, CommonJS, ESM, TypeScript, browsers, Node.js 14+, Bun, Deno, Cloudflare Workers and Vercel Edge. There are no runtime dependencies.
 
@@ -99,7 +99,7 @@ The same naming works without `run`: `TRACEPERF_PROFILE_BLOCKING=1 node --requir
 
 ## No code changes: `traceperf/auto`
 
-Start your app with traceperf preloaded. Every incoming HTTP request becomes a tree, with the outgoing `http`/`fetch` calls and the `pg`, `mysql2`, MongoDB/Mongoose and `ioredis` queries it made nested under it:
+Start your app with traceperf preloaded. Every incoming HTTP request becomes a tree, with the outgoing `http`/`fetch` calls and the `pg`, `mysql2`, MongoDB/Mongoose, `ioredis`, Prisma and `better-sqlite3` queries it made nested under it (Drizzle runs on these drivers, so its queries show up too):
 
 <!-- docs:skip -->
 ```bash
@@ -125,7 +125,7 @@ Database clients are only instrumented when your `package.json` lists them. Conf
 | `TRACEPERF_THRESHOLD=50` | Only report calls taking at least 50 ms |
 | `TRACEPERF_SAMPLE_RATE=0.1` | Track 10% of requests |
 | `TRACEPERF_IGNORE=^/health` | Regular expression of request paths not to track |
-| `TRACEPERF_DISABLE=http,fetch` | Skip targets: `server`, `http`, `fetch`, `pg`, `mysql2`, `mongodb`, `ioredis` |
+| `TRACEPERF_DISABLE=http,fetch` | Skip targets: `server`, `http`, `fetch`, `pg`, `mysql2`, `mongodb`, `ioredis`, `prisma`, `better-sqlite3` |
 | `TRACEPERF_SILENT=1` / `TRACEPERF_SUMMARY=0` / `TRACEPERF_QUIET=1` | No per-request trees / no exit summary / no startup line |
 | `TRACEPERF_ENABLED=0` | Load nothing |
 
@@ -203,13 +203,15 @@ Ready-made helpers for popular clients. Pass the module you already use; tracepe
 
 <!-- docs:skip -->
 ```javascript
-const { instrumentPg, instrumentMysql2, instrumentMongo, instrumentRedis, instrumentAwsClient, prismaExtension } = require('traceperf');
+const { instrumentPg, instrumentMysql2, instrumentMongo, instrumentRedis, instrumentAwsClient, instrumentPrisma, instrumentBetterSqlite3, prismaExtension } = require('traceperf');
 
 instrumentPg(tp, require('pg'));                    // "pg SELECT users" (Pool.query included)
 instrumentMysql2(tp, require('mysql2'));            // "mysql UPDATE orders" (callback and promise APIs)
 instrumentMongo(tp, require('mongodb'));            // "mongo find users", "mongo insertOne users"
 instrumentMongo(tp, require('mongoose').mongo);     // Mongoose uses its own copy of the driver
 instrumentRedis(tp, require('ioredis'));            // "redis GET"
+instrumentPrisma(tp, require('@prisma/client'));    // "prisma.User.findMany" (every client, $extends included)
+instrumentBetterSqlite3(tp, require('better-sqlite3')); // "sqlite SELECT users" (synchronous: slow ones show as blocking)
 instrumentAwsClient(tp, s3Client);                  // "aws S3.GetObject"
 const prisma = new PrismaClient().$extends(prismaExtension(tp)); // "prisma.User.findMany"
 ```

src/__tests__/drivers.test.ts

@@ -15,6 +15,9 @@ import {
   createTracePerf,
   ExecutionRecord,
   instrumentAwsClient,
+  instrumentBetterSqlite3,
+  instrumentPrisma,
+  prismaExtension,
   instrumentMysql2,
   instrumentPg,
   instrumentRedis,
@@ -248,3 +251,94 @@ describe('instrumentAwsClient (real AWS SDK v3 client, local endpoint)', () => {
     expect(labels(roots[0])).toEqual(['aws S3.ListBuckets']);
   });
 });
+
+describe('instrumentPrisma (client shaped like Prisma 6: every call goes through _request)', () => {
+  // Checked by hand against @prisma/client 6.19 (model calls, $extends clients, raw queries)
+  class FakePrisma {
+    _originalClient = this;
+    _request(params: any): Promise<unknown> {
+      return new Promise((resolve, reject) => setTimeout(() => (params.args?.fail ? reject(new Error('P2002')) : resolve([])), 2));
+    }
+    get user() { return { findMany: (args?: any) => this._request({ model: 'User', action: 'findMany', clientMethod: 'user.findMany', args }) }; }
+    $queryRawUnsafe(sql: string) { return this._request({ action: 'queryRaw', clientMethod: '$queryRawUnsafe', args: [sql] }); }
+    $extends() { return Object.create(this._originalClient, { _appliedParent: { value: this } }); }
+  }
+
+  test('model calls, raw queries, extended clients and failures', async () => {
+    const { tp, roots } = setup();
+    const uninstall = instrumentPrisma(tp, { PrismaClient: FakePrisma });
+    expect(instrumentPrisma(tp, FakePrisma)).toBeInstanceOf(Function); // idempotent
+    const prisma = new FakePrisma().$extends();
+    await tp.track(async () => {
+      await prisma.user.findMany();
+      await prisma.$queryRawUnsafe('SELECT * FROM "User" WHERE id = 1');
+      await prisma.user.findMany({ fail: true }).catch(() => undefined);
+    }, { label: 'GET /users' });
+    expect(labels(roots[0])).toEqual(['prisma.User.findMany', 'prisma.raw.$queryRawUnsafe SELECT User', 'prisma.User.findMany']);
+    expect(roots[0].children[2].error).toBeInstanceOf(Error);
+    uninstall();
+    roots.length = 0;
+    await tp.track(() => prisma.user.findMany(), { label: 'after' });
+    expect(labels(roots[0])).toEqual([]);
+  });
+
+  test('prismaExtension stands aside while the client is patched (no double counting)', async () => {
+    const { tp, roots } = setup();
+    const ext = prismaExtension(tp).query.$allModels.$allOperations;
+    const call = () => ext({ model: 'User', operation: 'findMany', args: {}, query: async () => [] });
+    const uninstall = instrumentPrisma(tp, FakePrisma);
+    await tp.track(() => call(), { label: 'patched' });
+    uninstall();
+    await tp.track(() => call(), { label: 'extension only' });
+    expect(roots.map(r => [r.label, labels(r)])).toEqual([['patched', []], ['extension only', ['prisma.User.findMany']]]);
+  });
+
+  test('a client instance works too; unknown objects are ignored', async () => {
+    const { tp, roots } = setup();
+    const client = new FakePrisma();
+    const uninstall = instrumentPrisma(tp, client);
+    await tp.track(() => client.user.findMany(), { label: 'r' });
+    expect(labels(roots[0])).toEqual(['prisma.User.findMany']);
+    uninstall();
+    expect(() => instrumentPrisma(tp, {})()).not.toThrow();
+    expect(() => instrumentPrisma(tp, undefined)()).not.toThrow();
+  });
+});
+
+describe('instrumentBetterSqlite3 (database shaped like better-sqlite3: Statement class not exported)', () => {
+  // Checked by hand against better-sqlite3 12 with Drizzle
+  class Statement {
+    constructor(public source: string) {}
+    run(..._a: unknown[]) { return { changes: 1 }; }
+    get(..._a: unknown[]) { return { id: 1 }; }
+    all() {
+      if (this.source.includes('missing')) throw new Error('no such table: missing');
+      return [{ id: 1 }];
+    }
+    iterate() { return [][Symbol.iterator](); }
+    raw() { return this; }
+  }
+  class Database {
+    prepare(sql: string) { return new Statement(sql); }
+    exec(sql: string) { return sql ? this : this; }
+  }
+
+  test('statements and exec are tracked as synchronous calls', () => {
+    const { tp, roots } = setup();
+    const uninstall = instrumentBetterSqlite3(tp, Database);
+    const db = new Database();
+    tp.track(() => {
+      db.prepare('SELECT * FROM users').all();
+      db.prepare('INSERT INTO posts (t) VALUES (?)').run('a');
+      db.prepare('select id from users where id = ?').raw().get(1);
+      db.exec('CREATE TABLE t (a)');
+      try { db.prepare('SELECT * FROM missing').all(); } catch { /* expected */ }
+    }, { label: 'job' });
+    expect(labels(roots[0])).toEqual(['sqlite SELECT users', 'sqlite INSERT posts', 'sqlite SELECT users', 'sqlite CREATE t', 'sqlite SELECT missing']);
+    expect(roots[0].children[4].error).toBeInstanceOf(Error);
+    uninstall();
+    roots.length = 0;
+    tp.track(() => { db.prepare('SELECT * FROM users').all(); }, { label: 'after' });
+    expect(labels(roots[0])).toEqual([]);
+  });
+});

src/auto.ts

@@ -12,11 +12,11 @@
 import type { OptimizedPerformanceMonitor } from './core/optimized-performance-monitor';
 import { loadNodeBuiltin } from './core/env';
 import { HttpServerInstrumentOptions, instrumentFetch, instrumentHttp, instrumentHttpServer, Uninstall } from './instrument';
-import { instrumentMongo, instrumentMysql2, instrumentPg, instrumentRedis } from './drivers';
+import { instrumentBetterSqlite3, instrumentMongo, instrumentMysql2, instrumentPg, instrumentPrisma, instrumentRedis } from './drivers';
 
-export type AutoTarget = 'server' | 'http' | 'fetch' | 'pg' | 'mysql2' | 'mongodb' | 'ioredis';
+export type AutoTarget = 'server' | 'http' | 'fetch' | 'pg' | 'mysql2' | 'mongodb' | 'ioredis' | 'prisma' | 'better-sqlite3';
 
-export const AUTO_TARGETS: AutoTarget[] = ['server', 'http', 'fetch', 'pg', 'mysql2', 'mongodb', 'ioredis'];
+export const AUTO_TARGETS: AutoTarget[] = ['server', 'http', 'fetch', 'pg', 'mysql2', 'mongodb', 'ioredis', 'prisma', 'better-sqlite3'];
 
 export interface AutoInstrumentOptions {
   /** Targets to skip, e.g. ['http'] */
@@ -94,6 +94,8 @@ export function autoInstrument(tp: OptimizedPerformanceMonitor, options: AutoIns
     const load = (name: string) => appRequire(name);
     if (deps.names.has('pg')) add('pg', () => instrumentPg(tp, load('pg')));
     if (deps.names.has('mysql2')) add('mysql2', () => instrumentMysql2(tp, load('mysql2')));
+    if (deps.names.has('better-sqlite3')) add('better-sqlite3', () => instrumentBetterSqlite3(tp, load('better-sqlite3')));
+    if (deps.names.has('@prisma/client')) add('prisma', () => instrumentPrisma(tp, load('@prisma/client')));
     if (deps.names.has('ioredis')) add('ioredis', () => instrumentRedis(tp, load('ioredis')));
     if (deps.names.has('mongodb')) add('mongodb', () => instrumentMongo(tp, load('mongodb')));
     else if (deps.names.has('mongoose')) {

src/core/explain.ts

@@ -385,6 +385,8 @@ function suggestFix(f: Finding, hotspots?: Record<string, BlockingHotspot[]>): s
     }
     case 'repeated': {
       const label = labels[0] || '';
+      if (/^prisma\./.test(label)) return `load them in one call: include the relation in the parent query (include: { ... }), or findMany({ where: { id: { in: ids } } }) and match results in memory`;
+      if (/^sqlite /.test(label)) return `load them in one query: WHERE id IN (...) (in Drizzle: inArray(column, ids), or db.query with: { ... }); then match results in memory`;
       return SQL.test(label)
         ? `load them in one query: WHERE id IN (...) (or = ANY($1) in Postgres), or your ORM's include/join; then match results in memory`
         : `make one batched call instead of one per item (a bulk API, or DataLoader to collect the calls of one tick)`;

src/drivers.ts

@@ -219,3 +219,76 @@ export function instrumentAwsClient(tp: OptimizedPerformanceMonitor, client: any
     delete client[PATCHED];
   };
 }
+
+/** The prototype that holds Prisma Client's internal `_request`, from a module, class or client */
+function prismaPrototype(target: any): any {
+  if (!target) return undefined;
+  const candidates = [
+    target.PrismaClient && target.PrismaClient.prototype, // require('@prisma/client')
+    typeof target === 'function' ? target.prototype : undefined, // the PrismaClient class
+    target._originalClient && Object.getPrototypeOf(target._originalClient), // a client (extended or not)
+    typeof target === 'object' ? Object.getPrototypeOf(target) : undefined,
+  ];
+  return candidates.find(p => p && typeof p._request === 'function');
+}
+
+/**
+ * Prisma Client (4 to 6, and newer clients that keep the same runtime):
+ * every model call and raw query, "prisma.User.findMany",
+ * "prisma.raw.$queryRaw SELECT users". Pass the module, the PrismaClient class
+ * or a client; clients made with $extends are covered too.
+ *
+ *   instrumentPrisma(tp, require('@prisma/client'));
+ */
+export function instrumentPrisma(tp: OptimizedPerformanceMonitor, prisma: any, options: DriverOptions = {}): Uninstall {
+  const restores: Uninstall[] = [];
+  patchMethod(prismaPrototype(prisma), '_request', original => function (this: unknown, params: any, ...rest: unknown[]) {
+    const p = params || {};
+    let label: string;
+    // Same labels as prismaExtension: "prisma.User.findMany", "prisma.raw.$queryRaw SELECT users"
+    if (p.model) label = `prisma.${p.model}.${p.action}`;
+    else {
+      const method = String(p.clientMethod || p.action || 'request');
+      const sql = Array.isArray(p.args) ? p.args[0] : p.args;
+      label = /Raw/.test(method) && sql ? `prisma.raw.${method} ${sqlLabel(sql)}` : `prisma.raw.${method}`;
+    }
+    return trackCall(tp, label, options, this, original, [params, ...rest], -1);
+  }, restores);
+  if (restores.length === 0) return () => undefined;
+  const g = globalThis as any;
+  const key = Symbol.for('traceperf.prisma.patched');
+  g[key] = (g[key] || 0) + 1;
+  return () => {
+    g[key]--;
+    restores.forEach(r => r());
+  };
+}
+
+/**
+ * better-sqlite3 (and Drizzle on it): every statement, "sqlite SELECT users".
+ * These calls are synchronous, so slow ones show up as blocking.
+ *
+ *   instrumentBetterSqlite3(tp, require('better-sqlite3'));
+ */
+export function instrumentBetterSqlite3(tp: OptimizedPerformanceMonitor, Database: any, options: DriverOptions = {}): Uninstall {
+  const restores: Uninstall[] = [];
+  const proto = Database && Database.prototype;
+  const patchStatement = (statement: any) => {
+    // The Statement class is not exported: patch its prototype on first prepare()
+    const sp = statement && Object.getPrototypeOf(statement);
+    for (const method of ['run', 'get', 'all', 'iterate']) {
+      patchMethod(sp, method, original => function (this: any, ...args: unknown[]) {
+        return trackCall(tp, `sqlite ${sqlLabel(this && this.source)}`, options, this, original, args, -1);
+      }, restores);
+    }
+  };
+  patchMethod(proto, 'prepare', original => function (this: unknown, ...args: unknown[]) {
+    const statement = original.apply(this, args);
+    patchStatement(statement);
+    return statement;
+  }, restores);
+  patchMethod(proto, 'exec', original => function (this: unknown, ...args: unknown[]) {
+    return trackCall(tp, `sqlite ${sqlLabel(args[0])}`, options, this, original, args, -1);
+  }, restores);
+  return () => restores.forEach(r => r());
+}

src/instrument.ts

@@ -197,6 +197,8 @@ export function prismaExtension(tp: OptimizedPerformanceMonitor, options: TrackO
     query: {
       $allModels: {
         $allOperations(params: { model?: string; operation: string; args: unknown; query: (args: unknown) => Promise<unknown> }) {
+          // Already tracked by instrumentPrisma / traceperf/auto: don't count it twice
+          if ((globalThis as any)[Symbol.for('traceperf.prisma.patched')] > 0) return params.query(params.args);
           const label = options.label ?? `prisma.${params.model ?? 'raw'}.${params.operation}`;
           return tp.track(() => params.query(params.args), { ...options, label });
         },

src/register.ts

@@ -12,7 +12,8 @@
  *   TRACEPERF_SAMPLE_RATE=0.1      track 10% of top-level calls
  *   TRACEPERF_SILENT=1             no per-call console trees
  *   TRACEPERF_SUMMARY=0            no stats + explanations on exit (default on)
- *   TRACEPERF_DISABLE=http,fetch   skip targets (server, http, fetch, pg, mysql2, mongodb, ioredis)
+ *   TRACEPERF_DISABLE=http,fetch   skip targets (server, http, fetch, pg, mysql2, mongodb, ioredis,
+ *                                  prisma, better-sqlite3)
  *   TRACEPERF_IGNORE=^/health      regular expression of request paths not to track
  *   TRACEPERF_QUIET=1              no "traceperf: tracking ..." line at startup
  *   TRACEPERF_PROFILE_BLOCKING=1   sample the CPU (V8 profiler) to name the