@lopatnov/express-reverse-proxy 1.0.1 → 1.2.0

package/node_modules/@pm2/io/build/main/featureManager.d.ts

@@ -0,0 +1,14 @@
+import { IOConfig } from './pmx';
+export declare function getObjectAtPath(context: Object, path: string): any;
+export declare class FeatureManager {
+    private logger;
+    init(options: IOConfig): void;
+    get(name: string): Feature;
+    destroy(): void;
+}
+export declare class FeatureConfig {
+}
+export interface Feature {
+    init(config?: any): void;
+    destroy(): void;
+}

package/node_modules/@pm2/io/build/main/featureManager.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const notify_1 = require("./features/notify");
+const profiling_1 = require("./features/profiling");
+const events_1 = require("./features/events");
+const metrics_1 = require("./features/metrics");
+const tracing_1 = require("./features/tracing");
+const dependencies_1 = require("./features/dependencies");
+const Debug = require("debug");
+function getObjectAtPath(context, path) {
+    if (path.indexOf('.') === -1 && path.indexOf('[') === -1) {
+        return context[path];
+    }
+    let crumbs = path.split(/\.|\[|\]/g);
+    let i = -1;
+    let len = crumbs.length;
+    let result;
+    while (++i < len) {
+        if (i === 0)
+            result = context;
+        if (!crumbs[i])
+            continue;
+        if (result === undefined)
+            break;
+        result = result[crumbs[i]];
+    }
+    return result;
+}
+exports.getObjectAtPath = getObjectAtPath;
+class AvailableFeature {
+}
+const availablesFeatures = [
+    {
+        name: 'notify',
+        optionsPath: '.',
+        module: notify_1.NotifyFeature
+    },
+    {
+        name: 'profiler',
+        optionsPath: 'profiling',
+        module: profiling_1.ProfilingFeature
+    },
+    {
+        name: 'events',
+        module: events_1.EventsFeature
+    },
+    {
+        name: 'metrics',
+        optionsPath: 'metrics',
+        module: metrics_1.MetricsFeature
+    },
+    {
+        name: 'tracing',
+        optionsPath: '.',
+        module: tracing_1.TracingFeature
+    },
+    {
+        name: 'dependencies',
+        module: dependencies_1.DependenciesFeature
+    }
+];
+class FeatureManager {
+    constructor() {
+        this.logger = Debug('axm:features');
+    }
+    init(options) {
+        for (let availableFeature of availablesFeatures) {
+            this.logger(`Creating feature ${availableFeature.name}`);
+            const feature = new availableFeature.module();
+            let config = undefined;
+            if (typeof availableFeature.optionsPath !== 'string') {
+                config = {};
+            }
+            else if (availableFeature.optionsPath === '.') {
+                config = options;
+            }
+            else {
+                config = getObjectAtPath(options, availableFeature.optionsPath);
+            }
+            this.logger(`Init feature ${availableFeature.name}`);
+            feature.init(config);
+            availableFeature.instance = feature;
+        }
+    }
+    get(name) {
+        const feature = availablesFeatures.find(feature => feature.name === name);
+        if (feature === undefined || feature.instance === undefined) {
+            throw new Error(`Tried to call feature ${name} which doesn't exist or wasn't initiated`);
+        }
+        return feature.instance;
+    }
+    destroy() {
+        for (let availableFeature of availablesFeatures) {
+            if (availableFeature.instance === undefined)
+                continue;
+            this.logger(`Destroy feature ${availableFeature.name}`);
+            availableFeature.instance.destroy();
+        }
+    }
+}
+exports.FeatureManager = FeatureManager;
+class FeatureConfig {
+}
+exports.FeatureConfig = FeatureConfig;
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/@pm2/io/build/main/features/dependencies.d.ts

@@ -0,0 +1,7 @@
+import { Feature } from '../featureManager';
+export declare class DependenciesFeature implements Feature {
+    private transport;
+    private logger;
+    init(): void;
+    destroy(): void;
+}

