peekinside 1.2.4 → 1.3.0

package/src/crypto.js

@@ -177,13 +177,37 @@ export class ApiKey {
   }
 
   /**
-   * @param {string} apiKey
+   * @param {string} apiKey - Surrounding spaces and quotes are ignored (env files that keep them)
    * @returns {ApiKey|null} The key's parts, or null when it isn't a well-formed v1 key
    */
   static parse(apiKey) {
-    const [version, projectId, secret, publicKey, ...rest] = String(apiKey).trim().split('.');
+    const [version, projectId, secret, publicKey, ...rest] = ApiKey.unquote(apiKey).split('.');
     if (version !== 'pik1' || rest.length) return null;
     if (!PROJECT_ID.test(projectId) || !SECRET.test(secret) || !PUBLIC_KEY.test(publicKey)) return null;
     return new ApiKey({ projectId, secret, publicKey });
   }
+
+  /**
+   * What's wrong with a value that isn't an API key, in words for the app's log. Never repeats the
+   * value: it may hold a secret.
+   *
+   * @param {string} value
+   * @returns {string} A sentence without its final period
+   */
+  static problem(value) {
+    const text = ApiKey.unquote(value);
+    if (PUBLIC_KEY.test(text) && Buffer.from(text, 'base64url')[0] === 4) {
+      return 'PEEKINSIDE_API_KEY holds your project\'s public key, not an API key. API keys start with "pik1.": create one in PeekInside Cloud, on the project\'s Settings page under API keys';
+    }
+    if (!text.startsWith('pik1.')) {
+      return 'PEEKINSIDE_API_KEY is not a PeekInside API key (those start with "pik1."). Create one in PeekInside Cloud, on the project\'s Settings page under API keys';
+    }
+    return 'PEEKINSIDE_API_KEY looks cut off or changed: copy the whole key, from "pik1." to its end';
+  }
+
+  // Without the spaces and one pair of matching quotes around it.
+  static unquote(value) {
+    const text = String(value).trim();
+    return /^(["'`]).*\1$/s.test(text) && text.length > 1 ? text.slice(1, -1).trim() : text;
+  }
 }

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 };
+  }
+}

package/src/dumps/dump-value.js

