@lopatnov/express-reverse-proxy 1.0.1 → 1.2.0

package/node_modules/@pm2/io/build/main/services/actions.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const serviceManager_1 = require("../serviceManager");
+const Debug = require("debug");
+class Action {
+}
+exports.Action = Action;
+class ActionService {
+    constructor() {
+        this.timer = undefined;
+        this.transport = undefined;
+        this.actions = new Map();
+        this.logger = Debug('axm:services:actions');
+    }
+    listener(data) {
+        this.logger(`Received new message from reverse`);
+        if (!data)
+            return false;
+        const actionName = data.msg ? data.msg : data.action_name ? data.action_name : data;
+        let action = this.actions.get(actionName);
+        if (typeof action !== 'object') {
+            return this.logger(`Received action ${actionName} but failed to find the implementation`);
+        }
+        if (!action.isScoped) {
+            this.logger(`Succesfully called custom action ${action.name} with arity ${action.handler.length}`);
+            if (action.handler.length === 2) {
+                let params = {};
+                if (typeof data === 'object') {
+                    params = data.opts;
+                }
+                return action.handler(params, action.callback);
+            }
+            return action.handler(action.callback);
+        }
+        if (data.uuid === undefined) {
+            return this.logger(`Received scoped action ${action.name} but without uuid`);
+        }
+        const stream = {
+            send: (dt) => {
+                this.transport.send('axm:scoped_action:stream', {
+                    data: dt,
+                    uuid: data.uuid,
+                    action_name: actionName
+                });
+            },
+            error: (dt) => {
+                this.transport.send('axm:scoped_action:error', {
+                    data: dt,
+                    uuid: data.uuid,
+                    action_name: actionName
+                });
+            },
+            end: (dt) => {
+                this.transport.send('axm:scoped_action:end', {
+                    data: dt,
+                    uuid: data.uuid,
+                    action_name: actionName
+                });
+            }
+        };
+        this.logger(`Succesfully called scoped action ${action.name}`);
+        return action.handler(data.opts || {}, stream);
+    }
+    init() {
+        this.transport = serviceManager_1.ServiceManager.get('transport');
+        if (this.transport === undefined) {
+            return this.logger(`Failed to load transport service`);
+        }
+        this.actions.clear();
+        this.transport.on('data', this.listener.bind(this));
+    }
+    destroy() {
+        if (this.timer !== undefined) {
+            clearInterval(this.timer);
+        }
+        if (this.transport !== undefined) {
+            this.transport.removeListener('data', this.listener.bind(this));
+        }
+    }
+    registerAction(actionName, opts, handler) {
+        if (typeof opts === 'function') {
+            handler = opts;
+            opts = undefined;
+        }
+        if (typeof actionName !== 'string') {
+            console.error(`You must define an name when registering an action`);
+            return;
+        }
+        if (typeof handler !== 'function') {
+            console.error(`You must define an callback when registering an action`);
+            return;
+        }
+        if (this.transport === undefined) {
+            return this.logger(`Failed to load transport service`);
+        }
+        let type = 'custom';
+        if (actionName.indexOf('km:') === 0 || actionName.indexOf('internal:') === 0) {
+            type = 'internal';
+        }
+        const reply = (data) => {
+            this.transport.send('axm:reply', {
+                at: new Date().getTime(),
+                action_name: actionName,
+                return: data
+            });
+        };
+        const action = {
+            name: actionName,
+            callback: reply,
+            handler,
+            type,
+            isScoped: false,
+            arity: handler.length,
+            opts
+        };
+        this.logger(`Succesfully registered custom action ${action.name}`);
+        this.actions.set(actionName, action);
+        this.transport.addAction(action);
+    }
+    scopedAction(actionName, handler) {
+        if (typeof actionName !== 'string') {
+            console.error(`You must define an name when registering an action`);
+            return -1;
+        }
+        if (typeof handler !== 'function') {
+            console.error(`You must define an callback when registering an action`);
+            return -1;
+        }
+        if (this.transport === undefined) {
+            return this.logger(`Failed to load transport service`);
+        }
+        const action = {
+            name: actionName,
+            handler,
+            type: 'scoped',
+            isScoped: true,
+            arity: handler.length,
+            opts: null
+        };
+        this.logger(`Succesfully registered scoped action ${action.name}`);
+        this.actions.set(actionName, action);
+        this.transport.addAction(action);
+    }
+}
+exports.ActionService = ActionService;
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/@pm2/io/build/main/services/inspector.d.ts

