peekinside 0.0.0-stage → 1.2.0

package/src/instrumentation/pg.js

@@ -0,0 +1,218 @@
+/**
+ * node-postgres (pg 8) queries on the request's timeline. Knex, Sequelize, TypeORM, Drizzle,
+ * Kysely and Prisma's pg adapter all send their queries through it.
+ *
+ * - Client.prototype.query starts the span, for every calling form: text, a config object, a
+ *   Submittable (pg.Query, pg-cursor, pg-query-stream), with a callback or a promise. It returns
+ *   exactly what pg returns: the promise pg created, the Submittable, or undefined.
+ * - The span ends when the query does, in Query#handleReadyForQuery / Query#handleError: the
+ *   methods pg's client calls on every query, whatever form it was sent in. Nothing is added to the
+ *   promise the app gets, and no listener to the query.
+ * - To know which span a query belongs to, Query.prototype gets a `callback` accessor: the Query
+ *   constructor assigns `this.callback`, inside client.query(), and the accessor turns that into
+ *   the same own property a plain assignment would create, while noting the span.
+ * - A pool hands a released client to the next waiting connect() from inside another request's
+ *   handling; queued callbacks are bound to the context they were queued in, so each query lands
+ *   on its own request's timeline. pool.query() also reads the caller, which a pooled query run
+ *   from a callback can no longer find on the stack.
+ */
+
+import { AsyncResource } from 'async_hooks';
+import { Caller } from '../timeline/caller.js';
+import { Timeline } from '../timeline/timeline.js';
+import { Operation } from './operation.js';
+import { ownerOf, patchMethod } from './patch.js';
+
+const kSpan = Symbol('peekInside.querySpan');
+const kAccessor = Symbol('peekInside.callbackAccessor');
+// The span of the query being created inside client.query(), for the callback accessor.
+let pending = null;
+
+/**
+ * Patches a pg module.
+ */
+export class PgInstrumentation {
+  /**
+   * @param {*} pg - What require('pg') returns
+   * @returns {boolean} Whether it was recognized and patched
+   */
+  static patch(pg) {
+    try {
+      const Client = pg && pg.Client;
+      if (typeof Client !== 'function' || !Client.prototype || typeof Client.prototype.query !== 'function') return false;
+      const Query = pg.Query || Client.Query;
+      if (typeof Query === 'function') patchQuery(Query.prototype);
+      patchClient(ownerOf(Client.prototype, 'query'), Query);
+      if (typeof pg.Pool === 'function') patchPool(pg.Pool.prototype);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+}
+
+function patchClient(owner, Query) {
+  patchMethod(owner, 'query', (original) => function query(config, values, callback) {
+    const timeline = Timeline.current();
+    if (!timeline || config === null || config === undefined || !timeline.settings.captureQueries) {
+      return original.apply(this, arguments);
+    }
+
+    let text;
+    let params;
+    try {
+      if (typeof config === 'string') {
+        text = config;
+        params = Array.isArray(values) ? values : undefined;
+      } else if (typeof config === 'object') {
+        // pg-query-stream keeps its statement on the cursor it wraps.
+        const source = typeof config.text !== 'string' && config.cursor && typeof config.cursor.text === 'string' ? config.cursor : config;
+        text = source.text;
+        params = Array.isArray(source.values) ? source.values : Array.isArray(values) ? values : undefined;
+      }
+    } catch (error) {
+      text = undefined;
+    }
+    if (typeof text !== 'string') return original.apply(this, arguments);
+
+    const span = timeline.query({ system: 'postgresql', client: 'pg', text, params, operation: Operation.noteQuery() });
+    if (!span) return original.apply(this, arguments);
+
+    const submittable = typeof config === 'object' && typeof config.submit === 'function';
+    const previous = pending;
+    pending = submittable ? null : span;
+    let returned = false;
+    try {
+      const result = original.apply(this, arguments);
+      returned = true;
+      return result;
+    } finally {
+      // The accessor took the span if a Query was created; otherwise it is still here.
+      const untaken = pending === span;
+      pending = previous;
+      if (!returned) {
+        span.cancel();
+      } else if (submittable) {
+        attach(config, span, Query);
+      } else if (untaken) {
+        // A pg version whose Query doesn't assign callback in its constructor: no way to see the
+        // end, so the span stays open (its duration is null).
+      }
+    }
+  });
+}
+
+// Query.prototype: the end of every query, and the accessor that tags new queries with their span.
+function patchQuery(proto) {
+  if (!proto || proto[kAccessor]) return;
+  const existing = Object.getOwnPropertyDescriptor(proto, 'callback');
+  if (!existing) {
+    Object.defineProperty(proto, 'callback', {
+      configurable: true,
+      enumerable: false,
+      get() {
+        return undefined;
+      },
+      set(value) {
+        Object.defineProperty(this, 'callback', { value, writable: true, enumerable: true, configurable: true });
+        if (pending && !this[kSpan]) {
+          Object.defineProperty(this, kSpan, { value: pending, writable: true, configurable: true });
+          pending = null;
+        }
+      }
+    });
+  }
+  Object.defineProperty(proto, kAccessor, { value: true });
+
+  patchMethod(proto, 'handleReadyForQuery', (original) => function handleReadyForQuery(con) {
+    const span = this[kSpan];
+    // A query canceled by an error ends in handleError, which this calls.
+    if (span && !this._canceledDueToError) {
+      this[kSpan] = null;
+      span.end({ rows: rowsOf(this._results) });
+    }
+    return original.apply(this, arguments);
+  });
+  patchMethod(proto, 'handleError', (original) => function handleError(err, connection) {
+    const span = this[kSpan];
+    if (span) {
+      this[kSpan] = null;
+      span.end({ error: this._canceledDueToError || err });
+    }
+    return original.apply(this, arguments);
+  });
+}
+
+// A Submittable the app created: pg.Query instances end through the patched prototype; other
+// classes (pg-cursor, pg-query-stream) through their own handlers, wrapped on the instance.
+function attach(submittable, span, Query) {
+  try {
+    Object.defineProperty(submittable, kSpan, { value: span, writable: true, configurable: true });
+    if (typeof Query === 'function' && submittable instanceof Query) return;
+    for (const name of ['handleReadyForQuery', 'handleError']) {
+      const handler = submittable[name];
+      if (typeof handler !== 'function') continue;
+      submittable[name] = function () {
+        const current = this[kSpan];
+        if (current) {
+          this[kSpan] = null;
+          // A cursor reads in batches: its last result holds only the last batch, so the row
+          // count isn't known.
+          current.end(name === 'handleError' ? { error: arguments[0] } : {});
+        }
+        return handler.apply(this, arguments);
+      };
+    }
+  } catch (error) {
+    span.end();
+  }
+}
+
+// pg-pool: queued callbacks run in the context they were queued in; pool.query() reads the caller.
+function patchPool(proto) {
+  // Bound whatever the caller's context: otherwise a callback queued outside any request (or by a
+  // request that has already answered) runs in the context of the request that freed the client.
+  patchMethod(ownerOf(proto, 'connect'), 'connect', (original) => function connect(cb) {
+    if (typeof cb === 'function') {
+      return original.call(this, AsyncResource.bind(cb));
+    }
+    return original.apply(this, arguments);
+  });
+  patchMethod(ownerOf(proto, 'query'), 'query', (original) => function query(text, values, cb) {
+    const timeline = Timeline.current();
+    if (!timeline || !timeline.settings.captureQueries) return original.apply(this, arguments);
+    let sql;
+    try {
+      sql = typeof text === 'string' ? text : text && typeof text === 'object' ? text.text : undefined;
+    } catch (error) {
+      sql = undefined;
+    }
+    if (typeof sql !== 'string') return original.apply(this, arguments);
+    const key = Timeline.sqlFingerprint(sql, 'postgresql');
+    // Inside a Prisma operation, the caller is the line that made the Prisma call, when known.
+    if (!timeline.needsCaller(key) || Operation.caller()) return original.apply(this, arguments);
+    const caller = timeline.settings.caller.capture();
+    const args = arguments;
+    return Caller.withHint({ key, caller }, () => original.apply(this, args));
+  });
+}
+
+// Rows returned or affected: one Result, or one per statement of a multi-statement query.
+function rowsOf(results) {
+  try {
+    const list = Array.isArray(results) ? results : [results];
+    let total = 0;
+    let known = false;
+    for (const result of list) {
+      if (!result) continue;
+      const count = Number.isInteger(result.rowCount) ? result.rowCount : Array.isArray(result.rows) ? result.rows.length : null;
+      if (count !== null) {
+        total += count;
+        known = true;
+      }
+    }
+    return known ? total : null;
+  } catch (error) {
+    return null;
+  }
+}

package/src/instrumentation/prisma.js

@@ -0,0 +1,181 @@
+/**
+ * Prisma Client operations on the request's timeline.
+ *
+ * Every Prisma Client call (prisma.user.findMany(), $queryRaw, ...) goes through the client's
+ * _request(), which gets the model, the action, the arguments and the call site Prisma captured
+ * where the app made the call.
+ *
+ * - With a query engine (Prisma 5 and 6 without driver adapters), the database work happens
+ *   inside the engine, out of reach: each operation is one span, such as
+ *   `User.findMany({ where: { id: ? }, include: { posts: ? } })`, with the arguments, masked, as
+ *   its parameters. Raw queries ($queryRaw, $executeRaw) are recorded as their SQL and values.
+ * - With a driver adapter (pg, mysql2 underneath), the driver's queries are recorded by the pg and
+ *   mysql2 integrations, with the operation that ran them ("User.findMany") and its caller (also
+ *   for the queries Prisma runs on its own, an include's); the operation itself isn't recorded, so
+ *   nothing is counted twice. Prisma 6 runs adapters from its WASM engine, outside the request's
+ *   context, where the driver queries can't be told apart: an operation none of whose queries
+ *   were seen is recorded as a whole, as with the query engine.
+ *
+ * The caller comes from Prisma's call site: Prisma runs the operation lazily, when its promise is
+ * awaited, by which time the app's frame is no longer on the stack. Without a call site
+ * (errorFormat "minimal"), the caller is unknown.
+ */
+
+import { performance } from 'perf_hooks';
+import { Shape } from '../timeline/shape.js';
+import { Timeline } from '../timeline/timeline.js';
+import { Operation } from './operation.js';
+import { ownerOf, patchMethod } from './patch.js';
+
+const SYSTEMS = { postgresql: 'postgresql', postgres: 'postgresql', cockroachdb: 'postgresql', mysql: 'mysql', sqlite: 'sqlite', sqlserver: 'sqlserver', mongodb: 'mongodb' };
+const RAW = new Set(['queryRaw', 'executeRaw']);
+const SINGLE = /^(findUnique|findFirst|findUniqueOrThrow|findFirstOrThrow|create|update|upsert|delete)$/;
+
+/**
+ * Patches Prisma Client.
+ */
+export class PrismaInstrumentation {
+  /**
+   * @param {*} target - A PrismaClient class, a PrismaClient instance, or the @prisma/client module
+   * @returns {boolean} Whether it was recognized and patched
+   */
+  static patch(target) {
+    try {
+      const proto = prototypeOf(target);
+      if (!proto) return false;
+      patchMethod(ownerOf(proto, '_request'), '_request', (original) => function _request(params) {
+        const timeline = Timeline.current();
+        if (!timeline || !timeline.settings.captureQueries || !params || typeof params !== 'object') {
+          return original.apply(this, arguments);
+        }
+        const action = String(params.action || '');
+        const name = params.model ? `${params.model}.${action}` : String(params.clientMethod || action || 'query');
+        const args = arguments;
+
+        // The span's description, or null if the call can't be described (it runs unrecorded).
+        const describe = (startedAt) => {
+          try {
+            const statement = RAW.has(action) ? rawStatement(params.args, this._activeProvider) : null;
+            return {
+              system: SYSTEMS[this._activeProvider] || 'other',
+              client: 'prisma',
+              text: statement ? statement.text : `${name}(${Shape.of(params.args)})`,
+              sql: Boolean(statement),
+              params: statement ? statement.values : params.args,
+              caller: () => callerOf(timeline.settings.caller, params.callsite),
+              startedAt
+            };
+          } catch (error) {
+            return null;
+          }
+        };
+
+        // A driver adapter: the driver integrations record the queries, labeled with the operation
+        // and with its caller.
+        if (usesAdapter(this)) {
+          const operation = { name, queries: 0, caller: params.callsite ? () => callerOf(timeline.settings.caller, params.callsite) : null };
+          const startedAt = performance.now();
+          const result = Operation.run(operation, () => original.apply(this, args));
+          if (!result || typeof result.then !== 'function') return result;
+          // None of its queries was seen: record the operation itself, from its start.
+          const settle = (outcome) => {
+            if (operation.queries > 0) return;
+            const description = describe(startedAt);
+            const span = description && timeline.query(description);
+            if (span) span.end(outcome);
+          };
+          return result.then(
+            (value) => {
+              settle({ rows: rowsOf(action, value) });
+              return value;
+            },
+            (error) => {
+              settle({ error });
+              throw error;
+            }
+          );
+        }
+
+        const description = describe(performance.now());
+        const span = description && timeline.query(description);
+        if (!span) return original.apply(this, arguments);
+
+        let result;
+        let returned = false;
+        try {
+          result = original.apply(this, arguments);
+          returned = true;
+        } finally {
+          if (!returned) span.cancel();
+        }
+        // Prisma's own promise, awaited by its PrismaPromise: not the one the app holds.
+        if (result && typeof result.then === 'function') {
+          return result.then(
+            (value) => {
+              span.end({ rows: rowsOf(action, value) });
+              return value;
+            },
+            (error) => {
+              span.end({ error });
+              throw error;
+            }
+          );
+        }
+        span.end();
+        return result;
+      });
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+}
+
+// The class's prototype, from the class itself, an instance, or the @prisma/client module.
+function prototypeOf(target) {
+  if (!target) return null;
+  if (typeof target === 'function' && target.prototype && typeof target.prototype._request === 'function') return target.prototype;
+  if (typeof target === 'object' && typeof target._request === 'function') return Object.getPrototypeOf(target);
+  if (typeof target === 'object' && typeof target.PrismaClient === 'function') return prototypeOf(target.PrismaClient);
+  return null;
+}
+
+function usesAdapter(client) {
+  try {
+    return Boolean(client._engineConfig && client._engineConfig.adapter);
+  } catch (error) {
+    return false;
+  }
+}
+
+// $queryRaw`...` passes a Sql object (text with $1 placeholders, sql with ?); $queryRawUnsafe
+// passes [query, ...values].
+function rawStatement(args, provider) {
+  if (Array.isArray(args)) return { text: String(args[0]), values: args.slice(1) };
+  if (!args || typeof args !== 'object') return null;
+  const pg = SYSTEMS[provider] === 'postgresql';
+  const text = pg ? args.text ?? args.sql : args.sql ?? args.text;
+  if (typeof text !== 'string') return null;
+  return { text, values: Array.isArray(args.values) ? args.values : undefined };
+}
+
+// The app's frame from the stack Prisma captured at the call, or from Prisma's own location.
+function callerOf(caller, callsite) {
+  if (!callsite || typeof callsite !== 'object') return null;
+  const error = callsite._error;
+  if (error && typeof error.stack === 'string') return caller.fromStack(error.stack);
+  if (typeof callsite.getLocation === 'function') return caller.fromLocation(callsite.getLocation());
+  return null;
+}
+
+function rowsOf(action, value) {
+  try {
+    if (Array.isArray(value)) return value.length;
+    if (value && typeof value === 'object' && Number.isInteger(value.count) && /Many$/.test(action)) return value.count;
+    if (action === 'executeRaw' && Number.isInteger(value)) return value;
+    if (SINGLE.test(action)) return value ? 1 : 0;
+  } catch (error) {
+    // A result that can't be read: the row count is unknown.
+  }
+  return null;
+}

package/src/integrations/express-errors.js

@@ -0,0 +1,135 @@
+/**
+ * Records the errors an Express app handles, and the ones it leaves to Express, without changing
+ * how either is answered.
+ *
+ * Express routes an error (thrown by a handler, passed to next(err), or a rejected promise in
+ * Express 5) through the router's stack to the error-handling middleware, the ones with four
+ * parameters. Two places see where it ends up:
+ *
+ * - The router's Layer runs every handler. A four-parameter handler receiving the error means the
+ *   app handles it (handled: true). Layer is reached through `router.stack[i].constructor`, and
+ *   its error method is `handle_error` in Express 4 and `handleError` in Express 5 (the "router"
+ *   package). The patch is on the prototype, so routers created with express.Router() are covered
+ *   too, and it only observes: the original runs with the same arguments.
+ * - When no handler is left, the router calls the `done` callback that app.handle() gave it:
+ *   Express's final handler, which answers 500 (handled: false). app.handle() is wrapped to tell
+ *   when it uses the final handler (no callback: the app isn't mounted inside another one), and
+ *   router.handle() to wrap that callback.
+ *
+ * An error middleware may log an error and pass it on with next(err): the record stays open until
+ * the error reaches the final handler (unhandled) or the request ends (handled). Every step is
+ * feature-detected; an Express version that doesn't fit is left alone.
+ */
+
+import { RequestContext } from '../exceptions/request-context.js';
+
+const kInstalled = Symbol('peekInside.expressErrors');
+const kLayerPatched = Symbol('peekInside.layerPatched');
+
+/**
+ * Installs the error hooks on Express apps (4 and 5).
+ */
+export class ExpressErrorHooks {
+  /**
+   * Hooks into an app's router, once per app. Does nothing for apps without an Express router
+   * (Connect) or before the app has one.
+   *
+   * @param {Function} app - Express app
+   * @returns {boolean} Whether the hooks are installed
+   */
+  static install(app) {
+    try {
+      if (!app || (typeof app !== 'function' && typeof app !== 'object')) return false;
+      if (app[kInstalled]) return true;
+      const router = routerOf(app);
+      if (!router || typeof router.handle !== 'function' || typeof app.handle !== 'function') return false;
+
+      Object.defineProperty(app, kInstalled, { value: true, configurable: true });
+      wrapFinalHandler(app, router);
+      patchLayers(router);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+}
+
+// Express 4 keeps the router in app._router (app.router throws there); Express 5 creates it on
+// first access of app.router.
+function routerOf(app) {
+  if (app._router) return app._router;
+  try {
+    return app.router || null;
+  } catch (error) {
+    return null;
+  }
+}
+
+function wrapFinalHandler(app, router) {
+  // The request app.handle() is dispatching with Express's final handler. router.handle() runs
+  // synchronously inside app.handle(), so one variable is enough.
+  let finalDispatch = null;
+
+  const originalAppHandle = app.handle;
+  app.handle = function handle(req, res, callback) {
+    if (typeof callback === 'function') return originalAppHandle.apply(this, arguments);
+    const previous = finalDispatch;
+    finalDispatch = req;
+    try {
+      return originalAppHandle.apply(this, arguments);
+    } finally {
+      finalDispatch = previous;
+    }
+  };
+
+  const originalRouterHandle = router.handle;
+  router.handle = function handle(req, res, out) {
+    if (finalDispatch !== req || typeof out !== 'function') {
+      return originalRouterHandle.apply(this, arguments);
+    }
+    const finalHandler = out;
+    return originalRouterHandle.call(this, req, res, function done(error) {
+      if (error && error !== 'route' && error !== 'router') noteError(req, error, false);
+      return finalHandler.apply(this, arguments);
+    });
+  };
+}
+
+function patchLayers(router) {
+  const stack = Array.isArray(router.stack) ? router.stack : [];
+  for (const layer of stack) {
+    const proto = layer && layer.constructor && layer.constructor.prototype;
+    if (proto && patchLayer(proto)) return;
+  }
+}
+
+// Observes four-parameter handlers receiving an error.
+function patchLayer(proto) {
+  if (proto[kLayerPatched]) return true;
+  const method = typeof proto.handle_error === 'function' ? 'handle_error' : typeof proto.handleError === 'function' ? 'handleError' : null;
+  if (!method) return false;
+
+  const original = proto[method];
+  const patched = {
+    [method](error, req, res, next) {
+      try {
+        if (error && typeof this.handle === 'function' && this.handle.length === 4) noteError(req, error, true);
+      } catch (failure) {
+        // Never in the way of the app's error handling.
+      }
+      return original.apply(this, arguments);
+    }
+  }[method];
+
+  Object.defineProperty(proto, kLayerPatched, { value: true, configurable: true });
+  proto[method] = patched;
+  return true;
+}
+
+// Handled errors stay open (an error middleware may still pass them on); unhandled ones are final.
+function noteError(req, error, handled) {
+  const context = RequestContext.of(req);
+  if (context && context.capture) {
+    context.capture.frameworkError(context, error, { mechanism: 'express', handled, open: handled });
+  }
+}

package/src/integrations/express.js

@@ -0,0 +1,57 @@
+/**
+ * Express integration, which also covers Connect and other apps built on use() middleware.
+ */
+
+import { ExpressErrorHooks } from './express-errors.js';
+import { FrameworkAdapter } from './framework-adapter.js';
+
+/**
+ * Records requests through a middleware, and the errors Express routes (see express-errors.js).
+ */
+export class ExpressAdapter extends FrameworkAdapter {
+  static framework = 'express';
+
+  /**
+   * @param {*} app
+   * @returns {boolean} Whether `app` takes middleware through use()
+   */
+  static matches(app) {
+    return Boolean(app) && typeof app.use === 'function';
+  }
+
+  /**
+   * Middleware that records each exchange. Its place in the stack doesn't matter: request bodies
+   * are captured as the app reads them, or taken from req.body when a parser ran first. The rest
+   * of the request runs inside its context, so exceptions are linked to it.
+   *
+   * Used on its own (expressMiddleware()), it installs the error hooks on the app of the first
+   * request it sees; errors that reach Express's final handler are recorded from the next request
+   * on.
+   *
+   * @returns {Function} Middleware `(req, res, next)`
+   */
+  middleware() {
+    return (req, res, next) => {
+      if (this.peekInside.options.captureExceptions !== false && req && req.app) {
+        ExpressErrorHooks.install(req.app);
+      }
+      return this.peekInside._intercept(req, res, next, 'express');
+    };
+  }
+
+  /**
+   * Adds the middleware, hooks into the app's error handling, and watches app.listen() for the
+   * app's server.
+   *
+   * @param {Object} app - Express or Connect app
+   * @returns {void}
+   */
+  attach(app) {
+    app.use(this.middleware());
+    // app.use() has created the router the hooks need.
+    if (this.peekInside.options.captureExceptions !== false) {
+      ExpressErrorHooks.install(app);
+    }
+    this.servers.patchListen(app);
+  }
+}

package/src/integrations/fastify.js

@@ -0,0 +1,72 @@
+/**
+ * Fastify integration.
+ */
+
+import { ExchangeRecorder } from '../capture/exchange-recorder.js';
+import { RequestContext } from '../exceptions/request-context.js';
+import { FrameworkAdapter } from './framework-adapter.js';
+
+/**
+ * Records requests from a Fastify onRequest hook, and errors from an onError hook.
+ *
+ * onRequest runs before Fastify reads the body, so bodies are captured as Fastify parses them.
+ * Hooks must be added before the app is ready, so attach before fastify.listen().
+ */
+export class FastifyAdapter extends FrameworkAdapter {
+  static framework = 'fastify';
+
+  /**
+   * @param {*} app
+   * @returns {boolean} Whether `app` looks like a Fastify instance
+   */
+  static matches(app) {
+    return Boolean(app) && typeof app.addHook === 'function' && typeof app.decorate === 'function';
+  }
+
+  /**
+   * Adds the hooks, and binds the Fastify server to learn the app's port.
+   *
+   * The rest of each request (Fastify's done()) runs inside the request's context. onError runs
+   * before Fastify's error handler and can't change the response: an error counts as handled when
+   * the app set its own error handler (setErrorHandler()).
+   *
+   * @param {Object} fastify - Fastify instance
+   * @returns {void}
+   */
+  attach(fastify) {
+    fastify.addHook('onRequest', (request, reply, done) => {
+      ExchangeRecorder.setBodySource(request.raw, () => request.body);
+      this.peekInside._intercept(request.raw, reply.raw, done, 'fastify');
+    });
+    if (this.peekInside.options.captureExceptions !== false) {
+      fastify.addHook('onError', (request, reply, error, done) => {
+        FastifyAdapter._noteError(request, error);
+        done();
+      });
+    }
+    if (fastify.server) {
+      this.servers.bind(fastify.server);
+    }
+  }
+
+  static _noteError(request, error) {
+    try {
+      const context = RequestContext.of(request.raw);
+      if (context && context.capture) {
+        context.capture.frameworkError(context, error, { mechanism: 'fastify', handled: FastifyAdapter._hasErrorHandler(request) });
+      }
+    } catch (failure) {
+      // Recording must never change the error the app sees.
+    }
+  }
+
+  // Fastify's own handler is named defaultErrorHandler; anything else was set by the app.
+  static _hasErrorHandler(request) {
+    try {
+      const handler = request.server && request.server.errorHandler;
+      return typeof handler === 'function' && handler.name !== 'defaultErrorHandler';
+    } catch (error) {
+      return false;
+    }
+  }
+}