@vtex/api 6.48.1-beta → 6.48.1-beta.2

package/lib/service/logger/metricsLogger.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="node" />
+interface ProcessEnv {
+    appName: string;
+    appVersion: string;
+    region: string;
+    vendor: string;
+    production: boolean;
+}
+interface Key {
+    name: string;
+}
+interface Metric {
+    Count: number;
+    Data: {
+        key: Key;
+        processEnv: ProcessEnv;
+        summary: NumericSummary | NodeJS.MemoryUsage | NodeJS.CpuUsage;
+    };
+    Max: number;
+    Min: number;
+    Name: string;
+    Sum: number;
+    Timestamp: number;
+    Unit: string;
+}
+interface NumericSummary {
+    count: number;
+    max: number;
+    median: number;
+    min: number;
+    percentile95: number;
+    percentile99: number;
+    sum: number;
+}
+export declare class MetricsLogger {
+    add: (key: Key, value: number) => void;
+    getSummaries: () => Metric[];
+    constructor();
+}
+export {};

package/lib/service/logger/metricsLogger.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsLogger = void 0;
+const fast_json_stable_stringify_1 = __importDefault(require("fast-json-stable-stringify"));
+const ramda_1 = require("ramda");
+const stats_lite_1 = require("stats-lite");
+const constants_1 = require("../../constants");
+const diff_1 = require("../worker/runtime/utils/diff");
+const runtimeBaseDefaultMetricNames = ['routeStats'];
+const runtimeNodeDefaultMetricNames = {
+    cpuUsage: 'cpuUsage',
+    memoryUsage: 'memoryUsage',
+};
+const invalidMetricNames = runtimeBaseDefaultMetricNames.concat(Object.values(runtimeNodeDefaultMetricNames));
+class MetricsLogger {
+    constructor() {
+        //////////////////////
+        // private attributes
+        //////////////////////
+        let samples = {};
+        let lastCpu = (0, diff_1.cpuSnapshot)();
+        //////////////////////
+        // private methods definitions
+        //////////////////////
+        const summaries = (0, ramda_1.compose)((0, ramda_1.reject)(ramda_1.isNil), ramda_1.values, (0, ramda_1.mapObjIndexed)(getSummary));
+        function getDefaultStoredashProperties() {
+            return {
+                Count: 1,
+                Max: 0,
+                Min: 0,
+                Name: 'runtime',
+                Sum: 0,
+                Timestamp: (new Date()).getTime(),
+                Unit: '',
+            };
+        }
+        function getProcessEnv() {
+            return {
+                appName: process.env.VTEX_APP_NAME || '',
+                appVersion: process.env.VTEX_APP_VERSION || '',
+                production: constants_1.PRODUCTION,
+                region: process.env.VTEX_REGION || '',
+                vendor: process.env.VTEX_APP_VENDOR || '',
+            };
+        }
+        function getCpuUsage() {
+            const cpu = (0, diff_1.cpuSnapshot)();
+            const cpuDiff = (0, diff_1.snapshotDiff)(cpu, lastCpu);
+            lastCpu = cpu;
+            const metric = {
+                Data: {
+                    key: {
+                        name: runtimeNodeDefaultMetricNames.cpuUsage,
+                    },
+                    processEnv: getProcessEnv(),
+                    summary: cpuDiff,
+                },
+                ...getDefaultStoredashProperties(),
+            };
+            return metric;
+        }
+        function getMemoryUsage() {
+            const metric = {
+                Data: {
+                    key: {
+                        name: runtimeNodeDefaultMetricNames.memoryUsage,
+                    },
+                    processEnv: getProcessEnv(),
+                    summary: process.memoryUsage(),
+                },
+                ...getDefaultStoredashProperties(),
+            };
+            return metric;
+        }
+        function getRuntimeSummaries() {
+            return [getCpuUsage(), getMemoryUsage()];
+        }
+        function getSummary(vals, strKey) {
+            if (strKey in samples) {
+                const summary = getNumericSummary(vals);
+                const keyObj = JSON.parse(strKey);
+                const metric = {
+                    Data: {
+                        key: keyObj,
+                        processEnv: getProcessEnv(),
+                        summary,
+                    },
+                    ...getDefaultStoredashProperties(),
+                };
+                return metric;
+            }
+            return null;
+        }
+        // TODO: create some kind of alert/log if metric is not valid
+        function validKey(key) {
+            if (!('name' in key)) {
+                return false;
+            }
+            if (invalidMetricNames.includes(key.name)) {
+                return false;
+            }
+            try {
+                (0, fast_json_stable_stringify_1.default)(key);
+            }
+            catch {
+                return false;
+            }
+            return true;
+        }
+        function getStrKey(key) {
+            return (0, fast_json_stable_stringify_1.default)(key);
+        }
+        function getNumericSummary(vals) {
+            return {
+                count: vals.length,
+                max: Math.max(...vals),
+                median: (0, stats_lite_1.median)(vals),
+                min: Math.min(...vals),
+                percentile95: (0, stats_lite_1.percentile)(vals, 0.95),
+                percentile99: (0, stats_lite_1.percentile)(vals, 0.99),
+                sum: (0, stats_lite_1.sum)(vals),
+            };
+        }
+        //////////////////////
+        // public methods definitions
+        //////////////////////
+        this.add = (key, value) => {
+            if (validKey(key)) {
+                const strKey = getStrKey(key);
+                if (!(strKey in samples)) {
+                    samples[strKey] = [];
+                }
+                samples[strKey].push(value);
+            }
+        };
+        this.getSummaries = () => {
+            const appSummaries = summaries(samples);
+            samples = {};
+            const runtimeSummaries = getRuntimeSummaries();
+            return runtimeSummaries.concat(appSummaries);
+        };
+        //////////////////////
+        // real constructor
+        //////////////////////
+    }
+}
+exports.MetricsLogger = MetricsLogger;

