@tramvai/module-metrics 2.70.1 → 2.72.3

package/lib/performance-devtools/PerfMetrics.browser.js

@@ -0,0 +1,56 @@
+import { Histogram, Summary, Gauge } from '@tinkoff/metrics-noop';
+import { startMeasure } from './startMeasure.browser.js';
+import { supportsUserTiming } from './supportsUserTiming.browser.js';
+import { uniqueId } from './uniqueId.browser.js';
+
+function startMeasurePerformance(name, startLabels = {}) {
+    if (!supportsUserTiming) {
+        return () => { };
+    }
+    const endMeasure = startMeasure(name, uniqueId());
+    return (endLabels = {}) => {
+        const labels = { ...startLabels, ...endLabels };
+        const labelsNames = Object.keys(labels)
+            .map((key) => `${key}="${labels[key]}"`)
+            .join(',');
+        endMeasure(labelsNames && `${name}{${labelsNames}}`);
+    };
+}
+class PerfHistogram extends Histogram {
+    constructor(configurator) {
+        super(configurator);
+        this.name = configurator.name;
+    }
+    startTimer(startLabels) {
+        const endMeasure = startMeasurePerformance(this.name, startLabels);
+        return (endLabels) => {
+            endMeasure(endLabels);
+        };
+    }
+}
+class PerfSummary extends Summary {
+    constructor(configurator) {
+        super(configurator);
+        this.name = configurator.name;
+    }
+    startTimer() {
+        const endMeasure = startMeasurePerformance(this.name);
+        return (endLabels) => {
+            endMeasure(endLabels);
+        };
+    }
+}
+class PerfGauge extends Gauge {
+    constructor(configurator) {
+        super(configurator);
+        this.name = configurator.name;
+    }
+    startTimer(startLabels) {
+        const endMeasure = startMeasurePerformance(this.name, startLabels);
+        return (endLabels) => {
+            endMeasure(endLabels);
+        };
+    }
+}
+
+export { PerfGauge, PerfHistogram, PerfSummary, startMeasurePerformance };

package/lib/performance-devtools/startMeasure.browser.js

@@ -0,0 +1,14 @@
+function startMeasure(markName, uniqueMarkId) {
+    const uniqueMarkName = `${markName}:${uniqueMarkId}`;
+    performance.mark(uniqueMarkName);
+    function endMeasure(measureName) {
+        try {
+            performance.measure(measureName || markName, uniqueMarkName);
+        }
+        catch (e) { }
+        performance.clearMarks(uniqueMarkName);
+    }
+    return endMeasure;
+}
+
+export { startMeasure };

package/lib/performance-devtools/supportsUserTiming.browser.js

@@ -0,0 +1,7 @@
+const supportsUserTiming = typeof performance !== 'undefined' &&
+    typeof performance.mark === 'function' &&
+    typeof performance.clearMarks === 'function' &&
+    typeof performance.measure === 'function' &&
+    typeof performance.clearMeasures === 'function';
+
+export { supportsUserTiming };

package/lib/performance-devtools/uniqueId.browser.js

@@ -0,0 +1,7 @@
+let idCounter = 0;
+function uniqueId() {
+    // eslint-disable-next-line no-plusplus
+    return ++idCounter;
+}
+
+export { uniqueId };

package/lib/request/MetricsServicesRegistry.es.js

@@ -0,0 +1,56 @@
+import isString from '@tinkoff/utils/is/string';
+import { PrefixTree } from './PrefixTree.es.js';
+
+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(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];
+    }
+}
+
+export { MetricsServicesRegistry };

package/lib/request/MetricsServicesRegistry.js

@@ -0,0 +1,64 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var isString = require('@tinkoff/utils/is/string');
+var PrefixTree = require('./PrefixTree.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var isString__default = /*#__PURE__*/_interopDefaultLegacy(isString);
+
+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.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];
+    }
+}
+
+exports.MetricsServicesRegistry = MetricsServicesRegistry;

package/lib/request/PrefixTree.es.js

