@bymax-one/nest-core 1.3.1 → 1.4.0

package/dist/index.cjs

@@ -2,8 +2,9 @@
 
 var common = require('@nestjs/common');
 var core = require('@nestjs/core');
-var rxjs = require('rxjs');
 var crypto = require('crypto');
+var async_hooks = require('async_hooks');
+var rxjs = require('rxjs');
 
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -17,6 +18,10 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
 
+// src/route-defaults.ts
+var DEFAULT_HEALTH_PATH = "health";
+var DEFAULT_METRICS_PATH = "metrics";
+
 // src/runtime.environment.ts
 var NON_PRODUCTION_ENVIRONMENTS = /* @__PURE__ */ new Set(["development", "test"]);
 function isProductionRuntime(value = process.env["NODE_ENV"]) {
@@ -27,9 +32,7 @@ function isProductionRuntime(value = process.env["NODE_ENV"]) {
 }
 
 // src/core.options.ts
-var DEFAULT_HEALTH_PATH = "health";
 var DEFAULT_INDICATOR_TIMEOUT_MS = 5e3;
-var DEFAULT_METRICS_PATH = "metrics";
 var DEFAULT_OPENAPI_PATH = "docs";
 var DEFAULT_OPENAPI_JSON_PATH = "docs-json";
 var DEFAULT_OPENAPI_TITLE = "API";
@@ -105,6 +108,14 @@ function resolveOpenApi(raw) {
     // consumer-owned nested objects, and the deep-freeze below would otherwise
     // reach into them.
     securitySchemes: structuredClone(raw?.securitySchemes ?? {}),
+    // Cloned for the same reason as the schemes above: both are consumer-owned
+    // nested structures, and the deep-freeze applied to the snapshot would
+    // otherwise reach into objects the consumer still holds a reference to.
+    security: structuredClone(raw?.security ?? []),
+    operationSecurity: structuredClone(raw?.operationSecurity ?? {}),
+    // Carried by reference, not cloned: it is a function the consumer owns, and
+    // `structuredClone` cannot copy one at all.
+    ...raw?.operationIdFactory === void 0 ? {} : { operationIdFactory: raw.operationIdFactory },
     includeCoreSchemas: raw?.includeCoreSchemas ?? true
   };
 }
@@ -585,141 +596,6 @@ exports.BymaxExceptionFilter = __decorateClass([
   __decorateParam(3, common.Optional()),
   __decorateParam(3, common.Inject(BYMAX_TRACE_CONTEXT))
 ], exports.BymaxExceptionFilter);