package/lib/service/master.d.ts

@@ -0,0 +1,2 @@
+import { ServiceJSON } from './worker/runtime/typings';
+export declare const startMaster: (service: ServiceJSON) => void;

package/lib/service/master.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startMaster = void 0;
+const cluster_1 = __importDefault(require("cluster"));
+const os_1 = require("os");
+const constants_1 = require("../constants");
+const logger_1 = require("./logger");
+const listeners_1 = require("./worker/listeners");
+const statusTrack_1 = require("./worker/runtime/statusTrack");
+let handledSignal;
+const onMessage = (worker, message) => {
+    if ((0, logger_1.isLog)(message)) {
+        (0, logger_1.logOnceToDevConsole)(message.message, message.level);
+    }
+    else if ((0, statusTrack_1.isStatusTrackBroadcast)(message)) {
+        (0, statusTrack_1.trackStatus)();
+        (0, statusTrack_1.broadcastStatusTrack)();
+    }
+    else {
+        listeners_1.logger.warn({
+            content: message,
+            message: 'Worker sent message',
+            pid: worker.process.pid,
+        });
+    }
+};
+const onExit = (worker, code, signal) => {
+    if (!constants_1.LINKED && worker.exitedAfterDisconnect === false) {
+        listeners_1.logger.error({
+            code,
+            message: 'Worker Died',
+            pid: worker.process.pid,
+            signal,
+        });
+        cluster_1.default.fork();
+    }
+    const exitOn = ['SIGTERM', 'SIGINT'];
+    if (handledSignal && exitOn.includes(handledSignal) && Object.keys(cluster_1.default.workers).length === 0) {
+        process.exit(os_1.constants.signals[handledSignal]);
+    }
+};
+let workersOnline = 0;
+const onOnline = (worker) => {
+    console.log('Worker ' + worker.process.pid + ' is listening');
+    workersOnline += 1;
+    if (workersOnline === 1) {
+        worker.send(constants_1.UP_SIGNAL);
+    }
+};
+const GRACEFULLY_SHUTDOWN_TIMEOUT_S = 30;
+const SIGINT_TIMEOUT_S = 1;
+const handleSignal = (timeout) => (signal) => {
+    // For each worker, let's try to kill it gracefully
+    Object.values(cluster_1.default.workers).forEach((worker) => worker === null || worker === void 0 ? void 0 : worker.kill(signal));
+    // Let's raise the flag to kill the master process after all workers have died
+    handledSignal = signal;
+    // Let's wait for all in-flight requests finish before send any kill signal
+    const waitTimeToForceKill = timeout * 1e3;
+    // Force workers and master to die after a graceful timeout
+    setTimeout(() => {
+        Object.values(cluster_1.default.workers).forEach((worker) => worker === null || worker === void 0 ? void 0 : worker.process.kill('SIGKILL'));
+        process.exit(os_1.constants.signals[signal]);
+    }, waitTimeToForceKill);
+};
+const startMaster = (service) => {
+    const { workers: numWorkers, timeout = GRACEFULLY_SHUTDOWN_TIMEOUT_S } = service;
+    if (service.deterministicVary) {
+        process.env.DETERMINISTIC_VARY = 'true';
+    }
+    // Setup dubugger
+    if (constants_1.LINKED) {
+        cluster_1.default.setupMaster({ inspectPort: constants_1.INSPECT_DEBUGGER_PORT });
+    }
+    const shutdownTimeout = Math.max(GRACEFULLY_SHUTDOWN_TIMEOUT_S, timeout);
+    console.log(`Spawning ${numWorkers} workers`);
+    console.log(`Using ${shutdownTimeout} seconds as worker graceful shutdown timeout`);
+    for (let i = 0; i < numWorkers; i++) {
+        cluster_1.default.fork();
+    }
+    cluster_1.default.on('online', onOnline);
+    cluster_1.default.on('exit', onExit);
+    cluster_1.default.on('message', onMessage);
+    process.on('SIGINT', handleSignal(SIGINT_TIMEOUT_S));
+    process.on('SIGTERM', handleSignal(shutdownTimeout));
+};
+exports.startMaster = startMaster;

