peekinside 1.2.5 → 1.3.0

package/src/hub/ingest-payload.js

@@ -13,9 +13,10 @@ import { PROJECT_ID } from './store.js';
 export const MAX_BATCH = 1000;
 // Exceptions per batch.
 export const MAX_EXCEPTIONS_BATCH = 500;
-// Job runs and log lines per batch.
+// Job runs, log lines and dumps per batch.
 export const MAX_JOBS_BATCH = 1000;
 export const MAX_LOGS_BATCH = 2000;
+export const MAX_DUMPS_BATCH = 1000;
 // Request ids are UUIDs in practice. They appear in URLs and index files, so only safe
 // characters are accepted.
 export const REQUEST_ID = /^[A-Za-z0-9_-]{1,64}$/;
@@ -27,13 +28,20 @@ const FINGERPRINT = /^[0-9a-f]{16}$/;
 const STAT_KEYS = ['queries', 'queryTime', 'slowQueries', 'nPlusOne', 'duplicates', 'http', 'httpTime', 'logs', 'loopBlock'];
 const STAT_TIMES = new Set(['queryTime', 'httpTime', 'loopBlock']);
 const MAX_STAT = 1e9;
-const MECHANISMS = new Set(['express', 'koa', 'fastify', 'http', 'uncaught', 'unhandledRejection', 'report', 'job']);
+const MECHANISMS = new Set(['express', 'koa', 'fastify', 'nest', 'hono', 'http', 'uncaught', 'unhandledRejection', 'report', 'job']);
 const JOB_STATUSES = new Set(['ok', 'failed']);
 const JOB_TRIGGERS = new Set(['cron', 'queue', 'manual']);
 const LOG_LEVELS = new Set(['debug', 'info', 'warn', 'error']);
-const LOG_SOURCES = new Set(['console', 'pino', 'winston']);
+const LOG_SOURCES = new Set(['console', 'pino', 'winston', 'nest']);
+// What the SDK keeps of a route pattern and a handler name.
+const MAX_ROUTE = 512;
+const MAX_HANDLER = 256;
 // What the index keeps of a log line; the line in full is its detail.
 const LOG_PREVIEW = 500;
+// What the index keeps of a dump: its label, the type and a one-line preview of its value.
+const DUMP_LABEL = 120;
+const DUMP_TYPE = 64;
+const DUMP_PREVIEW = 200;
 // What release.js produces.
 const RELEASE = /^[A-Za-z0-9._:@/+-]{1,64}$/;
 // Process samples per batch (the SDK sends one every 10 seconds, more after the hub was down).
@@ -77,10 +85,14 @@ export class IngestPayload {
     }
     const jobs = body.jobs != null ? body.jobs : [];
     const logs = body.logs != null ? body.logs : [];
+    const dumps = body.dumps != null ? body.dumps : [];
     if (!Array.isArray(jobs) || jobs.length > MAX_JOBS_BATCH || !Array.isArray(logs) || logs.length > MAX_LOGS_BATCH) {
       return null;
     }
-    return new IngestPayload({ project, instance, requests, exceptions, jobs, logs, samples: body.samples, blocked: body.blocked, hasExceptions: Array.isArray(body.exceptions) });
+    if (!Array.isArray(dumps) || dumps.length > MAX_DUMPS_BATCH) {
+      return null;
+    }
+    return new IngestPayload({ project, instance, requests, exceptions, jobs, logs, dumps, samples: body.samples, blocked: body.blocked, hasExceptions: Array.isArray(body.exceptions) });
   }
 
   /**
@@ -93,12 +105,13 @@ export class IngestPayload {
    * @param {Array} [parts.exceptions] - Exception records as sent
    * @param {Array} [parts.jobs] - Job runs as sent
    * @param {Array} [parts.logs] - Log lines as sent
+   * @param {Array} [parts.dumps] - Dumps as sent
    * @param {*} [parts.samples] - Process samples (memory, CPU, event-loop delay), as sent
    * @param {*} parts.blocked - Counts of unrecorded server requests, as sent
    * @param {boolean} [parts.hasExceptions=false] - Whether the batch had an exception list (SDKs
    *   from before exceptions don't send one)
    */
