peekinside 1.2.4 → 1.3.0

package/src/integrations/hono.js

@@ -0,0 +1,209 @@
+/**
+ * Hono integration, for Hono apps served on Node.js by @hono/node-server.
+ *
+ * node-server hands each request to app.fetch() along with the Node.js request and response
+ * (`env.incoming` and `env.outgoing`), so app.fetch is wrapped to record them; the rest of the
+ * request runs inside its context. node-server reads app.fetch when serve() is called, so attach
+ * before serve().
+ *
+ * Hono catches what a handler throws and passes it to the app's error handler (app.onError()), or
+ * to its default one, which answers 500 and logs it. The error handler is wrapped, whenever the app
+ * sets it, to see each error: handled when the app set its own handler, unhandled with Hono's. A
+ * sub-app mounted with its own error handler (app.route()) answers its errors itself; they are found
+ * on the context (c.error) once the route's handler returns. HTTPExceptions with a 4xx status are
+ * how an app answers bad requests, and aren't recorded.
+ *
+ * Route patterns ("/users/:id") come from the router: each handler it matches for a request is
+ * wrapped to note its route when it runs, and to forget it when it hands the request on (next()),
+ * so a request's route is the one of the handler that answered it, wherever PeekInside was attached
+ * among the app's routes and middleware.
+ */
+
+import { RequestContext } from '../exceptions/request-context.js';
+import { FrameworkAdapter } from './framework-adapter.js';
+
+const kAttached = Symbol('peekInside.hono');
+
+/**
+ * Records a Hono app's requests from app.fetch(), its errors from its error handler, and its routes
+ * from its router.
+ */
+export class HonoAdapter extends FrameworkAdapter {
+  static framework = 'hono';
+
+  /**
+   * @param {*} app
+   * @returns {boolean} Whether `app` looks like a Hono app
+   */
+  static matches(app) {
+    return Boolean(app) && typeof app.fetch === 'function' && typeof app.route === 'function' && typeof app.onError === 'function' && Array.isArray(app.routes);
+  }
+
+  /**
+   * Wraps app.fetch, the error handler and the router's match(). An app is wrapped once.
+   *
+   * @param {Object} app - Hono app
+   * @returns {void}
+   */
+  attach(app) {
+    if (app[kAttached]) return;
+    Object.defineProperty(app, kAttached, { value: true });
+    if (this.peekInside.options.captureExceptions !== false) wrapErrorHandler(app);
+    wrapRouter(app.router);
+    wrapFetch(app, this.peekInside);
+  }
+}
+
+function wrapFetch(app, peekInside) {
+  const original = app.fetch;
+  app.fetch = function fetch(request, env) {
+    const incoming = env && env.incoming;
+    const outgoing = env && env.outgoing;
+    // Elsewhere than node-server (app.request() in tests, other runtimes): nothing to record.
+    if (!incoming || !outgoing || typeof outgoing.on !== 'function') return original.apply(this, arguments);
+    const args = arguments;
+    return peekInside._intercept(incoming, outgoing, () => dispatch(original, this, args, incoming), 'hono');
+  };
+}
+
+// What escapes app.fetch() is what Hono itself didn't handle: a value thrown that isn't an Error,
+// or an error handler that threw. node-server answers it with a 500.
+function dispatch(original, self, args, incoming) {
+  let result;
+  try {
+    result = original.apply(self, args);
+  } catch (error) {
+    noteError(incoming, error, false);
+    throw error;
+  }
+  if (result && typeof result.then === 'function') {
+    return result.then(undefined, (error) => {
+      noteError(incoming, error, false);
+      throw error;
+    });
+  }
+  return result;
+}
+
+// app.errorHandler becomes an accessor: setting it (app.onError() does) keeps the wrapper in front.
+function wrapErrorHandler(app) {
+  const isDefault = defaultHandlerTest(app);
+  let current = app.errorHandler;
+  if (typeof current !== 'function') return;
+  const wrapper = function (error, c) {
+    noteError(c && c.env && c.env.incoming, error, !isDefault(current));
+    return current.apply(this, arguments);
+  };
+  Object.defineProperty(app, 'errorHandler', {
+    configurable: true,
+    enumerable: true,
+    get() {
+      return wrapper;
+    },
+    set(handler) {
+      current = handler;
+    }
+  });
+}
+
+// Hono's own error handler is the one a new app of the same class has; when one can't be made,
+// it is known by its name.
+function defaultHandlerTest(app) {
+  let fallback = null;
+  try {
+    const probe = typeof app.constructor === 'function' ? new app.constructor() : null;
+    fallback = probe && typeof probe.errorHandler === 'function' ? probe.errorHandler : null;
+  } catch (error) {
+    fallback = null;
+  }
+  return (handler) => (fallback ? handler === fallback : Boolean(handler) && handler.name === 'errorHandler');
+}
+
+// The router's match() becomes an accessor too: Hono's routers replace it on first use (and the
+// RegExpRouter then calls the replacement, whose result is wrapped already).
+function wrapRouter(router) {
+  if (!router || typeof router.match !== 'function') return;
+  let current = router.match;
+  const cache = { tuples: new WeakMap(), lists: new WeakMap(), own: new WeakSet() };
+  const match = function match() {
+    return withRoutes(current.apply(this, arguments), cache);
+  };
+  Object.defineProperty(router, 'match', {
+    configurable: true,
+    get() {
+      return match;
+    },
+    set(fn) {
+      current = fn;
+    }
+  });
+}
+
+// A match result is [[[handler, route], params][], stash?]: the same result, its handlers wrapped.
+// Lists and handlers are wrapped once each (the RegExpRouter returns the same list for a route).
+function withRoutes(result, { tuples, lists, own }) {
+  if (!Array.isArray(result) || !Array.isArray(result[0]) || own.has(result[0])) return result;
+  const handlers = result[0];
+  let wrapped = lists.get(handlers);
+  if (!wrapped) {
+    wrapped = handlers.map((entry) => {
+      const tuple = Array.isArray(entry) ? entry[0] : null;
+      if (!Array.isArray(tuple) || typeof tuple[0] !== 'function') return entry;
+      let routed = tuples.get(tuple);
+      if (!routed) {
+        routed = [routeHandler(tuple[0], tuple[1]), tuple[1]];
+        tuples.set(tuple, routed);
+      }
+      return [routed, entry[1]];
+    });
+    lists.set(handlers, wrapped);
+    own.add(wrapped);
+  }
+  const copy = result.slice();
+  copy[0] = wrapped;
+  return copy;
+}
+
+function routeHandler(handler, route) {
+  const pattern = route && typeof route.path === 'string' ? route.path : null;
+  return function (c, next) {
+    const context = c && c.env ? RequestContext.of(c.env.incoming) : null;
+    if (!context) return handler.apply(this, arguments);
+    context.noteRoute({ route: pattern, params: () => c.req.param() });
+    const args = Array.prototype.slice.call(arguments);
+    if (typeof next === 'function') {
+      args[1] = function () {
+        context.noteRoute({ route: null, params: null });
+        return next.apply(this, arguments);
+      };
+    }
+    const result = handler.apply(this, args);
+    if (result && typeof result.then === 'function') {
+      return result.then((value) => {
+        noteCaught(context, c);
+        return value;
+      });
+    }
+    noteCaught(context, c);
+    return result;
+  };
+}
+
+// A sub-app's own error handler answered an error: Hono leaves it on the context.
+function noteCaught(context, c) {
+  try {
+    if (c.error && context.capture) context.capture.frameworkError(context, c.error, { mechanism: 'hono', handled: true, open: true });
+  } catch (failure) {
+    // Recording must never change the response.
+  }
+}
+
+// An error the app's own handler answers stays open: the handler may still throw it on.
+function noteError(incoming, error, handled) {
+  try {
+    const context = RequestContext.of(incoming) || RequestContext.current();
+    if (context && context.capture) context.capture.frameworkError(context, error, { mechanism: 'hono', handled, open: handled });
+  } catch (failure) {
+    // Recording must never change the error the app sees.
+  }
+}