@@ -0,0 +1,428 @@
+/**
+ * The value a dump shows: a typed tree of what the app passed to dump(), read without running the
+ * app's code.
+ *
+ * console.log turns a value into text; a dump keeps its shape, so the dashboard can show it as a
+ * tree that opens level by level, with the type of each node: a Map stays a Map, a Date a date, a
+ * class instance says its class. Reading is careful: getters aren't called (they could do
+ * anything), proxies aren't looked into, and a cycle becomes a reference to the ancestor it loops
+ * back to. The tree stops at bounds on depth, items per object, string length and total size, and
+ * says what it left out.
+ *
+ * Nodes, by `t`:
+ *
+ *   str  { v, len? }                 a string; `len` is its full length when it was cut
+ *   num  { v }  big { v }            numbers and BigInts, as text (NaN, Infinity and -0 survive)
+ *   bool { v }  null  undef  hole    hole: an empty slot of a sparse array
+ *   sym  { v }                       a symbol, as text
+ *   fn   { name, kind? }             a function; kind is "class", "async" or "generator"
+ *   date { v }  re { v }             a date (ISO, or "Invalid Date") and a regular expression
+ *   err  { cls, msg, stack?, props } an error, with its own properties (code, status...)
+ *   arr  { cls?, len, items }        an array (cls for subclasses and typed arrays)
+ *   obj  { cls, len, props }         an object: cls is its class, null for a plain object
+ *   map  { len, entries }  set { len, items }
+ *   buf  { cls, len, hex }           a Buffer or ArrayBuffer: its size and first bytes
+ *   box  { cls, v }                  a boxed primitive (new String("x"))
+ *   get  { set? }                    an own accessor property, not called
+ *   ref  { path }                    a cycle: the ancestor it points back to ("$.owner")
+ *   cut  { cls?, len? }              not read: past the depth or size bounds
+ *   proxy  promise  weak { cls }     kinds whose contents aren't read
+ *
+ * `len` of a container counts all its items, even when only the first ones are in the tree.
+ */
+
+import { types } from 'util';
+
+export const DUMP_LIMITS = Object.freeze({
+  depth: 10,
+  items: 100,
+  string: 4000,
+  stack: 4000,
+  nodes: 5000,
+  // Characters of strings in one tree, all together.
+  text: 256 * 1024,
+  bytes: 48,
+  preview: 160
+});
+
+/**
+ * Reads values into dump trees.
+ */
+export class DumpValue {
+  /**
+   * @param {*} value
+   * @returns {{ tree: Object, type: string, preview: string, truncated: boolean }} The tree, a short
+   *   name of its type ("User", "array", "string"), a one-line preview, and whether bounds cut it
+   */
+  static capture(value) {
+    const reader = new Reader();
+    let tree;
+    try {
+      tree = reader.node(value, 0, '$');
+    } catch (error) {
+      // Every read is guarded; this is the last line of defense.
+      tree = { t: 'cut' };
+      reader.truncated = true;
+    }
+    return { tree, type: DumpValue.typeOf(tree), preview: DumpValue.preview(tree, DUMP_LIMITS.preview), truncated: reader.truncated };
+  }
+
+  /**
+   * A short name of a node's type: its class for objects, else its kind.
+   *
+   * @param {Object} node
+   * @returns {string}
+   */
+  static typeOf(node) {
+    switch (node.t) {
+      case 'str':
+        return 'string';
+      case 'num':
+        return 'number';
+      case 'big':
+        return 'bigint';
+      case 'bool':
+        return 'boolean';
+      case 'undef':
+        return 'undefined';
+      case 'sym':
+        return 'symbol';
+      case 'fn':
+        return node.kind === 'class' ? 'class' : 'function';
+      case 're':
+        return 'RegExp';
+      case 'date':
+        return 'Date';
+      case 'arr':
+        return node.cls || 'array';
+      case 'map':
+        return 'Map';
+      case 'set':
+        return 'Set';
+      case 'err':
+      case 'obj':
+      case 'buf':
+      case 'box':
+        return node.cls || 'object';
+      default:
+        return node.t;
+    }
+  }
+
+  /**
+   * The node on one line, as a list shows it: `User { id: 1, name: "Ada", … }`.
+   *
+   * @param {Object} node
+   * @param {number} [max=160] - Characters at most
+   * @returns {string}
+   */
+  static preview(node, max = DUMP_LIMITS.preview) {
+    const text = line(node, 2);
+    return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+  }
+}
+
+class Reader {
+  constructor() {
+    this.nodes = 0;
+    this.text = 0;
+    this.truncated = false;
+    // The objects being read, from the root down, to their paths: a cycle points back to one.
+    this.ancestors = new Map();
+  }
+
+  node(value, depth, path) {
+    this.nodes++;
+    switch (typeof value) {
+      case 'string':
+        return this.string(value, DUMP_LIMITS.string);
+      case 'number':
+        return { t: 'num', v: Object.is(value, -0) ? '-0' : String(value) };
+      case 'bigint':
+        return { t: 'big', v: value.toString() };
+      case 'boolean':
+        return { t: 'bool', v: value };
+      case 'undefined':
+        return { t: 'undef' };
+      case 'symbol':
+        return { t: 'sym', v: guard(() => value.toString(), 'Symbol()') };
+      case 'function':
+        return fn(value);
+      default:
+        return value === null ? { t: 'null' } : this.object(value, depth, path);
+    }
+  }
+
+  string(value, max) {
+    const room = Math.max(0, Math.min(max, DUMP_LIMITS.text - this.text));
+    if (value.length <= room) {
+      this.text += value.length;
+      return { t: 'str', v: value };
+    }
+    this.truncated = true;
+    const cut = value.slice(0, room);
+    this.text += cut.length;
+    return { t: 'str', v: cut, len: value.length };
+  }
+
+  object(value, depth, path) {
+    if (types.isProxy(value)) return { t: 'proxy' };
+    const ancestor = this.ancestors.get(value);
+    if (ancestor) return { t: 'ref', path: ancestor };
+    const cls = className(value);
+    if (types.isDate(value)) return { t: 'date', v: guard(() => (Number.isNaN(value.getTime()) ? 'Invalid Date' : value.toISOString()), 'Invalid Date') };
+    if (types.isRegExp(value)) return { t: 're', v: guard(() => RegExp.prototype.toString.call(value), '/(?:)/') };
+    if (types.isPromise(value)) return { t: 'promise' };
+    if (types.isWeakMap(value) || types.isWeakSet(value)) return { t: 'weak', cls: cls || 'Weak' };
+    if (Buffer.isBuffer(value)) return { t: 'buf', cls: 'Buffer', len: value.length, hex: value.subarray(0, DUMP_LIMITS.bytes).toString('hex') };
+    if (types.isAnyArrayBuffer(value)) {
+      return { t: 'buf', cls: cls || 'ArrayBuffer', len: value.byteLength, hex: Buffer.from(value, 0, Math.min(DUMP_LIMITS.bytes, value.byteLength)).toString('hex') };
+    }
+    if (types.isBoxedPrimitive(value)) return { t: 'box', cls: cls || 'Object', v: this.node(guard(() => value.valueOf(), undefined), depth + 1, path) };
+    if (depth >= DUMP_LIMITS.depth || this.nodes > DUMP_LIMITS.nodes || this.text >= DUMP_LIMITS.text) {
+      this.truncated = true;
+      return { t: 'cut', ...(cls ? { cls } : {}), ...sizeOf(value) };
+    }
+
+    this.ancestors.set(value, path);
+    try {
+      if (types.isNativeError(value) || value instanceof Error) return this.error(value, cls, depth, path);
+      if (Array.isArray(value)) return this.array(value, cls, depth, path);
+      if (types.isTypedArray(value)) return this.typedArray(value, cls);
+      if (types.isMap(value)) return this.map(value, depth, path);
+      if (types.isSet(value)) return this.set(value, depth, path);
+      return { t: 'obj', cls, ...this.props(value, depth, path, null) };
+    } finally {
+      this.ancestors.delete(value);
+    }
+  }
+
+  // Own enumerable properties, string keys then symbols; `skip` leaves some out.
+  props(value, depth, path, skip) {
+    const keys = guard(() => Reflect.ownKeys(value), []);
+    const props = [];
+    let len = 0;
+    for (const key of keys) {
+      if (skip && skip.has(key)) continue;
+      const descriptor = guard(() => Object.getOwnPropertyDescriptor(value, key), undefined);
+      if (!descriptor || !descriptor.enumerable) continue;
+      len++;
+      if (props.length >= DUMP_LIMITS.items || this.nodes > DUMP_LIMITS.nodes) {
+        this.truncated = true;
+        continue;
+      }
+      const name = typeof key === 'symbol' ? `[${guard(() => key.toString(), 'Symbol()')}]` : key;
+      props.push([name, this.property(descriptor, depth, childPath(path, name))]);
+    }
+    return { len, props };
+  }
+
+  property(descriptor, depth, path) {
+    if ('value' in descriptor) return this.node(descriptor.value, depth + 1, path);
+    this.nodes++;
+    return descriptor.set ? { t: 'get', set: true } : { t: 'get' };
+  }
+
+  array(value, cls, depth, path) {
+    const len = value.length;
+    const count = Math.min(len, DUMP_LIMITS.items);
+    const items = [];
+    for (let index = 0; index < count && this.nodes <= DUMP_LIMITS.nodes; index++) {
+      const descriptor = guard(() => Object.getOwnPropertyDescriptor(value, index), undefined);
+      items.push(descriptor ? this.property(descriptor, depth, `${path}[${index}]`) : (this.nodes++, { t: 'hole' }));
+    }
+    if (items.length < len) this.truncated = true;
+    return { t: 'arr', ...(cls && cls !== 'Array' ? { cls } : {}), len, items };
+  }
+
+  typedArray(value, cls) {
+    const len = value.length;
+    const count = Math.min(len, DUMP_LIMITS.items);
+    const items = [];
+    for (let index = 0; index < count; index++) {
+      this.nodes++;
+      const item = value[index];
+      items.push(typeof item === 'bigint' ? { t: 'big', v: item.toString() } : { t: 'num', v: Object.is(item, -0) ? '-0' : String(item) });
+    }
+    if (count < len) this.truncated = true;
+    return { t: 'arr', cls: cls || 'TypedArray', len, items };
+  }
+
+  map(value, depth, path) {
+    const len = guard(() => MAP_SIZE.call(value), 0);
+    const entries = [];
+    for (const [key, item] of guard(() => Map.prototype.entries.call(value), [])) {
+      if (entries.length >= DUMP_LIMITS.items || this.nodes > DUMP_LIMITS.nodes) break;
+      const keyNode = this.node(key, depth + 1, `${path}.keys()[${entries.length}]`);
+      entries.push([keyNode, this.node(item, depth + 1, `${path}.get(${keyText(keyNode)})`)]);
+    }
+    if (entries.length < len) this.truncated = true;
+    return { t: 'map', len, entries };
+  }
+
+  set(value, depth, path) {
+    const len = guard(() => SET_SIZE.call(value), 0);
+    const items = [];
+    for (const item of guard(() => Set.prototype.values.call(value), [])) {
+      if (items.length >= DUMP_LIMITS.items || this.nodes > DUMP_LIMITS.nodes) break;
+      items.push(this.node(item, depth + 1, `${path}[${items.length}]`));
+    }
+    if (items.length < len) this.truncated = true;
+    return { t: 'set', len, items };
+  }
+
+  error(value, cls, depth, path) {
+    const name = ownString(value, 'name') || cls || 'Error';
+    const message = ownString(value, 'message');
+    // V8 keeps a native error's stack behind its own accessor; reading it runs no app code.
+    const stack = types.isNativeError(value) ? guard(() => (typeof value.stack === 'string' ? value.stack : ''), '') : ownString(value, 'stack');
+    const { props } = this.props(value, depth, path, ERROR_OWN);
+    const cause = guard(() => Object.getOwnPropertyDescriptor(value, 'cause'), undefined);
+    if (cause && 'value' in cause) props.push(['cause', this.node(cause.value, depth + 1, `${path}.cause`)]);
+    return {
+      t: 'err',
+      cls: name,
+      msg: this.string(message, DUMP_LIMITS.string).v,
+      ...(stack ? { stack: this.string(stack, DUMP_LIMITS.stack).v } : {}),
+      props
+    };
+  }
+}
+
+const ERROR_OWN = new Set(['name', 'message', 'stack', 'cause']);
+// Map's and Set's own size getters, so an object's own `size` can't stand in.
+const MAP_SIZE = Object.getOwnPropertyDescriptor(Map.prototype, 'size').get;
+const SET_SIZE = Object.getOwnPropertyDescriptor(Set.prototype, 'size').get;
+
+function fn(value) {
+  if (types.isProxy(value)) return { t: 'proxy' };
+  const name = guard(() => {
+    const descriptor = Object.getOwnPropertyDescriptor(value, 'name');
+    return descriptor && typeof descriptor.value === 'string' ? descriptor.value : '';
+  }, '');
+  let kind = null;
+  if (types.isAsyncFunction(value)) kind = 'async';
+  else if (types.isGeneratorFunction(value)) kind = 'generator';
+  else if (guard(() => /^class\b/.test(Function.prototype.toString.call(value)), false)) kind = 'class';
+  return { t: 'fn', name, ...(kind ? { kind } : {}) };
+}
+
+// The class of an object, read without getters: null for plain objects (and those without a
+// prototype).
+function className(value) {
+  return guard(() => {
+    const proto = Object.getPrototypeOf(value);
+    if (proto === null || proto === Object.prototype) return null;
+    const constructor = Object.getOwnPropertyDescriptor(proto, 'constructor');
+    const name = constructor && typeof constructor.value === 'function' ? Object.getOwnPropertyDescriptor(constructor.value, 'name') : null;
+    return name && typeof name.value === 'string' && name.value ? name.value : 'Object';
+  }, null);
+}
+
+// How big a container left unread is, when that is cheap to know.
+function sizeOf(value) {
+  if (Array.isArray(value)) return { len: value.length };
+  if (types.isMap(value)) return { len: guard(() => MAP_SIZE.call(value), 0) };
+  if (types.isSet(value)) return { len: guard(() => SET_SIZE.call(value), 0) };
+  return {};
+}
+
+function ownString(value, key) {
+  const descriptor = guard(() => Object.getOwnPropertyDescriptor(value, key), undefined);
+  if (descriptor && typeof descriptor.value === 'string') return descriptor.value;
+  // name and message usually live on the prototype (Error.prototype.name); read as data only.
+  for (let proto = guard(() => Object.getPrototypeOf(value), null); proto; proto = guard(() => Object.getPrototypeOf(proto), null)) {
+    const inherited = guard(() => Object.getOwnPropertyDescriptor(proto, key), undefined);
+    if (inherited) return typeof inherited.value === 'string' ? inherited.value : '';
+  }
+  return '';
+}
+
+function childPath(path, key) {
+  return /^[A-Za-z_$][\w$]*$/.test(key) ? `${path}.${key}` : `${path}[${JSON.stringify(key)}]`;
+}
+
+function keyText(node) {
+  return node.t === 'str' ? JSON.stringify(node.v) : node.t === 'num' || node.t === 'big' || node.t === 'bool' ? String(node.v) : '…';
+}
+
+function guard(read, fallback) {
+  try {
+    return read();
+  } catch (error) {
+    return fallback;
+  }
+}
+
+// One node as text, `depth` levels down.
+function line(node, depth) {
+  switch (node.t) {
+    case 'str':
+      return JSON.stringify(node.v.length > 60 ? `${node.v.slice(0, 60)}…` : node.v);
+    case 'num':
+    case 'sym':
+    case 'date':
+    case 're':
+      return node.v;
+    case 'big':
+      return `${node.v}n`;
+    case 'bool':
+      return String(node.v);
+    case 'null':
+      return 'null';
+    case 'undef':
+      return 'undefined';
+    case 'hole':
+      return '<empty>';
+    case 'fn':
+      return node.kind === 'class' ? `[class ${node.name || '(anonymous)'}]` : `[${node.kind === 'async' ? 'AsyncFunction' : 'Function'}${node.name ? ` ${node.name}` : ''}]`;
+    case 'err':
+      return node.msg ? `${node.cls}: ${node.msg}` : node.cls;
+    case 'buf':
+      return `<${node.cls} ${(node.hex.match(/../g) || []).slice(0, 8).join(' ')}${node.len > 8 ? ' …' : ''}>`;
+    case 'box':
+      return `[${node.cls}: ${line(node.v, 0)}]`;
+    case 'get':
+      return node.set ? '[Getter/Setter]' : '[Getter]';
+    case 'ref':
+      return `[Circular ${node.path}]`;
+    case 'proxy':
+      return '[Proxy]';
+    case 'promise':
+      return 'Promise';
+    case 'weak':
+      return node.cls;
+    case 'cut':
+      return `${node.cls ? `${node.cls} ` : ''}{…}`;
+    case 'arr': {
+      const head = node.cls ? `${node.cls}(${node.len}) ` : '';
+      if (!node.len) return `${head}[]`;
+      if (depth <= 0) return `${head}[…]`;
+      return `${head}[${list(node.items.map((item) => line(item, depth - 1)), node.len)}]`;
+    }
+    case 'map': {
+      if (!node.len) return 'Map(0) {}';
+      if (depth <= 0) return `Map(${node.len}) {…}`;
+      return `Map(${node.len}) { ${list(node.entries.map(([key, value]) => `${line(key, 0)} => ${line(value, depth - 1)}`), node.len)} }`;
+    }
+    case 'set': {
+      if (!node.len) return 'Set(0) {}';
+      if (depth <= 0) return `Set(${node.len}) {…}`;
+      return `Set(${node.len}) { ${list(node.items.map((item) => line(item, depth - 1)), node.len)} }`;
+    }
+    case 'obj': {
+      const head = node.cls ? `${node.cls} ` : '';
+      if (!node.len) return `${head}{}`;
+      if (depth <= 0) return `${head}{…}`;
+      return `${head}{ ${list(node.props.map(([key, value]) => `${/^[A-Za-z_$][\w$]*$/.test(key) ? key : JSON.stringify(key)}: ${line(value, depth - 1)}`), node.len)} }`;
+    }
+    default:
+      return '…';
+  }
+}
+
+// The first few parts, and an ellipsis for the rest.
+function list(parts, total) {
+  const shown = parts.slice(0, 4);
+  return total > shown.length ? `${shown.join(', ')}, …` : shown.join(', ');
+}