-  constructor({ project, instance, requests, exceptions = [], jobs = [], logs = [], samples, blocked, hasExceptions = false }) {
+  constructor({ project, instance, requests, exceptions = [], jobs = [], logs = [], dumps = [], samples, blocked, hasExceptions = false }) {
     this.project = project;
     this.instance = instance;
     /**
@@ -139,6 +152,12 @@ export class IngestPayload {
     this.logs = logs.map(readLog).filter(Boolean);
     this.rejectedJobs = jobs.length - this.jobs.length;
     this.rejectedLogs = logs.length - this.logs.length;
+    /**
+     * The valid dumps, flattened into what the store keeps (the value's tree is the detail)
+     * @type {Object[]}
+     */
+    this.dumps = dumps.map(readDump).filter(Boolean);
+    this.rejectedDumps = dumps.length - this.dumps.length;
     /**
      * The valid counts of server requests the SDK didn't record
      * @type {{ kind: 'host'|'client', value: string, count: number }[]}
@@ -196,6 +215,8 @@ function readRecord(value) {
     url: text(summary.url, 16384),
     path: text(summary.path, 16384),
     contentType: text(summary.contentType, 256),
+    route: text(summary.route, MAX_ROUTE) || null,
+    handler: text(summary.handler, MAX_HANDLER) || null,
     user: readUser(summary.user),
     detail
   };
@@ -299,6 +320,43 @@ function readLog(value) {
   };
 }
 
+// A dump: its fields, the start of its value for the list, and the value's tree as its detail. The
+// tree is the dashboard's to read; the hub only keeps it.
+function readDump(value) {
+  if (!value || typeof value !== 'object') return null;
+  if (typeof value.id !== 'string' || !REQUEST_ID.test(value.id) || !Number.isFinite(value.occurredAt)) return null;
+  if (!optionalId(value.requestId) || !optionalId(value.jobRunId)) return null;
+  const summary = value.summary && typeof value.summary === 'object' ? value.summary : {};
+  const detail = value.detail && typeof value.detail === 'object' && !Array.isArray(value.detail) ? value.detail : {};
+  const tree = detail.value && typeof detail.value === 'object' && !Array.isArray(detail.value) && typeof detail.value.t === 'string' ? detail.value : { t: 'undef' };
+  return {
+    id: value.id,
+    occurredAt: value.occurredAt,
+    environment: text(value.environment, 32) || 'development',
+    release: release(value.release),
+    requestId: value.requestId || null,
+    jobRunId: value.jobRunId || null,
+    label: text(value.label, DUMP_LABEL) || null,
+    location: readCaller(value.location),
+    type: text(summary.type, DUMP_TYPE) || 'value',
+    preview: text(summary.preview, DUMP_PREVIEW),
+    truncated: summary.truncated === true,
+    detail: { value: tree }
+  };
+}
+
+// Where in the app something happened: an absolute file, the same relative to the project, a line.
+function readCaller(value) {
+  if (!value || typeof value !== 'object' || typeof value.file !== 'string' || !value.file) return null;
+  return {
+    file: value.file.slice(0, 4096),
+    relativeFile: typeof value.relativeFile === 'string' ? value.relativeFile.slice(0, 4096) : null,
+    line: positiveInt(value.line),
+    column: positiveInt(value.column),
+    function: typeof value.function === 'string' ? value.function.slice(0, 1024) : null
+  };
+}
+
 function optionalId(value) {
   return value === null || value === undefined || (typeof value === 'string' && REQUEST_ID.test(value));
 }
@@ -351,7 +409,9 @@ function readUser(value) {
 
 function readRequestLine(value) {
   if (!value || typeof value !== 'object' || typeof value.method !== 'string' || typeof value.path !== 'string') return null;
-  return { method: value.method.slice(0, 16), path: value.path.slice(0, 16384) };
+  const route = text(value.route, MAX_ROUTE);
+  const handler = text(value.handler, MAX_HANDLER);
+  return { method: value.method.slice(0, 16), path: value.path.slice(0, 16384), ...(route ? { route } : {}), ...(handler ? { handler } : {}) };
 }
 
 function positiveInt(value) {

package/src/hub/project-log.js

@@ -8,6 +8,7 @@
  *   exception-state.json     fingerprints the dashboard marked resolved
  *   jobs/00000001.*          job runs, in the same format
  *   logs/00000001.*          log lines: the index keeps the start of each line, the details the rest
+ *   dumps/00000001.*         dumps: the index keeps a preview of each value, the details its tree
  *
  * Process samples (memory, CPU, event-loop delay) are kept in memory only, for the Runtime page:
  * the last six hours of each of the project's recent processes.
@@ -33,13 +34,15 @@ const MAX_BLOCKED_ENTRIES = 10;
 const MAX_RUNTIME_SAMPLES = 2160;
 const MAX_RUNTIME_PROCESSES = 8;
 // Fields a summary may contain, in the order they are written.
-const SUMMARY_FIELDS = ['seq', 'id', 'occurredAt', 'environment', 'release', 'method', 'status', 'duration', 'requestSize', 'responseSize', 'aborted', 'exceptionCount', 'stats', 'url', 'path', 'contentType', 'user'];
+const SUMMARY_FIELDS = ['seq', 'id', 'occurredAt', 'environment', 'release', 'method', 'status', 'duration', 'requestSize', 'responseSize', 'aborted', 'exceptionCount', 'stats', 'url', 'path', 'contentType', 'route', 'handler', 'user'];
 const EXCEPTION_FIELDS = ['seq', 'id', 'occurredAt', 'environment', 'release', 'handled', 'fatal', 'requestId', 'jobRunId', 'name', 'message', 'code', 'fingerprint', 'mechanism', 'location', 'request', 'job', 'user'];
 const JOB_FIELDS = ['seq', 'id', 'occurredAt', 'environment', 'release', 'name', 'queue', 'schedule', 'timezone', 'trigger', 'status', 'duration', 'attempt', 'exceptionCount', 'stats', 'error', 'user'];
 const LOG_FIELDS = ['seq', 'id', 'occurredAt', 'environment', 'release', 'level', 'source', 'requestId', 'jobRunId', 'message'];
+const DUMP_FIELDS = ['seq', 'id', 'occurredAt', 'environment', 'release', 'requestId', 'jobRunId', 'label', 'location', 'type', 'preview', 'truncated'];
 const EXCEPTIONS_FOLDER = 'exceptions';
 const JOBS_FOLDER = 'jobs';
 const LOGS_FOLDER = 'logs';
+const DUMPS_FOLDER = 'dumps';
 
 /**
  * @typedef {Object} ProjectInfo
@@ -71,7 +74,8 @@ export class ProjectLog {
    * @param {number} limits.exceptionSegmentSize - Exceptions per segment file
    * @param {number} limits.maxJobs - Job runs kept
    * @param {number} limits.maxLogs - Log lines kept
-   * @param {{ requests?: SegmentLog, exceptions?: SegmentLog, jobs?: SegmentLog, logs?: SegmentLog }} [logs] - Logs
+   * @param {number} limits.maxDumps - Dumps kept
+   * @param {{ requests?: SegmentLog, exceptions?: SegmentLog, jobs?: SegmentLog, logs?: SegmentLog, dumps?: SegmentLog }} [logs] - Logs
    *   read from disk
    */
   constructor(dir, info, limits, logs = {}) {
@@ -82,6 +86,7 @@ export class ProjectLog {
     this.exceptions = logs.exceptions || new SegmentLog(path.join(dir, EXCEPTIONS_FOLDER), ProjectLog._exceptionOptions(info, limits));
     this.jobs = logs.jobs || new SegmentLog(path.join(dir, JOBS_FOLDER), ProjectLog._jobOptions(info, limits));
     this.logs = logs.logs || new SegmentLog(path.join(dir, LOGS_FOLDER), ProjectLog._logOptions(info, limits));
+    this.dumps = logs.dumps || new SegmentLog(path.join(dir, DUMPS_FOLDER), ProjectLog._dumpOptions(info, limits));
     this.exceptionState = new ExceptionState(dir);
     // Processes running the project, by pid. In memory only: they check in again after a restart.
     this.instances = new Map();
@@ -111,7 +116,8 @@ export class ProjectLog {
       seqBase: 1,
       exceptionSeqBase: 1,
       jobSeqBase: 1,
-      logSeqBase: 1
+      logSeqBase: 1,
+      dumpSeqBase: 1
     }, limits);
     project.save();
     return project;
@@ -138,13 +144,15 @@ export class ProjectLog {
       exceptionSeqBase: Number(saved.exceptionSeqBase) || 1,
       jobSeqBase: Number(saved.jobSeqBase) || 1,
       logSeqBase: Number(saved.logSeqBase) || 1,
+      dumpSeqBase: Number(saved.dumpSeqBase) || 1,
       ...(isBlockedInfo(saved.blocked) ? { blocked: saved.blocked } : {})
     };
     return new ProjectLog(dir, info, limits, {
       requests: SegmentLog.load(dir, ProjectLog._requestOptions(info, limits)),
       exceptions: SegmentLog.load(path.join(dir, EXCEPTIONS_FOLDER), ProjectLog._exceptionOptions(info, limits)),
       jobs: SegmentLog.load(path.join(dir, JOBS_FOLDER), ProjectLog._jobOptions(info, limits)),
-      logs: SegmentLog.load(path.join(dir, LOGS_FOLDER), ProjectLog._logOptions(info, limits))
+      logs: SegmentLog.load(path.join(dir, LOGS_FOLDER), ProjectLog._logOptions(info, limits)),
+      dumps: SegmentLog.load(path.join(dir, DUMPS_FOLDER), ProjectLog._dumpOptions(info, limits))
     });
   }
 
@@ -416,6 +424,48 @@ export class ProjectLog {
     this.save();
   }
 
+  /**
+   * Stores new dumps; ones already stored (same id) are skipped.
+   *
+   * @param {Object[]} records - Validated dumps, with their detail (the value's tree)
+   * @returns {Object[]}
+   */
+  appendDumps(records) {
+    return this.dumps.append(records);
+  }
+
+  /**
+   * Dump summaries, newest first; oldest first when `after` is given.
+   *
+   * @param {{ after?: number, before?: number, limit: number }} query
+   * @returns {{ dumps: Object[], hasMore: boolean }}
+   */
+  listDumps(query) {
+    const { entries, hasMore } = this.dumps.list(query);
+    return { dumps: entries, hasMore };
+  }
+
+  /**
+   * One dump's value (its tree).
+   *
+   * @param {string} dumpId
+   * @returns {Object|null}
+   */
+  dumpDetail(dumpId) {
+    return this.dumps.detail(dumpId);
+  }
+
+  /**
+   * Deletes all dumps.
+   *
+   * @returns {void}
+   */
+  clearDumps() {
+    this.dumps.clear();
+    this.info.dumpSeqBase = this.dumps.seqBase;
+    this.save();
+  }
+
   /**
    * Deletes the project's folder.
    *
@@ -444,6 +494,7 @@ export class ProjectLog {
     const newest = this.requests.newest;
     const newestException = this.exceptions.newest;
     const newestJob = this.jobs.newest;
+    const newestDump = this.dumps.newest;
     return {
       id: this.info.id,
       name: this.info.name,
@@ -457,6 +508,8 @@ export class ProjectLog {
       jobCount: this.jobs.size,
       lastJobAt: newestJob ? newestJob.occurredAt : null,
       logCount: this.logs.size,
+      dumpCount: this.dumps.size,
+      lastDumpAt: newestDump ? newestDump.occurredAt : null,
       online: instances.length > 0,
       instances,
       blocked: this.info.blocked && now - this.info.blocked.lastAt < BLOCKED_NOTICE_MS ? this.info.blocked : null
@@ -495,6 +548,7 @@ export class ProjectLog {
     this.exceptions.enforceRetention();
     this.jobs.enforceRetention();
     this.logs.enforceRetention();
+    this.dumps.enforceRetention();
   }
 
   static _requestOptions(info, limits) {
@@ -509,6 +563,10 @@ export class ProjectLog {
     return { maxEntries: limits.maxLogs, segmentSize: Math.max(10, Math.ceil(limits.maxLogs / 4)), seqBase: info.logSeqBase || 1, pick: pickLog };
   }
 
+  static _dumpOptions(info, limits) {
+    return { maxEntries: limits.maxDumps, segmentSize: Math.max(10, Math.ceil(limits.maxDumps / 4)), seqBase: info.dumpSeqBase || 1, pick: pickDump };
+  }
+
   static _exceptionOptions(info, limits) {
     return {
       maxEntries: limits.maxExceptions,
@@ -533,6 +591,9 @@ function pickSummary(source) {
   // Stored before releases (or users) were recorded.
   if (summary.release === undefined) summary.release = null;
   if (summary.user === undefined) summary.user = null;
+  // Stored before route patterns were recorded, or from a framework that doesn't name them.
+  if (summary.route === undefined) summary.route = null;
+  if (summary.handler === undefined) summary.handler = null;
   return summary;
 }
 
@@ -552,6 +613,12 @@ function pickJob(source) {
   return summary;
 }
 
+function pickDump(source) {
+  const summary = {};
+  for (const field of DUMP_FIELDS) summary[field] = source[field] === undefined ? null : source[field];
+  return summary;
+}
+
 function pickLog(source) {
   const summary = {};
   for (const field of LOG_FIELDS) summary[field] = source[field] === undefined ? null : source[field];

package/src/hub/server.js

@@ -2,7 +2,7 @@
  * The local hub's HTTP server, on 127.0.0.1 only.
  *
  *   GET    /                                   Dashboard page (also /p/<project id>, and its
- *                                              /exceptions, /routes, /queries, /logs, /jobs and /runtime)
+ *                                              /exceptions, /routes, /queries, /logs, /jobs, /dumps and /runtime)
  *   POST   /api/ingest                         Requests and exceptions from the SDK in each app, and
  *                                              counts of server requests it didn't record (free plan)
  *   GET    /api/status                         Hub version and settings
@@ -20,6 +20,9 @@
  *   GET    /api/projects/:id/logs              Log lines (their start), paged like requests
  *   GET    /api/projects/:id/logs/:lid         One log line in full
  *   DELETE /api/projects/:id/logs              Delete a project's log lines
+ *   GET    /api/projects/:id/dumps             Dumps (a preview of each value), paged like requests
+ *   GET    /api/projects/:id/dumps/:did        One dump's value
+ *   DELETE /api/projects/:id/dumps             Delete a project's dumps
  *   GET    /api/projects/:id/exception-state   Resolved issues, with a version
  *   PUT    /api/projects/:id/exception-state   Save them, if the version is still the current one
  *   DELETE /api/projects/:id                   Forget a project
@@ -38,7 +41,7 @@ import { readFileSync } from 'fs';
 import { HUB_API_VERSION, HUB_APP_ID } from '../config.js';
 import { ExceptionState } from './exception-state.js';
 import { IngestPayload, REQUEST_ID } from './ingest-payload.js';
-import { PROJECT_ID } from './store.js';
+import { DEFAULT_MAX_DUMPS, PROJECT_ID } from './store.js';
 
 const MAX_INGEST_BYTES = 32 * 1024 * 1024;
 // 5000 fingerprints with their timestamps take about 200 KB.
@@ -46,9 +49,9 @@ const MAX_STATE_BYTES = 1024 * 1024;
 const DEFAULT_PAGE = 500;
 const MAX_PAGE = 1000;
 // /api/projects/:id, then optionally a collection and an item.
-const PROJECT_ROUTE = /^\/api\/projects\/([^/]+)(?:\/(requests|exceptions|exception-state|runtime|jobs|logs)(?:\/([^/]+))?)?$/;
+const PROJECT_ROUTE = /^\/api\/projects\/([^/]+)(?:\/(requests|exceptions|exception-state|runtime|jobs|logs|dumps)(?:\/([^/]+))?)?$/;
 // The dashboard page: the project list, a project's requests, its exceptions and its queries.
-const SHELL_ROUTE = /^\/p\/[a-z0-9-]{1,64}(?:\/(?:exceptions|routes|queries|runtime|logs|jobs))?\/?$/;
+const SHELL_ROUTE = /^\/p\/[a-z0-9-]{1,64}(?:\/(?:exceptions|routes|queries|runtime|logs|jobs|dumps))?\/?$/;
 
 const BASE_HEADERS = {
   'X-Content-Type-Options': 'nosniff',
@@ -150,7 +153,9 @@ export class HubServer {
       dataDir: this.dataDir,
       siteUrl: this.siteUrl,
       maxRequests: this.store.maxRequests,
-      maxExceptions: this.store.maxExceptions
+      maxExceptions: this.store.maxExceptions,
+      // Also tells the dashboard this hub keeps dumps (older ones don't).
+      maxDumps: DEFAULT_MAX_DUMPS
     };
   }
 
@@ -243,6 +248,7 @@ export class HubServer {
     this.store.addSamples(payload.project.id, payload.instance, payload.samples);
     const addedJobs = this.store.appendJobs(payload.project.id, payload.jobs);
     const addedLogs = this.store.appendLogs(payload.project.id, payload.logs);
+    const addedDumps = this.store.appendDumps(payload.project.id, payload.dumps);
     // SDKs from before exceptions get the answer they know.
     return sendJson(res, 200, payload.hasExceptions
       ? {
@@ -251,9 +257,10 @@ export class HubServer {
         acceptedExceptions: addedExceptions.length,
         rejectedExceptions: payload.rejectedExceptions,
         acceptedJobs: addedJobs.length,
-        acceptedLogs: addedLogs.length
+        acceptedLogs: addedLogs.length,
+        acceptedDumps: addedDumps.length
       }
-      : { accepted: added.length, rejected: payload.rejected, acceptedJobs: addedJobs.length, acceptedLogs: addedLogs.length });
+      : { accepted: added.length, rejected: payload.rejected, acceptedJobs: addedJobs.length, acceptedLogs: addedLogs.length, acceptedDumps: addedDumps.length });
   }
 
   // Every /api/ route except ingest; the caller has checked the origin.
@@ -299,6 +306,10 @@ export class HubServer {
       if (item !== undefined) return this._item(req, res, decode(item), (id) => this.store.logDetail(projectId, id), 'This log line is no longer stored.');
       return this._collection(req, res, query, () => this.store.listLogs(projectId, pageOf(query)), () => this.store.clearLogs(projectId));
     }
+    if (collection === 'dumps') {
+      if (item !== undefined) return this._item(req, res, decode(item), (id) => this.store.dumpDetail(projectId, id), 'This dump is no longer stored.');
+      return this._collection(req, res, query, () => this.store.listDumps(projectId, pageOf(query)), () => this.store.clearDumps(projectId));
+    }
     if (collection === 'runtime') {
       if (item !== undefined) return sendJson(res, 404, { error: 'Not found' });
       return read ? sendJson(res, 200, this.store.runtime(projectId)) : methodNotAllowed(res, 'GET, HEAD');

package/src/hub/spool-ingester.js

@@ -104,6 +104,7 @@ export class SpoolIngester {
     const exceptions = this.store.appendExceptions(payload.project.id, payload.exceptions).length;
     this.store.appendJobs(payload.project.id, payload.jobs);
     this.store.appendLogs(payload.project.id, payload.logs);
+    this.store.appendDumps(payload.project.id, payload.dumps);
     spool.remove(name);
     return { requests, exceptions };
   }

package/src/hub/store.js

@@ -16,6 +16,7 @@ export const DEFAULT_MAX_REQUESTS = 1000;
 export const DEFAULT_MAX_EXCEPTIONS = 500;
 export const DEFAULT_MAX_JOBS = 2000;
 export const DEFAULT_MAX_LOGS = 10000;
+export const DEFAULT_MAX_DUMPS = 1000;
 
 /**
  * All projects on this machine.
@@ -206,6 +207,47 @@ export class Store {
     if (project) project.clearLogs();
   }
 
+  /**
+   * Stores new dumps of a project.
+   *
+   * @param {string} projectId
+   * @param {Object[]} records
+   * @returns {Object[]}
+   */
+  appendDumps(projectId, records) {
+    const project = this.projects.get(projectId);
+    return project && records.length ? project.appendDumps(records) : [];
+  }
+
+  /**
+   * @param {string} projectId
+   * @param {{ after?: number, before?: number, limit: number }} query
+   * @returns {{ dumps: Object[], hasMore: boolean }|null}
+   */
+  listDumps(projectId, query) {
+    const project = this.projects.get(projectId);
+    return project ? project.listDumps(query) : null;
+  }
+
+  /**
+   * @param {string} projectId
+   * @param {string} dumpId
+   * @returns {Object|null}
+   */
+  dumpDetail(projectId, dumpId) {
+    const project = this.projects.get(projectId);
+    return project ? project.dumpDetail(dumpId) : null;
+  }
+
+  /**
+   * @param {string} projectId
+   * @returns {void}
+   */
+  clearDumps(projectId) {
+    const project = this.projects.get(projectId);
+    if (project) project.clearDumps();
+  }
+
   /**
    * Adds process samples of a project's process (kept in memory, for the Runtime page).
    *
@@ -398,7 +440,8 @@ export class Store {
       maxExceptions: this.maxExceptions,
       exceptionSegmentSize: this.exceptionSegmentSize,
       maxJobs: DEFAULT_MAX_JOBS,
-      maxLogs: DEFAULT_MAX_LOGS
+      maxLogs: DEFAULT_MAX_LOGS,
+      maxDumps: DEFAULT_MAX_DUMPS
     };
   }
 }

package/src/instrumentation/index.js

@@ -12,12 +12,14 @@
  *
  * Outgoing HTTP and console capture are process-wide subscriptions; they record only for code
  * running inside a request (log lines go to the Logs page from anywhere). Loggers (pino, winston)
- * and job libraries (node-cron, cron, BullMQ) are found and patched like the drivers.
+ * and job libraries (node-cron, cron, BullMQ) are found and patched like the drivers; NestJS's
+ * Logger and @nestjs/schedule are reached through the app instead (see integrations/nest.js).
  */
 
 import { createRequire } from 'module';
 import fs from 'fs';
 import path from 'path';
+import { pathToFileURL } from 'url';
 import { ConsoleInstrumentation } from './console.js';
 import { HttpInstrumentation } from './http.js';
 import { JobInstrumentation } from './jobs.js';
@@ -71,6 +73,10 @@ export class Instrumentation {
     if (!fromRoot) return patched;
     if (patchWith(fromRoot, 'pino', LoggerInstrumentation.pino)) patched.push('pino');
     if (patchWith(fromRoot, 'winston', LoggerInstrumentation.winston)) patched.push('winston');
+    // NestJS's ConsoleLogger, for a NestJS project.
+    if (declares(root, '@nestjs/common')) {
+      void importInstalled(fromRoot, '@nestjs/common', null, (common) => LoggerInstrumentation.nest(exported(common, 'ConsoleLogger')));
+    }
     return patched;
   }
 
@@ -92,6 +98,11 @@ export class Instrumentation {
       const directory = packageDirectory(main, name);
       if (directory) void JobInstrumentation.patchModuleBuild(directory, patch);
     }
+    // @nestjs/schedule registers a NestJS app's scheduled methods as the app initializes, which a
+    // worker (NestFactory.createApplicationContext()) does before it can be attached.
+    if (declares(root, '@nestjs/schedule')) {
+      void importInstalled(fromRoot, '@nestjs/schedule', path.join('dist', 'schedule.explorer.js'), (explorer) => JobInstrumentation.nestSchedule(exported(explorer, 'ScheduleExplorer')));
+    }
     return patched;
   }
 
@@ -217,14 +228,48 @@ function resolve(fromSomewhere, name) {
   }
 }
 
