@tramvai/module-metrics 2.70.0 → 2.72.0

package/lib/browser.js

@@ -1,164 +1,13 @@
 import { __decorate } from 'tslib';
-import { Module, commandLineListTokens, Scope } from '@tramvai/core';
-import { COMBINE_REDUCERS, CONTEXT_TOKEN, LOGGER_TOKEN } from '@tramvai/tokens-common';
+import { Module, Scope, commandLineListTokens } from '@tramvai/core';
+import { LOGGER_TOKEN } from '@tramvai/tokens-common';
 import { METRICS_MODULE_TOKEN } from '@tramvai/tokens-metrics';
 export * from '@tramvai/tokens-metrics';
 import { browserTimings } from '@tinkoff/browser-timings';
-import { Histogram, Summary, Gauge, Counter } from '@tinkoff/metrics-noop';
+import { Counter, Gauge, Histogram, Summary } from '@tinkoff/metrics-noop';
 import { PAGE_SERVICE_TOKEN } from '@tramvai/tokens-router';
-import { PAPI_SERVICE } from '@tramvai/tokens-http-client';
-import { RemoteReporter } from '@tinkoff/logger';
-import { createEvent, createReducer } from '@tramvai/state';
-
-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,
-            {
-                // При такой схеме подключения отправка instant метрик заработает только после этого
-                // провайдера, но подлючить через LOGGER_INIT_HOOK не представляется возможным потому что
-                // возникает циклическая зависимость контекст -> логгер -> хук метрик -> контекст
-                provide: commandLineListTokens.init,
-                scope: Scope.SINGLETON,
-                multi: true,
-                useFactory({ logger, papiService, context, }) {
-                    if (!papiService) {
-                        return () => { };
-                    }
-                    const validMetricsMap = context.getStore('instantMetrics').getState().instantMetricsMap;
-                    const instantMetricsReporter = new RemoteReporter({
-                        requestCount: 1,
-                        emitLevels: {
-                            trace: true,
-                            debug: true,
-                            info: true,
-                            warn: true,
-                            error: true,
-                            fatal: true,
-                        },
-                        makeRequest(logObject) {
-                            if (validMetricsMap[logObject.event]) {
-                                return papiService
-                                    .request({
-                                    path: `metrics/${logObject.event}`,
-                                    method: 'post',
-                                    payload: logObject.value
-                                        ? {
-                                            value: logObject.value,
-                                        }
-                                        : {},
-                                })
-                                    .then(({ payload }) => payload);
-                            }
-                            return Promise.resolve();
-                        },
-                    });
-                    return () => {
-                        logger.addBeforeReporter(instantMetricsReporter);
-                    };
-                },
-                deps: {
-                    papiService: {
-                        token: PAPI_SERVICE,
-                        optional: true,
-                    },
-                    context: CONTEXT_TOKEN,
-                    logger: LOGGER_TOKEN,
-                },
-            },
-        ],
-    })
-], InstantMetricsModule);
-
-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;
-}
-
-const supportsUserTiming = typeof performance !== 'undefined' &&
-    typeof performance.mark === 'function' &&
-    typeof performance.clearMarks === 'function' &&
-    typeof performance.measure === 'function' &&
-    typeof performance.clearMeasures === 'function';
-
-let idCounter = 0;
-function uniqueId() {
-    // eslint-disable-next-line no-plusplus
-    return ++idCounter;
-}
-
-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);
-        };
-    }
-}
+import { InstantMetricsModule } from './instantMetrics/browser.browser.js';
+import { PerfGauge, PerfHistogram, PerfSummary } from './performance-devtools/PerfMetrics.browser.js';
 
 let MetricsModule = class MetricsModule {
 };

package/lib/constants.es.js

@@ -0,0 +1,3 @@
+const DEFAULT_BUCKETS = [0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10, 20, 40, 60];
+
+export { DEFAULT_BUCKETS };

package/lib/constants.js