@@ -0,0 +1,48 @@
+// Дерево использует подход структуры данных 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;
+    }
+}
+
+export { PrefixTree };

package/lib/request/PrefixTree.js

@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// Дерево использует подход структуры данных 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;
+    }
+}
+
+exports.PrefixTree = PrefixTree;

package/lib/request/createRequestWithMetrics.es.js

@@ -0,0 +1,123 @@
+import { format } from '@tinkoff/url';
+
+// 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;
+    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] = args;
+    }
+    if (isUrlObjectFirst) {
+        url = format(args[0]);
+    }
+    if (isOptionsFirst) {
+        [options] = args;
+        // Тут учитываем случай если передаётся не href в options, а отдельно protocol, host, port, path
+        if (options.href) {
+            url = options.href;
+        }
+        else {
+            const urlString = format({
+                protocol: options.protocol,
+                host: options.hostname || options.host,
+                port: options.port,
+                pathname: options.path,
+            });
+            // format где-то внутри делает encodeURIComponent и из-за этого потом не может обрезать query
+            try {
+                url = decodeURIComponent(urlString);
+            }
+            catch {
+                url = urlString;
+            }
+        }
+    }
+    if (isOptionsSecond) {
+        [, options] = args;
+    }
+    const parsedUrl = new URL(url);
+    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;
+    };
+};
+
+export { createRequestWithMetrics, getUrlAndOptions };

package/lib/request/createRequestWithMetrics.js

@@ -0,0 +1,128 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var url = require('@tinkoff/url');
+
+// 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;
+    };
+};
+
+exports.createRequestWithMetrics = createRequestWithMetrics;
+exports.getUrlAndOptions = getUrlAndOptions;

package/lib/request/index.es.js

@@ -0,0 +1,57 @@
+import { __decorate } from 'tslib';
+import { Module, commandLineListTokens, Scope } from '@tramvai/core';
+import { METRICS_MODULE_TOKEN, METRICS_SERVICES_REGISTRY_TOKEN, METRICS_MODULE_CONFIG_TOKEN } from '@tramvai/tokens-metrics';
+import { ENV_MANAGER_TOKEN } from '@tramvai/tokens-common';
+import noop from '@tinkoff/utils/function/noop';
+import https from 'https';
+import http from 'http';
+import { createRequestWithMetrics } from './createRequestWithMetrics.es.js';
+import { initRequestsMetrics } from './initRequestsMetrics.es.js';
+import { MetricsServicesRegistry } from './MetricsServicesRegistry.es.js';
+
+let RequestModule = class RequestModule {
+};
+RequestModule = __decorate([
+    Module({
+        providers: [
+            {
+                provide: commandLineListTokens.init,
+                multi: true,
+                useFactory: ({ metrics, envManager, metricsServicesRegistry, metricsModuleConfig, }) => {
+                    if (!metrics) {
+                        return noop;
+                    }
+                    return () => {
+                        const env = envManager.getAll();
+                        metricsServicesRegistry.registerEnv(env);
+                        const getServiceName = metricsServicesRegistry.getServiceName.bind(metricsServicesRegistry);
+                        initRequestsMetrics({
+                            metrics,
+                            getServiceName,
+                            http,
+                            https,
+                            createRequestWithMetrics,
+                            config: metricsModuleConfig,
+                        });
+                    };
+                },
+                deps: {
+                    metrics: {
+                        token: METRICS_MODULE_TOKEN,
+                        optional: true,
+                    },
+                    metricsServicesRegistry: METRICS_SERVICES_REGISTRY_TOKEN,
+                    envManager: ENV_MANAGER_TOKEN,
+                    metricsModuleConfig: METRICS_MODULE_CONFIG_TOKEN,
+                },
+            },
+            {
+                provide: METRICS_SERVICES_REGISTRY_TOKEN,
+                useClass: MetricsServicesRegistry,
+                scope: Scope.SINGLETON,
+            },
+        ],
+    })
+], RequestModule);
+
+export { RequestModule };