-// The folder of the package `name` that contains `file`.
+// The folder of the package `name` (scoped or not) that contains `file`.
 function packageDirectory(file, name) {
+  const [scope, base] = name.includes('/') ? name.split('/') : [null, name];
   for (let directory = path.dirname(file); ; directory = path.dirname(directory)) {
-    if (path.basename(directory) === name && fs.existsSync(path.join(directory, 'package.json'))) return directory;
+    const named = path.basename(directory) === base && (!scope || path.basename(path.dirname(directory)) === scope);
+    if (named && fs.existsSync(path.join(directory, 'package.json'))) return directory;
     if (path.dirname(directory) === directory) return null;
   }
 }
 
+// Whether the project's package.json depends on a package. Frameworks are only loaded for projects
+// that use them: a monorepo's shared node_modules may hold another app's.
+function declares(root, name) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+    return ['dependencies', 'devDependencies', 'optionalDependencies', 'peerDependencies'].some((field) => Boolean(pkg[field] && pkg[field][name]));
+  } catch (error) {
+    return false;
+  }
+}
+
+// Loads a package installed in the project (or one of its files) the way an import does, which
+// gives the module instance the app runs whether the package ships CommonJS or ES modules, and
+// patches it.
+async function importInstalled(fromRoot, name, file, patch) {
+  const main = resolve(fromRoot, name);
+  const directory = main && file ? packageDirectory(main, name) : null;
+  const target = file ? directory && path.join(directory, file) : main;
+  if (!target || !fs.existsSync(target)) return false;
+  try {
+    return patch(await import(pathToFileURL(target).href));
+  } catch (error) {
+    return false;
+  }
+}
+
+// An export of a module, imported as an ES module or as CommonJS (under `default`).
+function exported(module, name) {
+  if (!module) return undefined;
+  return module[name] || (module.default && module.default[name]);
+}
+
 // The file a module object was loaded from, found in the CommonJS cache.
 function fileOf(exports) {
   for (const module of Object.values(requireHere.cache)) {