package/lib/service/metrics/requestMetricsMiddleware.d.ts

@@ -0,0 +1,2 @@
+import { ServiceContext } from '../worker/runtime/typings';
+export declare const addRequestMetricsMiddleware: () => (ctx: ServiceContext, next: () => Promise<void>) => Promise<void>;

package/lib/service/metrics/requestMetricsMiddleware.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addRequestMetricsMiddleware = void 0;
+const stream_1 = require("stream");
+const utils_1 = require("../../utils");
+const instruments_1 = require("../tracing/metrics/instruments");
+const addRequestMetricsMiddleware = () => {
+    const concurrentRequests = (0, instruments_1.createConcurrentRequestsInstrument)();
+    const requestTimings = (0, instruments_1.createRequestsTimingsInstrument)();
+    const totalRequests = (0, instruments_1.createTotalRequestsInstrument)();
+    const responseSizes = (0, instruments_1.createRequestsResponseSizesInstrument)();
+    const abortedRequests = (0, instruments_1.createTotalAbortedRequestsInstrument)();
+    return async function addRequestMetrics(ctx, next) {
+        const start = process.hrtime();
+        concurrentRequests.inc(1);
+        ctx.req.once('aborted', () => abortedRequests.inc({ ["handler" /* RequestsMetricLabels.REQUEST_HANDLER */]: ctx.requestHandlerName }, 1));
+        let responseClosed = false;
+        ctx.res.once('close', () => (responseClosed = true));
+        try {
+            await next();
+        }
+        finally {
+            const responseLength = ctx.response.length;
+            if (responseLength) {
+                responseSizes.observe({ ["handler" /* RequestsMetricLabels.REQUEST_HANDLER */]: ctx.requestHandlerName }, responseLength);
+            }
+            totalRequests.inc({
+                ["handler" /* RequestsMetricLabels.REQUEST_HANDLER */]: ctx.requestHandlerName,
+                ["status_code" /* RequestsMetricLabels.STATUS_CODE */]: ctx.response.status,
+            }, 1);
+            const onResFinished = () => {
+                requestTimings.observe({
+                    ["handler" /* RequestsMetricLabels.REQUEST_HANDLER */]: ctx.requestHandlerName,
+                }, (0, utils_1.hrToMillisFloat)(process.hrtime(start)));
+                concurrentRequests.dec(1);
+            };
+            if (responseClosed) {
+                onResFinished();
+            }
+            else {
+                (0, stream_1.finished)(ctx.res, onResFinished);
+            }
+        }
+    };
+};
+exports.addRequestMetricsMiddleware = addRequestMetricsMiddleware;

package/lib/service/tracing/TracerSingleton.d.ts

@@ -0,0 +1,7 @@
+import { Tracer } from 'opentracing';
+export declare class TracerSingleton {
+    static getTracer(): Tracer;
+    private static singleton;
+    private static initServiceTracer;
+    private static createJaegerTracer;
+}