@@ -0,0 +1,7 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const DEFAULT_BUCKETS = [0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10, 20, 40, 60];
+
+exports.DEFAULT_BUCKETS = DEFAULT_BUCKETS;

package/lib/instantMetrics/browser.browser.js

@@ -0,0 +1,70 @@
+import { __decorate } from 'tslib';
+import { Module, commandLineListTokens, Scope } from '@tramvai/core';
+import { CONTEXT_TOKEN, LOGGER_TOKEN } from '@tramvai/tokens-common';
+import { PAPI_SERVICE } from '@tramvai/tokens-http-client';
+import { RemoteReporter } from '@tinkoff/logger';
+import { sharedProviders } from './shared.browser.js';
+
+let InstantMetricsModule = class InstantMetricsModule {
+};
+InstantMetricsModule = __decorate([
+    Module({
+        providers: [
+            ...sharedProviders,
+            {
+                // При такой схеме подключения отправка instant метрик заработает только после этого
+                // провайдера, но подлючить через LOGGER_INIT_HOOK не представляется возможным потому что
+                // возникает циклическая зависимость контекст -> логгер -> хук метрик -> контекст
+                provide: commandLineListTokens.init,
+                scope: Scope.SINGLETON,
+                multi: true,
+                useFactory({ logger, papiService, context, }) {
+                    if (!papiService) {
+                        return () => { };
+                    }
+                    const validMetricsMap = context.getStore('instantMetrics').getState().instantMetricsMap;
+                    const instantMetricsReporter = new RemoteReporter({
+                        requestCount: 1,
+                        emitLevels: {
+                            trace: true,
+                            debug: true,
+                            info: true,
+                            warn: true,
+                            error: true,
+                            fatal: true,
+                        },
+                        makeRequest(logObject) {
+                            if (validMetricsMap[logObject.event]) {
+                                return papiService
+                                    .request({
+                                    path: `metrics/${logObject.event}`,
+                                    method: 'post',
+                                    payload: logObject.value
+                                        ? {
+                                            value: logObject.value,
+                                        }
+                                        : {},
+                                })
+                                    .then(({ payload }) => payload);
+                            }
+                            return Promise.resolve();
+                        },
+                    });
+                    return () => {
+                        logger.addBeforeReporter(instantMetricsReporter);
+                    };
+                },
+                deps: {
+                    papiService: {
+                        token: PAPI_SERVICE,
+                        optional: true,
+                    },
+                    context: CONTEXT_TOKEN,
+                    logger: LOGGER_TOKEN,
+                },
+            },
+        ],
+    })
+], InstantMetricsModule);
+
+export { InstantMetricsModule };

package/lib/instantMetrics/server.es.js

@@ -0,0 +1,97 @@
+import { __decorate } from 'tslib';
+import { Module, commandLineListTokens } from '@tramvai/core';
+import { SERVER_MODULE_PAPI_PUBLIC_ROUTE } from '@tramvai/tokens-server';
+import { createPapiMethod } from '@tramvai/papi';
+import { METRICS_MODULE_TOKEN, REGISTER_INSTANT_METRIC_TOKEN } from '@tramvai/tokens-metrics';
+import { LOGGER_TOKEN, CONTEXT_TOKEN } from '@tramvai/tokens-common';
+import fromPairs from '@tinkoff/utils/object/fromPairs';
+import { sharedProviders } from './shared.es.js';
+import { setInstantMetrics } from './store.es.js';
+
+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);
+
+export { InstantMetricsModule };

package/lib/instantMetrics/server.js