@@ -0,0 +1,8 @@
+import * as inspector from 'inspector';
+export declare class InspectorService {
+    private session;
+    private logger;
+    init(): inspector.Session;
+    getSession(): inspector.Session;
+    destroy(): void;
+}

package/node_modules/@pm2/io/build/main/services/inspector.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const inspector = require("inspector");
+const debug_1 = require("debug");
+class InspectorService {
+    constructor() {
+        this.session = null;
+        this.logger = debug_1.default('axm:services:inspector');
+    }
+    init() {
+        this.logger(`Creating new inspector session`);
+        this.session = new inspector.Session();
+        this.session.connect();
+        this.logger('Connected to inspector');
+        this.session.post('Profiler.enable');
+        this.session.post('HeapProfiler.enable');
+        return this.session;
+    }
+    getSession() {
+        if (this.session === null) {
+            this.session = this.init();
+            return this.session;
+        }
+        else {
+            return this.session;
+        }
+    }
+    destroy() {
+        if (this.session !== null) {
+            this.session.post('Profiler.disable');
+            this.session.post('HeapProfiler.disable');
+            this.session.disconnect();
+            this.session = null;
+        }
+        else {
+            this.logger('No open session');
+        }
+    }
+}
+exports.InspectorService = InspectorService;
+module.exports = InspectorService;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5zcGVjdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3NlcnZpY2VzL2luc3BlY3Rvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLHVDQUFzQztBQUN0QyxpQ0FBeUI7QUFFekIsTUFBYSxnQkFBZ0I7SUFBN0I7UUFFVSxZQUFPLEdBQTZCLElBQUksQ0FBQTtRQUN4QyxXQUFNLEdBQWEsZUFBSyxDQUFDLHdCQUF3QixDQUFDLENBQUE7SUErQjVELENBQUM7SUE3QkMsSUFBSTtRQUNGLElBQUksQ0FBQyxNQUFNLENBQUMsZ0NBQWdDLENBQUMsQ0FBQTtRQUM3QyxJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksU0FBUyxDQUFDLE9BQU8sRUFBRSxDQUFBO1FBQ3RDLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUE7UUFDdEIsSUFBSSxDQUFDLE1BQU0sQ0FBQyx3QkFBd0IsQ0FBQyxDQUFBO1FBQ3JDLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLGlCQUFpQixDQUFDLENBQUE7UUFDcEMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMscUJBQXFCLENBQUMsQ0FBQTtRQUN4QyxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUE7SUFDckIsQ0FBQztJQUVELFVBQVU7UUFDUixJQUFJLElBQUksQ0FBQyxPQUFPLEtBQUssSUFBSSxFQUFFO1lBQ3pCLElBQUksQ0FBQyxPQUFPLEdBQUcsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFBO1lBQzFCLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQTtTQUNwQjthQUFNO1lBQ0wsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFBO1NBQ3BCO0lBQ0gsQ0FBQztJQUVELE9BQU87UUFDTCxJQUFJLElBQUksQ0FBQyxPQUFPLEtBQUssSUFBSSxFQUFFO1lBQ3pCLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLGtCQUFrQixDQUFDLENBQUE7WUFDckMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsc0JBQXNCLENBQUMsQ0FBQTtZQUN6QyxJQUFJLENBQUMsT0FBTyxDQUFDLFVBQVUsRUFBRSxDQUFBO1lBQ3pCLElBQUksQ0FBQyxPQUFPLEdBQUcsSUFBSSxDQUFBO1NBQ3BCO2FBQU07WUFDTCxJQUFJLENBQUMsTUFBTSxDQUFDLGlCQUFpQixDQUFDLENBQUE7U0FDL0I7SUFDSCxDQUFDO0NBQ0Y7QUFsQ0QsNENBa0NDO0FBRUQsTUFBTSxDQUFDLE9BQU8sR0FBRyxnQkFBZ0IsQ0FBQSJ9

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