-
-// src/timing/request-info.accessor.ts
-function stripQueryString(rawUrl) {
-  const queryIndex = rawUrl.indexOf("?");
-  return queryIndex === -1 ? rawUrl : rawUrl.slice(0, queryIndex);
-}
-function readExpressTemplate(request) {
-  const path = request.route?.path;
-  return path === void 0 ? void 0 : `${request.baseUrl ?? ""}${path}`;
-}
-function readFastifyTemplate(request) {
-  return request.routeOptions?.url;
-}
-function extractRequestInfo(context) {
-  const request = context.switchToHttp().getRequest();
-  const template = readExpressTemplate(request) ?? readFastifyTemplate(request);
-  const rawUrl = request.originalUrl ?? request.url ?? "";
-  return { method: request.method ?? "", route: template ?? stripQueryString(rawUrl) };
-}
-
-// src/timing/timing.interceptor.ts
-var DEFAULT_SUCCESS_STATUS = 200;
-var UNKNOWN_ERROR_STATUS = 500;
-exports.TimingInterceptor = class TimingInterceptor {
-  /**
-   * @param options - Resolved core options; supplies `slowRequestThresholdMs`.
-   * @param sink - The bound timing sink; its `record` failures are swallowed.
-   *   Injected with `@Optional()`: `BymaxCoreModule` binds no local default for
-   *   this token on the sync path when the metrics bridge is not registered, so
-   *   a consumer's own `BYMAX_TIMING_SINK` binding is not shadowed by one; when
-   *   nothing resolves, this falls back to a no-op sink.
-   * @param clock - Monotonic clock seam; defaults to `performance.now()`, and
-   *   is bound explicitly through {@link BYMAX_TIMING_CLOCK} so tests inject a
-   *   stub advancing by controlled amounts.
-   * @param traceContext - Reads the active span's identifiers. Injected with
-   *   `@Optional()` so this interceptor stays constructible on its own; when
-   *   nothing resolves, a no-op resolves no trace and the sample simply omits
-   *   the fields.
-   */
-  constructor(options, sink, clock = DEFAULT_MONOTONIC_CLOCK, traceContext) {
-    this.options = options;
-    this.clock = clock;
-    this.sink = sink ?? new NoopTimingSink();
-    this.traceContext = traceContext ?? new NoopTraceContextProvider();
-  }
-  /**
-   * Measure the handler chain and record exactly one sample per completed
-   * request, on the success path and on the error path alike.
-   *
-   * @param context - The execution context of the current request.
-   * @param next - The next handler in the chain.
-   * @returns The downstream response stream, unmodified beyond the measurement.
-   */
-  intercept(context, next) {
-    if (context.getType() !== "http") {
-      return next.handle();
-    }
-    const start = this.clock.now();
-    const { method, route } = extractRequestInfo(context);
-    return next.handle().pipe(
-      rxjs.tap({
-        complete: () => {
-          this.recordSample(method, route, this.readSuccessStatus(context), start);
-        }
-      }),
-      rxjs.catchError((error) => {
-        this.recordSample(method, route, this.readErrorStatus(error), start);
-        return rxjs.throwError(() => error);
-      })
-    );
-  }
-  /**
-   * Read the final status code from the response object on the success path.
-   *
-   * @param context - The execution context of the current request.
-   * @returns The response's status code, or the default success status when absent.
-   */
-  readSuccessStatus(context) {
-    const response = context.switchToHttp().getResponse();
-    return response.statusCode ?? DEFAULT_SUCCESS_STATUS;
-  }
-  /**
-   * Derive the final status code for an error that escaped the handler.
-   *
-   * @param error - The error propagated by the handler chain.
-   * @returns The `HttpException` status, or the generic 500 for anything else.
-   */
-  readErrorStatus(error) {
-    return error instanceof common.HttpException ? error.getStatus() : UNKNOWN_ERROR_STATUS;
-  }
-  /**
-   * Build the sample, compute the slow flag, and deliver it to the sink inside
-   * a try/catch that silences any failure: a throwing sink must never affect
-   * the request it is observing.
-   *
-   * @param method - HTTP method of the request.
-   * @param route - Route template of the request.
-   * @param statusCode - Final status code, success or error.
-   * @param start - Monotonic start timestamp captured before the handler ran.
-   */
-  recordSample(method, route, statusCode, start) {
-    const durationMs = this.clock.now() - start;
-    const threshold = this.options.timing.slowRequestThresholdMs;
-    const slow = threshold !== void 0 && durationMs > threshold;
-    let trace;
-    try {
-      trace = this.traceContext.getTraceContext();
-    } catch {
-    }
-    try {
-      this.sink.record({
-        method,
-        route,
-        statusCode,
-        durationMs,
-        slow,
-        // Spread rather than assigned: an absent trace must leave the keys off
-        // the sample entirely, so a sink cannot mistake `undefined` for an id.
-        ...trace !== void 0 ? { traceId: trace.traceId, spanId: trace.spanId } : {}
-      });
-    } catch {
-    }
-  }
-};
-exports.TimingInterceptor = __decorateClass([
-  common.Injectable(),
-  __decorateParam(0, common.Inject(BYMAX_CORE_OPTIONS)),
-  __decorateParam(1, common.Optional()),
-  __decorateParam(1, common.Inject(BYMAX_TIMING_SINK)),
-  __decorateParam(2, common.Inject(BYMAX_TIMING_CLOCK)),
-  __decorateParam(3, common.Optional()),
-  __decorateParam(3, common.Inject(BYMAX_TRACE_CONTEXT))
-], exports.TimingInterceptor);
-
-// src/passthrough.providers.ts
 var PassThroughExceptionFilter = class {
   constructor(adapterHost) {
     this.adapterHost = adapterHost;
@@ -738,18 +614,6 @@ var PassThroughExceptionFilter = class {
 PassThroughExceptionFilter = __decorateClass([
   common.Catch()
 ], PassThroughExceptionFilter);
-var PassThroughInterceptor = class {
-  /**
-   * Forward the request to the next handler unchanged.
-   *
-   * @param _context - The execution context; unused by a transparent forwarder.
-   * @param next - The next handler in the chain.
-   * @returns The downstream response stream, unmodified.
-   */
-  intercept(_context, next) {
-    return next.handle();
-  }
-};
 function assertAsyncFeatureEnabled(feature, enabled) {
   if (!enabled) {
     throw new common.NotFoundException(
@@ -760,9 +624,6 @@ function assertAsyncFeatureEnabled(feature, enabled) {
 function selectAsyncExceptionFilter(options, correlation, adapterHost) {
   return options.envelope.enabled ? new exports.BymaxExceptionFilter(options, correlation, adapterHost) : new PassThroughExceptionFilter(adapterHost);
 }
-function selectAsyncTimingInterceptor(options, sink, clock) {
-  return options.timing.enabled ? new exports.TimingInterceptor(options, sink, clock) : new PassThroughInterceptor();
-}
 
 // src/discovery.ts
 function labelFor(className, token) {
@@ -1218,12 +1079,12 @@ var TimingMetricsSink = class {
     this.histogram = getOrCreateHistogram(promClient, registry);
   }
   /**
-   * Record one completed request: increment the counter once and observe the
+   * Record one closed request: increment the counter once and observe the
    * duration in seconds, both under the bounded label set. Any failure is
    * swallowed so a metrics backend problem can never break the request being
    * observed.
    *
-   * @param sample - The timing sample for a completed request.
+   * @param sample - The timing sample for a closed request, however it ended.
    */
   record(sample) {
     const labels = {
@@ -1275,6 +1136,148 @@ function buildMetricsTimingSinkProvider() {
   };
 }
 
+// src/timing/fastify-route.bridge.ts
+function bridgeFastifyRouteMetadata(adapter) {
+  if (adapter?.getType?.() !== "fastify") {
+    return false;
+  }
+  const instance = adapter.getInstance?.();
+  if (!isFastifyInstance(instance)) {
+    return false;
+  }
+  instance.addHook("onRequest", (request, _reply, done) => {
+    if (request.raw !== void 0 && request.routeOptions !== void 0) {
+      request.raw["routeOptions"] = request.routeOptions;
+    }
+    done();
+  });
+  return true;
+}
+function isFastifyInstance(instance) {
+  return typeof instance?.addHook === "function";
+}
+
+// src/timing/request-info.accessor.ts
+var UNMATCHED_ROUTE = "<unmatched>";
+function readExpressTemplate(request) {
+  const path = request.route?.path;
+  return path === void 0 ? void 0 : `${request.baseUrl ?? ""}${path}`;
+}
+function readFastifyTemplate(request) {
+  return request.routeOptions?.url;
+}
+function readRequestInfo(request) {
+  const template = readExpressTemplate(request) ?? readFastifyTemplate(request);
+  return { method: request.method ?? "", route: template ?? UNMATCHED_ROUTE };
+}
+function extractRequestInfo(context) {
+  return readRequestInfo(context.switchToHttp().getRequest());
+}
+
+// src/timing/timing.sample.ts
+function readTraceContext(traceContext) {
+  try {
+    return traceContext.getTraceContext();
+  } catch {
+    return void 0;
+  }
+}
+function buildTimingSample(input) {
+  const { method, route, statusCode, durationMs, threshold, trace } = input;
+  return {
+    method,
+    route,
+    statusCode,
+    durationMs,
+    slow: threshold !== void 0 && durationMs > threshold,
+    // Spread rather than assigned: an absent trace must leave the keys off the
+    // sample entirely, so a sink cannot mistake `undefined` for an id.
+    ...trace !== void 0 ? { traceId: trace.traceId, spanId: trace.spanId } : {}
+  };
+}
+
+// src/timing/timing.middleware.ts
+exports.BymaxTimingMiddleware = class BymaxTimingMiddleware {
+  /**
+   * @param options - The resolved options, read for the slow-request threshold.
+   * @param sink - The bound timing sink; its failures are swallowed, because a
+   *   throwing sink must never affect the request it is observing.
+   * @param clock - Monotonic clock seam, so a test advances time by controlled
+   *   amounts instead of sleeping.
+   * @param traceContext - Reads the active span's identifiers. Optional: the
+   *   middleware stays constructible on its own, and a no-op resolves nothing.
+   */
+  constructor(options, sink, clock = DEFAULT_MONOTONIC_CLOCK, traceContext) {
+    this.options = options;
+    this.clock = clock;
+    this.sink = sink ?? new NoopTimingSink();
+    this.traceContext = traceContext ?? new NoopTraceContextProvider();
+  }
+  /**
+   * Start the measurement and arrange for the sample to be recorded once the
+   * connection closes, then hand the request straight on.
+   *
+   * The route is read inside the listener rather than here: at middleware time
+   * the router has not matched yet, so `req.route` is still empty. By the time
+   * the connection closes it is populated — including for a request a guard
+   * rejected, since matching happens before guards run.
+   *
+   * The trace lookup is tried in the live context first and in this moment's
+   * captured context second; see this file's header for the measurements that
+   * decided that order.
+   *
+   * @param request - The framework request object.
+   * @param response - The framework response object.
+   * @param next - Continues the chain; called synchronously and unconditionally.
+   */
+  use(request, response, next) {
+    const start = this.clock.now();
+    const readCapturedTrace = async_hooks.AsyncResource.bind(() => readTraceContext(this.traceContext));
+    response.on("close", () => {
+      this.record(
+        request,
+        response,
+        start,
+        readTraceContext(this.traceContext) ?? readCapturedTrace()
+      );
+    });
+    next();
+  }
+  /**
+   * Build the sample and hand it to the sink, guarding both steps.
+   *
+   * @param request - The framework request object.
+   * @param response - The framework response object.
+   * @param start - Monotonic timestamp captured before the chain ran.
+   * @param trace - The span identifiers already resolved by the caller, which
+   *   owns the choice of which context to read them from.
+   */
+  record(request, response, start, trace) {
+    const { method, route } = readRequestInfo(request);
+    const sample = buildTimingSample({
+      method,
+      route,
+      statusCode: response.statusCode ?? 0,
+      durationMs: this.clock.now() - start,
+      threshold: this.options.timing.slowRequestThresholdMs,
+      trace
+    });
+    try {
+      this.sink.record(sample);
+    } catch {
+    }
+  }
+};
+exports.BymaxTimingMiddleware = __decorateClass([
+  common.Injectable(),
+  __decorateParam(0, common.Inject(BYMAX_CORE_OPTIONS)),
+  __decorateParam(1, common.Optional()),
+  __decorateParam(1, common.Inject(BYMAX_TIMING_SINK)),
+  __decorateParam(2, common.Inject(BYMAX_TIMING_CLOCK)),
+  __decorateParam(3, common.Optional()),
+  __decorateParam(3, common.Inject(BYMAX_TRACE_CONTEXT))
+], exports.BymaxTimingMiddleware);
+
 // src/core.module.ts
 var {
   ConfigurableModuleClass: BymaxCoreModuleBase,
@@ -1293,7 +1296,7 @@ function buildSyncProviders(resolved) {
     providers.push({ provide: core.APP_FILTER, useClass: exports.BymaxExceptionFilter });
   }
   if (resolved.timing.enabled) {
-    providers.push({ provide: core.APP_INTERCEPTOR, useClass: exports.TimingInterceptor });
+    providers.push(exports.BymaxTimingMiddleware);
   }
   if (resolved.health.enabled) {
     providers.push(HealthService);
@@ -1330,11 +1333,6 @@ function buildAsyncSlots() {
         { token: BYMAX_CORRELATION_PROVIDER, optional: true },
         core.HttpAdapterHost
       ]
-    },
-    {
-      provide: core.APP_INTERCEPTOR,
-      useFactory: (options, sink, clock) => selectAsyncTimingInterceptor(options, sink, clock),
-      inject: [BYMAX_CORE_OPTIONS, BYMAX_TIMING_SINK, BYMAX_TIMING_CLOCK]
     }
   ];
 }
@@ -1349,6 +1347,77 @@ function augmentModule(base, providers, controllers, exportTokens = [BYMAX_CORE_
   };
 }
 exports.BymaxCoreModule = class BymaxCoreModule extends BymaxCoreModuleBase {
+  /**
+   * @param options - The resolved snapshot, read to decide whether the timing
+   *   middleware is applied at all.
+   */
+  constructor(resolved, adapterHost) {
+    super();
+    this.resolved = resolved;
+    this.adapterHost = adapterHost;
+  }
+  /**
+   * Apply the request-timing middleware to every route.
+   *
+   * Middleware rather than the interceptor this replaced, because guards run
+   * before interceptors: a request rejected by an authentication, authorization
+   * or throttling guard never reached the interceptor, and one matching no
+   * route never reached a controller at all. A deployment could therefore be
+   * under a credential-stuffing run — a flood of 401s — with a flat error
+   * graph, which is why this is a security fix rather than a metrics
+   * improvement.
+   *
+   * Applied on both registration paths, and only when timing is enabled: the
+   * middleware is the sole recorder now, since a second one would count every
+   * matched request twice.
+   *
+   * There is no single pattern that covers both adapters, which is the whole
+   * reason this reads the adapter first. Measured, requesting the root, a
+   * parameterised route, a nested path and an unmatched path, with and without
+   * `setGlobalPrefix('api')`:
+   *
+   * | `forRoutes(...)` | Express          | Fastify              |
+   * | ---------------- | ---------------- | -------------------- |
+   * | `'*splat'`       | skips the root   | —                    |
+   * | `'{*splat}'`     | skips `/api`     | every path           |
+   * | `'/'`            | every path       | matches `/` only     |
+   *
+   * On Express `'/'` is a mount and matches everything beneath whatever prefix
+   * it is scoped to, while `'{*splat}'` — the form Nest 11's migration guide
+   * prescribes for "all routes" — stops matching the prefixed root once an
+   * application calls `setGlobalPrefix`. That was reported as nest#14520 and
+   * fixed by nest#14522, whose regression test covers Fastify; on
+   * `@nestjs/core` 11.1.28 with the Express adapter the prefixed root still
+   * reaches no middleware while resolving to `200`.
+   *
+   * On Fastify the same `'/'` is an exact match rather than a mount — one of
+   * three requests reached the middleware — so the wildcard is the only form
+   * that works there.
+   *
+   * A recorder that quietly omits one route is the same class of defect this
+   * middleware exists to fix, so each adapter gets the form that omits none.
+   *
+   * Fastify also needs {@link bridgeFastifyRouteMetadata}, because middie hands
+   * middleware the raw request, which carries no route metadata at all; see
+   * that file for why the label would otherwise be `<unmatched>` for every
+   * request.
+   *
+   * One limit stays and is documented in the README: Nest scopes module
+   * middleware to the global prefix, so with `setGlobalPrefix('api')` a request
+   * to `/nope` — outside the prefix entirely — reaches no middleware and is not
+   * recorded, while `/api/nope` is. No `forRoutes` argument changes that, and
+   * nothing this module can register reaches outside its own scope.
+   *
+   * @param consumer - Nest's middleware consumer.
+   */
+  configure(consumer) {
+    if (!this.resolved.timing.enabled) {
+      return;
+    }
+    const adapter = this.adapterHost?.httpAdapter;
+    const onFastify = bridgeFastifyRouteMetadata(adapter);
+    consumer.apply(exports.BymaxTimingMiddleware).forRoutes(onFastify ? "{*splat}" : "/");
+  }
   /**
    * Register the module synchronously. Options are known now, so disabled
    * features are omitted from the providers and controllers arrays and the
@@ -1374,7 +1443,7 @@ exports.BymaxCoreModule = class BymaxCoreModule extends BymaxCoreModuleBase {
         exportTokens.push(BYMAX_TIMING_SINK);
       }
     }
-    const scansProviders = resolved.health.enabled && resolved.health.autoDiscover || resolved.metrics.enabled;
+    const scansProviders = resolved.health.enabled && resolved.health.autoDiscover || resolved.metrics.enabled || resolved.openapi.enabled;
     const imports = scansProviders ? [core.DiscoveryModule] : [];
     return augmentModule(
       super.forRoot(options),
@@ -1413,6 +1482,11 @@ exports.BymaxCoreModule = class BymaxCoreModule extends BymaxCoreModuleBase {
       },
       ...buildDefaultProviders(),
       ...buildAsyncSlots(),
+      // Registered unconditionally, applied conditionally: the class must be
+      // resolvable before `configure` can apply it, and whether timing is
+      // enabled is unknown until the consumer's factory has run. An unapplied
+      // middleware provider costs one construction and observes nothing.
+      exports.BymaxTimingMiddleware,
       HealthService,
       buildMetricsRegistryProvider(),
       buildMetricsTimingSinkProvider(),
@@ -1429,8 +1503,114 @@ exports.BymaxCoreModule = class BymaxCoreModule extends BymaxCoreModuleBase {
   }
 };
 exports.BymaxCoreModule = __decorateClass([
-  common.Module({})
+  common.Module({}),
+  __decorateParam(0, common.Inject(BYMAX_CORE_OPTIONS)),
+  __decorateParam(1, common.Optional()),
+  __decorateParam(1, common.Inject(core.HttpAdapterHost))
 ], exports.BymaxCoreModule);
+var DEFAULT_SUCCESS_STATUS = 200;
+var UNKNOWN_ERROR_STATUS = 500;
+exports.TimingInterceptor = class TimingInterceptor {
+  /**
+   * @param options - Resolved core options; supplies `slowRequestThresholdMs`.
+   * @param sink - The bound timing sink; its `record` failures are swallowed.
+   *   Injected with `@Optional()`: `BymaxCoreModule` binds no local default for
+   *   this token on the sync path when the metrics bridge is not registered, so
+   *   a consumer's own `BYMAX_TIMING_SINK` binding is not shadowed by one; when
+   *   nothing resolves, this falls back to a no-op sink.
+   * @param clock - Monotonic clock seam; defaults to `performance.now()`, and
+   *   is bound explicitly through {@link BYMAX_TIMING_CLOCK} so tests inject a
+   *   stub advancing by controlled amounts.
+   * @param traceContext - Reads the active span's identifiers. Injected with
+   *   `@Optional()` so this interceptor stays constructible on its own; when
+   *   nothing resolves, a no-op resolves no trace and the sample simply omits
+   *   the fields.
+   */
+  constructor(options, sink, clock = DEFAULT_MONOTONIC_CLOCK, traceContext) {
+    this.options = options;
+    this.clock = clock;
+    this.sink = sink ?? new NoopTimingSink();
+    this.traceContext = traceContext ?? new NoopTraceContextProvider();
+  }
+  /**
+   * Measure the handler chain and record exactly one sample per completed
+   * request, on the success path and on the error path alike.
+   *
+   * @param context - The execution context of the current request.
+   * @param next - The next handler in the chain.
+   * @returns The downstream response stream, unmodified beyond the measurement.
+   */
+  intercept(context, next) {
+    if (context.getType() !== "http") {
+      return next.handle();
+    }
+    const start = this.clock.now();
+    const { method, route } = extractRequestInfo(context);
+    return next.handle().pipe(
+      rxjs.tap({
+        complete: () => {
+          this.recordSample(method, route, this.readSuccessStatus(context), start);
+        }
+      }),
+      rxjs.catchError((error) => {
+        this.recordSample(method, route, this.readErrorStatus(error), start);
+        return rxjs.throwError(() => error);
+      })
+    );
+  }
+  /**
+   * Read the final status code from the response object on the success path.
+   *
+   * @param context - The execution context of the current request.
+   * @returns The response's status code, or the default success status when absent.
+   */
+  readSuccessStatus(context) {
+    const response = context.switchToHttp().getResponse();
+    return response.statusCode ?? DEFAULT_SUCCESS_STATUS;
+  }
+  /**
+   * Derive the final status code for an error that escaped the handler.
+   *
+   * @param error - The error propagated by the handler chain.
+   * @returns The `HttpException` status, or the generic 500 for anything else.
+   */
+  readErrorStatus(error) {
+    return error instanceof common.HttpException ? error.getStatus() : UNKNOWN_ERROR_STATUS;
+  }
+  /**
+   * Build the sample and deliver it to the sink inside a try/catch that
+   * silences any failure: a throwing sink must never affect the request it is
+   * observing.
+   *
+   * @param method - HTTP method of the request.
+   * @param route - Route template of the request.
+   * @param statusCode - Final status code, success or error.
+   * @param start - Monotonic start timestamp captured before the handler ran.
+   */
+  recordSample(method, route, statusCode, start) {
+    const sample = buildTimingSample({
+      method,
+      route,
+      statusCode,
+      durationMs: this.clock.now() - start,
+      threshold: this.options.timing.slowRequestThresholdMs,
+      trace: readTraceContext(this.traceContext)
+    });
+    try {
+      this.sink.record(sample);
+    } catch {
+    }
+  }
+};
+exports.TimingInterceptor = __decorateClass([
+  common.Injectable(),
+  __decorateParam(0, common.Inject(BYMAX_CORE_OPTIONS)),
+  __decorateParam(1, common.Optional()),
+  __decorateParam(1, common.Inject(BYMAX_TIMING_SINK)),
+  __decorateParam(2, common.Inject(BYMAX_TIMING_CLOCK)),
+  __decorateParam(3, common.Optional()),
+  __decorateParam(3, common.Inject(BYMAX_TRACE_CONTEXT))
+], exports.TimingInterceptor);
 
 exports.BYMAX_BAD_GATEWAY = BYMAX_BAD_GATEWAY;
 exports.BYMAX_BAD_REQUEST = BYMAX_BAD_REQUEST;
@@ -1454,5 +1634,6 @@ exports.BYMAX_UNAUTHORIZED = BYMAX_UNAUTHORIZED;
 exports.BYMAX_UNPROCESSABLE_ENTITY = BYMAX_UNPROCESSABLE_ENTITY;
 exports.BYMAX_UNSUPPORTED_MEDIA_TYPE = BYMAX_UNSUPPORTED_MEDIA_TYPE;
 exports.BYMAX_VALIDATION_FAILED = BYMAX_VALIDATION_FAILED;
+exports.UNMATCHED_ROUTE = UNMATCHED_ROUTE;
 exports.buildErrorEnvelope = buildErrorEnvelope;
 exports.codeForStatus = codeForStatus;