peekinside 1.2.5 → 1.3.0

package/README.md

@@ -21,11 +21,13 @@ const app = express();
 PeekInside.attach(app);
 ```
 
-Start your app, and PeekInside prints the link to its dashboard. It works with Express, Koa, Fastify and the native http module.
+Start your app, and PeekInside prints the link to its dashboard. It works with Express, Koa, Fastify, NestJS, Hono and the native http module.
 
 Check the setup before anything breaks on its own: `npx peekinside test` sends a test error from your project.
 
-Also recorded: background jobs (node-cron, cron, BullMQ, or `PeekInside.job()`, with an email when a scheduled job misses its run), log lines from the console, pino and winston, event-loop blocks and memory, the deploy each error came from, the user it happened to (`PeekInside.setUser()`), and TypeScript lines through your source maps.
+While you develop, `PeekInside.dump(value)` shows any value in the local dashboard instead of your terminal: as a tree you can open, under the request it belongs to, with the line that dumped it.
+
+Also recorded: background jobs (node-cron, cron, BullMQ, @nestjs/schedule, or `PeekInside.job()`, with an email when a scheduled job misses its run), log lines from the console, pino, winston and NestJS's Logger, event-loop blocks and memory, the deploy each error came from, the user it happened to (`PeekInside.setUser()`), and TypeScript lines through your source maps.
 
 ## Documentation
 
@@ -38,6 +40,7 @@ Everything else is in the docs: **[peekinside.dev/docs](https://peekinside.dev/d
 - [Timeline and queries](https://peekinside.dev/docs/timeline)
 - [Logs](https://peekinside.dev/docs/logs)
 - [Jobs and schedules](https://peekinside.dev/docs/jobs)
+- [Dumps](https://peekinside.dev/docs/dumps)
 - [Runtime](https://peekinside.dev/docs/runtime)
 - [Alerts](https://peekinside.dev/docs/alerts)
 - [Configuration](https://peekinside.dev/docs/configuration)

package/index.d.ts

@@ -3,8 +3,8 @@
  * and the exceptions that happen while handling them. In development they go to the free local
  * dashboard; with an API key they are encrypted and sent to PeekInside Cloud.
  *
- * The signatures are structural, so Express, Connect, Koa, Fastify and node:http objects fit
- * without PeekInside depending on any of those packages.
+ * The signatures are structural, so Express, Connect, Koa, Fastify, NestJS, Hono and node:http
+ * objects fit without PeekInside depending on any of those packages.
  */
 
 import type { IncomingMessage, Server, ServerResponse } from "node:http";
@@ -67,8 +67,8 @@ export interface PeekInsideOptions {
   projectRoot?: string;
 
   /**
-   * Records exceptions automatically: errors that reach Express, Koa or Fastify error handling,
-   * uncaught exceptions and unhandled rejections. `report()` works either way.
+   * Records exceptions automatically: errors that reach Express, Koa, Fastify, NestJS or Hono error
+   * handling, uncaught exceptions and unhandled rejections. `report()` works either way.
    * @default true
    */
   captureExceptions?: boolean;
@@ -109,8 +109,8 @@ export interface PeekInsideOptions {
   captureOutgoing?: boolean;
 
   /**
-   * Records log lines from the console, pino and winston: on the timeline of the request (or job
-   * run) they are written in, and on the Logs page, from anywhere in the app.
+   * Records log lines from the console, pino, winston and NestJS's Logger: on the timeline of the
+   * request (or job run) they are written in, and on the Logs page, from anywhere in the app.
    * @default true
    */
   captureLogs?: boolean;
@@ -122,7 +122,8 @@ export interface PeekInsideOptions {
   logLevel?: "debug" | "info" | "warn" | "error";
 
   /**
-   * Records runs of node-cron, cron and BullMQ jobs automatically (see `job()` for other jobs).
+   * Records runs of node-cron, cron, BullMQ and @nestjs/schedule jobs automatically (see `job()`
+   * for other jobs).
    * @default true
    */
   captureJobs?: boolean;
@@ -217,9 +218,14 @@ export type CaptureOptions = Pick<PeekInsideOptions, "maxBodySize" | "ignorePath
 
 /**
  * What `PeekInside.attach()` understands: an Express or Connect app, a Koa app, a Fastify
- * instance, or a node:http (or https) server.
+ * instance, a NestJS app or application context, a Hono app, or a node:http (or https) server.
  */
-export type AttachTarget = Server | { use(...args: any[]): unknown } | { addHook(...args: any[]): unknown };
+export type AttachTarget =
+  | Server
+  | { use(...args: any[]): unknown }
+  | { addHook(...args: any[]): unknown }
+  | { select(...args: any[]): unknown; useLogger(...args: any[]): unknown }
+  | { fetch(...args: any[]): unknown; onError(...args: any[]): unknown };
 
 /** Express and Connect style middleware. */
 export type NodeMiddleware = (req: IncomingMessage, res: ServerResponse, next: (error?: unknown) => void) => void;
@@ -236,7 +242,7 @@ export type KoaMiddleware = (
  * @example
  * import PeekInside from "peekinside";
  *
- * PeekInside.attach(app); // Express, Koa, Fastify or an http.Server
+ * PeekInside.attach(app); // Express, Koa, Fastify, NestJS, Hono or an http.Server
  */
 declare class PeekInside {
   /**
@@ -255,9 +261,11 @@ declare class PeekInside {
   readonly release: string | null;
 
   /**
-   * One-line setup: records every request the app handles.
+   * One-line setup: records every request the app handles. Attach a NestJS app before
+   * `app.listen()`, a Hono app before `serve()`, and a Fastify app before `fastify.listen()`.
    *
-   * @param app - Express or Connect app, Koa app, Fastify instance, or http.Server
+   * @param app - Express or Connect app, Koa app, Fastify instance, NestJS app or application
+   *   context, Hono app, or http.Server
    */
   static attach(app: AttachTarget, options?: PeekInsideOptions): PeekInside;
 
@@ -301,6 +309,27 @@ declare class PeekInside {
    */
   static measure<T>(name: string, fn: () => T): T;
 
+  /**
+   * Shows a value in the local dashboard instead of your terminal: on the Dumps page and under the
+   * request (or job run) it was dumped in, as a tree that opens level by level, with the line that
+   * dumped it. Returns the value, so it can wrap an expression in place.
+   *
+   * Dumps are for development: they go to the local dashboard only. With PeekInside Cloud, or when
+   * nothing is recorded, `dump()` just returns the value.
+   *
+   * @param label - Shown with the dump, such as `"cart before checkout"`
+   *
+   * @example
+   * const order = PeekInside.dump(await buildOrder(cart), "order");
+   */
+  dump<T>(value: T, label?: string): T;
+
+  /**
+   * `dump()` with the instance that tracks the current request, or else the most recently created
+   * instance that records.
+   */
+  static dump<T>(value: T, label?: string): T;
+
   /**
    * The id of the request the calling code runs for, as the dashboard knows it: put it in your
    * own logs to find the request from a log line. `null` outside a recorded request.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peekinside",
-  "version": "1.2.5",
+  "version": "1.3.0",
   "description": "Debug Node.js from the inside: errors with the requests, queries, logs and jobs behind them. A free local dashboard, and encrypted monitoring for production",
   "main": "index.js",
   "types": "./index.d.ts",
@@ -57,6 +57,12 @@
   },
   "homepage": "https://peekinside.dev",
   "devDependencies": {
+    "@hono/node-server": "2.1.3",
+    "@nestjs/common": "12.1.3",
+    "@nestjs/core": "12.1.3",
+    "@nestjs/platform-express": "12.1.3",
+    "@nestjs/platform-fastify": "12.1.3",
+    "@nestjs/schedule": "12.0.2",
     "@types/express": "4.17.25",
     "@types/koa": "2.15.0",
     "@types/node": "24.10.1",
@@ -65,6 +71,7 @@
     "express": "4.22.3",
     "express5": "npm:express@5.1.0",
     "fastify": "5.12.5",
+    "hono": "4.13.13",
     "koa": "2.16.4",
     "mongodb": "6.21.0",
     "mongodb-memory-server-core": "11.3.0",
@@ -73,6 +80,8 @@
     "node-cron": "4.6.0",
     "pg": "8.23.1",
     "pino": "10.4.0",
+    "reflect-metadata": "0.2.2",
+    "rxjs": "7.8.2",
     "typescript": "5.9.3",
     "winston": "3.19.0"
   }

package/src/PeekInside.js

@@ -4,7 +4,7 @@
  * Records every request and response your app handles. During development they go to the free
  * local dashboard, which is shared by all your projects and keeps its data on this machine.
  * With an API key they are encrypted and sent to PeekInside Cloud instead.
- * Works with Express, Koa, Fastify and the native http module.
+ * Works with Express, Koa, Fastify, NestJS, Hono and the native http module.
  *
  * Exceptions are recorded too: errors that reach the framework's error handling, crashes
  * (uncaught exceptions and unhandled rejections), and errors the app reports. Each is linked to the
@@ -13,6 +13,9 @@
  * Each request also gets a timeline: the database queries, outgoing HTTP calls, console lines and
  * exceptions that happened while it was handled (see src/timeline and src/instrumentation).
  *
+ * In development, dump() shows values in the local dashboard, under the request they were dumped
+ * in (see src/dumps).
+ *
  * This class is the public API. It decides where requests go and which requests are recorded,
  * and leaves the work to the capture (src/capture), exception (src/exceptions), framework
  * (src/integrations) and transport (src/transport) classes.
@@ -26,6 +29,7 @@ import { isIgnoredPath } from './capture/ignored-paths.js';
 import { LOG_PREFIX, VERSION, settings } from './config.js';
 import { TrafficClassifier } from './deployment.js';
 import { ExceptionCapture } from './exceptions/exception-capture.js';
+import { DumpCapture } from './dumps/dump-capture.js';
 import { ProcessMonitor } from './exceptions/process-monitor.js';
 import { RequestContext } from './exceptions/request-context.js';
 import { Instrumentation } from './instrumentation/index.js';
@@ -33,8 +37,10 @@ import { isNativePromise } from './instrumentation/patch.js';
 import { TIMELINE_DEFAULTS, Timeline, TimelineSettings } from './timeline/timeline.js';
 import { ExpressAdapter } from './integrations/express.js';
 import { FastifyAdapter } from './integrations/fastify.js';
+import { HonoAdapter } from './integrations/hono.js';
 import { HttpServerAdapter } from './integrations/http-server.js';
 import { KoaAdapter } from './integrations/koa.js';
+import { NestAdapter } from './integrations/nest.js';
 import { ServerBinder } from './integrations/server-binder.js';
 import { ProjectIdentity } from './project.js';
 import { Release } from './release.js';
@@ -60,9 +66,10 @@ const DEFAULT_OPTIONS = {
   ...TIMELINE_DEFAULTS
 };
 
-// Tried in this order by attachTo(): Fastify and Koa apps also have use(), and anything with
-// use() is handled as middleware before falling back to a plain server.
-const ADAPTERS = [FastifyAdapter, KoaAdapter, ExpressAdapter, HttpServerAdapter];
+// Tried in this order by attachTo(): Nest apps (which pass Express's or Fastify's methods
+// through), Hono, Fastify and Koa apps also have use(), and anything with use() is handled as
+// middleware before falling back to a plain server.
+const ADAPTERS = [NestAdapter, HonoAdapter, FastifyAdapter, KoaAdapter, ExpressAdapter, HttpServerAdapter];
 
 // Marks requests already being recorded, so a request that passes through several integrations
 // (or PeekInside instances) is recorded once.
@@ -73,7 +80,7 @@ const kTracked = Symbol('peekInside.tracked');
  *
  * @class PeekInside
  * @example
- * // Express, Koa, Fastify or an http.Server
+ * // Express, Koa, Fastify, NestJS, Hono or an http.Server
  * PeekInside.attach(app);
  *
  * @example
@@ -104,8 +111,8 @@ class PeekInside {
    *   "v2.4.0". Defaults to PEEKINSIDE_RELEASE, then the commit your host deployed (Vercel, Render,
    *   Railway, Heroku and others set it), then the commit checked out in the project folder.
    * @param {boolean} [options.captureExceptions=true] - Record exceptions automatically: errors that
-   *   reach Express, Koa or Fastify error handling, uncaught exceptions and unhandled rejections.
-   *   report() works either way.
+   *   reach Express, Koa, Fastify, NestJS or Hono error handling, uncaught exceptions and unhandled
+   *   rejections. report() works either way.
    * @param {boolean} [options.sourceContext=true] - Include the source lines around the app's own
    *   stack frames in exception records
    * @param {boolean} [options.sourceMaps=true] - Map stack frames of compiled code (TypeScript
@@ -114,11 +121,12 @@ class PeekInside {
    *   queries, outgoing calls, console lines and exceptions
    * @param {boolean} [options.captureQueries=true] - pg, mysql2, MongoDB (and Mongoose), Prisma
    * @param {boolean} [options.captureOutgoing=true] - node:http/https requests and fetch
-   * @param {boolean} [options.captureLogs=true] - Log lines (the console, pino, winston): on request
-   *   timelines and the Logs page
+   * @param {boolean} [options.captureLogs=true] - Log lines (the console, pino, winston, NestJS's
+   *   Logger): on request timelines and the Logs page
    * @param {'debug'|'info'|'warn'|'error'} [options.logLevel='info'] - The lowest level the Logs
    *   page records
-   * @param {boolean} [options.captureJobs=true] - Runs of node-cron, cron and BullMQ jobs
+   * @param {boolean} [options.captureJobs=true] - Runs of node-cron, cron, BullMQ and
+   *   @nestjs/schedule jobs
    * @param {boolean} [options.queryParams=true] - Keep the (masked) values sent with queries
    * @param {number} [options.slowQueryMs=100] - Queries this slow or slower are flagged
    * @param {number} [options.nPlusOneThreshold=5] - A statement run this many times in one request
@@ -162,9 +170,10 @@ class PeekInside {
     this._sampler = null;
     // The requests this instance serves, counted for its process samples.
     this._requests = null;
-    // Log lines for the Logs page, and job runs.
+    // Log lines for the Logs page, job runs, and dumps (local mode only).
     this._logs = null;
     this._jobs = null;
+    this._dumps = null;
     this._servers = new ServerBinder(this, { onListening: (port) => this._onAppListening(port) });
 
     const environment = this.options.environment || settings.environment();
@@ -237,6 +246,9 @@ class PeekInside {
       if (logs) {
         this._logs = new LogCapture({ level: LogCapture.level(this.options.logLevel), sink: () => this._transport, isEnabled: () => this.isEnabled });
       }
+      if (this._local) {
+        this._dumps = new DumpCapture({ capture: this._exceptions, sink: () => this._transport, isEnabled: () => this.isEnabled });
+      }
       this._jobs = new JobRunner({
         capture: this._exceptions,
         sink: () => this._transport,
@@ -364,6 +376,48 @@ class PeekInside {
     return instance ? instance.measure(name, fn) : fn();
   }
 
+  /**
+   * Shows a value in the local dashboard instead of your terminal: on the Dumps page and under the
+   * request (or job run) it was dumped in, as a tree that opens level by level, with the line that
+   * dumped it. Returns the value, so it can wrap an expression in place.
+   *
+   * Dumps are for development: they go to the local dashboard only. With PeekInside Cloud, or when
+   * nothing is recorded, dump() just returns the value.
+   *
+   * @template T
+   * @param {T} value - Anything: objects, arrays, Maps, class instances, errors...
+   * @param {string} [label] - Shown with the dump, such as "cart before checkout"
+   * @returns {T} The same value
+   *
+   * @example
+   * const order = PeekInside.dump(await buildOrder(cart), 'order');
+   */
+  dump(value, label) {
+    if (this._dumps) this._dumps.record(value, label, PeekInside.prototype.dump);
+    return value;
+  }
+
+  /**
+   * PeekInside#dump() with the instance that tracks the current request, or else the most recently
+   * created instance that records.
+   *
+   * @template T
+   * @param {T} value
+   * @param {string} [label]
+   * @returns {T} The same value
+   */
+  static dump(value, label) {
+    try {
+      const context = RequestContext.current();
+      const capture = context && context.capture && context.capture.recording ? context.capture : ExceptionCapture.latest();
+      const owner = capture ? capture.owner : null;
+      if (owner && owner._dumps) owner._dumps.record(value, label, PeekInside.dump);
+    } catch (error) {
+      // The value comes back all the same.
+    }
+    return value;
+  }
+
   /**
    * The id of the request the calling code runs for: the id its record has in the dashboard, to
    * put in the app's own logs.
@@ -559,7 +613,9 @@ class PeekInside {
   /**
    * Attach to an application and record its traffic
    *
-   * Detects Fastify, Koa, Express-like apps (Express, Connect) and native `http.Server`s.
+   * Detects NestJS apps (and application contexts), Hono apps, Fastify, Koa, Express-like apps
+   * (Express, Connect) and native `http.Server`s. Attach a NestJS app before app.listen(), a Hono
+   * app before serve(), and a Fastify app before fastify.listen().
    *
    * @param {Object} app - Application or server instance
    * @param {Object} [options] - `maxBodySize` and `ignorePaths` to merge into the configuration
@@ -573,7 +629,7 @@ class PeekInside {
     if (Adapter) {
       this._adapter(Adapter).attach(app);
     } else {
-      console.warn(`${LOG_PREFIX} Could not detect the framework. Use expressMiddleware(), koaMiddleware(), fastifyHook() or wrapHttpServer().`);
+      console.warn(`${LOG_PREFIX} Could not detect the framework. Pass an Express, Koa, Fastify, NestJS or Hono app, or use expressMiddleware(), koaMiddleware(), fastifyHook() or wrapHttpServer().`);
     }
     return this;
   }
@@ -581,7 +637,7 @@ class PeekInside {
   /**
    * One-line setup: record every request an app handles
    *
-   * @param {Object} app - Express, Koa or Fastify app, or an http.Server
+   * @param {Object} app - Express, Koa, Fastify, NestJS or Hono app, or an http.Server
    * @param {Object} [options] - Configuration options (see constructor)
    * @returns {PeekInside} PeekInside instance
    *

package/src/capture/exchange-recorder.js

@@ -11,7 +11,7 @@ import { randomUUID } from 'crypto';
 import http from 'http';
 import { performance } from 'perf_hooks';
 import { BodyDecoder, EMPTY_BODY } from './body-decoder.js';
-import { hasBody, parseQuery } from './http-message.js';
+import { hasBody, parseQuery, stringParams } from './http-message.js';
 import { RequestBodyTap } from './request-body-tap.js';
 import { ResponseTap } from './response-tap.js';
 
@@ -41,6 +41,10 @@ const kBodySource = Symbol('peekInside.bodySource');
  * @property {Array<{ id: string, name: string, message: string }>} [exceptions] - The first of them
  * @property {Object} [stats] - Timeline counters (queries, outgoing calls, logs), added by PeekInside
  * @property {Object} [timeline] - The request's timeline, when something was recorded on it
+ * @property {string} [route] - The route pattern it matched ("/users/:id"), when the framework says
+ * @property {string} [handler] - The code that handled it ("UsersController.findOne"), when known
+ * @property {Array<{ id: string, label: string|null, type: string, preview: string }>} [dumps] - The
+ *   dumps made during it (local dashboard only)
  */
 
 /**
@@ -250,14 +254,3 @@ export class ExchangeRecorder {
     return decoder.decodeValue(parsed, headers);
   }
 }
-
-// Route parameters as strings (Express keeps them as strings; other routers may not).
-function stringParams(params) {
-  const result = {};
-  if (!params || typeof params !== 'object') return result;
-  for (const key of Object.keys(params)) {
-    const value = params[key];
-    if (value !== undefined && value !== null && typeof value !== 'object') result[key] = String(value);
-  }
-  return result;
-}

package/src/capture/http-message.js

@@ -136,3 +136,20 @@ export function hasBody(headers) {
 export function setOwn(target, key, value) {
   Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true });
 }
+
+/**
+ * Route parameters as strings, as records keep them: Express keeps them as strings, other routers
+ * (Fastify, Hono) may not. Values that are objects are left out.
+ *
+ * @param {*} params
+ * @returns {Object<string, string>}
+ */
+export function stringParams(params) {
+  const result = {};
+  if (!params || typeof params !== 'object') return result;
+  for (const key of Object.keys(params)) {
+    const value = params[key];
+    if (value !== undefined && value !== null && typeof value !== 'object') setOwn(result, key, String(value));
+  }
+  return result;
+}

package/src/dumps/dump-capture.js

@@ -0,0 +1,100 @@
+/**
+ * The dumps of one PeekInside instance (PeekInside.dump()): each value is read into a tree (see
+ * DumpValue), with the line of the app that dumped it and the request or job run running then,
+ * and goes to the local dashboard. A dump during a request is listed on the request's record and
+ * placed on its timeline.
+ *
+ * Dumps are rate limited per process (50 a second, bursts of 200), like log lines. Nothing here
+ * throws into the app: dump() always hands the value back.
+ */
+
+import { randomUUID } from 'crypto';
+import { truncate } from '../exceptions/limits.js';
+import { TokenBucket } from '../exceptions/rate-limiter.js';
+import { RequestContext } from '../exceptions/request-context.js';
+import { DumpRecord } from './dump-record.js';
+import { DumpValue } from './dump-value.js';
+
+const MAX_LABEL = 120;
+
+/**
+ * Records dumps for one PeekInside instance.
+ */
+export class DumpCapture {
+  /**
+   * @param {Object} options
+   * @param {import('../exceptions/exception-capture.js').ExceptionCapture} options.capture - The
+   *   instance's exceptions, whose stack frames (mapped to source files) locate a dump
+   * @param {() => Object|null} options.sink - The instance's transport
+   * @param {() => boolean} options.isEnabled - Whether the instance records right now
+   * @param {TokenBucket} [options.limiter]
+   */
+  constructor({ capture, sink, isEnabled, limiter = new TokenBucket({ rate: 50, burst: 200 }) }) {
+    this.capture = capture;
+    this._sink = sink;
+    this._isEnabled = isEnabled;
+    this.limiter = limiter;
+  }
+
+  /**
+   * @type {boolean}
+   */
+  get recording() {
+    const sink = this._sink();
+    return Boolean(sink && !sink.disabled && this._isEnabled());
+  }
+
+  /**
+   * Records a dump. Never throws.
+   *
+   * @param {*} value
+   * @param {*} label - A string names the dump; anything else is ignored
+   * @param {Function} entry - The function the app called (PeekInside.dump): the stack is read
+   *   from its caller
+   * @returns {string|null} The dump's id, or null when nothing was recorded
+   */
+  record(value, label, entry) {
+    try {
+      if (!this.recording) return null;
+      const context = RequestContext.current();
+      // Requests local mode doesn't record (server traffic) take their dumps with them.
+      if (context && context.blocked) return null;
+      if (!this.limiter.take()) return null;
+      const own = context && context.capture === this.capture ? context : null;
+      const { tree, type, preview, truncated } = DumpValue.capture(value);
+      const sink = this._sink();
+      const record = new DumpRecord({
+        id: randomUUID(),
+        occurredAt: Date.now(),
+        environment: sink.environment,
+        release: sink.release || null,
+        requestId: own ? own.requestId : null,
+        jobRunId: own ? own.jobRunId || null : null,
+        label: typeof label === 'string' && label.trim() ? truncate(label.trim(), MAX_LABEL) : null,
+        location: this._callSite(entry),
+        summary: { type, preview, truncated },
+        detail: { value: tree }
+      });
+      if (own) own.noteDump(record);
+      sink.enqueueRecord(record);
+      return record.id;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  // The app's line that called `entry`, mapped through source maps like an exception's frames.
+  _callSite(entry) {
+    const holder = {};
+    const limit = Error.stackTraceLimit;
+    try {
+      Error.stackTraceLimit = 1;
+      Error.captureStackTrace(holder, entry);
+    } finally {
+      Error.stackTraceLimit = limit;
+    }
+    const [frame] = this.capture.builder.frames({ stack: String(holder.stack || ''), fullMessage: '', isError: true }, 1);
+    if (!frame || !frame.file) return null;
+    return { file: frame.file, relativeFile: frame.relativeFile, line: frame.line, column: frame.column, function: frame.function };
+  }
+}

package/src/dumps/dump-record.js

@@ -0,0 +1,57 @@
+/**
+ * One dump, as the local dashboard's Dumps page lists it: when, the label it was given, the line
+ * that dumped it, the request or job run it belongs to, and the value. The list shows the value's
+ * type and a one-line preview; the tree itself is the dump's detail, loaded when it is opened.
+ *
+ * Dumps are for development and go to the local dashboard only, so a record is never sealed.
+ */
+
+/**
+ * A recorded dump.
+ */
+export class DumpRecord {
+  /**
+   * @param {Object} fields
+   * @param {string} fields.id - UUID
+   * @param {number} fields.occurredAt - ms since the epoch
+   * @param {string} fields.environment
+   * @param {string|null} [fields.release=null]
+   * @param {string|null} [fields.requestId=null] - The request it was dumped during
+   * @param {string|null} [fields.jobRunId=null] - The job run it was dumped during
+   * @param {string|null} [fields.label=null] - What the app called it
+   * @param {Object|null} [fields.location=null] - The line that dumped it: file (absolute),
+   *   relativeFile, line, column, function
+   * @param {{ type: string, preview: string, truncated: boolean }} fields.summary
+   * @param {{ value: Object }} fields.detail - The value's tree (see DumpValue)
+   */
+  constructor({ id, occurredAt, environment, release = null, requestId = null, jobRunId = null, label = null, location = null, summary, detail }) {
+    this.id = id;
+    this.occurredAt = occurredAt;
+    this.environment = environment;
+    this.release = release;
+    this.requestId = requestId;
+    this.jobRunId = jobRunId;
+    this.label = label;
+    this.location = location;
+    this.summary = summary;
+    this.detail = detail;
+  }
+
+  /**
+   * What a request's record lists of the dumps made while it was handled.
+   *
+   * @returns {{ id: string, label: string|null, type: string, preview: string }}
+   */
+  link() {
+    return { id: this.id, label: this.label, type: this.summary.type, preview: this.summary.preview };
+  }
+
+  /**
+   * The plain form, as the local hub stores it.
+   *
+   * @returns {Object}
+   */
+  toJSON() {
+    return { ...this };
+  }
+}