package/node_modules/@pm2/io/build/main/features/dependencies.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const serviceManager_1 = require("../serviceManager");
+const Debug = require("debug");
+const configuration_1 = require("../configuration");
+const fs_1 = require("fs");
+class DependenciesFeature {
+    constructor() {
+        this.logger = Debug('axm:features:dependencies');
+    }
+    init() {
+        this.transport = serviceManager_1.ServiceManager.get('transport');
+        this.logger('init');
+        const pkgPath = configuration_1.default.findPackageJson();
+        if (typeof pkgPath !== 'string')
+            return this.logger('failed to found pkg.json path');
+        this.logger(`found pkg.json in ${pkgPath}`);
+        fs_1.readFile(pkgPath, (err, data) => {
+            if (err)
+                return this.logger(`failed to read pkg.json`, err);
+            try {
+                const pkg = JSON.parse(data.toString());
+                if (typeof pkg.dependencies !== 'object') {
+                    return this.logger(`failed to find deps in pkg.json`);
+                }
+                const dependencies = Object.keys(pkg.dependencies)
+                    .reduce((list, name) => {
+                    list[name] = { version: pkg.dependencies[name] };
+                    return list;
+                }, {});
+                this.logger(`collected ${Object.keys(dependencies).length} dependencies`);
+                this.transport.send('application:dependencies', dependencies);
+                this.logger('sent dependencies list');
+            }
+            catch (err) {
+                return this.logger(`failed to parse pkg.json`, err);
+            }
+        });
+    }
+    destroy() {
+        this.logger('destroy');
+    }
+}
+exports.DependenciesFeature = DependenciesFeature;
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/@pm2/io/build/main/features/entrypoint.d.ts

@@ -0,0 +1,11 @@
+import { IOConfig } from '../pmx';
+export declare class Entrypoint {
+    private io;
+    constructor();
+    events(): void;
+    sensors(): void;
+    actuators(): void;
+    onStart(cb: Function): void;
+    onStop(err: Error, cb: Function, code: number, signal: string): any;
+    conf(): IOConfig | undefined;
+}

