@lakutata/monitor 3.0.0-beta.0

package/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2023-present Lakutata
+
+All rights reserved
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,114 @@
+# @lakutata/monitor
+
+The monitors of the lakutata framework: components measuring the process's CPU usage, memory, event loop delay and
+utilization, and the durations of the HTTP requests it receives, on the histograms of Node.js, in constant memory. Each
+exposes a `statistics` getter (the latest value, minimum, maximum, mean and percentiles since its creation or its last
+`reset()`). The umbrella package `lakutata` re-exports it as `lakutata/com/monitor`.
+
+## Installation
+
+```shell
+npm install lakutata
+```
+
+It has no optional dependencies: the measures come from `node:process`, `node:os` and `node:perf_hooks`.
+
+## Usage
+
+Register the monitors in the `components` of the application and list them in `bootstrap`: a monitor starts measuring
+when it is created. Then read their `statistics` with `getObject()` or `@Inject`; they are singletons.
+
+```typescript
+import {Application} from 'lakutata'
+import {
+    CpuMonitor,
+    EventLoopMonitor,
+    HttpRequestMonitor,
+    MemoryMonitor,
+    type ICpuMonitorStatistics,
+    type IEventLoopMonitorStatistics,
+    type IHttpRequestMonitorStatistics,
+    type IMemoryMonitorStatistics
+} from 'lakutata/com/monitor'
+
+Application
+    .run(() => ({
+        id: 'monitor.app',
+        name: 'Monitor',
+        components: {
+            cpu: {class: CpuMonitor},
+            memory: {class: MemoryMonitor},
+            eventLoop: {class: EventLoopMonitor},
+            httpRequests: {class: HttpRequestMonitor}
+        },
+        bootstrap: ['cpu', 'memory', 'eventLoop', 'httpRequests']
+    }))
+    .onLaunched(async (app: Application): Promise<void> => {
+        const cpu: CpuMonitor = await app.getObject('cpu')
+        const memory: MemoryMonitor = await app.getObject('memory')
+        const eventLoop: EventLoopMonitor = await app.getObject('eventLoop')
+        const httpRequests: HttpRequestMonitor = await app.getObject('httpRequests')
+        //A report every minute, each covering the last minute
+        setInterval((): void => {
+            const cpuStatistics: ICpuMonitorStatistics = cpu.statistics
+            const memoryStatistics: IMemoryMonitorStatistics = memory.statistics
+            const loopStatistics: IEventLoopMonitorStatistics = eventLoop.statistics
+            const httpStatistics: IHttpRequestMonitorStatistics = httpRequests.statistics
+            console.log({
+                cpuPercent: cpuStatistics.usageAvg,
+                rssBytes: memoryStatistics.physicalUsed,
+                heapPercent: memoryStatistics.heapUsage,
+                loopDelayP99Ms: loopStatistics.p99,
+                loopBusyPercent: loopStatistics.utilRate,
+                requests: httpStatistics.count,
+                requestP95Ms: httpStatistics.p95
+            })
+            for (const monitor of [cpu, memory, eventLoop, httpRequests]) monitor.reset()
+        }, 60000).unref()
+    })
+```
+
+| Monitor | Measures | Unit | Sampling | Rounded to |
+|---|---|---|---|---|
+| `CpuMonitor` | User plus system CPU time of the process over each second | percent of one core (above 100 with several cores) | every second, first sample 1 s after creation | 5 decimals |
+| `MemoryMonitor` | `process.memoryUsage()`: resident set, V8 heap, external memory; the host's total memory | bytes (the `*Usage` fields in percent) | at creation, then every second | 2 decimals for the means and percentages |
+| `EventLoopMonitor` | How late the main event loop runs a 1 ms timer; the share of time it is busy | milliseconds; percent | continuously (Node's `monitorEventLoopDelay`, 1 ms resolution) | not rounded |
+| `HttpRequestMonitor` | The duration of each request received by a `node:http` server (Express, Fastify), from its arrival to the end of its response | milliseconds; a count | each request, delivered in batches shortly after its response | 2 decimals |
+
+- **Reading the statistics**: every getter call computes them anew. The minimum, maximum, mean and percentiles cover
+  every sample since the monitor was created or reset: call `reset()` after each report to read a period. The
+  percentiles come from histograms (3 significant digits); the minimum, maximum and mean are exact.
+- **Before the first sample**: the statistics are 0 (the CPU monitor's for its first second, the HTTP monitor's until a
+  request ends).
+- **Lifecycle**: the timers do not keep the process alive; the monitors stop when the application is destroyed.
+- **Scope**: the monitors measure the current process only: under a cluster or several instances, each has its own.
+  `physicalTotal` is the host's memory, not a container's limit. The requests the process sends, and HTTP/2 requests,
+  are not counted.
+
+## API
+
+| Export | What it is |
+|---|---|
+| `CpuMonitor` | The CPU usage component: `statistics`, `reset()` |
+| `MemoryMonitor` | The memory component: `statistics`, `reset()` |
+| `EventLoopMonitor` | The event loop component: `statistics`, `reset()` |
+| `HttpRequestMonitor` | The received HTTP requests component: `statistics`, `reset()` |
+| `ICpuMonitorStatistics` | `usage` and `usageMin`/`Max`/`Avg`/`P50`/`P90`/`P95`/`P99`, in percent of one core |
+| `IMemoryMonitorStatistics` | `physical*` (resident set), `heap*` (V8 heap), `external*`, in bytes, plus `physicalUsage` and `heapUsage` in percent |
+| `IEventLoopMonitorStatistics` | `min`, `max`, `avg`, `stdDev`, `p50`, `p90`, `p95`, `p99` in milliseconds, `utilRate` in percent |
+| `IHttpRequestMonitorStatistics` | `count`, then `min`, `max`, `avg`, `stdDev`, `p50`, `p90`, `p95`, `p99` in milliseconds |
+| `IMonitor` | The interface of the monitors: a `statistics` property |
+
+All are exported by `lakutata/com/monitor` and `@lakutata/monitor`. The typings document each declaration with
+examples.
+
+## Errors
+
+The monitors throw no exception of their own: reading `statistics` and calling `reset()` never fail. Declaring a
+monitor with options it does not have is warned of when the application starts.
+
+## See also
+
+- `doc/en/Core.md` of the package `lakutata` (Chinese in `doc/zh`): the components and the bootstrap.
+- `@lakutata/core` (`lakutata`): the components, `Application` and the dependency injection.
+- `@lakutata/logger` (`lakutata/com/logger`): the logger, to write the reports.

package/dist/cjs/exports/Monitor.d.ts

@@ -0,0 +1,9 @@
+export * from '../monitor/CpuMonitor.js';
+export * from '../monitor/EventLoopMonitor.js';
+export * from '../monitor/HttpRequestMonitor.js';
+export * from '../monitor/MemoryMonitor.js';
+export * from '../monitor/interfaces/IMonitor.js';
+export * from '../monitor/interfaces/ICpuMonitorStatistics.js';
+export * from '../monitor/interfaces/IEventLoopMonitorStatistics.js';
+export * from '../monitor/interfaces/IHttpRequestMonitorStatistics.js';
+export * from '../monitor/interfaces/IMemoryMonitorStatistics.js';

package/dist/cjs/exports/Monitor.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../monitor/CpuMonitor.js"), exports);
+__exportStar(require("../monitor/EventLoopMonitor.js"), exports);
+__exportStar(require("../monitor/HttpRequestMonitor.js"), exports);
+__exportStar(require("../monitor/MemoryMonitor.js"), exports);
+__exportStar(require("../monitor/interfaces/IMonitor.js"), exports);
+__exportStar(require("../monitor/interfaces/ICpuMonitorStatistics.js"), exports);
+__exportStar(require("../monitor/interfaces/IEventLoopMonitorStatistics.js"), exports);
+__exportStar(require("../monitor/interfaces/IHttpRequestMonitorStatistics.js"), exports);
+__exportStar(require("../monitor/interfaces/IMemoryMonitorStatistics.js"), exports);
+
+//The default of the entry: the entry itself (scripts/package-build/cjs-package.mjs)
+if (!Object.prototype.hasOwnProperty.call(exports, 'default')) Object.defineProperty(exports, 'default', {value: exports})

package/dist/cjs/monitor/CpuMonitor.d.ts

@@ -0,0 +1,60 @@
+import { Component } from '@lakutata/core';
+import { IMonitor } from './interfaces/IMonitor.js';
+import { ICpuMonitorStatistics } from './interfaces/ICpuMonitorStatistics.js';
+/**
+ * The CPU monitor: measures the CPU time the process uses (user plus system, all its threads), as a percentage of one
+ * core: 100 is one core fully busy, and a process using several cores (worker threads, the libuv thread pool) goes
+ * above 100. It takes a sample every second, each the average usage over that second, and keeps the statistics of
+ * every sample since it was created or last {@link CpuMonitor.reset}: the latest, the minimum, the maximum, the mean
+ * and percentiles, in constant memory.
+ *
+ * Declare it in the `components` of the application (`{class: CpuMonitor}`) and get it with `@Inject` or
+ * `getObject()`; it is a singleton. It starts sampling when it is created: list it in `bootstrap` to measure from the
+ * launch. The statistics are all 0 until the first sample, one second after its creation. Its timer does not keep the
+ * process alive, and stops when the component is destroyed.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {CpuMonitor, type ICpuMonitorStatistics} from 'lakutata/com/monitor'
+ *
+ * Application
+ *     .run(() => ({
+ *         id: 'cpu.app',
+ *         name: 'Cpu',
+ *         components: {
+ *             cpu: {class: CpuMonitor}
+ *         },
+ *         //Created at the launch, so that it samples from the start
+ *         bootstrap: ['cpu']
+ *     }))
+ *     .onLaunched(async (app: Application): Promise<void> => {
+ *         const cpu: CpuMonitor = await app.getObject('cpu')
+ *         setInterval((): void => {
+ *             const statistics: ICpuMonitorStatistics = cpu.statistics
+ *             console.log(`CPU ${statistics.usage}% (p95 ${statistics.usageP95}%, max ${statistics.usageMax}%)`)
+ *         }, 60000)
+ *     })
+ * ```
+ */
+export declare class CpuMonitor extends Component implements IMonitor<ICpuMonitorStatistics> {
+    #private;
+    /**
+     * The statistics of the CPU samples since the monitor was created or reset, computed at each read: the latest
+     * usage and the minimum, maximum, mean and percentiles (P50 to P99) of the samples, in percent of one core, rounded
+     * to 5 decimals. The percentiles are approximate (3 significant digits). All 0 before the first sample.
+     */
+    get statistics(): ICpuMonitorStatistics;
+    /**
+     * Take a sample: the CPU usage since the previous sample (user plus system time over the elapsed time, in percent of
+     * one core). Called every second.
+     * @protected
+     */
+    protected sampleCpuUsage(): void;
+    protected init(): Promise<void>;
+    protected destroy(): Promise<void>;
+    /**
+     * Forget the samples: the statistics are 0 until the next sample, then cover the samples taken since. Use it to
+     * measure a period, such as between two reports.
+     */
+    reset(): void;
+}

package/dist/cjs/monitor/CpuMonitor.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CpuMonitor = void 0;
+const core_1 = require("@lakutata/core");
+const Samples_js_1 = require("./lib/Samples.js");
+/**
+ * The CPU monitor: measures the CPU time the process uses (user plus system, all its threads), as a percentage of one
+ * core: 100 is one core fully busy, and a process using several cores (worker threads, the libuv thread pool) goes
+ * above 100. It takes a sample every second, each the average usage over that second, and keeps the statistics of
+ * every sample since it was created or last {@link CpuMonitor.reset}: the latest, the minimum, the maximum, the mean
+ * and percentiles, in constant memory.
+ *
+ * Declare it in the `components` of the application (`{class: CpuMonitor}`) and get it with `@Inject` or
+ * `getObject()`; it is a singleton. It starts sampling when it is created: list it in `bootstrap` to measure from the
+ * launch. The statistics are all 0 until the first sample, one second after its creation. Its timer does not keep the
+ * process alive, and stops when the component is destroyed.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {CpuMonitor, type ICpuMonitorStatistics} from 'lakutata/com/monitor'
+ *
+ * Application
+ *     .run(() => ({
+ *         id: 'cpu.app',
+ *         name: 'Cpu',
+ *         components: {
+ *             cpu: {class: CpuMonitor}
+ *         },
+ *         //Created at the launch, so that it samples from the start
+ *         bootstrap: ['cpu']
+ *     }))
+ *     .onLaunched(async (app: Application): Promise<void> => {
+ *         const cpu: CpuMonitor = await app.getObject('cpu')
+ *         setInterval((): void => {
+ *             const statistics: ICpuMonitorStatistics = cpu.statistics
+ *             console.log(`CPU ${statistics.usage}% (p95 ${statistics.usageP95}%, max ${statistics.usageMax}%)`)
+ *         }, 60000)
+ *     })
+ * ```
+ */
+class CpuMonitor extends core_1.Component {
+    #fractionDigits = 5;
+    #intervalDelay = 1000;
+    #samples = new Samples_js_1.Samples(1e5);
+    #sampleInterval;
+    #previousUsage = process.cpuUsage();
+    #previousTime = process.hrtime.bigint();
+    /**
+     * The statistics of the CPU samples since the monitor was created or reset, computed at each read: the latest
+     * usage and the minimum, maximum, mean and percentiles (P50 to P99) of the samples, in percent of one core, rounded
+     * to 5 decimals. The percentiles are approximate (3 significant digits). All 0 before the first sample.
+     */
+    get statistics() {
+        return {
+            usage: (0, Samples_js_1.round)(this.#samples.latest, this.#fractionDigits),
+            usageMin: (0, Samples_js_1.round)(this.#samples.min, this.#fractionDigits),
+            usageMax: (0, Samples_js_1.round)(this.#samples.max, this.#fractionDigits),
+            usageAvg: (0, Samples_js_1.round)(this.#samples.mean, this.#fractionDigits),
+            usageP50: (0, Samples_js_1.round)(this.#samples.percentile(50), this.#fractionDigits),
+            usageP90: (0, Samples_js_1.round)(this.#samples.percentile(90), this.#fractionDigits),
+            usageP95: (0, Samples_js_1.round)(this.#samples.percentile(95), this.#fractionDigits),
+            usageP99: (0, Samples_js_1.round)(this.#samples.percentile(99), this.#fractionDigits)
+        };
+    }
+    /**
+     * Take a sample: the CPU usage since the previous sample (user plus system time over the elapsed time, in percent of
+     * one core). Called every second.
+     * @protected
+     */
+    sampleCpuUsage() {
+        const now = process.hrtime.bigint();
+        const usage = process.cpuUsage();
+        const cpuMicroseconds = (usage.user - this.#previousUsage.user) + (usage.system - this.#previousUsage.system);
+        const elapsedMicroseconds = Number(now - this.#previousTime) / 1000;
+        this.#previousUsage = usage;
+        this.#previousTime = now;
+        if (elapsedMicroseconds > 0)
+            this.#samples.record(cpuMicroseconds / elapsedMicroseconds * 100);
+    }
+    async init() {
+        this.#previousUsage = process.cpuUsage();
+        this.#previousTime = process.hrtime.bigint();
+        this.#sampleInterval = setInterval(() => this.sampleCpuUsage(), this.#intervalDelay).unref();
+    }
+    async destroy() {
+        clearInterval(this.#sampleInterval);
+    }
+    /**
+     * Forget the samples: the statistics are 0 until the next sample, then cover the samples taken since. Use it to
+     * measure a period, such as between two reports.
+     */
+    reset() {
+        this.#samples.reset();
+    }
+}
+exports.CpuMonitor = CpuMonitor;

package/dist/cjs/monitor/EventLoopMonitor.d.ts

@@ -0,0 +1,65 @@
+import { type EventLoopUtilization, type IntervalHistogram } from 'node:perf_hooks';
+import { Component } from '@lakutata/core';
+import { IEventLoopMonitorStatistics } from './interfaces/IEventLoopMonitorStatistics.js';
+import { IMonitor } from './interfaces/IMonitor.js';
+/**
+ * The event loop monitor: measures how late the event loop of the main thread runs its timers (the event loop delay,
+ * in milliseconds, with Node's `monitorEventLoopDelay` at a 1 ms resolution) and how busy it is (its utilization, in
+ * percent of the time). A growing delay means synchronous work (CPU-bound code, synchronous I/O, large JSON) blocks the
+ * other requests; a utilization near 100 means the loop has no idle time left.
+ *
+ * Both cover the time since the monitor was created or last {@link EventLoopMonitor.reset}: the delays are a
+ * histogram of every measure, the utilization is the share of that whole time the loop was busy. Declare it in the
+ * `components` of the application (`{class: EventLoopMonitor}`) and get it with `@Inject` or `getObject()`; it is a
+ * singleton. It starts measuring when it is created: list it in `bootstrap` to measure from the launch; it stops when
+ * the component is destroyed.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {EventLoopMonitor, type IEventLoopMonitorStatistics} from 'lakutata/com/monitor'
+ *
+ * Application
+ *     .run(() => ({
+ *         id: 'loop.app',
+ *         name: 'Loop',
+ *         components: {
+ *             eventLoop: {class: EventLoopMonitor}
+ *         },
+ *         bootstrap: ['eventLoop']
+ *     }))
+ *     .onLaunched(async (app: Application): Promise<void> => {
+ *         const eventLoop: EventLoopMonitor = await app.getObject('eventLoop')
+ *         setInterval((): void => {
+ *             const statistics: IEventLoopMonitorStatistics = eventLoop.statistics
+ *             if (statistics.p99 > 100) console.log(`The event loop lags: p99 ${statistics.p99} ms, ${statistics.utilRate}% busy`)
+ *             //Each report covers the last minute
+ *             eventLoop.reset()
+ *         }, 60000)
+ *     })
+ * ```
+ */
+export declare class EventLoopMonitor extends Component implements IMonitor<IEventLoopMonitorStatistics> {
+    /**
+     * The histogram of the event loop delays, in nanoseconds, sampled every millisecond while enabled (from the
+     * monitor's initialization to its destruction).
+     */
+    protected readonly histogram: IntervalHistogram;
+    /**
+     * The event loop utilization when the monitor was created or reset: the start of the period that
+     * {@link IEventLoopMonitorStatistics.utilRate} covers.
+     */
+    protected initUtil: EventLoopUtilization;
+    /**
+     * The event loop statistics since the monitor was created or reset, computed at each read: the minimum, maximum,
+     * mean, standard deviation and percentiles of the delays in milliseconds (not rounded; all 0 before the first
+     * measure), and the utilization in percent.
+     */
+    get statistics(): IEventLoopMonitorStatistics;
+    protected init(): Promise<void>;
+    protected destroy(): Promise<void>;
+    /**
+     * Forget the delays and restart the utilization: the statistics then cover the time since this call. Use it to
+     * measure a period, such as between two reports.
+     */
+    reset(): void;
+}

package/dist/cjs/monitor/EventLoopMonitor.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventLoopMonitor = void 0;
+const node_perf_hooks_1 = require("node:perf_hooks");
+const core_1 = require("@lakutata/core");
+/**
+ * The event loop monitor: measures how late the event loop of the main thread runs its timers (the event loop delay,
+ * in milliseconds, with Node's `monitorEventLoopDelay` at a 1 ms resolution) and how busy it is (its utilization, in
+ * percent of the time). A growing delay means synchronous work (CPU-bound code, synchronous I/O, large JSON) blocks the
+ * other requests; a utilization near 100 means the loop has no idle time left.
+ *
+ * Both cover the time since the monitor was created or last {@link EventLoopMonitor.reset}: the delays are a
+ * histogram of every measure, the utilization is the share of that whole time the loop was busy. Declare it in the
+ * `components` of the application (`{class: EventLoopMonitor}`) and get it with `@Inject` or `getObject()`; it is a
+ * singleton. It starts measuring when it is created: list it in `bootstrap` to measure from the launch; it stops when
+ * the component is destroyed.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {EventLoopMonitor, type IEventLoopMonitorStatistics} from 'lakutata/com/monitor'
+ *
+ * Application
+ *     .run(() => ({
+ *         id: 'loop.app',
+ *         name: 'Loop',
+ *         components: {
+ *             eventLoop: {class: EventLoopMonitor}
+ *         },
+ *         bootstrap: ['eventLoop']
+ *     }))
+ *     .onLaunched(async (app: Application): Promise<void> => {
+ *         const eventLoop: EventLoopMonitor = await app.getObject('eventLoop')
+ *         setInterval((): void => {
+ *             const statistics: IEventLoopMonitorStatistics = eventLoop.statistics
+ *             if (statistics.p99 > 100) console.log(`The event loop lags: p99 ${statistics.p99} ms, ${statistics.utilRate}% busy`)
+ *             //Each report covers the last minute
+ *             eventLoop.reset()
+ *         }, 60000)
+ *     })
+ * ```
+ */
+class EventLoopMonitor extends core_1.Component {
+    constructor() {
+        super(...arguments);
+        /**
+         * The histogram of the event loop delays, in nanoseconds, sampled every millisecond while enabled (from the
+         * monitor's initialization to its destruction).
+         */
+        this.histogram = (0, node_perf_hooks_1.monitorEventLoopDelay)({ resolution: 1 });
+        /**
+         * The event loop utilization when the monitor was created or reset: the start of the period that
+         * {@link IEventLoopMonitorStatistics.utilRate} covers.
+         */
+        this.initUtil = node_perf_hooks_1.performance.eventLoopUtilization();
+    }
+    /**
+     * The event loop statistics since the monitor was created or reset, computed at each read: the minimum, maximum,
+     * mean, standard deviation and percentiles of the delays in milliseconds (not rounded; all 0 before the first
+     * measure), and the utilization in percent.
+     */
+    get statistics() {
+        //Without sample yet, the histogram gives no meaningful value
+        const sampled = this.histogram.count > 0;
+        const delay = (nanoseconds) => sampled ? nanoseconds / 1e6 : 0;
+        return {
+            min: delay(this.histogram.min),
+            max: delay(this.histogram.max),
+            avg: delay(this.histogram.mean),
+            stdDev: delay(this.histogram.stddev),
+            p50: delay(this.histogram.percentile(50)),
+            p90: delay(this.histogram.percentile(90)),
+            p95: delay(this.histogram.percentile(95)),
+            p99: delay(this.histogram.percentile(99)),
+            utilRate: node_perf_hooks_1.performance.eventLoopUtilization(this.initUtil).utilization * 100
+        };
+    }
+    async init() {
+        this.histogram.enable();
+    }
+    async destroy() {
+        this.histogram.disable();
+    }
+    /**
+     * Forget the delays and restart the utilization: the statistics then cover the time since this call. Use it to
+     * measure a period, such as between two reports.
+     */
+    reset() {
+        this.histogram.reset();
+        this.initUtil = node_perf_hooks_1.performance.eventLoopUtilization();
+    }
+}
+exports.EventLoopMonitor = EventLoopMonitor;

package/dist/cjs/monitor/HttpRequestMonitor.d.ts

@@ -0,0 +1,61 @@
+import { PerformanceObserver } from 'node:perf_hooks';
+import { Component } from '@lakutata/core';
+import { IMonitor } from './interfaces/IMonitor.js';
+import { IHttpRequestMonitorStatistics } from './interfaces/IHttpRequestMonitorStatistics.js';
+/**
+ * The HTTP request monitor: measures how long the HTTP requests received by the process take, in milliseconds, from
+ * their arrival to the end of their response, through the performance entries of `node:http` (so every server built on
+ * it is counted: the Express and Fastify adapters, and any other server of the process). The requests the process
+ * sends are not counted, nor are HTTP/2 requests.
+ *
+ * It keeps the count and the statistics of the durations since it was created or last {@link HttpRequestMonitor.reset},
+ * in constant memory. The entries reach it in batches, shortly after the responses end, so a request just answered may
+ * not be counted yet. Declare it in the `components` of the application (`{class: HttpRequestMonitor}`) and get it with
+ * `@Inject` or `getObject()`; it is a singleton. It only sees the requests ending after its creation: list it in
+ * `bootstrap` to measure from the launch; it stops when the component is destroyed.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {HttpRequestMonitor, type IHttpRequestMonitorStatistics} from 'lakutata/com/monitor'
+ *
+ * Application
+ *     .run(() => ({
+ *         id: 'http.app',
+ *         name: 'Http',
+ *         components: {
+ *             httpRequests: {class: HttpRequestMonitor}
+ *         },
+ *         bootstrap: ['httpRequests']
+ *     }))
+ *     .onLaunched(async (app: Application): Promise<void> => {
+ *         const httpRequests: HttpRequestMonitor = await app.getObject('httpRequests')
+ *         setInterval((): void => {
+ *             const statistics: IHttpRequestMonitorStatistics = httpRequests.statistics
+ *             console.log(`${statistics.count} requests, avg ${statistics.avg} ms, p99 ${statistics.p99} ms`)
+ *             httpRequests.reset()
+ *         }, 60000)
+ *     })
+ * ```
+ */
+export declare class HttpRequestMonitor extends Component implements IMonitor<IHttpRequestMonitorStatistics> {
+    #private;
+    /**
+     * The observer of the `http` performance entries, recording the duration of each received request (the
+     * `HttpRequest` entries); observing from the monitor's initialization to its destruction.
+     */
+    protected readonly observer: PerformanceObserver;
+    /**
+     * The statistics of the request durations since the monitor was created or reset, computed at each read: the
+     * number of requests, and the minimum, maximum, mean, standard deviation and percentiles of their durations in
+     * milliseconds, rounded to 2 decimals. The percentiles are approximate (3 significant digits). All 0 before the first
+     * request.
+     */
+    get statistics(): IHttpRequestMonitorStatistics;
+    protected init(): Promise<void>;
+    protected destroy(): Promise<void>;
+    /**
+     * Forget the requests: the count and the statistics restart from 0. Use it to measure a period, such as between
+     * two reports.
+     */
+    reset(): void;
+}

package/dist/cjs/monitor/HttpRequestMonitor.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpRequestMonitor = void 0;
+const node_perf_hooks_1 = require("node:perf_hooks");
+const core_1 = require("@lakutata/core");
+const Samples_js_1 = require("./lib/Samples.js");
+/**
+ * The HTTP request monitor: measures how long the HTTP requests received by the process take, in milliseconds, from
+ * their arrival to the end of their response, through the performance entries of `node:http` (so every server built on
+ * it is counted: the Express and Fastify adapters, and any other server of the process). The requests the process
+ * sends are not counted, nor are HTTP/2 requests.
+ *
+ * It keeps the count and the statistics of the durations since it was created or last {@link HttpRequestMonitor.reset},
+ * in constant memory. The entries reach it in batches, shortly after the responses end, so a request just answered may
+ * not be counted yet. Declare it in the `components` of the application (`{class: HttpRequestMonitor}`) and get it with
+ * `@Inject` or `getObject()`; it is a singleton. It only sees the requests ending after its creation: list it in
+ * `bootstrap` to measure from the launch; it stops when the component is destroyed.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {HttpRequestMonitor, type IHttpRequestMonitorStatistics} from 'lakutata/com/monitor'
+ *
+ * Application
+ *     .run(() => ({
+ *         id: 'http.app',
+ *         name: 'Http',
+ *         components: {
+ *             httpRequests: {class: HttpRequestMonitor}
+ *         },
+ *         bootstrap: ['httpRequests']
+ *     }))
+ *     .onLaunched(async (app: Application): Promise<void> => {
+ *         const httpRequests: HttpRequestMonitor = await app.getObject('httpRequests')
+ *         setInterval((): void => {
+ *             const statistics: IHttpRequestMonitorStatistics = httpRequests.statistics
+ *             console.log(`${statistics.count} requests, avg ${statistics.avg} ms, p99 ${statistics.p99} ms`)
+ *             httpRequests.reset()
+ *         }, 60000)
+ *     })
+ * ```
+ */
+class HttpRequestMonitor extends core_1.Component {
+    constructor() {
+        super(...arguments);
+        this.#fractionDigits = 2;
+        this.#durations = new Samples_js_1.Samples(100);
+        /**
+         * The observer of the `http` performance entries, recording the duration of each received request (the
+         * `HttpRequest` entries); observing from the monitor's initialization to its destruction.
+         */
+        this.observer = new node_perf_hooks_1.PerformanceObserver((list) => {
+            //Every request of the batch, the received ones only (HttpClient entries are the requests sent)
+            for (const entry of list.getEntriesByName('HttpRequest'))
+                this.#durations.record(entry.duration);
+        });
+    }
+    #fractionDigits;
+    #durations;
+    /**
+     * The statistics of the request durations since the monitor was created or reset, computed at each read: the
+     * number of requests, and the minimum, maximum, mean, standard deviation and percentiles of their durations in
+     * milliseconds, rounded to 2 decimals. The percentiles are approximate (3 significant digits). All 0 before the first
+     * request.
+     */
+    get statistics() {
+        return {
+            count: this.#durations.count,
+            min: (0, Samples_js_1.round)(this.#durations.min, this.#fractionDigits),
+            max: (0, Samples_js_1.round)(this.#durations.max, this.#fractionDigits),
+            avg: (0, Samples_js_1.round)(this.#durations.mean, this.#fractionDigits),
+            stdDev: (0, Samples_js_1.round)(this.#durations.stdDev, this.#fractionDigits),
+            p50: (0, Samples_js_1.round)(this.#durations.percentile(50), this.#fractionDigits),
+            p90: (0, Samples_js_1.round)(this.#durations.percentile(90), this.#fractionDigits),
+            p95: (0, Samples_js_1.round)(this.#durations.percentile(95), this.#fractionDigits),
+            p99: (0, Samples_js_1.round)(this.#durations.percentile(99), this.#fractionDigits)
+        };
+    }
+    async init() {
+        this.observer.observe({ entryTypes: ['http'] });
+    }
+    async destroy() {
+        this.observer.disconnect();
+    }
+    /**
+     * Forget the requests: the count and the statistics restart from 0. Use it to measure a period, such as between
+     * two reports.
+     */
+    reset() {
+        this.#durations.reset();
+    }
+}
+exports.HttpRequestMonitor = HttpRequestMonitor;