package/src/exceptions/exception-capture.js

@@ -13,7 +13,8 @@
  * - Whether an Express error was handled is only known later: an error middleware that receives
  *   it may still pass it on to Express's final handler. Such records stay open on the request and
  *   are settled when the error reaches the final handler (unhandled) or the request's record is
- *   built (handled).
+ *   built (handled). NestJS exception filters and Hono error handlers work the same way: one that
+ *   takes an error may still hand it to the framework's default answer.
  *
  * Nothing here ever throws into the app: a failure to record is a lost exception, never a new one.
  */
@@ -134,12 +135,12 @@ export class ExceptionCapture {
   }
 
   /**
-   * An error reached a framework during a request: Express, Koa or Fastify.
+   * An error reached a framework during a request: Express, Koa, Fastify, NestJS or Hono.
    *
    * @param {RequestContext|null} context - The request's context
    * @param {*} error
    * @param {Object} options
-   * @param {'express'|'koa'|'fastify'} options.mechanism
+   * @param {'express'|'koa'|'fastify'|'nest'|'hono'} options.mechanism
    * @param {boolean} options.handled - Whether the app handled it
    * @param {boolean} [options.open=false] - The outcome isn't final yet (see the module comment)
    * @returns {string|null} The exception's id, or null when nothing was recorded
@@ -290,7 +291,7 @@ export class ExceptionCapture {
           exchange.exceptionCount = own.exceptionCount;
           exchange.exceptions = own.links.slice();
           own.completeTimeline(exchange);
-          if (own.user) exchange.user = own.user;
+          own.describe(exchange);
           exchanges.push(exchange);
         }
       }