peekinside 1.2.5 → 1.3.0

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/timeline/timeline.js

@@ -37,7 +37,7 @@ export const TIMELINE_DEFAULTS = Object.freeze({
 });
 
 // Spans listed per request, by type.
-const SPAN_CAPS = Object.freeze({ query: 500, http: 100, log: 200, measure: 100, exception: 10, block: 20 });
+const SPAN_CAPS = Object.freeze({ query: 500, http: 100, log: 200, measure: 100, exception: 10, block: 20, dump: 50 });
 const MAX_STATEMENTS = 200;
 // Executions per statement whose parameters are kept.
 const PARAMS_PER_STATEMENT = 20;
@@ -121,7 +121,7 @@ export class Timeline {
     this.origin = origin;
     this.closed = false;
     this.spans = [];
-    this.listed = { query: 0, http: 0, log: 0, measure: 0, exception: 0, block: 0 };
+    this.listed = { query: 0, http: 0, log: 0, measure: 0, exception: 0, block: 0, dump: 0 };
     this.dropped = 0;
     this.statements = [];
     this.byFingerprint = new Map();
@@ -263,7 +263,7 @@ export class Timeline {
    *
    * @param {'debug'|'info'|'warn'|'error'} level
    * @param {string} message - Formatted as it was written
-   * @param {'console'|'pino'|'winston'} [source='console']
+   * @param {'console'|'pino'|'winston'|'nest'} [source='console']
    * @returns {void}
    */
   log(level, message, source = 'console') {
@@ -282,6 +282,27 @@ export class Timeline {
     }
   }
 
+  /**
+   * Records a dump made during the request (local dashboard only): its label and a preview of the
+   * value; the Dumps page has the value itself.
+   *
+   * @param {{ id: string, label: string|null, summary: { preview: string } }} record - A DumpRecord
+   * @returns {void}
+   */
+  dump(record) {
+    if (this.closed) return;
+    try {
+      if (this.listed.dump < SPAN_CAPS.dump) {
+        this.listed.dump++;
+        this.spans.push({ type: 'dump', start: this._offset(performance.now()), id: record.id, label: record.label, preview: cut(record.summary.preview, MAX_LOG) });
+      } else {
+        this.dropped++;
+      }
+    } catch (error) {
+      // The dump is still on the Dumps page.
+    }
+  }
+
   /**
    * Records an exception recorded during the request.
    *

package/src/transport/batch.js

@@ -13,6 +13,7 @@
 import { LOG_PREFIX } from '../config.js';
 import { ExceptionRecord } from '../exceptions/exception-record.js';
 import { RequestContext } from '../exceptions/request-context.js';
+import { DumpRecord } from '../dumps/dump-record.js';
 import { JobRunRecord } from '../jobs/job-run-record.js';
 import { LogRecord } from '../logs/log-record.js';
 import { RequestRecord } from '../record.js';
@@ -170,13 +171,15 @@ export class BatchTransport {
     const exceptions = [];
     const jobs = [];
     const logs = [];
+    const dumps = [];
     for (const record of records) {
       if (record instanceof ExceptionRecord) exceptions.push(record);
       else if (record instanceof JobRunRecord) jobs.push(record);
       else if (record instanceof LogRecord) logs.push(record);
+      else if (record instanceof DumpRecord) dumps.push(record);
       else requests.push(record);
     }
-    return { requests, exceptions, jobs, logs };
+    return { requests, exceptions, jobs, logs, dumps };
   }
 
   /**

package/src/transport/cloud.js

@@ -16,6 +16,7 @@ import { settings } from '../config.js';
 import { ApiKey, Sealer, SyncSealer } from '../crypto.js';
 import { RequestContext } from '../exceptions/request-context.js';
 import { ExceptionRecord } from '../exceptions/exception-record.js';
+import { DumpRecord } from '../dumps/dump-record.js';
 import { JobRunRecord } from '../jobs/job-run-record.js';
 import { LogRecord } from '../logs/log-record.js';
 import { RequestRecord } from '../record.js';
@@ -130,6 +131,17 @@ export class CloudTransport extends BatchTransport {
     this._scheduleResend(SPOOL_RESEND_DELAY_MS);
   }
 
+  /**
+   * Queues a record for sending. Dumps are for the local dashboard: PeekInside Cloud never gets them.
+   *
+   * @param {Object} record
+   * @returns {void}
+   */
+  enqueueRecord(record) {
+    if (record instanceof DumpRecord) return;
+    super.enqueueRecord(record);
+  }
+
   /**
    * Stops the background timer and the flush at exit. Sending itself stays possible: drain()
    * still sends what is queued.

package/src/transport/local.js

@@ -182,14 +182,15 @@ export class LocalTransport extends BatchTransport {
       const records = fatal ? [...this.sending, ...this.queue.splice(0)] : [];
       for (const exchange of exchanges) records.push(RequestRecord.fromExchange(exchange, this.environment, this.release));
       records.push(...exceptions);
-      const { requests, exceptions: errors, jobs, logs } = BatchTransport.split(records);
+      const { requests, exceptions: errors, jobs, logs, dumps } = BatchTransport.split(records);
       Spool.local(settings.dataDir(), this.project.id).write({
         project: this.project,
         instance: this.instance,
         requests: requests.slice(-MAX_SPOOLED_REQUESTS),
         exceptions: errors.slice(-MAX_SPOOLED_EXCEPTIONS),
         jobs: jobs.slice(-MAX_SPOOLED_EXCEPTIONS),
-        logs: logs.slice(-MAX_SPOOLED_REQUESTS)
+        logs: logs.slice(-MAX_SPOOLED_REQUESTS),
+        dumps: dumps.slice(-MAX_SPOOLED_EXCEPTIONS)
       });
     } catch (error) {
       // A data folder that can't be written loses the records, never the app.
@@ -207,13 +208,14 @@ export class LocalTransport extends BatchTransport {
     }
     const blocked = this.blocked.take();
     const samples = this.takeSamples();
-    const { requests, exceptions, jobs, logs } = BatchTransport.split(batch);
+    const { requests, exceptions, jobs, logs, dumps } = BatchTransport.split(batch);
     try {
       const answer = await this.hub.request('POST', '/api/ingest', {
-        body: { project: this.project, instance: this.instance, requests, exceptions, jobs, logs, samples, blocked: blocked.map(([, entry]) => entry) }
+        body: { project: this.project, instance: this.instance, requests, exceptions, jobs, logs, dumps, samples, blocked: blocked.map(([, entry]) => entry) }
       });
       if (exceptions.length && answer.acceptedExceptions === undefined) this._noteOutdatedHub();
       else if ((jobs.length || logs.length) && answer.acceptedJobs === undefined) this._noteOutdatedHub();
+      else if (dumps.length && answer.acceptedDumps === undefined) this._noteOutdatedHub();
       return true;
     } catch (error) {
       if (error.code === 'NOT_HUB') {
@@ -238,7 +240,7 @@ export class LocalTransport extends BatchTransport {
   }
 
   // A hub started before this version keeps running until it is restarted, and ignores what it
-  // doesn't know (exceptions, job runs, log lines).
+  // doesn't know (exceptions, job runs, log lines, dumps).
   _noteOutdatedHub() {
     if (this.outdatedHubNoted) return;
     this.outdatedHubNoted = true;