@lopatnov/express-reverse-proxy 1.1.1 → 1.2.0

package/node_modules/@pm2/io/build/main/metrics/eventLoopMetrics.js

@@ -0,0 +1,128 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const metrics_1 = require("../services/metrics");
+const serviceManager_1 = require("../serviceManager");
+const Debug = require("debug");
+const histogram_1 = require("../utils/metrics/histogram");
+class EventLoopMetricOption {
+}
+exports.EventLoopMetricOption = EventLoopMetricOption;
+const defaultOptions = {
+    eventLoopActive: true,
+    eventLoopDelay: true
+};
+class EventLoopHandlesRequestsMetric {
+    constructor() {
+        this.logger = Debug('axm:features:metrics:eventloop');
+        this.delayLoopInterval = 1000;
+    }
+    init(config) {
+        if (config === false)
+            return;
+        if (config === undefined) {
+            config = defaultOptions;
+        }
+        if (config === true) {
+            config = defaultOptions;
+        }
+        this.metricService = serviceManager_1.ServiceManager.get('metrics');
+        if (this.metricService === undefined)
+            return this.logger('Failed to load metric service');
+        this.logger('init');
+        if (typeof process._getActiveRequests === 'function' && config.eventLoopActive === true) {
+            const requestMetric = this.metricService.metric({
+                name: 'Active requests',
+                id: 'internal/libuv/requests',
+                historic: true
+            });
+            this.requestTimer = setInterval(_ => {
+                requestMetric.set(process._getActiveRequests().length);
+            }, 1000);
+            this.requestTimer.unref();
+        }
+        if (typeof process._getActiveHandles === 'function' && config.eventLoopActive === true) {
+            const handleMetric = this.metricService.metric({
+                name: 'Active handles',
+                id: 'internal/libuv/handles',
+                historic: true
+            });
+            this.handleTimer = setInterval(_ => {
+                handleMetric.set(process._getActiveHandles().length);
+            }, 1000);
+            this.handleTimer.unref();
+        }
+        if (config.eventLoopDelay === false)
+            return;
+        const histogram = new histogram_1.default();
+        const uvLatencyp50 = {
+            name: 'Event Loop Latency',
+            id: 'internal/libuv/latency/p50',
+            type: metrics_1.MetricType.histogram,
+            historic: true,
+            implementation: histogram,
+            handler: function () {
+                const percentiles = this.implementation.percentiles([0.5]);
+                if (percentiles[0.5] === null)
+                    return null;
+                return percentiles[0.5].toFixed(2);
+            },
+            unit: 'ms'
+        };
+        const uvLatencyp95 = {
+            name: 'Event Loop Latency p95',
+            id: 'internal/libuv/latency/p95',
+            type: metrics_1.MetricType.histogram,
+            historic: true,
+            implementation: histogram,
+            handler: function () {
+                const percentiles = this.implementation.percentiles([0.95]);
+                if (percentiles[0.95] === null)
+                    return null;
+                return percentiles[0.95].toFixed(2);
+            },
+            unit: 'ms'
+        };
+        this.metricService.registerMetric(uvLatencyp50);
+        this.metricService.registerMetric(uvLatencyp95);
+        this.runtimeStatsService = serviceManager_1.ServiceManager.get('runtimeStats');
+        if (this.runtimeStatsService === undefined) {
+            this.logger('runtimeStats module not found, fallbacking into pure js method');
+            let oldTime = process.hrtime();
+            this.delayTimer = setInterval(() => {
+                const newTime = process.hrtime();
+                const delay = (newTime[0] - oldTime[0]) * 1e3 + (newTime[1] - oldTime[1]) / 1e6 - this.delayLoopInterval;
+                oldTime = newTime;
+                histogram.update(delay);
+            }, this.delayLoopInterval);
+            this.delayTimer.unref();
+        }
+        else {
+            this.logger('using runtimeStats module as data source for event loop latency');
+            this.handle = (stats) => {
+                if (typeof stats !== 'object' || !Array.isArray(stats.ticks))
+                    return;
+                stats.ticks.forEach((tick) => {
+                    histogram.update(tick);
+                });
+            };
+            this.runtimeStatsService.on('data', this.handle);
+        }
+    }
+    destroy() {
+        if (this.requestTimer !== undefined) {
+            clearInterval(this.requestTimer);
+        }
+        if (this.handleTimer !== undefined) {
+            clearInterval(this.handleTimer);
+        }
+        if (this.delayTimer !== undefined) {
+            clearInterval(this.delayTimer);
+        }
+        if (this.runtimeStatsService !== undefined) {
+            this.runtimeStatsService.removeListener('data', this.handle);
+        }
+        this.logger('destroy');
+    }
+}
+exports.default = EventLoopHandlesRequestsMetric;
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/@pm2/io/build/main/metrics/httpMetrics.d.ts