package/node_modules/@pm2/io/build/main/features/entrypoint.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const IO_KEY = Symbol.for('@pm2/io');
+class Entrypoint {
+    constructor() {
+        try {
+            this.io = global[IO_KEY].init(this.conf());
+            this.onStart(err => {
+                if (err) {
+                    console.error(err);
+                    process.exit(1);
+                }
+                this.sensors();
+                this.events();
+                this.actuators();
+                this.io.onExit((code, signal) => {
+                    this.onStop(err, () => {
+                        this.io.destroy();
+                    }, code, signal);
+                });
+                if (process && process.send)
+                    process.send('ready');
+            });
+        }
+        catch (e) {
+            if (this.io) {
+                this.io.destroy();
+            }
+            throw (e);
+        }
+    }
+    events() {
+        return;
+    }
+    sensors() {
+        return;
+    }
+    actuators() {
+        return;
+    }
+    onStart(cb) {
+        throw new Error('Entrypoint onStart() not specified');
+    }
+    onStop(err, cb, code, signal) {
+        return cb();
+    }
+    conf() {
+        return undefined;
+    }
+}
+exports.Entrypoint = Entrypoint;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50cnlwb2ludC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9mZWF0dXJlcy9lbnRyeXBvaW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBRUEsTUFBTSxNQUFNLEdBQUcsTUFBTSxDQUFDLEdBQUcsQ0FBQyxTQUFTLENBQUMsQ0FBQTtBQUVwQyxNQUFhLFVBQVU7SUFHckI7UUFDRSxJQUFJO1lBQ0YsSUFBSSxDQUFDLEVBQUUsR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFBO1lBRTFDLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLEVBQUU7Z0JBQ2pCLElBQUksR0FBRyxFQUFFO29CQUNQLE9BQU8sQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUE7b0JBQ2xCLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUE7aUJBQ2hCO2dCQUVELElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQTtnQkFDZCxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUE7Z0JBQ2IsSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFBO2dCQUVoQixJQUFJLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxDQUFDLElBQUksRUFBRSxNQUFNLEVBQUUsRUFBRTtvQkFDOUIsSUFBSSxDQUFDLE1BQU0sQ0FBQyxHQUFHLEVBQUUsR0FBRyxFQUFFO3dCQUNwQixJQUFJLENBQUMsRUFBRSxDQUFDLE9BQU8sRUFBRSxDQUFBO29CQUNuQixDQUFDLEVBQUUsSUFBSSxFQUFFLE1BQU0sQ0FBQyxDQUFBO2dCQUNsQixDQUFDLENBQUMsQ0FBQTtnQkFFRixJQUFJLE9BQU8sSUFBSSxPQUFPLENBQUMsSUFBSTtvQkFBRSxPQUFPLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFBO1lBQ3BELENBQUMsQ0FBQyxDQUFBO1NBQ0g7UUFBQyxPQUFPLENBQUMsRUFBRTtZQUVWLElBQUksSUFBSSxDQUFDLEVBQUUsRUFBRTtnQkFDWCxJQUFJLENBQUMsRUFBRSxDQUFDLE9BQU8sRUFBRSxDQUFBO2FBQ2xCO1lBRUQsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFBO1NBQ1Y7SUFDSCxDQUFDO0lBRUQsTUFBTTtRQUNKLE9BQU07SUFDUixDQUFDO0lBRUQsT0FBTztRQUNMLE9BQU07SUFDUixDQUFDO0lBRUQsU0FBUztRQUNQLE9BQU07SUFDUixDQUFDO0lBRUQsT0FBTyxDQUFFLEVBQVk7UUFDbkIsTUFBTSxJQUFJLEtBQUssQ0FBQyxvQ0FBb0MsQ0FBQyxDQUFBO0lBQ3ZELENBQUM7SUFFRCxNQUFNLENBQUUsR0FBVSxFQUFFLEVBQVksRUFBRSxJQUFZLEVBQUUsTUFBYztRQUM1RCxPQUFPLEVBQUUsRUFBRSxDQUFBO0lBQ2IsQ0FBQztJQUVELElBQUk7UUFDRixPQUFPLFNBQVMsQ0FBQTtJQUNsQixDQUFDO0NBQ0Y7QUExREQsZ0NBMERDIn0=

package/node_modules/@pm2/io/build/main/features/events.d.ts

@@ -0,0 +1,8 @@
+import { Feature } from '../featureManager';
+export declare class EventsFeature implements Feature {
+    private transport;
+    private logger;
+    init(): void;
+    emit(name?: string, data?: any): any;
+    destroy(): void;
+}