package/src/integrations/nest.js

@@ -0,0 +1,277 @@
+/**
+ * NestJS integration (Nest 10 and later, on Express or Fastify).
+ *
+ * Nest answers errors itself: its exception filters run before Express or Fastify see an error,
+ * and its default filter answers 500 and logs it. So PeekInside hooks into Nest's own pieces,
+ * reached through the app object, which makes the copy of Nest the app runs the one that is
+ * patched, whichever module system loaded it:
+ *
+ * - Requests are recorded from the HTTP server Nest created, before Express or Fastify runs, so
+ *   bodies are captured as they arrive and middleware order doesn't matter.
+ * - Each route handler Nest builds (RouterExplorer#createCallbackProxy) is wrapped to note the
+ *   controller method and the route pattern on the request, before guards, pipes and
+ *   interceptors run.
+ * - Every error of an HTTP request passes through ExceptionsHandler#next. One that an exception
+ *   filter of the app catches is handled, unless the filter hands it to Nest's default answer
+ *   (BaseExceptionFilter#catch, what `super.catch()` calls); an error that gets the default answer
+ *   is unhandled. Errors with a 4xx status (NotFoundException, BadRequestException...) are how an
+ *   app answers bad requests, and aren't recorded.
+ * - Nest's Logger lines and @nestjs/schedule's jobs are recorded too (see
+ *   instrumentation/loggers.js and instrumentation/jobs.js).
+ *
+ * Nest registers routes and scheduled methods when the app initializes, so attach before
+ * app.listen() (or app.init()). A worker made with NestFactory.createApplicationContext() is
+ * initialized by then: for its scheduled methods, PeekInside must exist before the worker does
+ * (instrumentation/index.js patches @nestjs/schedule when PeekInside is created). Every step is
+ * feature-detected: a Nest version that doesn't fit is left alone.
+ */
+
+import { LOG_PREFIX } from '../config.js';
+import { RequestContext } from '../exceptions/request-context.js';
+import { JobInstrumentation } from '../instrumentation/jobs.js';
+import { LoggerInstrumentation } from '../instrumentation/loggers.js';
+import { FrameworkAdapter } from './framework-adapter.js';
+
+const kRoutes = Symbol('peekInside.nestRoutes');
+const kErrors = Symbol('peekInside.nestErrors');
+
+/**
+ * Records a Nest app's requests from its HTTP server, and hooks into Nest for the rest.
+ */
+export class NestAdapter extends FrameworkAdapter {
+  static framework = 'nest';
+
+  /**
+   * @param {*} app
+   * @returns {boolean} Whether `app` looks like a Nest application (NestFactory.create()) or
+   *   application context (NestFactory.createApplicationContext(), such as a worker)
+   */
+  static matches(app) {
+    return Boolean(app) && typeof app.select === 'function' && typeof app.useLogger === 'function' && typeof app.resolve === 'function';
+  }
+
+  /**
+   * Binds the app's HTTP server (an application context has none) and installs the hooks. Logs and
+   * jobs are only hooked for an instance that records.
+   *
+   * @param {Object} app - What NestFactory.create() returned
+   * @returns {void}
+   */
+  attach(app) {
+    const { options } = this.peekInside;
+    const records = Boolean(this.peekInside._transport);
+    const installed = NestHooks.install(app, {
+      exceptions: options.captureExceptions !== false,
+      logs: records && options.captureLogs !== false,
+      jobs: records && options.captureJobs !== false
+    });
+    if (installed.lateJobs) {
+      console.warn(`${LOG_PREFIX} This NestJS app set up its scheduled jobs before PeekInside existed, so their failures and their @Interval and @Timeout runs aren't recorded. Create PeekInside first (new PeekInside()), then attach it with peekInside.attachTo(app).`);
+    }
+    const server = httpServerOf(app);
+    if (server) this.servers.bind(server, { interceptRequests: true, integration: 'nest' });
+  }
+}
+
+/**
+ * Installs the hooks into a Nest app.
+ */
+export class NestHooks {
+  /**
+   * @param {Object} app
+   * @param {Object} [options]
+   * @param {boolean} [options.exceptions=true] - Record the errors Nest answers
+   * @param {boolean} [options.logs=true] - Record Nest's Logger lines (ConsoleLogger)
+   * @param {boolean} [options.jobs=true] - Record @nestjs/schedule's jobs
+   * @returns {{ routes: boolean, errors: boolean, logs: boolean, jobs: boolean, lateJobs: boolean }}
+   *   What was hooked, and whether scheduled methods were registered before the scheduler was
+   */
+  static install(app, { exceptions = true, logs = true, jobs = true } = {}) {
+    const installed = { routes: false, errors: false, logs: false, jobs: false, lateJobs: false };
+    try {
+      const resolver = read(app, 'routesResolver');
+      installed.routes = patchRoutes(read(resolver, 'routerExplorer'));
+      if (exceptions) installed.errors = patchErrors(read(resolver, 'routerExceptionsFilter'));
+      if (logs) installed.logs = LoggerInstrumentation.nest(activeLogger(app));
+      const explorer = jobs ? scheduleExplorer(app) : null;
+      if (explorer) {
+        installed.jobs = JobInstrumentation.nestSchedule(explorer);
+        installed.lateJobs = registeredBefore(explorer);
+      }
+    } catch (error) {
+      // Whatever was hooked stays; the rest is left alone.
+    }
+    return installed;
+  }
+}
+
+// Wraps the handler Nest builds for each route: it notes the controller method and the route the
+// request matched before Nest runs guards, pipes, interceptors and the method.
+function patchRoutes(explorer) {
+  const proto = explorer ? Object.getPrototypeOf(explorer) : null;
+  if (!proto || typeof proto.createCallbackProxy !== 'function') return false;
+  if (proto[kRoutes]) return true;
+  const original = proto.createCallbackProxy;
+  proto.createCallbackProxy = function (instance, callback, methodName) {
+    const proxy = original.apply(this, arguments);
+    if (typeof proxy !== 'function') return proxy;
+    const handler = handlerName(instance, methodName);
+    return function (req, res, next) {
+      noteRoute(req, handler);
+      return proxy.apply(this, arguments);
+    };
+  };
+  Object.defineProperty(proto, kRoutes, { value: true });
+  return true;
+}
+
+// Observes ExceptionsHandler#next and BaseExceptionFilter#catch. ExceptionsHandler isn't exported
+// by every Nest version: the app's RouterExceptionFilters creates one, which gives its prototype.
+function patchErrors(filters) {
+  let sample = null;
+  try {
+    sample = filters && typeof filters.create === 'function' ? filters.create({}, function handler() {}, undefined) : null;
+  } catch (error) {
+    sample = null;
+  }
+  const proto = sample ? Object.getPrototypeOf(sample) : null;
+  if (!proto || typeof proto.next !== 'function') return false;
+  if (proto[kErrors]) return true;
+
+  const originalNext = proto.next;
+  proto.next = function (exception, host) {
+    try {
+      if (catchesIt(this.filters, exception)) noteError(host, exception, true);
+    } catch (failure) {
+      // Never in the way of the app's error handling.
+    }
+    return originalNext.apply(this, arguments);
+  };
+  Object.defineProperty(proto, kErrors, { value: true });
+
+  const base = Object.getPrototypeOf(proto);
+  if (base && base !== Object.prototype && typeof base.catch === 'function' && !base[kErrors]) {
+    const originalCatch = base.catch;
+    base.catch = function (exception, host) {
+      noteError(host, exception, false);
+      return originalCatch.apply(this, arguments);
+    };
+    Object.defineProperty(base, kErrors, { value: true });
+  }
+  return true;
+}
+
+// Whether one of the app's exception filters catches the error, as Nest picks them: a filter
+// with no exception types catches everything.
+function catchesIt(filters, exception) {
+  if (!Array.isArray(filters) || !filters.length) return false;
+  return filters.some((filter) => {
+    const types = filter && Array.isArray(filter.exceptionMetatypes) ? filter.exceptionMetatypes : [];
+    return !types.length || types.some((type) => typeof type === 'function' && exception instanceof type);
+  });
+}
+
+// An error a filter catches stays open: the filter may still hand it to Nest's default answer.
+function noteError(host, exception, handled) {
+  try {
+    const req = host && typeof host.getArgByIndex === 'function' ? host.getArgByIndex(0) : null;
+    const context = RequestContext.of(nodeRequest(req)) || RequestContext.current();
+    if (context && context.capture) {
+      context.capture.frameworkError(context, exception, { mechanism: 'nest', handled, open: handled });
+    }
+  } catch (failure) {
+    // Recording must never change the error the app sees.
+  }
+}
+
+function noteRoute(req, handler) {
+  try {
+    const raw = nodeRequest(req);
+    const context = RequestContext.of(raw);
+    if (!context) return;
+    // Express keeps the route parameters on the Node.js request; Fastify on its own request.
+    context.noteRoute({ route: routeOf(req), handler, ...(raw !== req ? { params: () => req.params } : {}) });
+  } catch (error) {
+    // The request is recorded without them.
+  }
+}
+
+// The route pattern the platform matched: Express's Route, Fastify's route options (routerPath
+// before Fastify 4.10).
+function routeOf(req) {
+  if (!req) return null;
+  if (req.route && typeof req.route.path === 'string') return req.route.path;
+  const options = req.routeOptions;
+  if (options && typeof options === 'object') return typeof options.url === 'string' ? options.url : null;
+  return typeof req.routerPath === 'string' ? req.routerPath : null;
+}
+
+// "OrdersController.create"
+function handlerName(instance, methodName) {
+  const owner = instance && instance.constructor && typeof instance.constructor.name === 'string' ? instance.constructor.name : '';
+  const method = typeof methodName === 'string' ? methodName : '';
+  return owner && method ? `${owner}.${method}` : method || null;
+}
+
+// The Node.js request behind what Nest passes around: Express's request is the Node.js one,
+// Fastify's keeps it in `raw`.
+function nodeRequest(req) {
+  return req && typeof req === 'object' && req.raw && typeof req.raw === 'object' ? req.raw : req;
+}
+
+// The logger Nest's Logger writes through: its ConsoleLogger, unless the app set another one.
+function activeLogger(app) {
+  const logger = read(app, 'logger');
+  const Logger = logger && logger.constructor;
+  return Logger && typeof Logger === 'function' ? Logger.staticInstanceRef || null : null;
+}
+
+// @nestjs/schedule's ScheduleExplorer, one of the app's providers.
+function scheduleExplorer(app) {
+  const container = read(app, 'container');
+  const modules = container && typeof container.getModules === 'function' ? container.getModules() : null;
+  if (!modules || typeof modules.values !== 'function') return null;
+  for (const module of modules.values()) {
+    const providers = module && module.providers;
+    if (!providers || typeof providers.values !== 'function') continue;
+    for (const wrapper of providers.values()) {
+      let instance = null;
+      try {
+        instance = wrapper ? wrapper.instance : null;
+      } catch (error) {
+        instance = null;
+      }
+      if (instance && typeof instance.wrapFunctionInTryCatchBlocks === 'function' && typeof instance.lookupSchedulers === 'function') return instance;
+    }
+  }
+  return null;
+}
+
+// Whether the scheduler registered methods before it was patched: their errors are swallowed
+// unrecorded, and intervals and timeouts aren't job runs.
+function registeredBefore(explorer) {
+  const orchestrator = read(explorer, 'schedulerOrchestrator');
+  return ['cronJobs', 'intervals', 'timeouts'].some((key) => {
+    const registered = read(orchestrator, key);
+    return Boolean(registered) && Object.values(registered).some((entry) => entry && typeof entry.target === 'function' && !JobInstrumentation.isRun(entry.target));
+  });
+}
+
+function httpServerOf(app) {
+  try {
+    const server = typeof app.getHttpServer === 'function' ? app.getHttpServer() : null;
+    return server && typeof server.emit === 'function' ? server : null;
+  } catch (error) {
+    return null;
+  }
+}
+
+// An object property of Nest's internals, or null.
+function read(target, key) {
+  try {
+    const value = target ? target[key] : null;
+    return value && typeof value === 'object' ? value : null;
+  } catch (error) {
+    return null;
+  }
+}

