@phil-r/stats 1.4.3 → 2.0.0

package/README.md

@@ -1,179 +1,112 @@
 # stats
 
-> Request statistics middleware
-
-[![NPM version](http://img.shields.io/npm/v/@phil-r/stats.svg?style=flat-square)](https://www.npmjs.com/package/@phil-r/stats)
-[![build status](https://img.shields.io/travis/phil-r/stats/master.svg?style=flat-square)](https://travis-ci.org/phil-r/stats)
+[![NPM version](https://img.shields.io/npm/v/@phil-r/stats.svg?style=flat-square)](https://www.npmjs.com/package/@phil-r/stats)
+[![build status](https://github.com/phil-r/stats/workflows/Testing/badge.svg)](https://github.com/phil-r/stats/actions)
 [![code coverage](https://img.shields.io/codecov/c/github/phil-r/stats.svg?style=flat-square)](https://codecov.io/gh/phil-r/stats)
-[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
-
-## Installation
 
-```bash
-npm i @phil-r/stats
-```
+Small in-memory request statistics collector for Elysia, Express/Node HTTP,
+Fastify, Hono and NestJS (Express and Fastify platforms). TypeScript-first,
+ESM-only, for Node **22+** and Bun. Other frameworks may be integrated through
+an appropriate adapter.
 
-## API
+## Installation
 
-```js
-const initStats = require('@phil-r/stats');
-const { statsMiddleware, getStats } = initStats({
-  endpointStats: true,
-  complexEndpoints: ['/user/:id'],
-  customStats: true,
-  addHeader: true
-});
+```sh
+npm install @phil-r/stats
+# or: bun add @phil-r/stats
 ```
 
-### initStats([options])
-
-Returns `statsMiddleware` middleware function and `getStats` function,
-that returns current stats
-
-#### Options
-
-`initStats` accepts optional `options` object that may contain any of the following keys:
-
-##### endpointStats
-
-Defaults to `false`
-
-Boolean that indicates whether to track per endpoint stats.
+Install your framework separately. Framework peers are optional, and the root
+export loads no framework. No stats endpoint is exposed automatically; protect
+any endpoint you add.
 
-##### complexEndpoints
+## Usage
 
-Defaults to `[]`
+Create a collector and install the adapter **before routes or middleware that
+may respond early**. Share a collector to aggregate counts across adapters;
+install each adapter once per request path (Elysia deduplicates by collector).
 
-Used in conjunction with `endpointStats`
+### Elysia
 
-Use it in case your application has routes with params or wildcard routes
+```ts
+import { Elysia } from 'elysia';
+import { createStats } from '@phil-r/stats';
+import { elysiaStats } from '@phil-r/stats/elysia';
 
-**Recommended** for applications that have endpoints like `/user/123`
-
-##### customStats
-
-Defaults to `false`
+const stats = createStats({ endpointStats: true, addHeader: true });
+new Elysia()
+  .use(elysiaStats(stats))
+  .get('/', () => 'Hello')
+  .get('/stats', () => stats.getStats())
+  .listen(8080);
+```
 
-Adds `startMeasurement` and `finishMeasurement` functions to the request objects
-and allows measuring any parts of the app.
+### Express / Node HTTP
 
-**Usage:**
+```ts
+import express from 'express';
+import { createStats } from '@phil-r/stats';
+import { expressStats } from '@phil-r/stats/express';
 
-```js
-function handler(req, res) {
-  const measurement = req.startMeasurement('measurementName');
-  // Some code...
-  req.finishMeasurement(measurement);
-}
+const stats = createStats();
+const app = express();
+app.use(expressStats(stats));
+app.get('/', (_req, res) => res.send('Hello'));
+app.listen(8080);
 ```
 
-##### addHeader
+The middleware also accepts Node `IncomingMessage`/`ServerResponse` and `next`,
+without importing Express at runtime.
 
-Defaults to `false`
+### Fastify and Hono
 
-Adds `X-Response-Time` header to all responses, can be used to replace
-[`expressjs/response-time`](https://github.com/expressjs/response-time)
+With a collector named `stats`, register the appropriate adapter:
 
-## Example
+```ts
+import { fastifyStats } from '@phil-r/stats/fastify';
+// Fastify: native HTTP/1 hook, not a plugin for register().
+app.addHook('onRequest', fastifyStats(stats));
+```
 
-Examples for popular node web frameworks can be found [here](./examples)
+```ts
+import { honoStats } from '@phil-r/stats/hono';
+// Hono on Node/Bun, not edge runtimes: install first.
+app.use('*', honoStats(stats));
+```
 
-Here is the example of usage in express app:
+For NestJS, use its platform's adapter after `create`, before `init`/`listen`.
+See [Nest examples and integration details](./docs/guide.md) or
+[runnable apps](./examples).
 
-```js
-const app = require('express')();
-const initStats = require('@phil-r/stats');
+## Collector API
 
-const { statsMiddleware, getStats } = initStats({
-  endpointStats: true,
-  complexEndpoints: ['/user/:id'],
-  customStats: true,
-  addHeader: true
-});
+`createStats(options?)` returns an independent collector. All options default to
+false (or `[]`):
 
-app.use(statsMiddleware);
-app.get('/', (req, res) => res.end('Hello'));
-app.get('/user/:id', (req, res) => res.end(`Hello ${req.params.id}`));
-app.get('/long', async (req, res) => {
-  const measurement = req.startMeasurement('long');
-  await new Promise(resolve => {
-    setTimeout(() => resolve(), 2000);
-  });
-  req.finishMeasurement(measurement);
-  res.end(`Long job finished`);
-});
-app.get('/stats', (req, res) => res.send(getStats()));
+- `endpointStats`: per-method/path totals, excluding query strings.
+- `complexEndpoints`: ordered regexparam patterns, e.g. `['/user/:id']`; first
+  match groups dynamic URLs. Use with `endpointStats` to limit unique keys.
+- `customStats`: include named custom measurements in output.
+- `addHeader`: add `X-Response-Time: Nms`, preserving existing values.
 
-app.listen(8080);
-console.log('Server listens at http://localhost:8080');
-```
+`stats.getStats()` returns request count, total/average milliseconds, status
+counts, process identity/uptime and enabled endpoint/custom totals. Nested maps
+are live; treat them as read-only. Counters are process-local and unbounded.
 
-Visiting http://localhost:8080/stats will give following result:
-
-```json
-{
-  "uptime": 63881,
-  "uptimeHumanReadable": "1m 4s",
-  "statusCodes": {
-    "200": 5,
-    "404": 4
-  },
-  "uuid": "330d9cc6-7d40-4964-888c-4d2817905ee1",
-  "pid": 90603,
-  "totalTime": 4020.3912830000004,
-  "averageTime": 446.7101425555556,
-  "count": 9,
-  "endpointStats": {
-    "GET /long": {
-      "totalTime": 4009.410922,
-      "averageTime": 2004.705461,
-      "count": 2,
-      "statusCodes": {
-        "200": 2
-      }
-    },
-    "GET /favicon.ico": {
-      "totalTime": 4.286955,
-      "averageTime": 1.07173875,
-      "count": 4,
-      "statusCodes": {
-        "404": 4
-      }
-    },
-    "GET /stats": {
-      "totalTime": 6.227342999999999,
-      "averageTime": 6.227342999999999,
-      "count": 1,
-      "statusCodes": {
-        "200": 1
-      }
-    },
-    "GET /user/:id": {
-      "totalTime": 0.466063,
-      "averageTime": 0.2330315,
-      "count": 2,
-      "statusCodes": {
-        "200": 2
-      }
-    }
-  },
-  "customStats": {
-    "long": {
-      "totalTime": 4005.556455,
-      "averageTime": 2002.7782275,
-      "started": 2,
-      "count": 2
-    }
-  }
+```ts
+const stats = createStats({ customStats: true });
+const measurement = stats.startMeasurement('work');
+try {
+  await doWork();
+} finally {
+  stats.finishMeasurement(measurement);
 }
 ```
 
-All time related results are in milliseconds
-
-# [License](LICENSE)
-
-This is a fork of [zenmate/stats](https://github.com/zenmate/stats)
+Finish each token once on its originating collector. Timings are monotonic
+milliseconds, not body-transmission times. See the [guide](./docs/guide.md) for
+precise adapter timing, supported versions, migration and development commands.
 
-# Inspired by
+## License
 
-[`expressjs/response-time`](https://github.com/expressjs/response-time) and [`thoas/stats`](https://github.com/thoas/stats)
+[MIT](LICENSE). Fork of zenmate/stats.

package/dist/chunk-etf182vd.js

@@ -0,0 +1,13 @@
+// src/internal.ts
+var collectors = new WeakMap;
+function getCollector(stats) {
+  const state = collectors.get(stats);
+  if (!state)
+    throw new TypeError("Expected a collector from createStats()");
+  return state;
+}
+function hrTimeToMs([s, ns]) {
+  return s * 1000 + ns * 0.000001;
+}
+
+export { collectors, getCollector, hrTimeToMs };

package/dist/chunk-nwt5rk8q.js

@@ -0,0 +1,25 @@
+import {
+  getCollector,
+  hrTimeToMs
+} from "./chunk-etf182vd.js";
+
+// src/express.ts
+import onHeaders from "on-headers";
+function expressStats2(stats) {
+  const { record, addHeader } = getCollector(stats);
+  return function statsMiddleware(req, res, next) {
+    const start = process.hrtime();
+    const method = req.method || "GET";
+    const url = req.originalUrl || req.url || "/";
+    onHeaders(res, () => {
+      const elapsed = hrTimeToMs(process.hrtime(start));
+      if (addHeader && !res.hasHeader("X-Response-Time")) {
+        res.setHeader("X-Response-Time", `${elapsed.toFixed(0)}ms`);
+      }
+      record(method, url, res.statusCode, elapsed);
+    });
+    next();
+  };
+}
+
+export { expressStats2 };

package/dist/elysia.d.ts

@@ -0,0 +1,10 @@
+import { Elysia } from 'elysia';
+import type { StatsCollector } from './types.js';
+/**
+ * Create a plugin measuring until Elysia produces its final Response, not body transmission.
+ * Install with `.use(elysiaStats(stats))` before routes. The collector UUID seeds
+ * plugin deduplication: reusing one collector counts each request only once.
+ * Existing response-time headers are preserved. Requires Elysia 1.4.x on Bun.
+ * @param stats - Collector returned by createStats().
+ */
+export declare function elysiaStats(stats: StatsCollector): Elysia;

package/dist/elysia.js

@@ -0,0 +1,29 @@
+import {
+  getCollector,
+  hrTimeToMs
+} from "./chunk-etf182vd.js";
+
+// src/elysia.ts
+import { Elysia } from "elysia";
+function elysiaStats(stats) {
+  const { record, addHeader } = getCollector(stats);
+  const wrap = (handle) => async (request, ...rest) => {
+    const start = process.hrtime();
+    let response = await handle(request, ...rest);
+    const elapsed = hrTimeToMs(process.hrtime(start));
+    if (addHeader && !response.headers.has("X-Response-Time")) {
+      try {
+        response.headers.set("X-Response-Time", `${elapsed.toFixed(0)}ms`);
+      } catch {
+        response = new Response(response.body, response);
+        response.headers.set("X-Response-Time", `${elapsed.toFixed(0)}ms`);
+      }
+    }
+    record(request.method, request.url, response.status, elapsed);
+    return response;
+  };
+  return new Elysia({ name: "stats", seed: stats.getStats().uuid }).wrap(wrap);
+}
+export {
+  elysiaStats
+};

package/dist/express.d.ts

@@ -0,0 +1,13 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { StatsCollector } from './types.js';
+/**
+ * Create Express/Node HTTP middleware that records when response headers are written.
+ * Install before routes and any middleware that may respond early; for Nest's
+ * Express platform, install after create and before init/listen. Uses originalUrl
+ * for mounted routers and preserves existing response-time headers. Aborted
+ * requests without headers are not counted; body transmission is not measured.
+ * @param stats - Collector returned by createStats(); install once per request path.
+ */
+export declare function expressStats(stats: StatsCollector): (req: IncomingMessage & {
+    originalUrl?: string;
+}, res: ServerResponse, next: () => void) => void;

package/dist/express.js

@@ -0,0 +1,6 @@
+import {
+  expressStats2
+} from "./chunk-nwt5rk8q.js";
+export {
+  expressStats2 as expressStats
+};

package/dist/fastify.d.ts

@@ -0,0 +1,10 @@
+import type { onRequestHookHandler } from 'fastify';
+import type { StatsCollector } from './types.js';
+/**
+ * Create an HTTP/1 onRequest hook (not a plugin for register()).
+ * Add before routes and early hooks, once in the desired encapsulation scope.
+ * For Nest/Fastify, add to the native instance after create, before init/listen.
+ * Records at header write, not body completion; preserves staged/raw timing headers.
+ * @param stats - Collector returned by createStats().
+ */
+export declare function fastifyStats(stats: StatsCollector): onRequestHookHandler;

package/dist/fastify.js

@@ -0,0 +1,29 @@
+import {
+  expressStats2
+} from "./chunk-nwt5rk8q.js";
+import {
+  getCollector
+} from "./chunk-etf182vd.js";
+
+// src/fastify.ts
+import onHeaders from "on-headers";
+function fastifyStats(stats) {
+  const middleware = expressStats2(stats);
+  const { addHeader } = getCollector(stats);
+  return function(request, reply, done) {
+    middleware(request.raw, reply.raw, () => {
+      if (addHeader) {
+        onHeaders(reply.raw, () => {
+          const existing = reply.getHeader("X-Response-Time");
+          if (!reply.raw.hasHeader("X-Response-Time") && existing !== undefined) {
+            reply.raw.setHeader("X-Response-Time", existing);
+          }
+        });
+      }
+      done();
+    });
+  };
+}
+export {
+  fastifyStats
+};

package/dist/hono.d.ts

@@ -0,0 +1,10 @@
+import type { MiddlewareHandler } from 'hono';
+import type { StatsCollector } from './types.js';
+/**
+ * Create Node/Bun middleware; install first with app.use('*', honoStats(stats)).
+ * Records after downstream middleware and Hono's error handler finalize a Response,
+ * not after streaming its body. Escaping errors without a Response are not counted.
+ * Preserves existing response-time headers. Install once per request path.
+ * @param stats - Collector returned by createStats().
+ */
+export declare function honoStats(stats: StatsCollector): MiddlewareHandler;

package/dist/hono.js

@@ -0,0 +1,25 @@
+import {
+  getCollector,
+  hrTimeToMs
+} from "./chunk-etf182vd.js";
+
+// src/hono.ts
+function honoStats(stats) {
+  const { record, addHeader } = getCollector(stats);
+  return async (context, next) => {
+    const start = process.hrtime();
+    const method = context.req.method;
+    const url = context.req.url;
+    await next();
+    const elapsed = hrTimeToMs(process.hrtime(start));
+    if (addHeader && !context.res.headers.has("X-Response-Time")) {
+      const response = new Response(context.res.body, context.res);
+      response.headers.set("X-Response-Time", `${elapsed.toFixed(0)}ms`);
+      context.res = response;
+    }
+    record(method, url, context.res.status, elapsed);
+  };
+}
+export {
+  honoStats
+};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import type { StatsOptions, StatsCollector } from './types.js';
+export type { StatsOptions, StatsCollector, Stats, Timing, EndpointStats, CustomStats, Measurement, } from './types.js';
+/**
+ * Create an independent in-memory collector for one or more framework adapters.
+ * Counters are unbounded and process-local; configure endpoint patterns to group
+ * dynamic URLs. No endpoint is exposed automatically.
+ * @param opts - Collection and response-header options, disabled by default.
+ */
+export declare function createStats(opts?: StatsOptions): StatsCollector;

package/dist/index.js

@@ -0,0 +1,92 @@
+import {
+  collectors,
+  hrTimeToMs
+} from "./chunk-etf182vd.js";
+
+// src/index.ts
+import { randomUUID as uuidv4 } from "node:crypto";
+import { parse } from "regexparam";
+import prettyTime from "pretty-time";
+function createStats(opts = {}) {
+  const active = new WeakSet;
+  const stats = {
+    uuid: uuidv4(),
+    pid: process.pid,
+    totalTime: 0,
+    averageTime: 0,
+    count: 0
+  };
+  const statusCodes = {};
+  const endpointStats = {};
+  const customStats = {};
+  const complexEndpoints = (opts.complexEndpoints || []).map((path) => ({
+    ...parse(path),
+    path
+  }));
+  function getStats() {
+    const result = {
+      uptime: process.uptime() * 1000,
+      uptimeHumanReadable: prettyTime(Math.floor(process.uptime() * 1e9)),
+      statusCodes,
+      ...stats
+    };
+    if (opts.endpointStats)
+      result.endpointStats = endpointStats;
+    if (opts.customStats)
+      result.customStats = customStats;
+    return result;
+  }
+  function startMeasurement(name) {
+    if (!Object.prototype.hasOwnProperty.call(customStats, name)) {
+      Object.defineProperty(customStats, name, {
+        value: { totalTime: 0, averageTime: 0, started: 0, count: 0 },
+        enumerable: true
+      });
+    }
+    customStats[name].started++;
+    const measurement = { start: process.hrtime(), name };
+    active.add(measurement);
+    return measurement;
+  }
+  function finishMeasurement(measurement) {
+    if (!active.has(measurement))
+      throw new TypeError("Unknown or finished measurement");
+    active.delete(measurement);
+    const { name, start } = measurement;
+    const time = hrTimeToMs(process.hrtime(start));
+    customStats[name].totalTime += time;
+    customStats[name].count++;
+    customStats[name].averageTime = customStats[name].totalTime / customStats[name].count;
+  }
+  function record(method, url, status, time) {
+    stats.totalTime += time;
+    stats.count++;
+    stats.averageTime = stats.totalTime / stats.count;
+    statusCodes[status] = (statusCodes[status] || 0) + 1;
+    if (!opts.endpointStats)
+      return;
+    let path = url.startsWith("/") ? url.split(/[?#]/, 1)[0] : new URL(url, "http://localhost").pathname;
+    const complexPath = complexEndpoints.find((endpoint) => endpoint.pattern.test(path));
+    path = complexPath ? complexPath.path : path;
+    const endpoint = `${method} ${path}`;
+    if (!endpointStats[endpoint]) {
+      endpointStats[endpoint] = {
+        totalTime: 0,
+        averageTime: 0,
+        count: 0,
+        statusCodes: {}
+      };
+    }
+    const stat = endpointStats[endpoint];
+    stat.totalTime += time;
+    stat.count++;
+    stat.averageTime = stat.totalTime / stat.count;
+    stat.statusCodes[status] = (stat.statusCodes[status] || 0) + 1;
+  }
+  const collector = { getStats, startMeasurement, finishMeasurement };
+  collectors.set(collector, { record, addHeader: !!opts.addHeader });
+  return collector;
+}
+export {
+  createStats
+};

package/dist/internal.d.ts

@@ -0,0 +1,10 @@
+import type { StatsCollector } from './types.js';
+export declare const collectors: WeakMap<StatsCollector, {
+    addHeader: boolean;
+    record(method: string, url: string, status: number, time: number): void;
+}>;
+export declare function getCollector(stats: StatsCollector): {
+    addHeader: boolean;
+    record(method: string, url: string, status: number, time: number): void;
+};
+export declare function hrTimeToMs([s, ns]: [number, number]): number;

package/dist/types.d.ts

@@ -0,0 +1,66 @@
+/** Collection features; every option defaults to false or an empty list. */
+export interface StatsOptions {
+    /** Include counters keyed by HTTP method and path, excluding query strings. */
+    endpointStats?: boolean;
+    /** Ordered regexparam patterns; first match groups dynamic URLs. Requires endpointStats. */
+    complexEndpoints?: string[];
+    /** Include custom measurements in getStats(); measurement methods always work. */
+    customStats?: boolean;
+    /** Add X-Response-Time in milliseconds unless the response already has it. */
+    addHeader?: boolean;
+}
+/** Token owned by its originating collector; pass it unchanged to finishMeasurement. */
+export interface Measurement {
+    /** Monotonic start time, not a wall-clock timestamp. */
+    readonly start: [number, number];
+    /** Name used to aggregate this measurement. */
+    readonly name: string;
+}
+/** Completed request or custom measurement totals. All times are milliseconds. */
+export interface Timing {
+    /** Sum of completed durations in milliseconds. */
+    totalTime: number;
+    /** totalTime / count, or zero before completion. */
+    averageTime: number;
+    /** Number of completed requests or measurements. */
+    count: number;
+}
+/** Request totals for a single method/path group. */
+export interface EndpointStats extends Timing {
+    /** Counts keyed by final HTTP status code. */
+    statusCodes: Record<string, number>;
+}
+/** Totals for a named custom measurement, including unfinished starts. */
+export interface CustomStats extends Timing {
+    /** Number of starts, including measurements not yet finished. */
+    started: number;
+}
+/** Collector totals; nested maps are live and should be treated as read-only. */
+export interface Stats extends Timing {
+    /** Unique collector identity, also used for Elysia plugin deduplication. */
+    uuid: string;
+    /** ID of the hosting process. */
+    pid: number;
+    /** Process uptime in milliseconds, not collector age. */
+    uptime: number;
+    /** Human-readable process uptime. */
+    uptimeHumanReadable: string;
+    /** Request counts keyed by final HTTP status code. */
+    statusCodes: Record<string, number>;
+    /** Method/path totals, present only when endpointStats is enabled. */
+    endpointStats?: Record<string, EndpointStats>;
+    /** Named measurement totals, present only when customStats is enabled. */
+    customStats?: Record<string, CustomStats>;
+}
+/** Independent collector that can be shared across framework adapters. */
+export interface StatsCollector {
+    /** Return current totals with live nested maps; clone for a durable snapshot. */
+    getStats(): Stats;
+    /** Start a named monotonic timing; overlapping measurements are supported. */
+    startMeasurement(name: string): Measurement;
+    /**
+     * Finish a token exactly once on its originating collector and update totals.
+     * @throws TypeError - If the token is unknown or already finished.
+     */
+    finishMeasurement(measurement: Measurement): void;
+}

package/docs/guide.md

@@ -0,0 +1,82 @@
+# Integration guide
+
+## NestJS
+
+Use the platform adapter **after `create`, before `init`/`listen`** and before
+middleware that may respond early. No Nest module, interceptor or `/nestjs`
+export is needed. Install Nest and its platform dependencies separately.
+
+```ts
+import { NestFactory } from '@nestjs/core';
+import { createStats } from '@phil-r/stats';
+import { expressStats } from '@phil-r/stats/express';
+import { AppModule } from './app.module.js';
+
+const stats = createStats();
+const app = await NestFactory.create(AppModule);
+app.use(expressStats(stats));
+await app.listen(8080);
+```
+
+For Fastify, create with `new FastifyAdapter()` from
+`@nestjs/platform-fastify`, then register its native hook instead of `app.use`:
+
+```ts
+import { fastifyStats } from '@phil-r/stats/fastify';
+
+app.getHttpAdapter().getInstance().addHook('onRequest', fastifyStats(stats));
+```
+
+Group patterns must include any global prefix, e.g. `/api/user/:id`.
+See [runnable examples](../examples) for both platforms.
+
+## Timing and adapter limits
+
+- Express/Node, Fastify and Nest record the final status when headers are written;
+  `originalUrl` preserves mounted paths. Fastify's HTTP/1 hook is not a
+  `register()` plugin: register at root for all routes/404s, or inside a plugin
+  before its routes for that scope. HTTP/2 is unsupported.
+- Elysia and Hono record when the final Response is ready, including early
+  responses, errors, validation failures and 404s. Streams are not buffered or
+  awaited; immutable headers do not discard the body. Hono requires Node/Bun,
+  must be registered first, and error handlers must return a Response normally.
+  Errors escaping without a Response and requests rejected by Bun before Elysia
+  are not counted.
+- No adapter measures body transmission or counts requests aborted before a
+  response/headers. A stats JSON response excludes its own request, which is
+  recorded after serialization.
+- Times are monotonic milliseconds; averages are total/count. Custom `started`
+  counts all starts, `count` only finishes. Uptime is process uptime, not collector
+  age. Counters and unique keys are in-memory and unbounded; nested output maps
+  are live/read-only. Clone or serialize for a durable snapshot.
+
+Tested: Elysia **1.4.32** (advanced `wrap` API; restricted to 1.4.x), Express
+**5.3.0**, Fastify **5.12.8**, Hono **4.13.18** (`@hono/node-server` **2.1.8**),
+Nest and both platform adapters **12.5.0**, on Node **22.23.5/24.22.2** and Bun.
+Older Nest majors and other platforms are unverified; retest before widening
+Elysia support.
+
+## From v1
+
+Use named ESM `createStats` and framework-specific adapter imports, passing
+the collector instead of options. Replace `statsMiddleware`/`statsPlugin` and
+move measurement calls onto the collector. Node 22+ is required; there is no
+CJS build, framework registry or dashboard.
+
+## Development
+
+Use the pinned [Bun](../.bun-version) and [Node](../.node-version) versions.
+
+```sh
+bun install --frozen-lockfile
+bun run format:check  # bun run format to fix
+bun check
+bun test
+bun run build
+bun run test:node
+bun run test:package
+```
+
+Build emits ESM and declarations; checks do not emit. CI tests Node 22/24,
+including real framework listeners. The package smoke test verifies packed
+exports and peer-free Node imports/declarations, not framework behavior.

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@phil-r/stats",
-  "version": "1.4.3",
+  "version": "2.0.0",
   "license": "MIT",
   "author": "Phil Rukin <philipp@rukin.me> (https://rukin.me)",
   "description": "Request statistics middleware",
-  "main": "index.js",
+  "main": "./dist/index.js",
   "keywords": [
     "middleware",
     "statistics",
@@ -16,7 +16,10 @@
     "koa",
     "rayo",
     "polka",
-    "fastify"
+    "fastify",
+    "elysia",
+    "hono",
+    "nestjs"
   ],
   "bugs": {
     "url": "https://github.com/phil-r/stats/issues"
@@ -27,33 +30,92 @@
   },
   "homepage": "https://github.com/phil-r/stats#readme",
   "scripts": {
-    "test": "npm run lint && npm run ava",
-    "ava": "nyc --reporter=lcov --reporter=text ava",
-    "lint": "eslint --ignore-path .gitignore **/*.js"
-  },
-  "husky": {
-    "hooks": {
-      "pre-commit": "pretty-quick --staged"
-    }
-  },
-  "prettier": {
-    "singleQuote": true
+    "check": "bun check --no-script",
+    "build": "bun scripts/build.ts",
+    "test": "bun test tests/*.test.ts",
+    "test:node": "node --test tests/*.integration.mjs",
+    "test:package": "bun scripts/package-smoke.ts",
+    "prepack": "bun run build",
+    "format": "bun fmt --no-script",
+    "format:check": "bun fmt --no-script --check",
+    "prepare": "node -e \"if (require('node:fs').existsSync('.git') && process.env.NODE_ENV !== 'production' && process.env.HUSKY !== '0') import('husky').then(({default: install}) => install())\""
   },
   "dependencies": {
-    "on-headers": "^1.0.1",
+    "on-headers": "^1.1.0",
     "pretty-time": "^1.1.0",
-    "regexparam": "^1.3.0",
-    "uuid": "^7.0.2"
+    "regexparam": "^3.0.0"
   },
   "devDependencies": {
-    "ava": "^3.3.0",
-    "eslint": "^6.8.0",
-    "eslint-config-prettier": "^6.0.0",
-    "eslint-plugin-prettier": "^3.1.2",
-    "husky": "^4.2.3",
-    "nyc": "^15.0.0",
-    "prettier": "^1.19.1",
-    "pretty-quick": "^2.0.1",
-    "supertest": "^4.0.2"
+    "@hono/node-server": "^2.1.8",
+    "@nestjs/common": "^12.5.0",
+    "@nestjs/core": "^12.5.0",
+    "@nestjs/platform-express": "^12.5.0",
+    "@nestjs/platform-fastify": "^12.5.0",
+    "@types/bun": "^1.3.0",
+    "@types/express": "^5.0.0",
+    "@types/node": "^22.19.1",
+    "@types/on-headers": "^1.0.4",
+    "@types/pretty-time": "^1.1.5",
+    "elysia": "1.4.32",
+    "express": "^5.2.1",
+    "fastify": "^5.12.8",
+    "hono": "^4.13.18",
+    "husky": "^9.1.7",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.2",
+    "typescript": "5.9.3"
+  },
+  "peerDependencies": {
+    "elysia": ">=1.4.32 <1.5.0",
+    "express": ">=4.18.0 <6",
+    "fastify": ">=5.12.8 <6",
+    "hono": ">=4.13.18 <5"
+  },
+  "peerDependenciesMeta": {
+    "elysia": {
+      "optional": true
+    },
+    "express": {
+      "optional": true
+    },
+    "fastify": {
+      "optional": true
+    },
+    "hono": {
+      "optional": true
+    }
+  },
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "docs/guide.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "packageManager": "bun@1.4.4",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./elysia": {
+      "types": "./dist/elysia.d.ts",
+      "import": "./dist/elysia.js"
+    },
+    "./express": {
+      "types": "./dist/express.d.ts",
+      "import": "./dist/express.js"
+    },
+    "./fastify": {
+      "types": "./dist/fastify.d.ts",
+      "import": "./dist/fastify.js"
+    },
+    "./hono": {
+      "types": "./dist/hono.d.ts",
+      "import": "./dist/hono.js"
+    }
   }
 }

package/.eslintrc

@@ -1,15 +0,0 @@
-{
-  "env": {
-    "node": true,
-    "es6": true
-  },
-  "parserOptions": { "ecmaVersion": 9 },
-
-  "extends": ["eslint:recommended", "plugin:prettier/recommended"],
-
-  "plugins": ["prettier"],
-
-  "rules": {
-    "prettier/prettier": "error"
-  }
-}

package/index.js

@@ -1,122 +0,0 @@
-const urlParse = require('url').parse;
-const onHeaders = require('on-headers');
-const { v4: uuidv4 } = require('uuid');
-const regexparam = require('regexparam');
-const prettyTime = require('pretty-time');
-
-const { hrTimeToMs } = require('./utils');
-
-function initMiddleware(opts = {}) {
-  const stats = {
-    uuid: uuidv4(),
-    pid: process.pid,
-    totalTime: 0,
-    averageTime: 0,
-    count: 0
-  };
-
-  const statusCodes = {};
-  const endpointStats = {};
-  const complexEndpoints =
-    (opts.complexEndpoints &&
-      opts.complexEndpoints.map(path => ({ ...regexparam(path), path }))) ||
-    [];
-  const customStats = {};
-
-  function getStats() {
-    const result = {
-      uptime: process.uptime() * 1e3, // convert to ms
-      uptimeHumanReadable: prettyTime(Math.floor(process.uptime() * 1e9)),
-      statusCodes,
-      ...stats
-    };
-    if (opts.endpointStats) {
-      result.endpointStats = endpointStats;
-    }
-    if (opts.customStats) {
-      result.customStats = customStats;
-    }
-    return result;
-  }
-
-  function startMeasurement(name) {
-    if (!customStats[name]) {
-      customStats[name] = {
-        totalTime: 0,
-        averageTime: 0,
-        started: 0,
-        count: 0
-      };
-    }
-    customStats[name].started++;
-    return { start: process.hrtime(), name };
-  }
-
-  function finishMeasurement({ name, start }) {
-    const time = hrTimeToMs(process.hrtime(start));
-    customStats[name].totalTime += time;
-    customStats[name].count++;
-    customStats[name].averageTime =
-      customStats[name].totalTime / customStats[name].count;
-  }
-
-  function statsMiddleware(req, res, next) {
-    const requestStart = process.hrtime();
-
-    if (opts.customStats) {
-      req.startMeasurement = startMeasurement;
-      req.finishMeasurement = finishMeasurement;
-    }
-
-    onHeaders(res, () => {
-      const time = hrTimeToMs(process.hrtime(requestStart));
-
-      if (opts.addHeader) {
-        if (!res.getHeader('X-Response-Time')) {
-          res.setHeader('X-Response-Time', `${time.toFixed(0)}ms`);
-        }
-      }
-
-      stats.totalTime += time;
-      stats.count++;
-      stats.averageTime = stats.totalTime / stats.count;
-      statusCodes[res.statusCode] = statusCodes[res.statusCode]
-        ? statusCodes[res.statusCode] + 1
-        : 1;
-
-      if (opts.endpointStats) {
-        // prefer using `req.originalUrl` as some frameworks replace `req.url`
-        const url = req.originalUrl || req.url;
-        let path = urlParse(url).pathname;
-        const complexPath = complexEndpoints.find(endpoint =>
-          endpoint.pattern.test(path)
-        );
-        path = complexPath ? complexPath.path : path;
-        const endpoint = `${req.method} ${path}`;
-
-        if (!endpointStats[endpoint]) {
-          endpointStats[endpoint] = {
-            totalTime: 0,
-            averageTime: 0,
-            count: 0,
-            statusCodes: {}
-          };
-        }
-
-        endpointStats[endpoint].totalTime += time;
-        endpointStats[endpoint].count++;
-        endpointStats[endpoint].averageTime =
-          endpointStats[endpoint].totalTime / endpointStats[endpoint].count;
-        const eStatusCodes = endpointStats[endpoint].statusCodes;
-        eStatusCodes[res.statusCode] = eStatusCodes[res.statusCode]
-          ? eStatusCodes[res.statusCode] + 1
-          : 1;
-      }
-    });
-
-    return next();
-  }
-  return { getStats, statsMiddleware };
-}
-
-module.exports = initMiddleware;

package/utils.js

@@ -1,5 +0,0 @@
-function hrTimeToMs([s, ns]) {
-  return s * 1e3 + ns * 1e-6; // convert to ms
-}
-
-module.exports = { hrTimeToMs };