package/node_modules/@pm2/io/build/main/features/events.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const serviceManager_1 = require("../serviceManager");
+const Debug = require("debug");
+class EventsFeature {
+    constructor() {
+        this.logger = Debug('axm:features:events');
+    }
+    init() {
+        this.transport = serviceManager_1.ServiceManager.get('transport');
+        this.logger('init');
+    }
+    emit(name, data) {
+        if (typeof name !== 'string') {
+            console.error('event name must be a string');
+            return console.trace();
+        }
+        if (typeof data !== 'object') {
+            console.error('event data must be an object');
+            return console.trace();
+        }
+        if (data instanceof Array) {
+            console.error(`event data cannot be an array`);
+            return console.trace();
+        }
+        let inflightObj = {};
+        try {
+            inflightObj = JSON.parse(JSON.stringify(data));
+        }
+        catch (err) {
+            return console.log('Failed to serialize the event data', err.message);
+        }
+        inflightObj.__name = name;
+        if (this.transport === undefined) {
+            return this.logger('Failed to send event as transporter isnt available');
+        }
+        this.transport.send('human:event', inflightObj);
+    }
+    destroy() {
+        this.logger('destroy');
+    }
+}
+exports.EventsFeature = EventsFeature;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2ZlYXR1cmVzL2V2ZW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLHNEQUFrRDtBQUdsRCwrQkFBOEI7QUFFOUIsTUFBYSxhQUFhO0lBQTFCO1FBR1UsV0FBTSxHQUFhLEtBQUssQ0FBQyxxQkFBcUIsQ0FBQyxDQUFBO0lBc0N6RCxDQUFDO0lBcENDLElBQUk7UUFDRixJQUFJLENBQUMsU0FBUyxHQUFHLCtCQUFjLENBQUMsR0FBRyxDQUFDLFdBQVcsQ0FBQyxDQUFBO1FBQ2hELElBQUksQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUE7SUFDckIsQ0FBQztJQUVELElBQUksQ0FBRSxJQUFhLEVBQUUsSUFBVTtRQUM3QixJQUFJLE9BQU8sSUFBSSxLQUFLLFFBQVEsRUFBRTtZQUM1QixPQUFPLENBQUMsS0FBSyxDQUFDLDZCQUE2QixDQUFDLENBQUE7WUFDNUMsT0FBTyxPQUFPLENBQUMsS0FBSyxFQUFFLENBQUE7U0FDdkI7UUFDRCxJQUFJLE9BQU8sSUFBSSxLQUFLLFFBQVEsRUFBRTtZQUM1QixPQUFPLENBQUMsS0FBSyxDQUFDLDhCQUE4QixDQUFDLENBQUE7WUFDN0MsT0FBTyxPQUFPLENBQUMsS0FBSyxFQUFFLENBQUE7U0FDdkI7UUFDRCxJQUFJLElBQUksWUFBWSxLQUFLLEVBQUU7WUFDekIsT0FBTyxDQUFDLEtBQUssQ0FBQywrQkFBK0IsQ0FBQyxDQUFBO1lBQzlDLE9BQU8sT0FBTyxDQUFDLEtBQUssRUFBRSxDQUFBO1NBQ3ZCO1FBRUQsSUFBSSxXQUFXLEdBQWlCLEVBQUUsQ0FBQTtRQUNsQyxJQUFJO1lBQ0YsV0FBVyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFBO1NBQy9DO1FBQUMsT0FBTyxHQUFHLEVBQUU7WUFDWixPQUFPLE9BQU8sQ0FBQyxHQUFHLENBQUMsb0NBQW9DLEVBQUUsR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFBO1NBQ3RFO1FBRUQsV0FBVyxDQUFDLE1BQU0sR0FBRyxJQUFJLENBQUE7UUFDekIsSUFBSSxJQUFJLENBQUMsU0FBUyxLQUFLLFNBQVMsRUFBRTtZQUNoQyxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsb0RBQW9ELENBQUMsQ0FBQTtTQUN6RTtRQUNELElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLGFBQWEsRUFBRSxXQUFXLENBQUMsQ0FBQTtJQUNqRCxDQUFDO0lBRUQsT0FBTztRQUNMLElBQUksQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUFDLENBQUE7SUFDeEIsQ0FBQztDQUNGO0FBekNELHNDQXlDQyJ9

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

