@lopatnov/express-reverse-proxy 1.1.0 → 1.3.0

package/node_modules/@pm2/io/build/main/census/plugins/http.js

@@ -0,0 +1,325 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@opencensus/core");
+const httpModule = require("http");
+const semver = require("semver");
+const shimmer = require("shimmer");
+const url = require("url");
+const uuid = require("uuid");
+const express_1 = require("./express");
+class HttpPlugin extends core_1.BasePlugin {
+    constructor(moduleName) {
+        super(moduleName);
+    }
+    applyPatch() {
+        this.logger.debug('applying patch to %s@%s', this.moduleName, this.version);
+        shimmer.wrap(this.moduleExports, 'request', this.getPatchOutgoingRequestFunction());
+        if (semver.satisfies(this.version, '>=8.0.0')) {
+            shimmer.wrap(this.moduleExports, 'get', () => {
+                return function getTrace(options, callback) {
+                    const req = httpModule.request(options, callback);
+                    req.end();
+                    return req;
+                };
+            });
+        }
+        if (this.moduleExports && this.moduleExports.Server &&
+            this.moduleExports.Server.prototype) {
+            shimmer.wrap(this.moduleExports.Server.prototype, 'emit', this.getPatchIncomingRequestFunction());
+        }
+        else {
+            this.logger.error('Could not apply patch to %s.emit. Interface is not as expected.', this.moduleName);
+        }
+        return this.moduleExports;
+    }
+    applyUnpatch() {
+        shimmer.unwrap(this.moduleExports, 'request');
+        if (semver.satisfies(this.version, '>=8.0.0')) {
+            shimmer.unwrap(this.moduleExports, 'get');
+        }
+        if (this.moduleExports && this.moduleExports.Server &&
+            this.moduleExports.Server.prototype) {
+            shimmer.unwrap(this.moduleExports.Server.prototype, 'emit');
+        }
+    }
+    isIgnored(url, request, list) {
+        if (!list) {
+            return false;
+        }
+        for (const pattern of list) {
+            if (this.isSatisfyPattern(url, request, pattern)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    isSatisfyPattern(url, request, pattern) {
+        if (typeof pattern === 'string') {
+            return pattern === url;
+        }
+        else if (pattern instanceof RegExp) {
+            return pattern.test(url);
+        }
+        else if (typeof pattern === 'function') {
+            return pattern(url, request);
+        }
+        else {
+            throw new TypeError('Pattern is in unsupported datatype');
+        }
+    }
+    getPatchIncomingRequestFunction() {
+        return (original) => {
+            const plugin = this;
+            return function incomingRequest(event, ...args) {
+                if (event !== 'request') {
+                    return original.apply(this, arguments);
+                }
+                const request = args[0];
+                const response = args[1];
+                const path = url.parse(request.url).pathname;
+                plugin.logger.debug('%s plugin incomingRequest', plugin.moduleName);
+                if (plugin.isIgnored(path, request, plugin.options.ignoreIncomingPaths)) {
+                    return original.apply(this, arguments);
+                }
+                const propagation = plugin.tracer.propagation;
+                const headers = request.headers;
+                const getter = {
+                    getHeader(name) {
+                        return headers[name];
+                    }
+                };
+                const context = propagation ? propagation.extract(getter) : null;
+                const traceOptions = {
+                    name: path,
+                    kind: core_1.SpanKind.SERVER,
+                    spanContext: context !== null ? context : undefined
+                };
+                return plugin.createSpan(traceOptions, rootSpan => {
+                    if (!rootSpan)
+                        return original.apply(this, arguments);
+                    plugin.tracer.wrapEmitter(request);
+                    plugin.tracer.wrapEmitter(response);
+                    const originalEnd = response.end;
+                    response.end = function () {
+                        response.end = originalEnd;
+                        const returned = response.end.apply(this, arguments);
+                        const requestUrl = url.parse(request.url || 'localhost');
+                        const host = headers.host || 'localhost';
+                        const userAgent = (headers['user-agent'] || headers['User-Agent']);
+                        rootSpan.addAttribute(HttpPlugin.ATTRIBUTE_HTTP_HOST, host.replace(/^(.*)(\:[0-9]{1,5})/, '$1'));
+                        rootSpan.addAttribute(HttpPlugin.ATTRIBUTE_HTTP_METHOD, request.method || 'GET');
+                        rootSpan.addAttribute(HttpPlugin.ATTRIBUTE_HTTP_PATH, `${requestUrl.pathname}`);
+                        let route = `${requestUrl.path}`;
+                        const middlewareStack = request[express_1.kMiddlewareStack];
+                        if (middlewareStack) {
+                            route = middlewareStack
+                                .filter(path => path !== '/')
+                                .map(path => {
+                                return path[0] === '/' ? path : '/' + path;
+                            }).join('');
+                        }
+                        rootSpan.addAttribute(HttpPlugin.ATTRIBUTE_HTTP_ROUTE, route);
+                        rootSpan.addAttribute(HttpPlugin.ATTRIBUTE_HTTP_USER_AGENT, userAgent);
+                        rootSpan.addAttribute(HttpPlugin.ATTRIBUTE_HTTP_STATUS_CODE, response.statusCode.toString());
+                        rootSpan.setStatus(HttpPlugin.convertTraceStatus(response.statusCode));
+                        rootSpan.addMessageEvent(core_1.MessageEventType.RECEIVED, uuid.v4().split('-').join(''));
+                        rootSpan.end();
+                        return returned;
+                    };
+                    return original.apply(this, arguments);
+                });
+            };
+        };
+    }
+    getPatchOutgoingRequestFunction() {
+        return (original) => {
+            const plugin = this;
+            const kind = plugin.moduleName === 'https' ? 'HTTPS' : 'HTTP';
+            return function outgoingRequest(options, callback) {
+                if (!options) {
+                    return original.apply(this, arguments);
+                }
+                let pathname = '';
+                let method = 'GET';
+                let origin = '';
+                if (typeof (options) === 'string') {
+                    const parsedUrl = url.parse(options);
+                    options = parsedUrl;
+                    pathname = parsedUrl.pathname || '/';
+                    origin = `${parsedUrl.protocol || 'http:'}//${parsedUrl.host}`;
+                }
+                else {
+                    if (options.headers &&
+                        options.headers['x-opencensus-outgoing-request']) {
+                        plugin.logger.debug('header with "x-opencensus-outgoing-request" - do not trace');
+                        return original.apply(this, arguments);
+                    }
+                    try {
+                        pathname = options.pathname || '';
+                        if (pathname.length === 0 && typeof options.path === 'string') {
+                            pathname = url.parse(options.path).pathname || '';
+                        }
+                        method = options.method || 'GET';
+                        origin = `${options.protocol || 'http:'}//${options.host}`;
+                    }
+                    catch (e) {
+                        return original.apply(this, arguments);
+                    }
+                }
+                const request = original.apply(this, arguments);
+                if (plugin.isIgnored(origin + pathname, request, plugin.options.ignoreOutgoingUrls)) {
+                    return request;
+                }
+                plugin.tracer.wrapEmitter(request);
+                plugin.logger.debug('%s plugin outgoingRequest', plugin.moduleName);
+                const traceOptions = {
+                    name: `${kind.toLowerCase()}-${(method || 'GET').toLowerCase()}`,
+                    kind: core_1.SpanKind.CLIENT
+                };
+                if (!plugin.tracer.currentRootSpan) {
+                    plugin.logger.debug('outgoingRequest starting a root span');
+                    return plugin.tracer.startRootSpan(traceOptions, plugin.getMakeRequestTraceFunction(request, options, plugin));
+                }
+                else {
+                    plugin.logger.debug('outgoingRequest starting a child span');
+                    const span = plugin.tracer.startChildSpan(traceOptions.name, traceOptions.kind);
+                    return (plugin.getMakeRequestTraceFunction(request, options, plugin))(span);
+                }
+            };
+        };
+    }
+    getMakeRequestTraceFunction(request, options, plugin) {
+        return (span) => {
+            plugin.logger.debug('makeRequestTrace');
+            if (!span) {
+                plugin.logger.debug('makeRequestTrace span is null');
+                return request;
+            }
+            const setter = {
+                setHeader(name, value) {
+                    if (plugin.hasExpectHeader(options) && options.headers) {
+                        if (options.__cloned !== true) {
+                            options = Object.assign({}, options);
+                            options.headers = Object.assign({}, options.headers);
+                            options.__cloned = true;
+                        }
+                        options.headers[name] = value;
+                    }
+                    else {
+                        request.setHeader(name, value);
+                    }
+                }
+            };
+            const propagation = plugin.tracer.propagation;
+            if (propagation) {
+                propagation.inject(setter, span.spanContext);
+            }
+            request.on('response', (response) => {
+                plugin.tracer.wrapEmitter(response);
+                plugin.logger.debug('outgoingRequest on response()');
+                response.on('end', () => {
+                    plugin.logger.debug('outgoingRequest on end()');
+                    const method = response.method ? response.method : 'GET';
+                    const headers = options.headers;
+                    const userAgent = headers ? (headers['user-agent'] || headers['User-Agent']) : null;
+                    if (options.host || options.hostname) {
+                        const value = options.host || options.hostname;
+                        span.addAttribute(HttpPlugin.ATTRIBUTE_HTTP_HOST, `${value}`);
+                    }
+                    span.addAttribute(HttpPlugin.ATTRIBUTE_HTTP_METHOD, method);
+                    span.addAttribute(HttpPlugin.ATTRIBUTE_HTTP_PATH, `${options.path}`);
+                    span.addAttribute(HttpPlugin.ATTRIBUTE_HTTP_ROUTE, `${options.path}`);
+                    if (userAgent) {
+                        span.addAttribute(HttpPlugin.ATTRIBUTE_HTTP_USER_AGENT, userAgent.toString());
+                    }
+                    span.addAttribute(HttpPlugin.ATTRIBUTE_HTTP_STATUS_CODE, `${response.statusCode}`);
+                    span.setStatus(HttpPlugin.convertTraceStatus(response.statusCode || 0));
+                    span.addMessageEvent(core_1.MessageEventType.SENT, uuid.v4().split('-').join(''));
+                    span.end();
+                });
+                response.on('error', error => {
+                    span.addAttribute(HttpPlugin.ATTRIBUTE_HTTP_ERROR_NAME, error.name);
+                    span.addAttribute(HttpPlugin.ATTRIBUTE_HTTP_ERROR_MESSAGE, error.message);
+                    span.setStatus(core_1.CanonicalCode.UNKNOWN);
+                    span.end();
+                });
+            });
+            request.on('error', error => {
+                span.addAttribute(HttpPlugin.ATTRIBUTE_HTTP_ERROR_NAME, error.name);
+                span.addAttribute(HttpPlugin.ATTRIBUTE_HTTP_ERROR_MESSAGE, error.message);
+                span.setStatus(core_1.CanonicalCode.UNKNOWN);
+                span.end();
+            });
+            plugin.logger.debug('makeRequestTrace return request');
+            return request;
+        };
+    }
+    createSpan(options, fn) {
+        const forceChildspan = this.options.createSpanWithNet === true;
+        if (forceChildspan) {
+            const span = this.tracer.startChildSpan(options.name, options.kind);
+            return fn(span);
+        }
+        else {
+            return this.tracer.startRootSpan(options, fn);
+        }
+    }
+    static convertTraceStatus(statusCode) {
+        if (statusCode < 200 || statusCode > 504) {
+            return TraceStatusCodes.UNKNOWN;
+        }
+        else if (statusCode >= 200 && statusCode < 400) {
+            return TraceStatusCodes.OK;
+        }
+        else {
+            switch (statusCode) {
+                case (400):
+                    return TraceStatusCodes.INVALID_ARGUMENT;
+                case (504):
+                    return TraceStatusCodes.DEADLINE_EXCEEDED;
+                case (404):
+                    return TraceStatusCodes.NOT_FOUND;
+                case (403):
+                    return TraceStatusCodes.PERMISSION_DENIED;
+                case (401):
+                    return TraceStatusCodes.UNAUTHENTICATED;
+                case (429):
+                    return TraceStatusCodes.RESOURCE_EXHAUSTED;
+                case (501):
+                    return TraceStatusCodes.UNIMPLEMENTED;
+                case (503):
+                    return TraceStatusCodes.UNAVAILABLE;
+                default:
+                    return TraceStatusCodes.UNKNOWN;
+            }
+        }
+    }
+    hasExpectHeader(options) {
+        return !!(options.headers &&
+            options.headers.Expect);
+    }
+}
+HttpPlugin.ATTRIBUTE_HTTP_HOST = 'http.host';
+HttpPlugin.ATTRIBUTE_HTTP_METHOD = 'http.method';
+HttpPlugin.ATTRIBUTE_HTTP_PATH = 'http.path';
+HttpPlugin.ATTRIBUTE_HTTP_ROUTE = 'http.route';
+HttpPlugin.ATTRIBUTE_HTTP_USER_AGENT = 'http.user_agent';
+HttpPlugin.ATTRIBUTE_HTTP_STATUS_CODE = 'http.status_code';
+HttpPlugin.ATTRIBUTE_HTTP_ERROR_NAME = 'http.error_name';
+HttpPlugin.ATTRIBUTE_HTTP_ERROR_MESSAGE = 'http.error_message';
+exports.HttpPlugin = HttpPlugin;
+var TraceStatusCodes;
+(function (TraceStatusCodes) {
+    TraceStatusCodes[TraceStatusCodes["UNKNOWN"] = 2] = "UNKNOWN";
+    TraceStatusCodes[TraceStatusCodes["OK"] = 0] = "OK";
+    TraceStatusCodes[TraceStatusCodes["INVALID_ARGUMENT"] = 3] = "INVALID_ARGUMENT";
+    TraceStatusCodes[TraceStatusCodes["DEADLINE_EXCEEDED"] = 4] = "DEADLINE_EXCEEDED";
+    TraceStatusCodes[TraceStatusCodes["NOT_FOUND"] = 5] = "NOT_FOUND";
+    TraceStatusCodes[TraceStatusCodes["PERMISSION_DENIED"] = 7] = "PERMISSION_DENIED";
+    TraceStatusCodes[TraceStatusCodes["UNAUTHENTICATED"] = 16] = "UNAUTHENTICATED";
+    TraceStatusCodes[TraceStatusCodes["RESOURCE_EXHAUSTED"] = 8] = "RESOURCE_EXHAUSTED";
+    TraceStatusCodes[TraceStatusCodes["UNIMPLEMENTED"] = 12] = "UNIMPLEMENTED";
+    TraceStatusCodes[TraceStatusCodes["UNAVAILABLE"] = 14] = "UNAVAILABLE";
+})(TraceStatusCodes = exports.TraceStatusCodes || (exports.TraceStatusCodes = {}));
+exports.plugin = new HttpPlugin('http');
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http.js","sourceRoot":"","sources":["../../../../src/census/plugins/http.ts"],"names":[],"mappings":"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"}

package/node_modules/@pm2/io/build/main/census/plugins/http2.d.ts

@@ -0,0 +1,17 @@
+import { HttpPlugin } from './http';
+import * as http2 from 'http2';
+export declare type Http2Module = typeof http2;
+export declare type ConnectFunction = typeof http2.connect;
+export declare type CreateServerFunction = typeof http2.createServer;
+export declare class Http2Plugin extends HttpPlugin {
+    constructor();
+    protected applyPatch(): any;
+    protected applyUnpatch(): void;
+    private getPatchConnectFunction;
+    private getPatchRequestFunction;
+    private getMakeHttp2RequestTraceFunction;
+    private getPatchCreateServerFunction;
+    private getPatchEmitFunction;
+}
+declare const plugin: Http2Plugin;
+export { plugin };

package/node_modules/@pm2/io/build/main/census/plugins/http2.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@opencensus/core");
+const http_1 = require("./http");
+const shimmer = require("shimmer");
+const url = require("url");
+const uuid = require("uuid");
+class Http2Plugin extends http_1.HttpPlugin {
+    constructor() {
+        super('http2');
+    }
+    applyPatch() {
+        shimmer.wrap(this.moduleExports, 'createServer', this.getPatchCreateServerFunction());
+        shimmer.wrap(this.moduleExports, 'createSecureServer', this.getPatchCreateServerFunction());
+        shimmer.wrap(this.moduleExports, 'connect', this.getPatchConnectFunction());
+        return this.moduleExports;
+    }
+    applyUnpatch() {
+        shimmer.unwrap(this.moduleExports, 'createServer');
+        shimmer.unwrap(this.moduleExports, 'createSecureServer');
+        shimmer.unwrap(this.moduleExports, 'connect');
+    }
+    getPatchConnectFunction() {
+        const plugin = this;
+        return (original) => {
+            return function patchedConnect(authority) {
+                const client = original.apply(this, arguments);
+                shimmer.wrap(client, 'request', (original) => (plugin.getPatchRequestFunction())(original, authority));
+                shimmer.unwrap(plugin.moduleExports, 'connect');
+                return client;
+            };
+        };
+    }
+    getPatchRequestFunction() {
+        const plugin = this;
+        return (original, authority) => {
+            return function patchedRequest(headers) {
+                if (headers['x-opencensus-outgoing-request']) {
+                    return original.apply(this, arguments);
+                }
+                const request = original.apply(this, arguments);
+                plugin.tracer.wrapEmitter(request);
+                const traceOptions = {
+                    name: `http2-${(headers[':method'] || 'GET').toLowerCase()}`,
+                    kind: core_1.SpanKind.CLIENT
+                };
+                if (!plugin.tracer.currentRootSpan) {
+                    return plugin.tracer.startRootSpan(traceOptions, plugin.getMakeHttp2RequestTraceFunction(request, headers, authority, plugin));
+                }
+                else {
+                    const span = plugin.tracer.startChildSpan(traceOptions.name, traceOptions.kind);
+                    return (plugin.getMakeHttp2RequestTraceFunction(request, headers, authority, plugin))(span);
+                }
+            };
+        };
+    }
+    getMakeHttp2RequestTraceFunction(request, headers, authority, plugin) {
+        return (span) => {
+            if (!span)
+                return request;
+            const setter = {
+                setHeader(name, value) {
+                    headers[name] = value;
+                }
+            };
+            const propagation = plugin.tracer.propagation;
+            if (propagation) {
+                propagation.inject(setter, span.spanContext);
+            }
+            request.on('response', (responseHeaders) => {
+                const status = `${responseHeaders[':status']}`;
+                span.addAttribute(Http2Plugin.ATTRIBUTE_HTTP_STATUS_CODE, status);
+                span.setStatus(Http2Plugin.convertTraceStatus(parseInt(status, 10)));
+            });
+            request.on('end', () => {
+                const userAgent = headers['user-agent'] || headers['User-Agent'] || null;
+                span.addAttribute(Http2Plugin.ATTRIBUTE_HTTP_HOST, `${url.parse(authority).host}`);
+                span.addAttribute(Http2Plugin.ATTRIBUTE_HTTP_METHOD, `${headers[':method']}`);
+                span.addAttribute(Http2Plugin.ATTRIBUTE_HTTP_PATH, `${headers[':path']}`);
+                span.addAttribute(Http2Plugin.ATTRIBUTE_HTTP_ROUTE, `${headers[':path']}`);
+                if (userAgent) {
+                    span.addAttribute(Http2Plugin.ATTRIBUTE_HTTP_USER_AGENT, `${userAgent}`);
+                }
+                span.addMessageEvent(core_1.MessageEventType.SENT, uuid.v4().split('-').join(''));
+                span.end();
+            });
+            request.on('error', (err) => {
+                span.addAttribute(http_1.HttpPlugin.ATTRIBUTE_HTTP_ERROR_NAME, err.name);
+                span.addAttribute(http_1.HttpPlugin.ATTRIBUTE_HTTP_ERROR_MESSAGE, err.message);
+                span.setStatus(core_1.CanonicalCode.UNKNOWN, err.message);
+                span.end();
+            });
+            return request;
+        };
+    }
+    getPatchCreateServerFunction() {
+        const plugin = this;
+        return (original) => {
+            return function patchedCreateServer() {
+                const server = original.apply(this, arguments);
+                shimmer.wrap(server.constructor.prototype, 'emit', plugin.getPatchEmitFunction());
+                shimmer.unwrap(plugin.moduleExports, 'createServer');
+                shimmer.unwrap(plugin.moduleExports, 'createSecureServer');
+                return server;
+            };
+        };
+    }
+    getPatchEmitFunction() {
+        const plugin = this;
+        return (original) => {
+            return function patchedEmit(event, stream, headers) {
+                if (event !== 'stream') {
+                    return original.apply(this, arguments);
+                }
+                const propagation = plugin.tracer.propagation;
+                const getter = {
+                    getHeader(name) {
+                        return headers[name];
+                    }
+                };
+                const traceOptions = {
+                    name: headers[':path'],
+                    kind: core_1.SpanKind.SERVER,
+                    spanContext: propagation ? propagation.extract(getter) : null
+                };
+                let statusCode = 0;
+                const originalRespond = stream.respond;
+                stream.respond = function () {
+                    stream.respond = originalRespond;
+                    statusCode = arguments[0][':status'];
+                    return stream.respond.apply(this, arguments);
+                };
+                return plugin.tracer.startRootSpan(traceOptions, rootSpan => {
+                    if (!rootSpan)
+                        return original.apply(this, arguments);
+                    plugin.tracer.wrapEmitter(stream);
+                    const originalEnd = stream.end;
+                    stream.end = function () {
+                        stream.end = originalEnd;
+                        const returned = stream.end.apply(this, arguments);
+                        const userAgent = (headers['user-agent'] || headers['User-Agent'] ||
+                            null);
+                        rootSpan.addAttribute(Http2Plugin.ATTRIBUTE_HTTP_HOST, `${headers[':authority']}`);
+                        rootSpan.addAttribute(Http2Plugin.ATTRIBUTE_HTTP_METHOD, `${headers[':method']}`);
+                        rootSpan.addAttribute(Http2Plugin.ATTRIBUTE_HTTP_PATH, `${headers[':path']}`);
+                        rootSpan.addAttribute(Http2Plugin.ATTRIBUTE_HTTP_ROUTE, `${headers[':path']}`);
+                        rootSpan.addAttribute(Http2Plugin.ATTRIBUTE_HTTP_USER_AGENT, userAgent);
+                        rootSpan.addAttribute(Http2Plugin.ATTRIBUTE_HTTP_STATUS_CODE, `${statusCode}`);
+                        rootSpan.setStatus(Http2Plugin.convertTraceStatus(statusCode));
+                        rootSpan.addMessageEvent(core_1.MessageEventType.RECEIVED, uuid.v4().split('-').join(''));
+                        rootSpan.end();
+                        return returned;
+                    };
+                    return original.apply(this, arguments);
+                });
+            };
+        };
+    }
+}
+exports.Http2Plugin = Http2Plugin;
+const plugin = new Http2Plugin();
+exports.plugin = plugin;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http2.js","sourceRoot":"","sources":["../../../../src/census/plugins/http2.ts"],"names":[],"mappings":"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"}

package/node_modules/@pm2/io/build/main/census/plugins/https.d.ts

@@ -0,0 +1,9 @@
+import { HttpPlugin } from './http';
+export declare class HttpsPlugin extends HttpPlugin {
+    constructor();
+    protected applyPatch(): any;
+    private getPatchHttpsOutgoingRequest;
+    protected applyUnpatch(): void;
+}
+declare const plugin: HttpsPlugin;
+export { plugin };

package/node_modules/@pm2/io/build/main/census/plugins/https.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const http_1 = require("./http");
+const https = require("https");
+const semver = require("semver");
+const shimmer = require("shimmer");
+class HttpsPlugin extends http_1.HttpPlugin {
+    constructor() {
+        super('https');
+    }
+    applyPatch() {
+        this.logger.debug('applying patch to %s@%s', this.moduleName, this.version);
+        if (this.moduleExports && this.moduleExports.Server &&
+            this.moduleExports.Server.prototype) {
+            shimmer.wrap(this.moduleExports && this.moduleExports.Server &&
+                this.moduleExports.Server.prototype, 'emit', this.getPatchIncomingRequestFunction());
+        }
+        else {
+            this.logger.error('Could not apply patch to %s.emit. Interface is not as expected.', this.moduleName);
+        }
+        shimmer.wrap(this.moduleExports, 'request', this.getPatchHttpsOutgoingRequest());
+        if (semver.satisfies(this.version, '>=8.0.0')) {
+            shimmer.wrap(this.moduleExports, 'get', () => {
+                return function getTrace(options, callback) {
+                    const req = https.request(options, callback);
+                    req.end();
+                    return req;
+                };
+            });
+        }
+        return this.moduleExports;
+    }
+    getPatchHttpsOutgoingRequest() {
+        return (original) => {
+            const plugin = this;
+            return function httpsOutgoingRequest(options, callback) {
+                if (typeof (options) !== 'string') {
+                    options.protocol = options.protocol || 'https:';
+                    options.port = options.port || 443;
+                    options.agent = options.agent || https.globalAgent;
+                }
+                return (plugin.getPatchOutgoingRequestFunction())(original)(options, callback);
+            };
+        };
+    }
+    applyUnpatch() {
+        if (this.moduleExports && this.moduleExports.Server &&
+            this.moduleExports.Server.prototype) {
+            shimmer.unwrap(this.moduleExports && this.moduleExports.Server &&
+                this.moduleExports.Server.prototype, 'emit');
+        }
+        shimmer.unwrap(this.moduleExports, 'request');
+        if (semver.satisfies(this.version, '>=8.0.0')) {
+            shimmer.unwrap(this.moduleExports, 'get');
+        }
+    }
+}
+exports.HttpsPlugin = HttpsPlugin;
+const plugin = new HttpsPlugin();
+exports.plugin = plugin;
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/@pm2/io/build/main/census/plugins/ioredis.d.ts

@@ -0,0 +1,23 @@
+import { BasePlugin, Span } from '@opencensus/core';
+export declare type IgnoreMatcher = string | RegExp;
+export declare type IORedisPluginConfig = {
+    detailedCommands: boolean;
+};
+export declare type IORedisCommand = {
+    reject: (err: Error) => void | undefined;
+    resolve: (result: any) => void | undefined;
+    promise: Promise<any>;
+    args: Array<string | Buffer | number>;
+    callback: Function | undefined;
+    name: string;
+};
+export declare class IORedisPlugin extends BasePlugin {
+    protected options: IORedisPluginConfig;
+    constructor(moduleName: string);
+    protected applyPatch(): any;
+    applyUnpatch(): void;
+    private getPatchSendCommand;
+    patchEnd(span: Span, resultHandler: Function): Function;
+}
+declare const plugin: IORedisPlugin;
+export { plugin };