package/lib/service/tracing/TracerSingleton.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TracerSingleton = void 0;
+const jaeger_client_1 = require("jaeger-client");
+const prom_client_1 = __importDefault(require("prom-client"));
+const constants_1 = require("../../constants");
+const utils_1 = require("../../utils");
+class TracerSingleton {
+    static getTracer() {
+        if (!TracerSingleton.singleton) {
+            TracerSingleton.singleton = TracerSingleton.initServiceTracer();
+        }
+        return TracerSingleton.singleton;
+    }
+    static initServiceTracer() {
+        return TracerSingleton.createJaegerTracer((0, utils_1.appIdToAppAtMajor)(constants_1.APP.ID), {
+            ["app.linked" /* AppTags.VTEX_APP_LINKED */]: constants_1.LINKED,
+            ["app.node_vtex_api_version" /* AppTags.VTEX_APP_NODE_VTEX_API_VERSION */]: constants_1.NODE_VTEX_API_VERSION,
+            ["app.production" /* AppTags.VTEX_APP_PRODUCTION */]: constants_1.PRODUCTION,
+            ["app.region" /* AppTags.VTEX_APP_REGION */]: constants_1.REGION,
+            ["app.version" /* AppTags.VTEX_APP_VERSION */]: constants_1.APP.VERSION,
+            ["app.workspace" /* AppTags.VTEX_APP_WORKSPACE */]: constants_1.WORKSPACE,
+            ["app.node_env" /* AppTags.VTEX_APP_NODE_ENV */]: constants_1.NODE_ENV !== null && constants_1.NODE_ENV !== void 0 ? constants_1.NODE_ENV : 'undefined',
+        });
+    }
+    static createJaegerTracer(serviceName, defaultTags) {
+        const config = {
+            reporter: {
+                agentHost: process.env.VTEX_OWN_NODE_IP,
+            },
+            serviceName,
+        };
+        const options = {
+            /**
+             * Jaeger metric names are available in:
+             * https://github.com/jaegertracing/jaeger-client-node/blob/master/src/metrics/metrics.js
+             *
+             * Runtime will prefix these metrics with 'runtime:'
+             */
+            metrics: new jaeger_client_1.PrometheusMetricsFactory(prom_client_1.default, 'runtime'),
+            tags: defaultTags,
+        };
+        return (0, jaeger_client_1.initTracer)(config, options);
+    }
+}
+exports.TracerSingleton = TracerSingleton;

package/lib/service/tracing/metrics/MetricNames.d.ts

@@ -0,0 +1,60 @@
+declare const enum METRIC_TYPES {
+    /** Counter is monotonic */
+    COUNTER = "counter",
+    /** Gauge is a counter that can be increased and decreased */
+    GAUGE = "gauge",
+    /** Histogram creates a counter timeseries for each bucket specified */
+    HISTOGRAM = "histogram"
+}
+export declare const enum RequestsMetricLabels {
+    /** The status code for the HTTP request */
+    STATUS_CODE = "status_code",
+    /** The service.json handler name for the current request (e.g. 'public-handler:render') */
+    REQUEST_HANDLER = "handler"
+}
+export declare const enum EventLoopMetricLabels {
+    PERCENTILE = "percentile"
+}
+export declare const CONCURRENT_REQUESTS: {
+    name: string;
+    help: string;
+    type: METRIC_TYPES;
+};
+export declare const REQUESTS_TOTAL: {
+    name: string;
+    help: string;
+    labelNames: RequestsMetricLabels[];
+    type: METRIC_TYPES;
+};
+export declare const REQUESTS_ABORTED: {
+    name: string;
+    help: string;
+    labelNames: RequestsMetricLabels[];
+    type: METRIC_TYPES;
+};
+export declare const REQUEST_TIMINGS: {
+    name: string;
+    help: string;
+    labelNames: RequestsMetricLabels[];
+    buckets: number[];
+    type: METRIC_TYPES;
+};
+export declare const REQUEST_RESPONSE_SIZES: {
+    name: string;
+    help: string;
+    labelNames: RequestsMetricLabels[];
+    buckets: number[];
+    type: METRIC_TYPES;
+};
+export declare const BETWEEN_SCRAPES_EVENT_LOOP_LAG_MAX: {
+    name: string;
+    help: string;
+    type: METRIC_TYPES;
+};
+export declare const BETWEEN_SCRAPES_EVENT_LOOP_LAG_PERCENTILES: {
+    name: string;
+    help: string;
+    labelNames: EventLoopMetricLabels[];
+    type: METRIC_TYPES;
+};
+export {};