@@ -0,0 +1,103 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var core = require('@tramvai/core');
+var tokensServer = require('@tramvai/tokens-server');
+var papi = require('@tramvai/papi');
+var tokensMetrics = require('@tramvai/tokens-metrics');
+var tokensCommon = require('@tramvai/tokens-common');
+var fromPairs = require('@tinkoff/utils/object/fromPairs');
+var shared = require('./shared.js');
+var store = require('./store.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var fromPairs__default = /*#__PURE__*/_interopDefaultLegacy(fromPairs);
+
+exports.InstantMetricsModule = class InstantMetricsModule {
+};
+exports.InstantMetricsModule = tslib.__decorate([
+    core.Module({
+        providers: [
+            ...shared.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(store.setInstantMetrics({ instantMetricsMap }));
+                    };
+                },
+                deps: {
+                    context: tokensCommon.CONTEXT_TOKEN,
+                    instantMetrics: {
+                        token: tokensMetrics.REGISTER_INSTANT_METRIC_TOKEN,
+                        multi: true,
+                        optional: true,
+                    },
+                },
+            },
+        ],
+    })
+], exports.InstantMetricsModule);

package/lib/instantMetrics/shared.browser.js

@@ -0,0 +1,12 @@
+import { COMBINE_REDUCERS } from '@tramvai/tokens-common';
+import { MetricsStore } from './store.browser.js';
+
+const sharedProviders = [
+    {
+        provide: COMBINE_REDUCERS,
+        multi: true,
+        useValue: [MetricsStore],
+    },
+];
+
+export { sharedProviders };

package/lib/instantMetrics/shared.es.js

@@ -0,0 +1,12 @@
+import { COMBINE_REDUCERS } from '@tramvai/tokens-common';
+import { MetricsStore } from './store.es.js';
+
+const sharedProviders = [
+    {
+        provide: COMBINE_REDUCERS,
+        multi: true,
+        useValue: [MetricsStore],
+    },
+];
+
+export { sharedProviders };

package/lib/instantMetrics/shared.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tokensCommon = require('@tramvai/tokens-common');
+var store = require('./store.js');
+
+const sharedProviders = [
+    {
+        provide: tokensCommon.COMBINE_REDUCERS,
+        multi: true,
+        useValue: [store.MetricsStore],
+    },
+];
+
+exports.sharedProviders = sharedProviders;

package/lib/instantMetrics/store.browser.js

@@ -0,0 +1,8 @@
+import { createEvent, createReducer } from '@tramvai/state';
+
+const setInstantMetrics = createEvent('set instant metrics map');
+const MetricsStore = createReducer('instantMetrics', { instantMetricsMap: {} }).on(setInstantMetrics, (_prevState, nextState) => {
+    return nextState;
+});
+
+export { MetricsStore, setInstantMetrics };

package/lib/instantMetrics/store.es.js

@@ -0,0 +1,8 @@
+import { createEvent, createReducer } from '@tramvai/state';
+
+const setInstantMetrics = createEvent('set instant metrics map');
+const MetricsStore = createReducer('instantMetrics', { instantMetricsMap: {} }).on(setInstantMetrics, (_prevState, nextState) => {
+    return nextState;
+});
+
+export { MetricsStore, setInstantMetrics };

package/lib/instantMetrics/store.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var state = require('@tramvai/state');
+
+const setInstantMetrics = state.createEvent('set instant metrics map');
+const MetricsStore = state.createReducer('instantMetrics', { instantMetricsMap: {} }).on(setInstantMetrics, (_prevState, nextState) => {
+    return nextState;
+});
+
+exports.MetricsStore = MetricsStore;
+exports.setInstantMetrics = setInstantMetrics;

package/lib/metrics/commandLine.es.js

@@ -0,0 +1,22 @@
+import { DEFAULT_BUCKETS } from '../constants.es.js';
+
+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);
+            }
+        }
+    };
+};
+
+export { commandLineMetrics };

package/lib/metrics/commandLine.js

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('../constants.js');
+
+const commandLineMetrics = (metrics) => {
+    const metricsInstance = metrics.histogram({
+        name: `command_line_runner_execution_time`,
+        help: 'Command line processing duration',
+        labelNames: ['line'],
+        buckets: constants.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.commandLineMetrics = commandLineMetrics;

package/lib/metrics/eventLoop.es.js

@@ -0,0 +1,23 @@
+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);
+};
+
+export { eventLoopMetrics };

package/lib/metrics/eventLoop.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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);
+};
+
+exports.eventLoopMetrics = eventLoopMetrics;