@vtex/api 6.48.1-beta.3 → 6.49.0

package/lib/service/logger/console.js

@@ -7,23 +7,25 @@ const history = new caches_1.LRUCache({
     max: 42,
 });
 exports.LOG_ONCE = 'logOnce';
-exports.isLog = (message) => (message === null || message === void 0 ? void 0 : message.cmd) === exports.LOG_ONCE;
-exports.log = (message, level) => {
+const isLog = (message) => (message === null || message === void 0 ? void 0 : message.cmd) === exports.LOG_ONCE;
+exports.isLog = isLog;
+const log = (message, level) => {
     const logger = console[level];
     if (typeof logger === 'function') {
         logger(message);
     }
 };
+exports.log = log;
 // Since we are now using clusters, if we simply console.log something,
 // it may overwhelm the programmer's console with lots of repeated info.
 // This function should be used when you want to warn about something
 // only once
-exports.logOnceToDevConsole = (message, level) => {
+const logOnceToDevConsole = (message, level) => {
     const strigified = JSON.stringify(message);
     if (!history.has(strigified)) {
         history.set(strigified, true);
         if (cluster_1.isMaster) {
-            exports.log(message, level);
+            (0, exports.log)(message, level);
         }
         else if (cluster_1.isWorker && process.send) {
             const logMessage = {
@@ -35,3 +37,4 @@ exports.logOnceToDevConsole = (message, level) => {
         }
     }
 };
+exports.logOnceToDevConsole = logOnceToDevConsole;

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

@@ -1,2 +1,4 @@
 export * from './console';
 export * from './logger';
+export * from './loggerTypes';
+export * from './client';

package/lib/service/logger/index.js

@@ -1,14 +1,20 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./console"), exports);
 __exportStar(require("./logger"), exports);
+__exportStar(require("./loggerTypes"), exports);
+__exportStar(require("./client"), exports);

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

@@ -1,17 +1,4 @@
-import { IUserLandTracer } from '../../tracing';
-import { IOContext } from '../worker/runtime/typings';
-export interface LoggerTracingContext {
-    requestTracer: IUserLandTracer;
-}
-export declare enum LogLevel {
-    Debug = "debug",
-    Info = "info",
-    Warn = "warn",
-    Error = "error"
-}
-interface LoggerContext extends Pick<IOContext, 'account' | 'workspace' | 'requestId' | 'operationId' | 'production'> {
-    tracer?: IOContext['tracer'];
-}
+import { LoggerContext, LogLevel } from './loggerTypes';
 export declare class Logger {
     private account;
     private workspace;
@@ -19,11 +6,13 @@ export declare class Logger {
     private requestId;
     private production;
     private tracingState?;
+    private logClient;
+    private clientInitPromise;
     constructor(ctx: LoggerContext);
+    private initLogClient;
     debug: (message: any) => void;
     info: (message: any) => void;
     warn: (warning: any) => void;
     error: (error: any) => void;
     log: (message: any, level: LogLevel) => void;
 }
-export {};

package/lib/service/logger/logger.js

@@ -1,29 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Logger = exports.LogLevel = void 0;
+exports.Logger = void 0;
 const constants_1 = require("../../constants");
 const error_1 = require("../../utils/error");
 const log_1 = require("../../utils/log");
-const linked = !!process.env.VTEX_APP_LINK;
+const loggerTypes_1 = require("./loggerTypes");
+const client_1 = require("./client");
 const app = constants_1.APP.ID;
 const EMPTY_MESSAGE = 'Logger.log was called with null or undefined message';
-var LogLevel;
-(function (LogLevel) {
-    LogLevel["Debug"] = "debug";
-    LogLevel["Info"] = "info";
-    LogLevel["Warn"] = "warn";
-    LogLevel["Error"] = "error";
-})(LogLevel = exports.LogLevel || (exports.LogLevel = {}));
 class Logger {
     constructor(ctx) {
-        this.debug = (message) => this.log(message, LogLevel.Debug);
-        this.info = (message) => this.log(message, LogLevel.Info);
-        this.warn = (warning) => this.log(warning, LogLevel.Warn);
-        this.error = (error) => this.log(error, LogLevel.Error);
+        this.logClient = undefined;
+        this.clientInitPromise = undefined;
+        this.debug = (message) => this.log(message, loggerTypes_1.LogLevel.Debug);
+        this.info = (message) => this.log(message, loggerTypes_1.LogLevel.Info);
+        this.warn = (warning) => this.log(warning, loggerTypes_1.LogLevel.Warn);
+        this.error = (error) => this.log(error, loggerTypes_1.LogLevel.Error);
         this.log = (message, level) => {
             var _a;
-            const data = message ? error_1.cleanError(message) : EMPTY_MESSAGE;
-            log_1.cleanLog(data);
+            const data = message ? (0, error_1.cleanError)(message) : EMPTY_MESSAGE;
+            (0, log_1.cleanLog)(data);
             /* tslint:disable:object-literal-sort-keys */
             const inflatedLog = {
                 __VTEX_IO_LOG: true,
@@ -40,11 +36,35 @@ class Logger {
             // Mark third-party apps logs to send to skidder
             if (constants_1.APP.IS_THIRD_PARTY()) {
                 Object.assign(inflatedLog, {
-                    __SKIDDER_TOPIC_1: `skidder.vendor.${constants_1.APP.VENDOR}`,
-                    __SKIDDER_TOPIC_2: `skidder.app.${constants_1.APP.VENDOR}.${constants_1.APP.NAME}`,
+                    '__SKIDDER_TOPIC_1': `skidder.vendor.${constants_1.APP.VENDOR}`,
+                    '__SKIDDER_TOPIC_2': `skidder.app.${constants_1.APP.VENDOR}.${constants_1.APP.NAME}`,
                 });
             }
-            console.log(JSON.stringify(inflatedLog));
+            if (this.logClient) {
+                try {
+                    let logMessage = typeof data === 'string' ? data : JSON.stringify(data);
+                    switch (level) {
+                        case loggerTypes_1.LogLevel.Debug:
+                            this.logClient.debug(logMessage, inflatedLog);
+                            break;
+                        case loggerTypes_1.LogLevel.Info:
+                            this.logClient.info(logMessage, inflatedLog);
+                            break;
+                        case loggerTypes_1.LogLevel.Warn:
+                            this.logClient.warn(logMessage, inflatedLog);
+                            break;
+                        case loggerTypes_1.LogLevel.Error:
+                            this.logClient.error(logMessage, inflatedLog);
+                            break;
+                        default:
+                            this.logClient.info(logMessage, inflatedLog);
+                    }
+                }
+                catch (e) {
+                    console.error('Error using diagnostics client for logging:', e);
+                }
+            }
+            console.log(typeof inflatedLog === 'string' ? JSON.stringify(inflatedLog) : inflatedLog);
         };
         this.account = ctx.account;
         this.workspace = ctx.workspace;
@@ -57,6 +77,29 @@ class Logger {
                 traceId: ctx.tracer.traceId,
             };
         }
+        // this.initLogClient();
+    }
+    initLogClient() {
+        if (this.clientInitPromise) {
+            return this.clientInitPromise;
+        }
+        this.clientInitPromise = (async () => {
+            try {
+                const timeoutPromise = new Promise((_, reject) => {
+                    setTimeout(() => reject(new Error('Log client initialization timeout')), constants_1.LOG_CLIENT_INIT_TIMEOUT_MS);
+                });
+                this.logClient = await Promise.race([
+                    (0, client_1.getLogClient)(this.account, this.workspace, constants_1.APP.NAME),
+                    timeoutPromise
+                ]);
+                return this.logClient;
+            }
+            catch (error) {
+                console.error('Failed to initialize log client:', error);
+                return undefined;
+            }
+        })();
+        return this.clientInitPromise;
     }
 }
 exports.Logger = Logger;

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

@@ -0,0 +1,14 @@
+import { IOContext } from '../worker/runtime/typings';
+export interface LoggerContext extends Pick<IOContext, 'account' | 'workspace' | 'requestId' | 'operationId' | 'production'> {
+    tracer?: IOContext['tracer'];
+}
+export interface TracingState {
+    isTraceSampled: boolean;
+    traceId?: string;
+}
+export declare enum LogLevel {
+    Debug = "debug",
+    Info = "info",
+    Warn = "warn",
+    Error = "error"
+}

package/lib/service/logger/loggerTypes.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevel = void 0;
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["Debug"] = "debug";
+    LogLevel["Info"] = "info";
+    LogLevel["Warn"] = "warn";
+    LogLevel["Error"] = "error";
+})(LogLevel = exports.LogLevel || (exports.LogLevel = {}));

package/lib/service/logger/metricsLogger.js

@@ -21,11 +21,11 @@ class MetricsLogger {
         // private attributes
         //////////////////////
         let samples = {};
-        let lastCpu = diff_1.cpuSnapshot();
+        let lastCpu = (0, diff_1.cpuSnapshot)();
         //////////////////////
         // private methods definitions
         //////////////////////
-        const summaries = ramda_1.compose(ramda_1.reject(ramda_1.isNil), ramda_1.values, ramda_1.mapObjIndexed(getSummary));
+        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,
@@ -47,8 +47,8 @@ class MetricsLogger {
             };
         }
         function getCpuUsage() {
-            const cpu = diff_1.cpuSnapshot();
-            const cpuDiff = diff_1.snapshotDiff(cpu, lastCpu);
+            const cpu = (0, diff_1.cpuSnapshot)();
+            const cpuDiff = (0, diff_1.snapshotDiff)(cpu, lastCpu);
             lastCpu = cpu;
             const metric = {
                 Data: {
@@ -103,7 +103,7 @@ class MetricsLogger {
                 return false;
             }
             try {
-                fast_json_stable_stringify_1.default(key);
+                (0, fast_json_stable_stringify_1.default)(key);
             }
             catch {
                 return false;
@@ -111,17 +111,17 @@ class MetricsLogger {
             return true;
         }
         function getStrKey(key) {
-            return fast_json_stable_stringify_1.default(key);
+            return (0, fast_json_stable_stringify_1.default)(key);
         }
         function getNumericSummary(vals) {
             return {
                 count: vals.length,
                 max: Math.max(...vals),
-                median: stats_lite_1.median(vals),
+                median: (0, stats_lite_1.median)(vals),
                 min: Math.min(...vals),
-                percentile95: stats_lite_1.percentile(vals, 0.95),
-                percentile99: stats_lite_1.percentile(vals, 0.99),
-                sum: stats_lite_1.sum(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),
             };
         }
         //////////////////////

package/lib/service/master.js

@@ -12,12 +12,12 @@ const listeners_1 = require("./worker/listeners");
 const statusTrack_1 = require("./worker/runtime/statusTrack");
 let handledSignal;
 const onMessage = (worker, message) => {
-    if (logger_1.isLog(message)) {
-        logger_1.logOnceToDevConsole(message.message, message.level);
+    if ((0, logger_1.isLog)(message)) {
+        (0, logger_1.logOnceToDevConsole)(message.message, message.level);
     }
-    else if (statusTrack_1.isStatusTrackBroadcast(message)) {
-        statusTrack_1.trackStatus();
-        statusTrack_1.broadcastStatusTrack();
+    else if ((0, statusTrack_1.isStatusTrackBroadcast)(message)) {
+        (0, statusTrack_1.trackStatus)();
+        (0, statusTrack_1.broadcastStatusTrack)();
     }
     else {
         listeners_1.logger.warn({
@@ -65,7 +65,7 @@ const handleSignal = (timeout) => (signal) => {
         process.exit(os_1.constants.signals[signal]);
     }, waitTimeToForceKill);
 };
-exports.startMaster = (service) => {
+const startMaster = (service) => {
     const { workers: numWorkers, timeout = GRACEFULLY_SHUTDOWN_TIMEOUT_S } = service;
     if (service.deterministicVary) {
         process.env.DETERMINISTIC_VARY = 'true';
@@ -86,3 +86,4 @@ exports.startMaster = (service) => {
     process.on('SIGINT', handleSignal(SIGINT_TIMEOUT_S));
     process.on('SIGTERM', handleSignal(shutdownTimeout));
 };
+exports.startMaster = startMaster;

package/lib/service/metrics/requestMetricsMiddleware.js

@@ -4,16 +4,16 @@ exports.addRequestMetricsMiddleware = void 0;
 const stream_1 = require("stream");
 const utils_1 = require("../../utils");
 const instruments_1 = require("../tracing/metrics/instruments");
-exports.addRequestMetricsMiddleware = () => {
-    const concurrentRequests = instruments_1.createConcurrentRequestsInstrument();
-    const requestTimings = instruments_1.createRequestsTimingsInstrument();
-    const totalRequests = instruments_1.createTotalRequestsInstrument();
-    const responseSizes = instruments_1.createRequestsResponseSizesInstrument();
-    const abortedRequests = instruments_1.createTotalAbortedRequestsInstrument();
+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" /* REQUEST_HANDLER */]: ctx.requestHandlerName }, 1));
+        ctx.req.once('aborted', () => abortedRequests.inc({ ["handler" /* RequestsMetricLabels.REQUEST_HANDLER */]: ctx.requestHandlerName }, 1));
         let responseClosed = false;
         ctx.res.once('close', () => (responseClosed = true));
         try {
@@ -22,24 +22,25 @@ exports.addRequestMetricsMiddleware = () => {
         finally {
             const responseLength = ctx.response.length;
             if (responseLength) {
-                responseSizes.observe({ ["handler" /* REQUEST_HANDLER */]: ctx.requestHandlerName }, responseLength);
+                responseSizes.observe({ ["handler" /* RequestsMetricLabels.REQUEST_HANDLER */]: ctx.requestHandlerName }, responseLength);
             }
             totalRequests.inc({
-                ["handler" /* REQUEST_HANDLER */]: ctx.requestHandlerName,
-                ["status_code" /* STATUS_CODE */]: ctx.response.status,
+                ["handler" /* RequestsMetricLabels.REQUEST_HANDLER */]: ctx.requestHandlerName,
+                ["status_code" /* RequestsMetricLabels.STATUS_CODE */]: ctx.response.status,
             }, 1);
             const onResFinished = () => {
                 requestTimings.observe({
-                    ["handler" /* REQUEST_HANDLER */]: ctx.requestHandlerName,
-                }, utils_1.hrToMillisFloat(process.hrtime(start)));
+                    ["handler" /* RequestsMetricLabels.REQUEST_HANDLER */]: ctx.requestHandlerName,
+                }, (0, utils_1.hrToMillisFloat)(process.hrtime(start)));
                 concurrentRequests.dec(1);
             };
             if (responseClosed) {
                 onResFinished();
             }
             else {
-                stream_1.finished(ctx.res, onResFinished);
+                (0, stream_1.finished)(ctx.res, onResFinished);
             }
         }
     };
 };
+exports.addRequestMetricsMiddleware = addRequestMetricsMiddleware;

package/lib/service/telemetry/client.d.ts

@@ -0,0 +1,3 @@
+import { TelemetryClient } from '@vtex/diagnostics-nodejs/dist/telemetry';
+export declare function getTelemetryClient(): Promise<TelemetryClient>;
+export declare function resetTelemetryClient(): void;

package/lib/service/telemetry/client.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetTelemetryClient = exports.getTelemetryClient = void 0;
+const diagnostics_nodejs_1 = require("@vtex/diagnostics-nodejs");
+const constants_1 = require("../../constants");
+class TelemetryClientSingleton {
+    constructor() {
+        this.initializationPromise = undefined;
+    }
+    static getInstance() {
+        if (!TelemetryClientSingleton.instance) {
+            TelemetryClientSingleton.instance = new TelemetryClientSingleton();
+        }
+        return TelemetryClientSingleton.instance;
+    }
+    async initTelemetryClient() {
+        try {
+            const telemetryClient = await (0, diagnostics_nodejs_1.NewTelemetryClient)('node-vtex-api', constants_1.APP.ID || 'vtex-app', {
+                additionalAttrs: {
+                    'version': constants_1.APP.VERSION || '',
+                    'environment': process.env.VTEX_WORKSPACE || 'development',
+                },
+            });
+            this.telemetryClient = telemetryClient;
+            return telemetryClient;
+        }
+        catch (error) {
+            console.error('Failed to initialize telemetry client:', error);
+            throw error;
+        }
+        finally {
+            this.initializationPromise = undefined;
+        }
+    }
+    async getClient() {
+        if (this.telemetryClient) {
+            return this.telemetryClient;
+        }
+        if (this.initializationPromise) {
+            return this.initializationPromise;
+        }
+        this.initializationPromise = this.initTelemetryClient();
+        return this.initializationPromise;
+    }
+    reset() {
+        this.telemetryClient = undefined;
+        this.initializationPromise = undefined;
+    }
+}
+async function getTelemetryClient() {
+    return TelemetryClientSingleton.getInstance().getClient();
+}
+exports.getTelemetryClient = getTelemetryClient;
+function resetTelemetryClient() {
+    TelemetryClientSingleton.getInstance().reset();
+}
+exports.resetTelemetryClient = resetTelemetryClient;

package/lib/service/telemetry/index.d.ts

@@ -0,0 +1 @@
+export * from './client';

package/lib/service/telemetry/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client"), exports);

package/lib/service/tracing/TracerSingleton.js

@@ -16,14 +16,14 @@ class TracerSingleton {
         return TracerSingleton.singleton;
     }
     static initServiceTracer() {
-        return TracerSingleton.createJaegerTracer(utils_1.appIdToAppAtMajor(constants_1.APP.ID), {
-            ["app.linked" /* VTEX_APP_LINKED */]: constants_1.LINKED,
-            ["app.node_vtex_api_version" /* VTEX_APP_NODE_VTEX_API_VERSION */]: constants_1.NODE_VTEX_API_VERSION,
-            ["app.production" /* VTEX_APP_PRODUCTION */]: constants_1.PRODUCTION,
-            ["app.region" /* VTEX_APP_REGION */]: constants_1.REGION,
-            ["app.version" /* VTEX_APP_VERSION */]: constants_1.APP.VERSION,
-            ["app.workspace" /* VTEX_APP_WORKSPACE */]: constants_1.WORKSPACE,
-            ["app.node_env" /* VTEX_APP_NODE_ENV */]: constants_1.NODE_ENV !== null && constants_1.NODE_ENV !== void 0 ? constants_1.NODE_ENV : 'undefined',
+        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) {
@@ -43,7 +43,7 @@ class TracerSingleton {
             metrics: new jaeger_client_1.PrometheusMetricsFactory(prom_client_1.default, 'runtime'),
             tags: defaultTags,
         };
-        return jaeger_client_1.initTracer(config, options);
+        return (0, jaeger_client_1.initTracer)(config, options);
     }
 }
 exports.TracerSingleton = TracerSingleton;

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

@@ -4,42 +4,42 @@ exports.BETWEEN_SCRAPES_EVENT_LOOP_LAG_PERCENTILES = exports.BETWEEN_SCRAPES_EVE
 exports.CONCURRENT_REQUESTS = {
     name: 'io_http_requests_current',
     help: 'The current number of requests in course.',
-    type: "gauge" /* GAUGE */,
+    type: "gauge" /* METRIC_TYPES.GAUGE */,
 };
 exports.REQUESTS_TOTAL = {
     name: 'runtime_http_requests_total',
     help: 'The total number of HTTP requests.',
-    labelNames: ["status_code" /* STATUS_CODE */, "handler" /* REQUEST_HANDLER */],
-    type: "counter" /* COUNTER */,
+    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" /* REQUEST_HANDLER */],
-    type: "counter" /* COUNTER */,
+    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" /* REQUEST_HANDLER */],
+    labelNames: ["handler" /* RequestsMetricLabels.REQUEST_HANDLER */],
     buckets: [10, 20, 40, 80, 160, 320, 640, 1280, 2560, 5120],
-    type: "histogram" /* HISTOGRAM */,
+    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" /* REQUEST_HANDLER */],
+    labelNames: ["handler" /* RequestsMetricLabels.REQUEST_HANDLER */],
     buckets: [500, 2000, 8000, 16000, 64000, 256000, 1024000, 4096000],
-    type: "histogram" /* HISTOGRAM */,
+    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" /* GAUGE */,
+    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" /* PERCENTILE */],
-    type: "gauge" /* GAUGE */,
+    labelNames: ["percentile" /* EventLoopMetricLabels.PERCENTILE */],
+    type: "gauge" /* METRIC_TYPES.GAUGE */,
 };

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

@@ -3,10 +3,17 @@ 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");
-exports.createTotalRequestsInstrument = () => new prom_client_1.Counter(MetricNames_1.REQUESTS_TOTAL);
-exports.createTotalAbortedRequestsInstrument = () => new prom_client_1.Counter(MetricNames_1.REQUESTS_ABORTED);
-exports.createRequestsTimingsInstrument = () => new prom_client_1.Histogram(MetricNames_1.REQUEST_TIMINGS);
-exports.createRequestsResponseSizesInstrument = () => new prom_client_1.Histogram(MetricNames_1.REQUEST_RESPONSE_SIZES);
-exports.createConcurrentRequestsInstrument = () => new prom_client_1.Gauge(MetricNames_1.CONCURRENT_REQUESTS);
-exports.createEventLoopLagMaxInstrument = () => new prom_client_1.Gauge(MetricNames_1.BETWEEN_SCRAPES_EVENT_LOOP_LAG_MAX);
-exports.createEventLoopLagPercentilesInstrument = () => new prom_client_1.Gauge(MetricNames_1.BETWEEN_SCRAPES_EVENT_LOOP_LAG_PERCENTILES);
+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.js

@@ -6,21 +6,21 @@ const utils_1 = require("../../../../utils");
 const instruments_1 = require("../instruments");
 class EventLoopLagMeasurer {
     constructor() {
-        this.eventLoopDelayMonitor = perf_hooks_1.monitorEventLoopDelay({ resolution: 10 });
-        this.percentilesInstrument = instruments_1.createEventLoopLagPercentilesInstrument();
-        this.maxInstrument = instruments_1.createEventLoopLagMaxInstrument();
+        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(utils_1.nanosecondsToSeconds(this.eventLoopDelayMonitor.max));
+        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" /* PERCENTILE */]: percentile }, utils_1.nanosecondsToSeconds(this.eventLoopDelayMonitor.percentile(percentile)));
+        this.percentilesInstrument.set({ ["percentile" /* EventLoopMetricLabels.PERCENTILE */]: percentile }, (0, utils_1.nanosecondsToSeconds)(this.eventLoopDelayMonitor.percentile(percentile)));
     }
 }
 exports.EventLoopLagMeasurer = EventLoopLagMeasurer;