package/lib/service/tracing/metrics/MetricNames.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BETWEEN_SCRAPES_EVENT_LOOP_LAG_PERCENTILES = exports.BETWEEN_SCRAPES_EVENT_LOOP_LAG_MAX = exports.REQUEST_RESPONSE_SIZES = exports.REQUEST_TIMINGS = exports.REQUESTS_ABORTED = exports.REQUESTS_TOTAL = exports.CONCURRENT_REQUESTS = void 0;
+exports.CONCURRENT_REQUESTS = {
+    name: 'io_http_requests_current',
+    help: 'The current number of requests in course.',
+    type: "gauge" /* METRIC_TYPES.GAUGE */,
+};
+exports.REQUESTS_TOTAL = {
+    name: 'runtime_http_requests_total',
+    help: 'The total number of HTTP requests.',
+    labelNames: ["status_code" /* RequestsMetricLabels.STATUS_CODE */, "handler" /* RequestsMetricLabels.REQUEST_HANDLER */],
+    type: "counter" /* METRIC_TYPES.COUNTER */,
+};
+exports.REQUESTS_ABORTED = {
+    name: 'runtime_http_aborted_requests_total',
+    help: 'The total number of HTTP requests aborted.',
+    labelNames: ["handler" /* RequestsMetricLabels.REQUEST_HANDLER */],
+    type: "counter" /* METRIC_TYPES.COUNTER */,
+};
+exports.REQUEST_TIMINGS = {
+    name: 'runtime_http_requests_duration_milliseconds',
+    help: 'The incoming http requests total duration.',
+    labelNames: ["handler" /* RequestsMetricLabels.REQUEST_HANDLER */],
+    buckets: [10, 20, 40, 80, 160, 320, 640, 1280, 2560, 5120],
+    type: "histogram" /* METRIC_TYPES.HISTOGRAM */,
+};
+exports.REQUEST_RESPONSE_SIZES = {
+    name: 'runtime_http_response_size_bytes',
+    help: `The outgoing response sizes (only applicable when the response isn't a stream).`,
+    labelNames: ["handler" /* RequestsMetricLabels.REQUEST_HANDLER */],
+    buckets: [500, 2000, 8000, 16000, 64000, 256000, 1024000, 4096000],
+    type: "histogram" /* METRIC_TYPES.HISTOGRAM */,
+};
+exports.BETWEEN_SCRAPES_EVENT_LOOP_LAG_MAX = {
+    name: 'runtime_event_loop_lag_max_between_scrapes_seconds',
+    help: 'The max event loop lag that occurred between this and the previous scrape',
+    type: "gauge" /* METRIC_TYPES.GAUGE */,
+};
+exports.BETWEEN_SCRAPES_EVENT_LOOP_LAG_PERCENTILES = {
+    name: 'runtime_event_loop_lag_percentiles_between_scrapes_seconds',
+    help: 'Event loop lag percentiles from the observations that occurred between this and the previous scrape',
+    labelNames: ["percentile" /* EventLoopMetricLabels.PERCENTILE */],
+    type: "gauge" /* METRIC_TYPES.GAUGE */,
+};

package/lib/service/tracing/metrics/instruments.d.ts

@@ -0,0 +1,9 @@
+import { Counter, Gauge, Histogram } from 'prom-client';
+export { EventLoopMetricLabels, RequestsMetricLabels } from './MetricNames';
+export declare const createTotalRequestsInstrument: () => Counter<import("./MetricNames").RequestsMetricLabels>;
+export declare const createTotalAbortedRequestsInstrument: () => Counter<import("./MetricNames").RequestsMetricLabels>;
+export declare const createRequestsTimingsInstrument: () => Histogram<import("./MetricNames").RequestsMetricLabels>;
+export declare const createRequestsResponseSizesInstrument: () => Histogram<import("./MetricNames").RequestsMetricLabels>;
+export declare const createConcurrentRequestsInstrument: () => Gauge<string>;
+export declare const createEventLoopLagMaxInstrument: () => Gauge<string>;
+export declare const createEventLoopLagPercentilesInstrument: () => Gauge<import("./MetricNames").EventLoopMetricLabels>;