@@ -0,0 +1,18 @@
+import { MetricInterface } from '../features/metrics';
+export declare class HttpMetricsConfig {
+    http: boolean;
+}
+export default class HttpMetrics implements MetricInterface {
+    private defaultConf;
+    private metrics;
+    private logger;
+    private metricService;
+    private modules;
+    private hooks;
+    init(config?: HttpMetricsConfig | boolean): any;
+    private registerHttpMetric;
+    private registerHttpsMetric;
+    destroy(): void;
+    private hookHttp;
+    private hookRequire;
+}

package/node_modules/@pm2/io/build/main/metrics/httpMetrics.js

@@ -0,0 +1,178 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const shimmer = require("shimmer");
+const debug_1 = require("debug");
+const configuration_1 = require("../configuration");
+const serviceManager_1 = require("../serviceManager");
+const histogram_1 = require("../utils/metrics/histogram");
+const requireMiddle = require("require-in-the-middle");
+const metrics_1 = require("../services/metrics");
+class HttpMetricsConfig {
+}
+exports.HttpMetricsConfig = HttpMetricsConfig;
+class HttpMetrics {
+    constructor() {
+        this.defaultConf = {
+            http: true
+        };
+        this.metrics = new Map();
+        this.logger = debug_1.default('axm:features:metrics:http');
+        this.modules = {};
+    }
+    init(config) {
+        if (config === false)
+            return;
+        if (config === undefined) {
+            config = this.defaultConf;
+        }
+        if (typeof config !== 'object') {
+            config = this.defaultConf;
+        }
+        this.logger('init');
+        configuration_1.default.configureModule({
+            latency: true
+        });
+        this.metricService = serviceManager_1.ServiceManager.get('metrics');
+        if (this.metricService === undefined)
+            return this.logger(`Failed to load metric service`);
+        this.logger('hooking to require');
+        this.hookRequire();
+    }
+    registerHttpMetric() {
+        if (this.metricService === undefined)
+            return this.logger(`Failed to load metric service`);
+        const histogram = new histogram_1.default();
+        const p50 = {
+            name: `HTTP Mean Latency`,
+            id: 'internal/http/builtin/latency/p50',
+            type: metrics_1.MetricType.histogram,
+            historic: true,
+            implementation: histogram,
+            unit: 'ms',
+            handler: () => {
+                const percentiles = histogram.percentiles([0.5]);
+                return percentiles[0.5];
+            }
+        };
+        const p95 = {
+            name: `HTTP P95 Latency`,
+            id: 'internal/http/builtin/latency/p95',
+            type: metrics_1.MetricType.histogram,
+            historic: true,
+            implementation: histogram,
+            handler: () => {
+                const percentiles = histogram.percentiles([0.95]);
+                return percentiles[0.95];
+            },
+            unit: 'ms'
+        };
+        const meter = {
+            name: 'HTTP',
+            historic: true,
+            id: 'internal/http/builtin/reqs',
+            unit: 'req/min'
+        };
+        this.metricService.registerMetric(p50);
+        this.metricService.registerMetric(p95);
+        this.metrics.set('http.latency', histogram);
+        this.metrics.set('http.meter', this.metricService.meter(meter));
+    }
+    registerHttpsMetric() {
+        if (this.metricService === undefined)
+            return this.logger(`Failed to load metric service`);
+        const histogram = new histogram_1.default();
+        const p50 = {
+            name: `HTTPS Mean Latency`,
+            id: 'internal/https/builtin/latency/p50',
+            type: metrics_1.MetricType.histogram,
+            historic: true,
+            implementation: histogram,
+            unit: 'ms',
+            handler: () => {
+                const percentiles = histogram.percentiles([0.5]);
+                return percentiles[0.5];
+            }
+        };
+        const p95 = {
+            name: `HTTPS P95 Latency`,
+            id: 'internal/https/builtin/latency/p95',
+            type: metrics_1.MetricType.histogram,
+            historic: true,
+            implementation: histogram,
+            handler: () => {
+                const percentiles = histogram.percentiles([0.95]);
+                return percentiles[0.95];
+            },
+            unit: 'ms'
+        };
+        const meter = {
+            name: 'HTTPS',
+            historic: true,
+            id: 'internal/https/builtin/reqs',
+            unit: 'req/min'
+        };
+        this.metricService.registerMetric(p50);
+        this.metricService.registerMetric(p95);
+        this.metrics.set('https.latency', histogram);
+        this.metrics.set('https.meter', this.metricService.meter(meter));
+    }
+    destroy() {
+        if (this.modules.http !== undefined) {
+            this.logger('unwraping http module');
+            shimmer.unwrap(this.modules.http, 'emit');
+            this.modules.http = undefined;
+        }
+        if (this.modules.https !== undefined) {
+            this.logger('unwraping https module');
+            shimmer.unwrap(this.modules.https, 'emit');
+            this.modules.https = undefined;
+        }
+        if (this.hooks) {
+            this.hooks.unhook();
+        }
+        this.logger('destroy');
+    }
+    hookHttp(nodule, name) {
+        if (nodule.Server === undefined || nodule.Server.prototype === undefined)
+            return;
+        if (this.modules[name] !== undefined)
+            return this.logger(`Module ${name} already hooked`);
+        this.logger(`Hooking to ${name} module`);
+        this.modules[name] = nodule.Server.prototype;
+        if (name === 'http') {
+            this.registerHttpMetric();
+        }
+        else if (name === 'https') {
+            this.registerHttpsMetric();
+        }
+        const self = this;
+        shimmer.wrap(nodule.Server.prototype, 'emit', (original) => {
+            return function (event, req, res) {
+                if (event !== 'request')
+                    return original.apply(this, arguments);
+                const meter = self.metrics.get(`${name}.meter`);
+                if (meter !== undefined) {
+                    meter.mark();
+                }
+                const latency = self.metrics.get(`${name}.latency`);
+                if (latency === undefined)
+                    return original.apply(this, arguments);
+                if (res === undefined || res === null)
+                    return original.apply(this, arguments);
+                const startTime = Date.now();
+                res.once('finish', _ => {
+                    latency.update(Date.now() - startTime);
+                });
+                return original.apply(this, arguments);
+            };
+        });
+    }
+    hookRequire() {
+        this.hooks = requireMiddle(['http', 'https'], (exports, name) => {
+            this.hookHttp(exports, name);
+            return exports;
+        });
+    }
+}
+exports.default = HttpMetrics;
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/@pm2/io/build/main/metrics/network.d.ts

