@tramvai/module-metrics 2.70.0 → 2.72.0

package/lib/server.js

@@ -11,487 +11,21 @@ var tokensMetrics = require('@tramvai/tokens-metrics');
 var measureFastifyRequests = require('@tinkoff/measure-fastify-requests');
 var promClient = require('prom-client');
 var flatten = require('@tinkoff/utils/array/flatten');
-var tokensCommon = require('@tramvai/tokens-common');
-var noop = require('@tinkoff/utils/function/noop');
-var https = require('https');
-var http = require('http');
-var url = require('@tinkoff/url');
-var monkeypatch = require('@tinkoff/monkeypatch');
-var isString = require('@tinkoff/utils/is/string');
-var papi = require('@tramvai/papi');
-var fromPairs = require('@tinkoff/utils/object/fromPairs');
-var state = require('@tramvai/state');
+var index = require('./request/index.js');
+var server = require('./instantMetrics/server.js');
+var eventLoop = require('./metrics/eventLoop.js');
+var commandLine = require('./metrics/commandLine.js');
+var createRequestWithMetrics = require('./request/createRequestWithMetrics.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var flatten__default = /*#__PURE__*/_interopDefaultLegacy(flatten);
-var noop__default = /*#__PURE__*/_interopDefaultLegacy(noop);
-var https__default = /*#__PURE__*/_interopDefaultLegacy(https);
-var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
-var monkeypatch__default = /*#__PURE__*/_interopDefaultLegacy(monkeypatch);
-var isString__default = /*#__PURE__*/_interopDefaultLegacy(isString);
-var fromPairs__default = /*#__PURE__*/_interopDefaultLegacy(fromPairs);
-
-// https://nodejs.org/api/errors.html#nodejs-error-codes - Common system errors possible for net/http/dns
-const POSSIBLE_ERRORS = [
-    'EADDRINUSE',
-    'ECONNREFUSED',
-    'ECONNRESET',
-    'ENOTFOUND',
-    'EPIPE',
-    'ETIMEDOUT',
-];
-const getUrlAndOptions = (args) => {
-    let url$1;
-    let options;
-    // У request первый аргумент либо урл либо объект опций, кейс когда первого аргумента нет не валиден
-    const isUrlStringFirst = args[0].constructor === String;
-    const isUrlObjectFirst = args[0].constructor === URL;
-    const isOptionsFirst = !isUrlStringFirst && !isUrlObjectFirst;
-    const isOptionsSecond = !isOptionsFirst && !(args[0] instanceof Function);
-    if (isUrlStringFirst) {
-        [url$1] = args;
-    }
-    if (isUrlObjectFirst) {
-        url$1 = url.format(args[0]);
-    }
-    if (isOptionsFirst) {
-        [options] = args;
-        // Тут учитываем случай если передаётся не href в options, а отдельно protocol, host, port, path
-        if (options.href) {
-            url$1 = options.href;
-        }
-        else {
-            const urlString = url.format({
-                protocol: options.protocol,
-                host: options.hostname || options.host,
-                port: options.port,
-                pathname: options.path,
-            });
-            // format где-то внутри делает encodeURIComponent и из-за этого потом не может обрезать query
-            try {
-                url$1 = decodeURIComponent(urlString);
-            }
-            catch {
-                url$1 = urlString;
-            }
-        }
-    }
-    if (isOptionsSecond) {
-        [, options] = args;
-    }
-    const parsedUrl = new URL(url$1);
-    const urlWOQuery = parsedUrl.origin + parsedUrl.pathname;
-    return [urlWOQuery, options || {}, parsedUrl];
-};
-// in seconds
-const getDuration = (current, prev) => 
-// max to avoid negative values and turn that into zero
-prev === 0 ? 0 : Math.max((current - prev) / 1000, 0);
-const createRequestWithMetrics = ({ metricsInstances: { requestsTotal, requestsErrors, requestsDuration, dnsResolveDuration, tcpConnectDuration, tlsHandshakeDuration, }, getServiceName, config, }) => {
-    const socketSet = new WeakSet();
-    return function requestWithMetrics(originalRequest, ...args) {
-        const [url, options] = getUrlAndOptions(args);
-        const serviceName = getServiceName(url);
-        const req = originalRequest.apply(this, args);
-        const timerDone = requestsDuration.startTimer();
-        const labelsValues = {
-            method: options.method || 'unknown',
-            service: serviceName || new URL(url).origin || 'unknown',
-            status: 'unknown',
-        };
-        req.on('response', (res) => {
-            labelsValues.status = res.statusCode.toString();
-            if (res.statusCode >= 400) {
-                requestsErrors.inc(labelsValues);
-            }
-            requestsTotal.inc(labelsValues);
-            timerDone(labelsValues);
-        });
-        req.on('error', (e) => {
-            if (POSSIBLE_ERRORS.includes(e === null || e === void 0 ? void 0 : e.code)) {
-                labelsValues.status = req.aborted ? 'aborted' : e.code;
-            }
-            requestsTotal.inc(labelsValues);
-            requestsErrors.inc(labelsValues);
-            timerDone(labelsValues);
-        });
-        if (config.enableConnectionResolveMetrics) {
-            req.on('socket', (socket) => {
-                // due to keep-alive tcp option sockets might be reused
-                // ignore them because they have already emitted events we are interested in
-                if (socketSet.has(socket)) {
-                    return;
-                }
-                socketSet.add(socket);
-                const timings = {
-                    start: Date.now(),
-                    lookupEnd: 0,
-                    connectEnd: 0,
-                    secureConnectEnd: 0,
-                };
-                const { service } = labelsValues;
-                socket.on('lookup', () => {
-                    timings.lookupEnd = Date.now();
-                    dnsResolveDuration.observe({ service }, getDuration(timings.lookupEnd, timings.start));
-                });
-                socket.on('connect', () => {
-                    timings.connectEnd = Date.now();
-                    tcpConnectDuration.observe({ service }, getDuration(timings.connectEnd, timings.lookupEnd));
-                });
-                socket.on('secureConnect', () => {
-                    timings.secureConnectEnd = Date.now();
-                    tlsHandshakeDuration.observe({ service }, getDuration(timings.secureConnectEnd, timings.connectEnd));
-                });
-                socket.on('close', () => {
-                    socketSet.delete(socket);
-                });
-            });
-        }
-        return req;
-    };
-};
-
-const DEFAULT_BUCKETS = [0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10, 20, 40, 60];
-
-const initRequestsMetrics = ({ metrics, getServiceName, http, https, createRequestWithMetrics, config, }) => {
-    const metricsInstances = {
-        requestsTotal: metrics.counter({
-            name: 'http_sent_requests_total',
-            help: 'Number of requests sent',
-            labelNames: ['status', 'method', 'service'],
-        }),
-        requestsErrors: metrics.counter({
-            name: 'http_sent_requests_errors',
-            help: 'Number of requests that failed',
-            labelNames: ['status', 'method', 'service'],
-        }),
-        requestsDuration: metrics.histogram({
-            name: 'http_sent_requests_duration',
-            help: 'Execution time of the sent requests',
-            labelNames: ['status', 'method', 'service'],
-            buckets: DEFAULT_BUCKETS,
-        }),
-        dnsResolveDuration: metrics.histogram({
-            name: 'dns_resolve_duration',
-            help: 'Time for dns resolve of the outhgoing requests',
-            labelNames: ['service'],
-            buckets: DEFAULT_BUCKETS,
-        }),
-        tcpConnectDuration: metrics.histogram({
-            name: 'tcp_connect_duration',
-            help: 'Duration of tcp connect of the outgoing requests',
-            labelNames: ['service'],
-            buckets: DEFAULT_BUCKETS,
-        }),
-        tlsHandshakeDuration: metrics.histogram({
-            name: 'tls_handshake_duration',
-            help: 'Duration of tls handshake of the outgoing requests',
-            labelNames: ['service'],
-            buckets: DEFAULT_BUCKETS,
-        }),
-    };
-    monkeypatch__default["default"]({
-        obj: https,
-        method: 'request',
-        handler: createRequestWithMetrics({ metricsInstances, getServiceName, config }),
-    });
-    monkeypatch__default["default"]({
-        obj: http,
-        method: 'request',
-        handler: createRequestWithMetrics({ metricsInstances, getServiceName, config }),
-    });
-};
-
-// Дерево использует подход структуры данных trie для прямого доступа к serviceName, но в отличие от
-// trie возвращает не все значения соответствующие префиксу, а значение соответствующее самому
-// длинному ключу в дереве который является подстрокой входной строки
-class PrefixTree {
-    constructor(options = {}) {
-        this.index = Object.create(null);
-        this.delimiter = options.delimiter || '';
-    }
-    // На случай если value не примитивные значения есть возможность передать функцию и там как угодно
-    // модифицировать объект
-    set(key, valueOrUpdateFn) {
-        let tree = this.index;
-        const parts = key.split(this.delimiter);
-        do {
-            const letter = parts.shift();
-            if (letter === '')
-                continue;
-            if (!tree[letter]) {
-                tree[letter] = Object.create(null);
-            }
-            tree = tree[letter];
-        } while (parts.length);
-        if (valueOrUpdateFn instanceof Function) {
-            tree.value = valueOrUpdateFn(tree.value);
-        }
-        else {
-            tree.value = valueOrUpdateFn;
-        }
-    }
-    get(key) {
-        let tree = this.index;
-        const parts = key.split(this.delimiter);
-        let prevTree;
-        do {
-            const letter = parts.shift();
-            if (letter === '')
-                continue;
-            prevTree = tree;
-            tree = tree[letter];
-        } while (parts.length && tree);
-        if (tree) {
-            return tree.value;
-        }
-        return prevTree.value;
-    }
-}
-
-const NO_PROTOCOL = 'NO PROTOCOL';
-const PROTOCOL_REGEX = /^([a-z0-9.+-]+:)/i;
-const splitProtocolAndUrl = (url) => {
-    // Регулярка используется потому что протокол обязателен и класс URL не распарсит такую строку
-    const urlMatches = url.match(PROTOCOL_REGEX);
-    const protocol = urlMatches && urlMatches[0];
-    // Под + 2 тут подразумевается два слеша после протокола например для http: обрежется http://
-    const urlWOProtocol = protocol ? url.slice(protocol.length + 2) : url;
-    return [protocol, urlWOProtocol];
-};
-class MetricsServicesRegistry {
-    constructor() {
-        this.registryPrefixTree = new PrefixTree({
-            delimiter: '/',
-        });
-    }
-    registerEnv(env) {
-        Object.keys(env).forEach((name) => {
-            // В env могут быть undefined, и number, т.к. это явно не урлы, просто пропускаем
-            if (isString__default["default"](env[name])) {
-                this.register(env[name], name);
-            }
-        });
-    }
-    register(url, serviceName) {
-        if (!url) {
-            return;
-        }
-        const [protocol, urlWOProtocol] = splitProtocolAndUrl(url);
-        // Некоторые модули не хранят инфу о протоколе, потому что tinkoff-request сам подставляет протокол.
-        // В результате при поиске префиксное дерево не отрабатывает.
-        // предусматриваем этот случай добавляя инфу о том для какого протокола храним имя сервиса.
-        this.registryPrefixTree.set(urlWOProtocol, (value) => ({
-            ...(value || {}),
-            [protocol || NO_PROTOCOL]: serviceName,
-        }));
-    }
-    getServiceName(url) {
-        if (!url) {
-            return undefined;
-        }
-        const [protocol, urlWOProtocol] = splitProtocolAndUrl(url);
-        const treeValue = this.registryPrefixTree.get(urlWOProtocol);
-        if (!treeValue) {
-            return undefined;
-        }
-        // Когда урл запросен из регистри, мы не знаем был ли он добавлен с протоколом, поэтому
-        // проверяем оба варианта
-        return treeValue[protocol] || treeValue[NO_PROTOCOL];
-    }
-}
-
-let RequestModule = class RequestModule {
-};
-RequestModule = tslib.__decorate([
-    core.Module({
-        providers: [
-            {
-                provide: core.commandLineListTokens.init,
-                multi: true,
-                useFactory: ({ metrics, envManager, metricsServicesRegistry, metricsModuleConfig, }) => {
-                    if (!metrics) {
-                        return noop__default["default"];
-                    }
-                    return () => {
-                        const env = envManager.getAll();
-                        metricsServicesRegistry.registerEnv(env);
-                        const getServiceName = metricsServicesRegistry.getServiceName.bind(metricsServicesRegistry);
-                        initRequestsMetrics({
-                            metrics,
-                            getServiceName,
-                            http: http__default["default"],
-                            https: https__default["default"],
-                            createRequestWithMetrics,
-                            config: metricsModuleConfig,
-                        });
-                    };
-                },
-                deps: {
-                    metrics: {
-                        token: tokensMetrics.METRICS_MODULE_TOKEN,
-                        optional: true,
-                    },
-                    metricsServicesRegistry: tokensMetrics.METRICS_SERVICES_REGISTRY_TOKEN,
-                    envManager: tokensCommon.ENV_MANAGER_TOKEN,
-                    metricsModuleConfig: tokensMetrics.METRICS_MODULE_CONFIG_TOKEN,
-                },
-            },
-            {
-                provide: tokensMetrics.METRICS_SERVICES_REGISTRY_TOKEN,
-                useClass: MetricsServicesRegistry,
-                scope: core.Scope.SINGLETON,
-            },
-        ],
-    })
-], RequestModule);
-
-const setInstantMetrics = state.createEvent('set instant metrics map');
-const MetricsStore = state.createReducer('instantMetrics', { instantMetricsMap: {} }).on(setInstantMetrics, (_prevState, nextState) => {
-    return nextState;
-});
-
-const sharedProviders = [
-    {
-        provide: tokensCommon.COMBINE_REDUCERS,
-        multi: true,
-        useValue: [MetricsStore],
-    },
-];
-
-let InstantMetricsModule = class InstantMetricsModule {
-};
-InstantMetricsModule = tslib.__decorate([
-    core.Module({
-        providers: [
-            ...sharedProviders,
-            {
-                provide: tokensServer.SERVER_MODULE_PAPI_PUBLIC_ROUTE,
-                multi: true,
-                useFactory({ metrics, logger, instantMetrics, }) {
-                    const log = logger('instantmetrics:papi');
-                    const instantMetricsMap = fromPairs__default["default"](instantMetrics || []);
-                    return papi.createPapiMethod({
-                        method: 'post',
-                        path: '/metrics/:metric',
-                        options: {
-                            schema: {
-                                body: {
-                                    type: 'object',
-                                    properties: {
-                                        value: {
-                                            type: 'number',
-                                            minimum: 0,
-                                        },
-                                    },
-                                    additionalProperties: false,
-                                },
-                            },
-                        },
-                        async handler({ params: { metric }, body, responseManager }) {
-                            if (!instantMetricsMap[metric]) {
-                                log.error({
-                                    event: 'client-instant-metric-mismatch',
-                                    metricName: metric,
-                                    error: new Error(`No instant metric instance found with name: ${metric}`),
-                                });
-                                responseManager.setStatus(404);
-                                responseManager.setBody({
-                                    resultCode: 'NOT_FOUND',
-                                    errorMessage: 'metric not found',
-                                });
-                                return;
-                            }
-                            instantMetricsMap[metric].inc(body === null || body === void 0 ? void 0 : body.value);
-                            return { status: 'ok' };
-                        },
-                    });
-                },
-                deps: {
-                    metrics: tokensMetrics.METRICS_MODULE_TOKEN,
-                    logger: tokensCommon.LOGGER_TOKEN,
-                    instantMetrics: {
-                        token: tokensMetrics.REGISTER_INSTANT_METRIC_TOKEN,
-                        multi: true,
-                        optional: true,
-                    },
-                },
-            },
-            {
-                provide: core.commandLineListTokens.customerStart,
-                multi: true,
-                useFactory({ instantMetrics, context, }) {
-                    return async () => {
-                        if (!instantMetrics) {
-                            return;
-                        }
-                        const instantMetricsMap = instantMetrics.reduce((acc, [metricName]) => {
-                            acc[metricName] = true;
-                            return acc;
-                        }, {});
-                        await context.dispatch(setInstantMetrics({ instantMetricsMap }));
-                    };
-                },
-                deps: {
-                    context: tokensCommon.CONTEXT_TOKEN,
-                    instantMetrics: {
-                        token: tokensMetrics.REGISTER_INSTANT_METRIC_TOKEN,
-                        multi: true,
-                        optional: true,
-                    },
-                },
-            },
-        ],
-    })
-], InstantMetricsModule);
-
-const NODEJS_EVENTLOOP_LAG = 'nodejs_eventloop_setinterval_lag_seconds';
-function startEventLoopLagMeasure(histogram) {
-    let start = process.hrtime();
-    const interval = 100;
-    setInterval(() => {
-        const delta = process.hrtime(start);
-        const nanosec = delta[0] * 1e9 + delta[1];
-        const ms = nanosec / 1e6;
-        const lag = ms - interval;
-        histogram.observe(lag / 1e3);
-        start = process.hrtime();
-    }, interval).unref();
-}
-const eventLoopMetrics = (metrics) => {
-    const histogram = metrics.histogram({
-        name: NODEJS_EVENTLOOP_LAG,
-        help: 'Lag of event loop in seconds (setInterval based).',
-        buckets: [0.02, 0.1, 0.2, 0.5, 1, 3, 5, 7.5, 10],
-    });
-    startEventLoopLagMeasure(histogram);
-};
-
-const commandLineMetrics = (metrics) => {
-    const metricsInstance = metrics.histogram({
-        name: `command_line_runner_execution_time`,
-        help: 'Command line processing duration',
-        labelNames: ['line'],
-        buckets: DEFAULT_BUCKETS,
-    });
-    return (di, type, status, timingInfo) => {
-        for (const line in timingInfo) {
-            const info = timingInfo[line];
-            if (info.end) {
-                const durationInMs = info.end - info.start;
-                const durationInSec = durationInMs / 1000;
-                metricsInstance.observe({ line }, durationInSec);
-            }
-        }
-    };
-};
 
 exports.MetricsModule = class MetricsModule {
 };
 exports.MetricsModule = tslib.__decorate([
     core.Module({
-        imports: [RequestModule, InstantMetricsModule],
+        imports: [index.RequestModule, server.InstantMetricsModule],
         providers: [
             core.provide({
                 provide: tokensMetrics.METRICS_MODULE_CONFIG_TOKEN,
@@ -582,7 +116,7 @@ exports.MetricsModule = tslib.__decorate([
                 provide: core.commandLineListTokens.listen,
                 useFactory: ({ metrics }) => {
                     return () => {
-                        eventLoopMetrics(metrics);
+                        eventLoop.eventLoopMetrics(metrics);
                     };
                 },
                 deps: {
@@ -593,7 +127,7 @@ exports.MetricsModule = tslib.__decorate([
             core.provide({
                 provide: tokensCorePrivate.COMMAND_LINE_EXECUTION_END_TOKEN,
                 useFactory: ({ metrics }) => {
-                    return commandLineMetrics(metrics);
+                    return commandLine.commandLineMetrics(metrics);
                 },
                 deps: {
                     metrics: tokensMetrics.METRICS_MODULE_TOKEN,
@@ -603,7 +137,7 @@ exports.MetricsModule = tslib.__decorate([
     })
 ], exports.MetricsModule);
 
-exports.getUrlAndOptions = getUrlAndOptions;
+exports.getUrlAndOptions = createRequestWithMetrics.getUrlAndOptions;
 Object.keys(tokensMetrics).forEach(function (k) {
     if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
         enumerable: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/module-metrics",
-  "version": "2.70.0",
+  "version": "2.72.0",
   "description": "",
   "browser": "lib/browser.js",
   "main": "lib/server.js",
@@ -14,29 +14,28 @@
     "url": "git@github.com:Tinkoff/tramvai.git"
   },
   "scripts": {
-    "build": "tramvai-build --for-publish",
-    "watch": "tsc -w",
-    "build-for-publish": "true"
+    "build": "tramvai-build --forPublish --preserveModules",
+    "watch": "tsc -w"
   },
   "dependencies": {
-    "@tramvai/core": "2.70.0",
-    "@tramvai/tokens-common": "2.70.0",
-    "@tramvai/tokens-core-private": "2.70.0",
-    "@tramvai/tokens-server": "2.70.0",
-    "@tramvai/tokens-server-private": "2.70.0",
-    "@tramvai/tokens-metrics": "2.70.0",
-    "@tramvai/tokens-router": "2.70.0",
-    "@tramvai/tokens-http-client": "2.70.0",
-    "@tramvai/state": "2.70.0",
-    "@tramvai/papi": "2.70.0",
-    "@tinkoff/measure-fastify-requests": "0.1.6",
-    "@tinkoff/monkeypatch": "2.0.3",
-    "@tinkoff/url": "0.8.4",
+    "@tramvai/core": "2.72.0",
+    "@tramvai/tokens-common": "2.72.0",
+    "@tramvai/tokens-core-private": "2.72.0",
+    "@tramvai/tokens-server": "2.72.0",
+    "@tramvai/tokens-server-private": "2.72.0",
+    "@tramvai/tokens-metrics": "2.72.0",
+    "@tramvai/tokens-router": "2.72.0",
+    "@tramvai/tokens-http-client": "2.72.0",
+    "@tramvai/state": "2.72.0",
+    "@tramvai/papi": "2.72.0",
+    "@tinkoff/measure-fastify-requests": "0.1.7",
+    "@tinkoff/monkeypatch": "2.0.4",
+    "@tinkoff/url": "0.8.5",
     "@tinkoff/utils": "^2.1.2",
     "prom-client": "^12.0.0",
-    "@tinkoff/logger": "0.10.57",
-    "@tinkoff/metrics-noop": "2.0.4",
-    "@tinkoff/browser-timings": "0.10.4"
+    "@tinkoff/logger": "0.10.58",
+    "@tinkoff/metrics-noop": "2.0.5",
+    "@tinkoff/browser-timings": "0.10.5"
   },
   "peerDependencies": {
     "tslib": "^2.4.0"