package/lib/service/tracing/metrics/instruments.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEventLoopLagPercentilesInstrument = exports.createEventLoopLagMaxInstrument = exports.createConcurrentRequestsInstrument = exports.createRequestsResponseSizesInstrument = exports.createRequestsTimingsInstrument = exports.createTotalAbortedRequestsInstrument = exports.createTotalRequestsInstrument = void 0;
+const prom_client_1 = require("prom-client");
+const MetricNames_1 = require("./MetricNames");
+const createTotalRequestsInstrument = () => new prom_client_1.Counter(MetricNames_1.REQUESTS_TOTAL);
+exports.createTotalRequestsInstrument = createTotalRequestsInstrument;
+const createTotalAbortedRequestsInstrument = () => new prom_client_1.Counter(MetricNames_1.REQUESTS_ABORTED);
+exports.createTotalAbortedRequestsInstrument = createTotalAbortedRequestsInstrument;
+const createRequestsTimingsInstrument = () => new prom_client_1.Histogram(MetricNames_1.REQUEST_TIMINGS);
+exports.createRequestsTimingsInstrument = createRequestsTimingsInstrument;
+const createRequestsResponseSizesInstrument = () => new prom_client_1.Histogram(MetricNames_1.REQUEST_RESPONSE_SIZES);
+exports.createRequestsResponseSizesInstrument = createRequestsResponseSizesInstrument;
+const createConcurrentRequestsInstrument = () => new prom_client_1.Gauge(MetricNames_1.CONCURRENT_REQUESTS);
+exports.createConcurrentRequestsInstrument = createConcurrentRequestsInstrument;
+const createEventLoopLagMaxInstrument = () => new prom_client_1.Gauge(MetricNames_1.BETWEEN_SCRAPES_EVENT_LOOP_LAG_MAX);
+exports.createEventLoopLagMaxInstrument = createEventLoopLagMaxInstrument;
+const createEventLoopLagPercentilesInstrument = () => new prom_client_1.Gauge(MetricNames_1.BETWEEN_SCRAPES_EVENT_LOOP_LAG_PERCENTILES);
+exports.createEventLoopLagPercentilesInstrument = createEventLoopLagPercentilesInstrument;

package/lib/service/tracing/metrics/measurers/EventLoopLagMeasurer.d.ts

@@ -0,0 +1,9 @@
+export declare class EventLoopLagMeasurer {
+    private eventLoopDelayMonitor;
+    private percentilesInstrument;
+    private maxInstrument;
+    constructor();
+    start(): void;
+    updateInstrumentsAndReset(): Promise<void>;
+    private setPercentileObservation;
+}

package/lib/service/tracing/metrics/measurers/EventLoopLagMeasurer.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventLoopLagMeasurer = void 0;
+const perf_hooks_1 = require("perf_hooks");
+const utils_1 = require("../../../../utils");
+const instruments_1 = require("../instruments");
+class EventLoopLagMeasurer {
+    constructor() {
+        this.eventLoopDelayMonitor = (0, perf_hooks_1.monitorEventLoopDelay)({ resolution: 10 });
+        this.percentilesInstrument = (0, instruments_1.createEventLoopLagPercentilesInstrument)();
+        this.maxInstrument = (0, instruments_1.createEventLoopLagMaxInstrument)();
+    }
+    start() {
+        this.eventLoopDelayMonitor.enable();
+    }
+    async updateInstrumentsAndReset() {
+        this.maxInstrument.set((0, utils_1.nanosecondsToSeconds)(this.eventLoopDelayMonitor.max));
+        this.setPercentileObservation(95);
+        this.setPercentileObservation(99);
+        this.eventLoopDelayMonitor.reset();
+    }
+    setPercentileObservation(percentile) {
+        this.percentilesInstrument.set({ ["percentile" /* EventLoopMetricLabels.PERCENTILE */]: percentile }, (0, utils_1.nanosecondsToSeconds)(this.eventLoopDelayMonitor.percentile(percentile)));
+    }
+}
+exports.EventLoopLagMeasurer = EventLoopLagMeasurer;

package/lib/service/tracing/tracingMiddlewares.d.ts

@@ -0,0 +1,5 @@
+import { Tracer } from 'opentracing';
+import { ServiceContext } from '../worker/runtime/typings';
+export declare const addTracingMiddleware: (tracer: Tracer) => (ctx: ServiceContext, next: () => Promise<void>) => Promise<void>;
+export declare const nameSpanOperationMiddleware: (operationType: string, operationName: string) => (ctx: ServiceContext, next: () => Promise<void>) => Promise<void>;
+export declare const traceUserLandRemainingPipelineMiddleware: () => (ctx: ServiceContext, next: () => Promise<void>) => Promise<void>;