package/src/integrations/server-binder.js

@@ -3,9 +3,10 @@
  * it, and registers the app as soon as it is known) and, for plain http servers, to see every
  * request.
  *
- * Servers are found three ways: passed directly (http.Server, Fastify), returned by a patched
- * app.listen() (Express, Koa), or discovered from the socket of a request the app handled, which
- * catches servers created with http.createServer(app).
+ * Servers are found three ways: passed directly (http.Server, Fastify, the server a NestJS app
+ * created), returned by a patched app.listen() (Express, Koa), or discovered from the socket of a
+ * request the app handled, which catches servers created with http.createServer(app) and Hono's
+ * serve().
  */
 
 /**
@@ -73,10 +74,12 @@ export class ServerBinder {
    * @param {import('http').Server} server
    * @param {Object} [options]
    * @param {boolean} [options.interceptRequests=false] - Also record every request the server
-   *   emits, for plain http servers where no middleware runs
+   *   emits, for plain http servers where no middleware runs, and for frameworks recorded before
+   *   their own code runs (NestJS)
+   * @param {string} [options.integration='http'] - The integration recording those requests
    * @returns {void}
    */
-  bind(server, { interceptRequests = false } = {}) {
+  bind(server, { interceptRequests = false, integration = 'http' } = {}) {
     if (!server || typeof server.emit !== 'function' || this._bound.has(server)) {
       return;
     }
@@ -91,7 +94,7 @@ export class ServerBinder {
       server.emit = function (event, req, res) {
         if (event === 'request' && req && res) {
           const args = arguments;
-          return peekInside._intercept(req, res, () => originalEmit.apply(this, args), 'http');
+          return peekInside._intercept(req, res, () => originalEmit.apply(this, args), integration);
         }
         return originalEmit.apply(this, arguments);
       };

package/src/logs/log-capture.js

@@ -1,7 +1,7 @@
 /**
- * Log lines for the Logs page: what the app writes with the console, pino or winston, inside a
- * request, inside a job run, or anywhere else (startup, timers), each linked to its request or job
- * run when there is one.
+ * Log lines for the Logs page: what the app writes with the console, pino, winston or NestJS's
+ * Logger, inside a request, inside a job run, or anywhere else (startup, timers), each linked to
+ * its request or job run when there is one.
  *
  * Lines are rate limited per process (100 a second, bursts of 500) and below the `logLevel` option
  * are left out, so an app that logs heavily costs a bounded amount. PeekInside's own lines are
@@ -67,8 +67,8 @@ export class LogCapture {
    * @param {'debug'|'info'|'warn'|'error'} level
    * @param {string} message - As written (formatted)
    * @param {Object} [options]
-   * @param {'console'|'pino'|'winston'} [options.source='console']
-   * @param {*} [options.fields] - Structured data written with the line (pino, winston)
+   * @param {'console'|'pino'|'winston'|'nest'} [options.source='console']
+   * @param {*} [options.fields] - Structured data written with the line (pino, winston, nest)
    * @returns {string|null} The record's id, or null when nothing was recorded
    */
   static record(level, message, { source = 'console', fields } = {}) {

package/src/logs/log-record.js

@@ -1,6 +1,6 @@
 /**
  * One log line, as the Logs page lists it (see the data contract): when, its level, where it came
- * from (console, pino, winston), the request or job run it belongs to, and the line itself.
+ * from (console, pino, winston, nest), the request or job run it belongs to, and the line itself.
  *
  * PeekInside Cloud receives the line sealed: only the time, level, source and links are readable.
  */
@@ -18,7 +18,7 @@ export class LogRecord {
    * @param {string} fields.environment
    * @param {string|null} [fields.release=null]
    * @param {'debug'|'info'|'warn'|'error'} fields.level
-   * @param {'console'|'pino'|'winston'} fields.source
+   * @param {'console'|'pino'|'winston'|'nest'} fields.source
    * @param {string|null} [fields.requestId=null] - The request it was written during
    * @param {string|null} [fields.jobRunId=null] - The job run it was written during
    * @param {{ message: string, fields?: Object|null }} fields.summary - The line (sealed in Cloud)

package/src/record.js

@@ -32,8 +32,9 @@ export class RequestRecord {
    *   lists the first of them)
    * @param {Object} [fields.stats] - Timeline counters: queries, queryTime, slowQueries, nPlusOne,
    *   duplicates, http, httpTime, logs (detail.timeline holds the spans); absent when the timeline is off
-   * @param {{ url: string, path: string, contentType: string, user?: Object }} fields.summary - Shown in
-   *   the request list (with the user, when the app set one)
+   * @param {{ url: string, path: string, contentType: string, route?: string, handler?: string, user?: Object }} fields.summary -
+   *   Shown in the request list: with the route pattern and the handler when the framework says
+   *   (NestJS, Hono, Fastify), and the user when the app set one
    * @param {Object} fields.detail - Everything else: headers, bodies, query, client details
    */
   constructor({ id, occurredAt, environment, release = null, method, status, duration, requestSize, responseSize, aborted, exceptionCount = 0, stats, summary, detail }) {
@@ -83,6 +84,8 @@ export class RequestRecord {
         url: exchange.url,
         path: exchange.path,
         contentType: headerValue(response.headers, 'content-type'),
+        ...(exchange.route ? { route: exchange.route } : {}),
+        ...(exchange.handler ? { handler: exchange.handler } : {}),
         ...(exchange.user ? { user: exchange.user } : {})
       },
       detail: {
@@ -106,6 +109,7 @@ export class RequestRecord {
           bodyEncoding: response.bodyEncoding
         },
         exceptions: Array.isArray(exchange.exceptions) ? exchange.exceptions.slice(0, MAX_EXCEPTION_LINKS) : [],
+        ...(Array.isArray(exchange.dumps) && exchange.dumps.length ? { dumps: exchange.dumps } : {}),
         ...(exchange.timeline ? { timeline: exchange.timeline } : {})
       }
     });

package/src/runtime/request-counter.js

@@ -0,0 +1,40 @@
+/**
+ * The requests an instance serves, for its process samples: how many are open, and how many
+ * finished since the last sample. Two numbers, no request data.
+ */
+export class RequestCounter {
+  constructor() {
+    this.open = 0;
+    this.finished = 0;
+  }
+
+  /**
+   * A request started.
+   *
+   * @returns {void}
+   */
+  started() {
+    this.open++;
+  }
+
+  /**
+   * A request finished (or its connection closed first).
+   *
+   * @returns {void}
+   */
+  ended() {
+    this.open = Math.max(0, this.open - 1);
+    this.finished++;
+  }
+
+  /**
+   * The requests finished since the last call, and the ones open now.
+   *
+   * @returns {{ finished: number, open: number }}
+   */
+  take() {
+    const finished = this.finished;
+    this.finished = 0;
+    return { finished, open: this.open };
+  }
+}