@@ -0,0 +1,15 @@
+import { MetricInterface } from '../features/metrics';
+export declare class NetworkTrafficConfig {
+    upload: boolean;
+    download: boolean;
+}
+export default class NetworkMetric implements MetricInterface {
+    private metricService;
+    private timer;
+    private logger;
+    private socketProto;
+    init(config?: NetworkTrafficConfig | boolean): any;
+    destroy(): void;
+    private catchDownload;
+    private catchUpload;
+}

package/node_modules/@pm2/io/build/main/metrics/network.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const netModule = require("net");
+const metrics_1 = require("../services/metrics");
+const Debug = require("debug");
+const meter_1 = require("../utils/metrics/meter");
+const shimmer = require("shimmer");
+const serviceManager_1 = require("../serviceManager");
+class NetworkTrafficConfig {
+}
+exports.NetworkTrafficConfig = NetworkTrafficConfig;
+const defaultConfig = {
+    upload: false,
+    download: false
+};
+const allEnabled = {
+    upload: true,
+    download: true
+};
+class NetworkMetric {
+    constructor() {
+        this.logger = Debug('axm:features:metrics:network');
+    }
+    init(config) {
+        if (config === false)
+            return;
+        if (config === true) {
+            config = allEnabled;
+        }
+        if (config === undefined) {
+            config = defaultConfig;
+        }
+        this.metricService = serviceManager_1.ServiceManager.get('metrics');
+        if (this.metricService === undefined) {
+            return this.logger(`Failed to load metric service`);
+        }
+        if (config.download === true) {
+            this.catchDownload();
+        }
+        if (config.upload === true) {
+            this.catchUpload();
+        }
+        this.logger('init');
+    }
+    destroy() {
+        if (this.timer !== undefined) {
+            clearTimeout(this.timer);
+        }
+        if (this.socketProto !== undefined && this.socketProto !== null) {
+            shimmer.unwrap(this.socketProto, 'read');
+            shimmer.unwrap(this.socketProto, 'write');
+        }
+        this.logger('destroy');
+    }
+    catchDownload() {
+        if (this.metricService === undefined)
+            return this.logger(`Failed to load metric service`);
+        const downloadMeter = new meter_1.default({});
+        this.metricService.registerMetric({
+            name: 'Network In',
+            id: 'internal/network/in',
+            historic: true,
+            type: metrics_1.MetricType.meter,
+            implementation: downloadMeter,
+            unit: 'kb/s',
+            handler: function () {
+                return Math.floor(this.implementation.val() / 1024 * 1000) / 1000;
+            }
+        });
+        setTimeout(() => {
+            const property = netModule.Socket.prototype.read;
+            const isWrapped = property && property.__wrapped === true;
+            if (isWrapped) {
+                return this.logger(`Already patched socket read, canceling`);
+            }
+            shimmer.wrap(netModule.Socket.prototype, 'read', function (original) {
+                return function () {
+                    this.on('data', (data) => {
+                        if (typeof data.length === 'number') {
+                            downloadMeter.mark(data.length);
+                        }
+                    });
+                    return original.apply(this, arguments);
+                };
+            });
+        }, 500);
+    }
+    catchUpload() {
+        if (this.metricService === undefined)
+            return this.logger(`Failed to load metric service`);
+        const uploadMeter = new meter_1.default();
+        this.metricService.registerMetric({
+            name: 'Network Out',
+            id: 'internal/network/out',
+            type: metrics_1.MetricType.meter,
+            historic: true,
+            implementation: uploadMeter,
+            unit: 'kb/s',
+            handler: function () {
+                return Math.floor(this.implementation.val() / 1024 * 1000) / 1000;
+            }
+        });
+        setTimeout(() => {
+            const property = netModule.Socket.prototype.write;
+            const isWrapped = property && property.__wrapped === true;
+            if (isWrapped) {
+                return this.logger(`Already patched socket write, canceling`);
+            }
+            shimmer.wrap(netModule.Socket.prototype, 'write', function (original) {
+                return function (data) {
+                    if (typeof data.length === 'number') {
+                        uploadMeter.mark(data.length);
+                    }
+                    return original.apply(this, arguments);
+                };
+            });
+        }, 500);
+    }
+}
+exports.default = NetworkMetric;
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/@pm2/io/build/main/metrics/runtime.d.ts

@@ -0,0 +1,16 @@
+import { MetricInterface } from '../features/metrics';
+export declare class RuntimeMetricsOptions {
+    gcOldPause: boolean;
+    gcNewPause: boolean;
+    pageFaults: boolean;
+    contextSwitchs: boolean;
+}
+export default class RuntimeMetrics implements MetricInterface {
+    private metricService;
+    private logger;
+    private runtimeStatsService;
+    private handle;
+    private metrics;
+    init(config?: RuntimeMetricsOptions | boolean): any;
+    destroy(): void;
+}