@@ -0,0 +1,63 @@
+import Meter from '../utils/metrics/meter';
+import Counter from '../utils/metrics/counter';
+import Histogram from '../utils/metrics/histogram';
+import { Service } from '../serviceManager';
+import Gauge from '../utils/metrics/gauge';
+export declare enum MetricType {
+    'meter' = "meter",
+    'histogram' = "histogram",
+    'counter' = "counter",
+    'gauge' = "gauge",
+    'metric' = "metric"
+}
+export declare enum MetricMeasurements {
+    'min' = "min",
+    'max' = "max",
+    'sum' = "sum",
+    'count' = "count",
+    'variance' = "variance",
+    'mean' = "mean",
+    'stddev' = "stddev",
+    'median' = "median",
+    'p75' = "p75",
+    'p95' = "p95",
+    'p99' = "p99",
+    'p999' = "p999"
+}
+export interface InternalMetric {
+    name?: string;
+    type?: MetricType;
+    id?: string;
+    historic?: boolean;
+    unit?: string;
+    handler: Function;
+    implementation: any;
+    value?: number;
+}
+export declare class Metric {
+    name?: string;
+    id?: string;
+    historic?: boolean;
+    unit?: string;
+    value?: () => number;
+}
+export declare class MetricBulk extends Metric {
+    type: MetricType;
+}
+export declare class HistogramOptions extends Metric {
+    measurement: MetricMeasurements;
+}
+export declare class MetricService implements Service {
+    private metrics;
+    private timer;
+    private transport;
+    private logger;
+    init(): void;
+    registerMetric(metric: InternalMetric): void;
+    meter(opts: Metric): Meter;
+    counter(opts: Metric): Counter;
+    histogram(opts: HistogramOptions): Histogram;
+    metric(opts: Metric): Gauge;
+    deleteMetric(name: string): boolean;
+    destroy(): void;
+}

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

