@tramvai/module-metrics 2.70.1 → 2.72.3

package/lib/request/index.js

@@ -0,0 +1,65 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var core = require('@tramvai/core');
+var tokensMetrics = require('@tramvai/tokens-metrics');
+var tokensCommon = require('@tramvai/tokens-common');
+var noop = require('@tinkoff/utils/function/noop');
+var https = require('https');
+var http = require('http');
+var createRequestWithMetrics = require('./createRequestWithMetrics.js');
+var initRequestsMetrics = require('./initRequestsMetrics.js');
+var MetricsServicesRegistry = require('./MetricsServicesRegistry.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var noop__default = /*#__PURE__*/_interopDefaultLegacy(noop);
+var https__default = /*#__PURE__*/_interopDefaultLegacy(https);
+var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
+
+exports.RequestModule = class RequestModule {
+};
+exports.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.initRequestsMetrics({
+                            metrics,
+                            getServiceName,
+                            http: http__default["default"],
+                            https: https__default["default"],
+                            createRequestWithMetrics: createRequestWithMetrics.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.MetricsServicesRegistry,
+                scope: core.Scope.SINGLETON,
+            },
+        ],
+    })
+], exports.RequestModule);

package/lib/request/initRequestsMetrics.es.js

@@ -0,0 +1,53 @@
+import monkeypatch from '@tinkoff/monkeypatch';
+import { DEFAULT_BUCKETS } from '../constants.es.js';
+
+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({
+        obj: https,
+        method: 'request',
+        handler: createRequestWithMetrics({ metricsInstances, getServiceName, config }),
+    });
+    monkeypatch({
+        obj: http,
+        method: 'request',
+        handler: createRequestWithMetrics({ metricsInstances, getServiceName, config }),
+    });
+};
+
+export { initRequestsMetrics };

package/lib/request/initRequestsMetrics.js

@@ -0,0 +1,61 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var monkeypatch = require('@tinkoff/monkeypatch');
+var constants = require('../constants.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var monkeypatch__default = /*#__PURE__*/_interopDefaultLegacy(monkeypatch);
+
+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: constants.DEFAULT_BUCKETS,
+        }),
+        dnsResolveDuration: metrics.histogram({
+            name: 'dns_resolve_duration',
+            help: 'Time for dns resolve of the outhgoing requests',
+            labelNames: ['service'],
+            buckets: constants.DEFAULT_BUCKETS,
+        }),
+        tcpConnectDuration: metrics.histogram({
+            name: 'tcp_connect_duration',
+            help: 'Duration of tcp connect of the outgoing requests',
+            labelNames: ['service'],
+            buckets: constants.DEFAULT_BUCKETS,
+        }),
+        tlsHandshakeDuration: metrics.histogram({
+            name: 'tls_handshake_duration',
+            help: 'Duration of tls handshake of the outgoing requests',
+            labelNames: ['service'],
+            buckets: constants.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 }),
+    });
+};
+
+exports.initRequestsMetrics = initRequestsMetrics;

package/lib/server.es.js

@@ -1,478 +1,18 @@
 import { __decorate } from 'tslib';
-import { Module, commandLineListTokens, Scope, provide } from '@tramvai/core';
+import { Module, provide, Scope, commandLineListTokens } from '@tramvai/core';
 import { COMMAND_LINE_EXECUTION_END_TOKEN } from '@tramvai/tokens-core-private';
-import { SERVER_MODULE_PAPI_PUBLIC_ROUTE, UTILITY_SERVER_PATHS } from '@tramvai/tokens-server';
+import { UTILITY_SERVER_PATHS } from '@tramvai/tokens-server';
 import { WEB_FASTIFY_APP_BEFORE_INIT_TOKEN, UTILITY_WEB_FASTIFY_APP_TOKEN, WEB_FASTIFY_APP_METRICS_TOKEN, WEB_FASTIFY_APP_TOKEN } from '@tramvai/tokens-server-private';
-import { METRICS_MODULE_TOKEN, METRICS_SERVICES_REGISTRY_TOKEN, METRICS_MODULE_CONFIG_TOKEN, REGISTER_INSTANT_METRIC_TOKEN } from '@tramvai/tokens-metrics';
+import { METRICS_MODULE_CONFIG_TOKEN, METRICS_MODULE_TOKEN } from '@tramvai/tokens-metrics';
 export * from '@tramvai/tokens-metrics';
 import { fastifyMeasureRequests } from '@tinkoff/measure-fastify-requests';
 import { Registry, collectDefaultMetrics, Counter, Gauge, Histogram, Summary } from 'prom-client';
 import flatten from '@tinkoff/utils/array/flatten';
-import { ENV_MANAGER_TOKEN, COMBINE_REDUCERS, LOGGER_TOKEN, CONTEXT_TOKEN } from '@tramvai/tokens-common';
-import noop from '@tinkoff/utils/function/noop';
-import https from 'https';
-import http from 'http';
-import { format } from '@tinkoff/url';
-import monkeypatch from '@tinkoff/monkeypatch';
-import isString from '@tinkoff/utils/is/string';
-import { createPapiMethod } from '@tramvai/papi';
-import fromPairs from '@tinkoff/utils/object/fromPairs';
-import { createEvent, createReducer } from '@tramvai/state';
-
-// 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;
-    };
-};
-
-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({
-        obj: https,
-        method: 'request',
-        handler: createRequestWithMetrics({ metricsInstances, getServiceName, config }),
-    });
-    monkeypatch({
-        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(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 = __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);
-
-const setInstantMetrics = createEvent('set instant metrics map');
-const MetricsStore = createReducer('instantMetrics', { instantMetricsMap: {} }).on(setInstantMetrics, (_prevState, nextState) => {
-    return nextState;
-});
-
-const sharedProviders = [
-    {
-        provide: COMBINE_REDUCERS,
-        multi: true,
-        useValue: [MetricsStore],
-    },
-];
-
-let InstantMetricsModule = class InstantMetricsModule {
-};
-InstantMetricsModule = __decorate([
-    Module({
-        providers: [
-            ...sharedProviders,
-            {
-                provide: SERVER_MODULE_PAPI_PUBLIC_ROUTE,
-                multi: true,
-                useFactory({ metrics, logger, instantMetrics, }) {
-                    const log = logger('instantmetrics:papi');
-                    const instantMetricsMap = fromPairs(instantMetrics || []);
-                    return 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: METRICS_MODULE_TOKEN,
-                    logger: LOGGER_TOKEN,
-                    instantMetrics: {
-                        token: REGISTER_INSTANT_METRIC_TOKEN,
-                        multi: true,
-                        optional: true,
-                    },
-                },
-            },
-            {
-                provide: 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: CONTEXT_TOKEN,
-                    instantMetrics: {
-                        token: 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);
-            }
-        }
-    };
-};
+import { RequestModule } from './request/index.es.js';
+import { InstantMetricsModule } from './instantMetrics/server.es.js';
+import { eventLoopMetrics } from './metrics/eventLoop.es.js';
+import { commandLineMetrics } from './metrics/commandLine.es.js';
+export { getUrlAndOptions } from './request/createRequestWithMetrics.es.js';
 
 let MetricsModule = class MetricsModule {
 };
@@ -590,4 +130,4 @@ MetricsModule = __decorate([
     })
 ], MetricsModule);
 
-export { MetricsModule, getUrlAndOptions };
+export { MetricsModule };