@@ -0,0 +1,24 @@
+import { Feature } from '../featureManager';
+import { EventLoopMetricOption } from '../metrics/eventLoopMetrics';
+import { NetworkTrafficConfig } from '../metrics/network';
+import { HttpMetricsConfig } from '../metrics/httpMetrics';
+import { V8MetricsConfig } from '../metrics/v8';
+import { RuntimeMetricsOptions } from '../metrics/runtime';
+export declare const defaultMetricConf: MetricConfig;
+export declare class MetricConfig {
+    v8?: V8MetricsConfig | boolean;
+    runtime?: RuntimeMetricsOptions | boolean;
+    http?: HttpMetricsConfig | boolean;
+    network?: NetworkTrafficConfig | boolean;
+    eventLoop?: EventLoopMetricOption | boolean;
+}
+export interface MetricInterface {
+    init(config?: Object | boolean): void;
+    destroy(): void;
+}
+export declare class MetricsFeature implements Feature {
+    private logger;
+    init(options?: Object): void;
+    get(name: string): MetricInterface | undefined;
+    destroy(): void;
+}

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

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const debug_1 = require("debug");
+const featureManager_1 = require("../featureManager");
+const eventLoopMetrics_1 = require("../metrics/eventLoopMetrics");
+const network_1 = require("../metrics/network");
+const httpMetrics_1 = require("../metrics/httpMetrics");
+const v8_1 = require("../metrics/v8");
+const runtime_1 = require("../metrics/runtime");
+exports.defaultMetricConf = {
+    eventLoop: true,
+    network: false,
+    http: true,
+    runtime: true,
+    v8: true
+};
+class MetricConfig {
+}
+exports.MetricConfig = MetricConfig;
+class AvailableMetric {
+}
+const availableMetrics = [
+    {
+        name: 'eventloop',
+        module: eventLoopMetrics_1.default,
+        optionsPath: 'eventLoop'
+    },
+    {
+        name: 'http',
+        module: httpMetrics_1.default,
+        optionsPath: 'http'
+    },
+    {
+        name: 'network',
+        module: network_1.default,
+        optionsPath: 'network'
+    },
+    {
+        name: 'v8',
+        module: v8_1.default,
+        optionsPath: 'v8'
+    },
+    {
+        name: 'runtime',
+        module: runtime_1.default,
+        optionsPath: 'runtime'
+    }
+];
+class MetricsFeature {
+    constructor() {
+        this.logger = debug_1.default('axm:features:metrics');
+    }
+    init(options) {
+        if (typeof options !== 'object')
+            options = {};
+        this.logger('init');
+        for (let availableMetric of availableMetrics) {
+            const metric = new availableMetric.module();
+            let config = undefined;
+            if (typeof availableMetric.optionsPath !== 'string') {
+                config = {};
+            }
+            else if (availableMetric.optionsPath === '.') {
+                config = options;
+            }
+            else {
+                config = featureManager_1.getObjectAtPath(options, availableMetric.optionsPath);
+            }
+            metric.init(config);
+            availableMetric.instance = metric;
+        }
+    }
+    get(name) {
+        const metric = availableMetrics.find(metric => metric.name === name);
+        if (metric === undefined)
+            return undefined;
+        return metric.instance;
+    }
+    destroy() {
+        this.logger('destroy');
+        for (let availableMetric of availableMetrics) {
+            if (availableMetric.instance === undefined)
+                continue;
+            availableMetric.instance.destroy();
+        }
+    }
+}
+exports.MetricsFeature = MetricsFeature;
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/@pm2/io/build/main/features/notify.d.ts

@@ -0,0 +1,23 @@
+import { Feature } from '../featureManager';
+export declare class NotifyOptions {
+    catchExceptions: boolean;
+}
+export declare class ErrorContext {
+    http?: Object;
+    custom?: Object;
+}
+export declare class NotifyFeature implements Feature {
+    private logger;
+    private transport;
+    private cache;
+    private stackParser;
+    init(options?: NotifyOptions): any;
+    destroy(): void;
+    getSafeError(err: any): Error;
+    notifyError(err: Error | string | {}, context?: ErrorContext): any;
+    private onUncaughtException;
+    private onUnhandledRejection;
+    private catchAll;
+    expressErrorHandler(): (err: any, req: any, res: any, next: any) => any;
+    koaErrorHandler(): (ctx: any, next: any) => Promise<void>;
+}