@@ -0,0 +1,186 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const meter_1 = require("../utils/metrics/meter");
+const counter_1 = require("../utils/metrics/counter");
+const histogram_1 = require("../utils/metrics/histogram");
+const serviceManager_1 = require("../serviceManager");
+const constants_1 = require("../constants");
+const Debug = require("debug");
+const gauge_1 = require("../utils/metrics/gauge");
+var MetricType;
+(function (MetricType) {
+    MetricType["meter"] = "meter";
+    MetricType["histogram"] = "histogram";
+    MetricType["counter"] = "counter";
+    MetricType["gauge"] = "gauge";
+    MetricType["metric"] = "metric";
+})(MetricType = exports.MetricType || (exports.MetricType = {}));
+var MetricMeasurements;
+(function (MetricMeasurements) {
+    MetricMeasurements["min"] = "min";
+    MetricMeasurements["max"] = "max";
+    MetricMeasurements["sum"] = "sum";
+    MetricMeasurements["count"] = "count";
+    MetricMeasurements["variance"] = "variance";
+    MetricMeasurements["mean"] = "mean";
+    MetricMeasurements["stddev"] = "stddev";
+    MetricMeasurements["median"] = "median";
+    MetricMeasurements["p75"] = "p75";
+    MetricMeasurements["p95"] = "p95";
+    MetricMeasurements["p99"] = "p99";
+    MetricMeasurements["p999"] = "p999";
+})(MetricMeasurements = exports.MetricMeasurements || (exports.MetricMeasurements = {}));
+class Metric {
+}
+exports.Metric = Metric;
+class MetricBulk extends Metric {
+}
+exports.MetricBulk = MetricBulk;
+class HistogramOptions extends Metric {
+}
+exports.HistogramOptions = HistogramOptions;
+class MetricService {
+    constructor() {
+        this.metrics = new Map();
+        this.timer = null;
+        this.transport = null;
+        this.logger = Debug('axm:services:metrics');
+    }
+    init() {
+        this.transport = serviceManager_1.ServiceManager.get('transport');
+        if (this.transport === null)
+            return this.logger('Failed to init metrics service cause no transporter');
+        this.logger('init');
+        this.timer = setInterval(() => {
+            if (this.transport === null)
+                return this.logger('Abort metrics update since transport is not available');
+            this.logger('refreshing metrics value');
+            for (let metric of this.metrics.values()) {
+                metric.value = metric.handler();
+            }
+            this.logger('sending update metrics value to transporter');
+            const metricsToSend = Array.from(this.metrics.values())
+                .filter(metric => {
+                if (metric === null || metric === undefined)
+                    return false;
+                if (metric.value === undefined || metric.value === null)
+                    return false;
+                const isNumber = typeof metric.value === 'number';
+                const isString = typeof metric.value === 'string';
+                const isBoolean = typeof metric.value === 'boolean';
+                const isValidNumber = !isNaN(metric.value);
+                return isString || isBoolean || (isNumber && isValidNumber);
+            });
+            this.transport.setMetrics(metricsToSend);
+        }, constants_1.default.METRIC_INTERVAL);
+        this.timer.unref();
+    }
+    registerMetric(metric) {
+        if (typeof metric.name !== 'string') {
+            console.error(`Invalid metric name declared: ${metric.name}`);
+            return console.trace();
+        }
+        else if (typeof metric.type !== 'string') {
+            console.error(`Invalid metric type declared: ${metric.type}`);
+            return console.trace();
+        }
+        else if (typeof metric.handler !== 'function') {
+            console.error(`Invalid metric handler declared: ${metric.handler}`);
+            return console.trace();
+        }
+        if (typeof metric.historic !== 'boolean') {
+            metric.historic = true;
+        }
+        this.logger(`Registering new metric: ${metric.name}`);
+        this.metrics.set(metric.name, metric);
+    }
+    meter(opts) {
+        const metric = {
+            name: opts.name,
+            type: MetricType.meter,
+            id: opts.id,
+            historic: opts.historic,
+            implementation: new meter_1.default(opts),
+            unit: opts.unit,
+            handler: function () {
+                return this.implementation.isUsed() ? this.implementation.val() : NaN;
+            }
+        };
+        this.registerMetric(metric);
+        return metric.implementation;
+    }
+    counter(opts) {
+        const metric = {
+            name: opts.name,
+            type: MetricType.counter,
+            id: opts.id,
+            historic: opts.historic,
+            implementation: new counter_1.default(opts),
+            unit: opts.unit,
+            handler: function () {
+                return this.implementation.isUsed() ? this.implementation.val() : NaN;
+            }
+        };
+        this.registerMetric(metric);
+        return metric.implementation;
+    }
+    histogram(opts) {
+        if (opts.measurement === undefined || opts.measurement === null) {
+            opts.measurement = MetricMeasurements.mean;
+        }
+        const metric = {
+            name: opts.name,
+            type: MetricType.histogram,
+            id: opts.id,
+            historic: opts.historic,
+            implementation: new histogram_1.default(opts),
+            unit: opts.unit,
+            handler: function () {
+                return this.implementation.isUsed() ?
+                    (Math.round(this.implementation.val() * 100) / 100) : NaN;
+            }
+        };
+        this.registerMetric(metric);
+        return metric.implementation;
+    }
+    metric(opts) {
+        let metric;
+        if (typeof opts.value === 'function') {
+            metric = {
+                name: opts.name,
+                type: MetricType.gauge,
+                id: opts.id,
+                implementation: undefined,
+                historic: opts.historic,
+                unit: opts.unit,
+                handler: opts.value
+            };
+        }
+        else {
+            metric = {
+                name: opts.name,
+                type: MetricType.gauge,
+                id: opts.id,
+                historic: opts.historic,
+                implementation: new gauge_1.default(),
+                unit: opts.unit,
+                handler: function () {
+                    return this.implementation.isUsed() ? this.implementation.val() : NaN;
+                }
+            };
+        }
+        this.registerMetric(metric);
+        return metric.implementation;
+    }
+    deleteMetric(name) {
+        return this.metrics.delete(name);
+    }
+    destroy() {
+        if (this.timer !== null) {
+            clearInterval(this.timer);
+        }
+        this.metrics.clear();
+    }
+}
+exports.MetricService = MetricService;
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/@pm2/io/build/main/services/runtimeStats.d.ts

@@ -0,0 +1,10 @@
+import { EventEmitter2 } from 'eventemitter2';
+export declare class RuntimeStatsService extends EventEmitter2 {
+    private logger;
+    private handle;
+    private noduleInstance;
+    private enabled;
+    init(): any;
+    isEnabled(): boolean;
+    destroy(): void;
+}

package/node_modules/@pm2/io/build/main/services/runtimeStats.js

@@ -0,0 +1,49 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const debug_1 = require("debug");
+const module_1 = require("../utils/module");
+const eventemitter2_1 = require("eventemitter2");
+class RuntimeStatsService extends eventemitter2_1.EventEmitter2 {
+    constructor() {
+        super(...arguments);
+        this.logger = debug_1.default('axm:services:runtimeStats');
+        this.enabled = false;
+    }
+    init() {
+        this.logger('init');
+        if (process.env.PM2_APM_DISABLE_RUNTIME_STATS === 'true') {
+            return this.logger('disabling service because of the environment flag');
+        }
+        const modulePath = module_1.default.detectModule('@pm2/node-runtime-stats');
+        if (typeof modulePath !== 'string')
+            return;
+        const RuntimeStats = module_1.default.loadModule(modulePath);
+        if (RuntimeStats instanceof Error) {
+            return this.logger(`Failed to require module @pm2/node-runtime-stats: ${RuntimeStats.message}`);
+        }
+        this.noduleInstance = new RuntimeStats({
+            delay: 1000
+        });
+        this.logger('starting runtime stats');
+        this.noduleInstance.start();
+        this.handle = (data) => {
+            this.logger('received runtime stats', data);
+            this.emit('data', data);
+        };
+        this.noduleInstance.on('sense', this.handle);
+        this.enabled = true;
+    }
+    isEnabled() {
+        return this.enabled;
+    }
+    destroy() {
+        if (this.noduleInstance !== undefined && this.noduleInstance !== null) {
+            this.logger('removing listener on runtime stats service');
+            this.noduleInstance.removeListener('sense', this.handle);
+            this.noduleInstance.stop();
+        }
+        this.logger('destroy');
+    }
+}
+exports.RuntimeStatsService = RuntimeStatsService;
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/@pm2/io/build/main/services/transport.d.ts

@@ -0,0 +1,22 @@
+import { Action } from './actions';
+import { InternalMetric } from './metrics';
+import { EventEmitter2 } from 'eventemitter2';
+export declare class TransportConfig {
+    publicKey: string;
+    secretKey: string;
+    appName: string;
+    serverName?: string;
+    sendLogs?: Boolean;
+    logFilter?: string | RegExp;
+    disableLogs?: Boolean;
+    proxy?: string;
+}
+export interface Transport extends EventEmitter2 {
+    init: (config: TransportConfig) => Transport;
+    destroy: () => void;
+    send: (channel: string, payload: Object) => void;
+    addAction: (action: Action) => void;
+    setMetrics: (metrics: InternalMetric[]) => void;
+    setOptions: (options: any) => void;
+}
+export declare function createTransport(name: string, config: TransportConfig): Transport;

package/node_modules/@pm2/io/build/main/services/transport.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const IPCTransport_1 = require("../transports/IPCTransport");
+class TransportConfig {
+}
+exports.TransportConfig = TransportConfig;
+function createTransport(name, config) {
+    const transport = new IPCTransport_1.IPCTransport();
+    transport.init(config);
+    return transport;
+}
+exports.createTransport = createTransport;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNwb3J0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3NlcnZpY2VzL3RyYW5zcG9ydC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUdBLDZEQUF5RDtBQUl6RCxNQUFhLGVBQWU7Q0EwQzNCO0FBMUNELDBDQTBDQztBQWdDRCxTQUFnQixlQUFlLENBQUUsSUFBWSxFQUFFLE1BQXVCO0lBQ3BFLE1BQU0sU0FBUyxHQUFHLElBQUksMkJBQVksRUFBRSxDQUFBO0lBQ3BDLFNBQVMsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUE7SUFDdEIsT0FBTyxTQUFTLENBQUE7QUFlbEIsQ0FBQztBQWxCRCwwQ0FrQkMifQ==

package/node_modules/@pm2/io/build/main/transports/IPCTransport.d.ts

@@ -0,0 +1,17 @@
+import { Transport, TransportConfig } from '../services/transport';
+import { Action } from '../services/actions';
+import { InternalMetric } from '../services/metrics';
+import { EventEmitter2 } from 'eventemitter2';
+export declare class IPCTransport extends EventEmitter2 implements Transport {
+    private initiated;
+    private logger;
+    private onMessage;
+    private autoExitHandle;
+    init(config?: TransportConfig): Transport;
+    private autoExitHook;
+    setMetrics(metrics: InternalMetric[]): void;
+    addAction(action: Action): void;
+    setOptions(options: any): -1 | undefined;
+    send(channel: any, payload: any): -1 | undefined;
+    destroy(): void;
+}