@vtex/api 7.2.4 → 7.2.5

package/lib/HttpClient/middlewares/metrics.js

@@ -14,6 +14,7 @@ const metricsMiddleware = ({ metrics, serverTiming, name }) => {
         target: name || 'unknown',
     }));
     return async (ctx, next) => {
+        var _a;
         const start = process.hrtime();
         let status = 'unknown';
         let errorCode;
@@ -57,29 +58,70 @@ const metricsMiddleware = ({ metrics, serverTiming, name }) => {
                 const label = `http-client-${ctx.config.metric}`;
                 const extensions = {};
                 Object.assign(extensions, { [status]: 1 });
+                // Determine cache state for diagnostics metrics
+                let cacheState = 'none';
                 if (ctx.cacheHit) {
                     Object.assign(extensions, ctx.cacheHit, { [`${status}-hit`]: 1 });
+                    cacheState = 'hit';
                 }
                 else if (!ctx.inflightHit && !ctx.memoizedHit) {
                     // Lets us know how many calls passed through to origin
                     Object.assign(extensions, { [`${status}-miss`]: 1 });
+                    cacheState = 'miss';
                 }
                 if (ctx.inflightHit) {
                     Object.assign(extensions, { [`${status}-inflight`]: 1 });
+                    cacheState = 'inflight';
                 }
                 if (ctx.memoizedHit) {
                     Object.assign(extensions, { [`${status}-memoized`]: 1 });
+                    cacheState = 'memoized';
                 }
-                if (ctx.config.retryCount) {
-                    const retryCount = ctx.config.retryCount;
-                    if (retryCount > 0) {
-                        extensions[`retry-${status}-${retryCount}`] = 1;
-                    }
+                const retryCount = ctx.config.retryCount || 0;
+                if (retryCount > 0) {
+                    extensions[`retry-${status}-${retryCount}`] = 1;
                 }
                 const end = status === 'success' && !ctx.cacheHit && !ctx.inflightHit && !ctx.memoizedHit
                     ? process.hrtime(start)
                     : undefined;
+                // Legacy metrics (backward compatibility)
                 metrics.batch(label, end, extensions);
+                // New diagnostics metrics with stable names and attributes
+                if (global.diagnosticsMetrics) {
+                    const elapsed = process.hrtime(start);
+                    const rawStatusCode = ((_a = ctx.response) === null || _a === void 0 ? void 0 : _a.status) || errorStatus;
+                    const baseAttributes = {
+                        component: 'http-client',
+                        client_metric: ctx.config.metric,
+                        status_code: rawStatusCode,
+                        status,
+                    };
+                    // Record latency histogram with all context
+                    global.diagnosticsMetrics.recordLatency(elapsed, {
+                        ...baseAttributes,
+                        cache_state: cacheState,
+                    });
+                    // Increment counters for different event types (replaces extensions behavior)
+                    // Main request counter with status as attribute
+                    global.diagnosticsMetrics.incrementCounter('http_client_requests_total', 1, baseAttributes);
+                    // Cache counter with cache_state as attribute (replaces extensions like 'success-hit', 'error-miss')
+                    if (cacheState !== 'none') {
+                        global.diagnosticsMetrics.incrementCounter('http_client_cache_total', 1, {
+                            ...baseAttributes,
+                            cache_state: cacheState,
+                        });
+                    }
+                    // Retry counter (replaces 'retry-{status}-{count}' extensions)
+                    if (retryCount > 0) {
+                        global.diagnosticsMetrics.incrementCounter('http_client_requests_retried_total', 1, {
+                            ...baseAttributes,
+                            retry_count: retryCount,
+                        });
+                    }
+                }
+                else {
+                    console.warn('DiagnosticsMetrics not available. HTTP client metrics not reported.');
+                }
                 if (ctx.config.verbose) {
                     console.log(`VERBOSE: ${name}.${ctx.config.label}`, {
                         ...extensions,

package/lib/HttpClient/middlewares/request/HttpAgentSingleton.d.ts

@@ -6,6 +6,11 @@ export declare class HttpAgentSingleton {
         pendingRequests: number;
         sockets: number;
     };
+    /**
+     * Update HTTP agent statistics as diagnostics metrics (gauges).
+     * This method should be called periodically to export current HTTP agent state.
+     */
+    static updateHttpAgentMetrics(): void;
     private static httpAgent;
     private static count;
 }

package/lib/HttpClient/middlewares/request/HttpAgentSingleton.js

@@ -19,6 +19,21 @@ class HttpAgentSingleton {
             sockets,
         };
     }
+    /**
+     * Update HTTP agent statistics as diagnostics metrics (gauges).
+     * This method should be called periodically to export current HTTP agent state.
+     */
+    static updateHttpAgentMetrics() {
+        if (!global.diagnosticsMetrics) {
+            console.warn('DiagnosticsMetrics not available. HTTP agent metrics not reported.');
+            return;
+        }
+        const stats = HttpAgentSingleton.httpAgentStats();
+        // Report HTTP agent stats as gauges (current state)
+        global.diagnosticsMetrics.setGauge('http_agent_sockets_current', stats.sockets, {});
+        global.diagnosticsMetrics.setGauge('http_agent_free_sockets_current', stats.freeSockets, {});
+        global.diagnosticsMetrics.setGauge('http_agent_pending_requests_current', stats.pendingRequests, {});
+    }
     static count(obj) {
         try {
             return Object.values(obj).reduce((acc, val) => acc += val.length, 0);

package/lib/constants.d.ts

@@ -130,6 +130,7 @@ export declare const PRODUCTION: boolean;
 export declare const INSPECT_DEBUGGER_PORT = 5858;
 export declare const cancellableMethods: Set<string>;
 export declare const LOG_CLIENT_INIT_TIMEOUT_MS = 5000;
+export declare const METRIC_CLIENT_INIT_TIMEOUT_MS = 5000;
 export declare const OTEL_EXPORTER_OTLP_ENDPOINT: string;
 export declare const DK_APP_ID: string;
 export declare const DIAGNOSTICS_TELEMETRY_ENABLED: boolean;

package/lib/constants.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LOG_CLIENT_INIT_TIMEOUT_MS = exports.cancellableMethods = exports.INSPECT_DEBUGGER_PORT = exports.PRODUCTION = exports.WORKSPACE = exports.ACCOUNT = exports.NODE_ENV = exports.APP = exports.PUBLIC_ENDPOINT = exports.REGION = exports.LINKED = exports.MAX_WORKERS = exports.HTTP_SERVER_PORT = exports.MAX_AGE = exports.UP_SIGNAL = exports.BODY_HASH = exports.PROVIDER_HEADER = exports.TRACE_ID_HEADER = exports.COLOSSUS_PARAMS_HEADER = exports.COLOSSUS_ROUTE_ID_HEADER = exports.COLOSSUS_ROUTE_DECLARER_HEADER = exports.EVENT_HANDLER_ID_HEADER = exports.EVENT_SUBJECT_HEADER = exports.EVENT_SENDER_HEADER = exports.EVENT_KEY_HEADER = exports.WORKSPACE_HEADER = exports.WORKSPACE_IS_PRODUCTION_HEADER = exports.PLATFORM_HEADER = exports.OPERATION_ID_HEADER = exports.ROUTER_CACHE_HEADER = exports.REQUEST_ID_HEADER = exports.CREDENTIAL_HEADER = exports.ACCOUNT_HEADER = exports.ETAG_HEADER = exports.META_HEADER_BUCKET = exports.META_HEADER = exports.BINDING_HEADER = exports.TENANT_HEADER = exports.FORWARDED_HOST_HEADER = exports.LOCALE_HEADER = exports.PRODUCT_HEADER = exports.SESSION_HEADER = exports.SEGMENT_HEADER = exports.CACHE_CONTROL_HEADER = exports.AttributeKeys = exports.HeaderKeys = exports.PID = exports.IS_IO = exports.DEFAULT_WORKSPACE = exports.NODE_VTEX_API_VERSION = void 0;
-exports.DIAGNOSTICS_TELEMETRY_ENABLED = exports.DK_APP_ID = exports.OTEL_EXPORTER_OTLP_ENDPOINT = void 0;
+exports.DIAGNOSTICS_TELEMETRY_ENABLED = exports.DK_APP_ID = exports.OTEL_EXPORTER_OTLP_ENDPOINT = exports.METRIC_CLIENT_INIT_TIMEOUT_MS = void 0;
 const app_1 = require("./utils/app");
 const diagnostics_semconv_1 = require("@vtex/diagnostics-semconv");
 // tslint:disable-next-line
@@ -141,6 +141,7 @@ exports.PRODUCTION = process.env.VTEX_PRODUCTION === 'true';
 exports.INSPECT_DEBUGGER_PORT = 5858;
 exports.cancellableMethods = new Set(['GET', 'OPTIONS', 'HEAD']);
 exports.LOG_CLIENT_INIT_TIMEOUT_MS = 5000;
+exports.METRIC_CLIENT_INIT_TIMEOUT_MS = 5000;
 exports.OTEL_EXPORTER_OTLP_ENDPOINT = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
 exports.DK_APP_ID = process.env.NODE_VTEX_API_DK_APP_ID || "apps-team";
 exports.DIAGNOSTICS_TELEMETRY_ENABLED = process.env.VTEX_DIAGNOSTICS_TELEMETRY_ENABLED === 'true';

package/lib/index.d.ts

@@ -3,6 +3,7 @@ export * from './clients';
 export * from './errors';
 export * from './HttpClient';
 export * from './metrics/MetricsAccumulator';
+export * from './metrics/DiagnosticsMetrics';
 export * from './responses';
 export * from './service/worker/runtime/Service';
 export * from './service/worker/runtime/method';

package/lib/index.js

@@ -20,6 +20,7 @@ __exportStar(require("./clients"), exports);
 __exportStar(require("./errors"), exports);
 __exportStar(require("./HttpClient"), exports);
 __exportStar(require("./metrics/MetricsAccumulator"), exports);
+__exportStar(require("./metrics/DiagnosticsMetrics"), exports);
 __exportStar(require("./responses"), exports);
 __exportStar(require("./service/worker/runtime/Service"), exports);
 __exportStar(require("./service/worker/runtime/method"), exports);

package/lib/metrics/DiagnosticsMetrics.d.ts

@@ -0,0 +1,94 @@
+import { Attributes } from '@opentelemetry/api';
+/**
+ * DiagnosticsMetrics provides a high-level API for recording metrics using
+ * the @vtex/diagnostics-nodejs library. It completely abstracts instrument
+ * management, bucket configuration, and lifecycle.
+ *
+ * Uses a single histogram for all latency measurements with attributes to differentiate.
+ * This follows OpenTelemetry best practices and reduces metric cardinality.
+ *
+ * @example
+ * ```typescript
+ * const diagnosticsMetrics = new DiagnosticsMetrics()
+ * diagnosticsMetrics.initMetricClient()
+ *
+ * // Record latency with operation type in attributes
+ * const start = process.hrtime()
+ * // ... do work ...
+ * diagnosticsMetrics.recordLatency(process.hrtime(start), { operation: 'api-call', status: '2xx' })
+ *
+ * // Or from milliseconds
+ * diagnosticsMetrics.recordLatency(42.5, { operation: 'db-query', status: 'success' })
+ *
+ * // Increment a counter
+ * diagnosticsMetrics.incrementCounter('http_requests_total', 1, { method: 'GET', status: '2xx' })
+ *
+ * // Set a gauge value
+ * diagnosticsMetrics.setGauge('cache_items_current', 1024, { cache: 'pages' })
+ * ```
+ */
+export declare class DiagnosticsMetrics {
+    private metricsClient;
+    private clientInitPromise;
+    private latencyHistogram;
+    private counters;
+    private gauges;
+    constructor();
+    /**
+     * Initialize the metrics client with timeout handling.
+     * Called automatically in constructor.
+     */
+    private initMetricClient;
+    /**
+     * Create the single shared histogram for all latency measurements.
+     * Called after metric client is initialized.
+     */
+    private createLatencyHistogram;
+    /**
+     * Record a latency measurement using the single shared histogram.
+     * Accepts either an hrtime tuple from process.hrtime() or milliseconds as a number.
+     * Use attributes to differentiate between different operations.
+     *
+     * @param value Either [seconds, nanoseconds] from process.hrtime() or milliseconds
+     * @param attributes Attributes including 'operation' to identify the operation type (max of MAX_ATTRIBUTES attributes)
+     *
+     * @example
+     * ```typescript
+     * const start = process.hrtime()
+     * // ... do work ...
+     * diagnosticsMetrics.recordLatency(process.hrtime(start), { operation: 'api-call', status: '2xx' })
+     *
+     * // Or with milliseconds
+     * diagnosticsMetrics.recordLatency(42.5, { operation: 'db-query', status: 'success' })
+     * ```
+     */
+    recordLatency(value: [number, number] | number, attributes?: Attributes): void;
+    /**
+     * Increment a counter by a specific value.
+     * Multiple counters are stored by name since counters represent different types of events.
+     *
+     * @param name Counter name (e.g., 'http_requests_total', 'cache_hits_total')
+     * @param value Amount to increment by (typically 1)
+     * @param attributes Optional attributes for the counter (max of MAX_ATTRIBUTES attributes, e.g., { method: 'GET', status: '2xx' })
+     *
+     * @example
+     * ```typescript
+     * diagnosticsMetrics.incrementCounter('http_requests_total', 1, { method: 'GET', status: '2xx' })
+     * ```
+     */
+    incrementCounter(name: string, value: number, attributes?: Attributes): void;
+    /**
+     * Set a gauge to a specific value (current state).
+     * Multiple gauges are stored by name since gauges represent different types of measurements.
+     *
+     * @param name Gauge name (e.g., 'cache_items_current', 'memory_usage_bytes')
+     * @param value Current value
+     * @param attributes Optional attributes for the gauge (max of MAX_ATTRIBUTES attributes, e.g., { cache: 'pages' })
+     *
+     * @example
+     * ```typescript
+     * diagnosticsMetrics.setGauge('cache_items_current', 1024, { cache: 'pages' })
+     * ```
+     */
+    setGauge(name: string, value: number, attributes?: Attributes): void;
+}

package/lib/metrics/DiagnosticsMetrics.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiagnosticsMetrics = void 0;
+const client_1 = require("../service/metrics/client");
+const constants_1 = require("../constants");
+/**
+ * Maximum number of attributes allowed per metric to control cardinality.
+ * This limit applies to external usage (VTEX IO Apps) to prevent unbounded metric dimensions.
+ */
+const MAX_ATTRIBUTES = 5;
+/**
+ * Converts an hrtime tuple [seconds, nanoseconds] to milliseconds.
+ */
+function hrtimeToMillis(hrtime) {
+    return (hrtime[0] * 1e3) + (hrtime[1] / 1e6);
+}
+/**
+ * Limits the number of attributes to prevent high cardinality.
+ * Takes the first MAX_ATTRIBUTES entries if the limit is exceeded.
+ *
+ * @param attributes Optional attributes object
+ * @returns Limited attributes object or undefined
+ */
+function limitAttributes(attributes) {
+    if (!attributes) {
+        return undefined;
+    }
+    const entries = Object.entries(attributes);
+    if (entries.length <= MAX_ATTRIBUTES) {
+        return attributes;
+    }
+    if (constants_1.LINKED) {
+        console.warn(`Attribute limit exceeded: ${entries.length} attributes provided, using only the first ${MAX_ATTRIBUTES}. ` +
+            `Consider reducing the number of attributes to avoid high cardinality.`);
+    }
+    return Object.fromEntries(entries.slice(0, MAX_ATTRIBUTES));
+}
+/**
+ * DiagnosticsMetrics provides a high-level API for recording metrics using
+ * the @vtex/diagnostics-nodejs library. It completely abstracts instrument
+ * management, bucket configuration, and lifecycle.
+ *
+ * Uses a single histogram for all latency measurements with attributes to differentiate.
+ * This follows OpenTelemetry best practices and reduces metric cardinality.
+ *
+ * @example
+ * ```typescript
+ * const diagnosticsMetrics = new DiagnosticsMetrics()
+ * diagnosticsMetrics.initMetricClient()
+ *
+ * // Record latency with operation type in attributes
+ * const start = process.hrtime()
+ * // ... do work ...
+ * diagnosticsMetrics.recordLatency(process.hrtime(start), { operation: 'api-call', status: '2xx' })
+ *
+ * // Or from milliseconds
+ * diagnosticsMetrics.recordLatency(42.5, { operation: 'db-query', status: 'success' })
+ *
+ * // Increment a counter
+ * diagnosticsMetrics.incrementCounter('http_requests_total', 1, { method: 'GET', status: '2xx' })
+ *
+ * // Set a gauge value
+ * diagnosticsMetrics.setGauge('cache_items_current', 1024, { cache: 'pages' })
+ * ```
+ */
+class DiagnosticsMetrics {
+    constructor() {
+        this.counters = new Map();
+        this.gauges = new Map();
+        this.initMetricClient();
+    }
+    /**
+     * Initialize the metrics client with timeout handling.
+     * Called automatically in constructor.
+     */
+    initMetricClient() {
+        if (this.clientInitPromise) {
+            return this.clientInitPromise;
+        }
+        this.clientInitPromise = (async () => {
+            try {
+                const timeoutPromise = new Promise((_, reject) => {
+                    setTimeout(() => reject(new Error('Metric client initialization timeout')), constants_1.METRIC_CLIENT_INIT_TIMEOUT_MS);
+                });
+                this.metricsClient = await Promise.race([
+                    (0, client_1.getMetricClient)(),
+                    timeoutPromise
+                ]);
+                // Create the single latency histogram after client is ready
+                this.createLatencyHistogram();
+                return this.metricsClient;
+            }
+            catch (error) {
+                console.error('Failed to initialize metric client:', error);
+                return undefined;
+            }
+        })();
+        return this.clientInitPromise;
+    }
+    /**
+     * Create the single shared histogram for all latency measurements.
+     * Called after metric client is initialized.
+     */
+    createLatencyHistogram() {
+        if (!this.metricsClient) {
+            return;
+        }
+        this.latencyHistogram = this.metricsClient.createHistogram('io_app_operation_duration_milliseconds', {
+            description: 'Duration of VTEX IO app operations in milliseconds',
+            unit: 'ms',
+        });
+    }
+    /**
+     * Record a latency measurement using the single shared histogram.
+     * Accepts either an hrtime tuple from process.hrtime() or milliseconds as a number.
+     * Use attributes to differentiate between different operations.
+     *
+     * @param value Either [seconds, nanoseconds] from process.hrtime() or milliseconds
+     * @param attributes Attributes including 'operation' to identify the operation type (max of MAX_ATTRIBUTES attributes)
+     *
+     * @example
+     * ```typescript
+     * const start = process.hrtime()
+     * // ... do work ...
+     * diagnosticsMetrics.recordLatency(process.hrtime(start), { operation: 'api-call', status: '2xx' })
+     *
+     * // Or with milliseconds
+     * diagnosticsMetrics.recordLatency(42.5, { operation: 'db-query', status: 'success' })
+     * ```
+     */
+    recordLatency(value, attributes) {
+        if (!this.latencyHistogram) {
+            console.warn('DiagnosticsMetrics not initialized. Call initialize() first.');
+            return;
+        }
+        // Convert hrtime to milliseconds if needed
+        const milliseconds = Array.isArray(value) ? hrtimeToMillis(value) : value;
+        // Limit attributes to prevent high cardinality
+        const limitedAttributes = limitAttributes(attributes);
+        // Record to the single shared histogram with attributes
+        this.latencyHistogram.record(milliseconds, limitedAttributes);
+    }
+    /**
+     * Increment a counter by a specific value.
+     * Multiple counters are stored by name since counters represent different types of events.
+     *
+     * @param name Counter name (e.g., 'http_requests_total', 'cache_hits_total')
+     * @param value Amount to increment by (typically 1)
+     * @param attributes Optional attributes for the counter (max of MAX_ATTRIBUTES attributes, e.g., { method: 'GET', status: '2xx' })
+     *
+     * @example
+     * ```typescript
+     * diagnosticsMetrics.incrementCounter('http_requests_total', 1, { method: 'GET', status: '2xx' })
+     * ```
+     */
+    incrementCounter(name, value, attributes) {
+        if (!this.metricsClient) {
+            console.warn('DiagnosticsMetrics not initialized. Call initialize() first.');
+            return;
+        }
+        // Get or create counter instrument
+        if (!this.counters.has(name)) {
+            const counter = this.metricsClient.createCounter(name, {
+                description: `Counter for ${name}`,
+                unit: '1',
+            });
+            this.counters.set(name, counter);
+        }
+        // Limit attributes to prevent high cardinality
+        const limitedAttributes = limitAttributes(attributes);
+        // Increment the counter
+        this.counters.get(name).add(value, limitedAttributes);
+    }
+    /**
+     * Set a gauge to a specific value (current state).
+     * Multiple gauges are stored by name since gauges represent different types of measurements.
+     *
+     * @param name Gauge name (e.g., 'cache_items_current', 'memory_usage_bytes')
+     * @param value Current value
+     * @param attributes Optional attributes for the gauge (max of MAX_ATTRIBUTES attributes, e.g., { cache: 'pages' })
+     *
+     * @example
+     * ```typescript
+     * diagnosticsMetrics.setGauge('cache_items_current', 1024, { cache: 'pages' })
+     * ```
+     */
+    setGauge(name, value, attributes) {
+        if (!this.metricsClient) {
+            console.warn('DiagnosticsMetrics not initialized. Call initialize() first.');
+            return;
+        }
+        // Get or create gauge instrument
+        if (!this.gauges.has(name)) {
+            const gauge = this.metricsClient.createGauge(name, {
+                description: `Gauge for ${name}`,
+                unit: '1',
+            });
+            this.gauges.set(name, gauge);
+        }
+        // Limit attributes to prevent high cardinality
+        const limitedAttributes = limitAttributes(attributes);
+        // Set the gauge value
+        this.gauges.get(name).set(value, limitedAttributes);
+    }
+}
+exports.DiagnosticsMetrics = DiagnosticsMetrics;

package/lib/service/index.d.ts

@@ -1,10 +1,12 @@
 import { MetricsAccumulator } from '../metrics/MetricsAccumulator';
+import { DiagnosticsMetrics } from '../metrics/DiagnosticsMetrics';
 export declare const startApp: () => Promise<void>;
 export { appPath } from './loaders';
 declare global {
     namespace NodeJS {
         interface Global {
             metrics: MetricsAccumulator;
+            diagnosticsMetrics: DiagnosticsMetrics;
         }
     }
 }

package/lib/service/index.js

@@ -31,12 +31,17 @@ const telemetry_1 = require("./telemetry");
 const cluster_1 = __importDefault(require("cluster"));
 const constants_1 = require("../constants");
 const MetricsAccumulator_1 = require("../metrics/MetricsAccumulator");
+const DiagnosticsMetrics_1 = require("../metrics/DiagnosticsMetrics");
 const loaders_1 = require("./loaders");
 const logger_1 = require("./logger");
 const startApp = async () => {
     await (0, telemetry_1.initializeTelemetry)();
-    // Initialize global.metrics for both master and worker processes
+    // Initialize both legacy and new metrics systems independently
+    // Legacy: MetricsAccumulator for backward compatibility
+    // External apps and internal code can continue using this during migration
     global.metrics = new MetricsAccumulator_1.MetricsAccumulator();
+    // New: DiagnosticsMetrics for new diagnostics-based instrumentation
+    global.diagnosticsMetrics = new DiagnosticsMetrics_1.DiagnosticsMetrics();
     const serviceJSON = (0, loaders_1.getServiceJSON)();
     try {
         // if it is a master process then call setting up worker process

package/lib/service/worker/runtime/graphql/schema/schemaDirectives/Metric.js

@@ -21,11 +21,28 @@ class Metric extends graphql_tools_1.SchemaDirectiveVisitor {
                 result = error;
                 failedToResolve = true;
             }
-            ctx.graphql.status = failedToResolve ? 'error' : 'success';
+            const status = failedToResolve ? 'error' : 'success';
+            ctx.graphql.status = status;
             const payload = {
-                [ctx.graphql.status]: 1,
+                [status]: 1,
             };
+            // Legacy metrics (backward compatibility)
             metrics.batch(`graphql-metric-${name}`, failedToResolve ? undefined : ellapsed, payload);
+            // New diagnostics metrics with stable names and attributes
+            if (global.diagnosticsMetrics) {
+                const attributes = {
+                    component: 'graphql',
+                    field_name: name,
+                    status,
+                };
+                // Record latency histogram (record all requests, not just successful ones)
+                global.diagnosticsMetrics.recordLatency(ellapsed, attributes);
+                // Increment counter (status is an attribute, not in metric name)
+                global.diagnosticsMetrics.incrementCounter('graphql_field_requests_total', 1, attributes);
+            }
+            else {
+                console.warn('DiagnosticsMetrics not available. GraphQL field metrics not reported.');
+            }
             if (failedToResolve) {
                 throw result;
             }

package/lib/service/worker/runtime/http/middlewares/requestStats.js

@@ -22,20 +22,56 @@ class IncomingRequestStats {
     }
 }
 exports.incomingRequestStats = new IncomingRequestStats();
-const requestClosed = () => {
+const requestClosed = (ctx) => () => {
     exports.incomingRequestStats.closed++;
+    // Report to diagnostics metrics (cumulative counter)
+    const { status: statusCode, vtex: { route: { id, type } } } = ctx;
+    if (global.diagnosticsMetrics) {
+        global.diagnosticsMetrics.incrementCounter('http_server_requests_closed_total', 1, {
+            route_id: id,
+            route_type: type,
+            status_code: statusCode,
+        });
+    }
+    else {
+        console.warn('DiagnosticsMetrics not available. Request closed metric not reported.');
+    }
 };
 const requestAborted = (ctx) => () => {
     exports.incomingRequestStats.aborted++;
+    // Report to diagnostics metrics (cumulative counter)
+    const { status: statusCode, vtex: { route: { id, type } } } = ctx;
+    if (global.diagnosticsMetrics) {
+        global.diagnosticsMetrics.incrementCounter('http_server_requests_aborted_total', 1, {
+            route_id: id,
+            route_type: type,
+            status_code: statusCode,
+        });
+    }
+    else {
+        console.warn('DiagnosticsMetrics not available. Request aborted metric not reported.');
+    }
     if (ctx.vtex.cancellation && ctx.vtex.cancellation.cancelable) {
         ctx.vtex.cancellation.source.cancel(exports.cancelMessage);
         ctx.vtex.cancellation.cancelled = true;
     }
 };
 async function trackIncomingRequestStats(ctx, next) {
-    ctx.req.on('close', requestClosed);
+    ctx.req.on('close', requestClosed(ctx));
     ctx.req.on('aborted', requestAborted(ctx));
     exports.incomingRequestStats.total++;
+    // Report total requests to diagnostics metrics (cumulative counter)
+    const { status: statusCode, vtex: { route: { id, type } } } = ctx;
+    if (global.diagnosticsMetrics) {
+        global.diagnosticsMetrics.incrementCounter('http_server_requests_total', 1, {
+            route_id: id,
+            route_type: type,
+            status_code: statusCode,
+        });
+    }
+    else {
+        console.warn('DiagnosticsMetrics not available. Request total metric not reported.');
+    }
     await next();
 }
 exports.trackIncomingRequestStats = trackIncomingRequestStats;

package/lib/service/worker/runtime/http/middlewares/timings.js

@@ -35,12 +35,30 @@ const logBillingInfo = ({ account, workspace, production, route: { id, type } },
 async function timings(ctx, next) {
     // Errors will be caught by the next middleware so we don't have to catch.
     await next();
-    const { status: statusCode, vtex: { route: { id } }, timings: { total }, vtex } = ctx;
+    const { status: statusCode, vtex: { route: { id, type } }, timings: { total }, vtex } = ctx;
     const totalMillis = (0, time_1.hrToMillis)(total);
     console.log(log(ctx, totalMillis));
     console.log(logBillingInfo(vtex, totalMillis));
     const status = (0, status_1.statusLabel)(statusCode);
+    // Legacy metrics (backward compatibility)
     // Only batch successful responses so metrics don't consider errors
     metrics.batch(`http-handler-${id}`, status === 'success' ? total : undefined, { [status]: 1 });
+    // New diagnostics metrics with stable names and attributes
+    if (global.diagnosticsMetrics) {
+        const attributes = {
+            component: 'http-handler',
+            route_id: id,
+            route_type: type,
+            status_code: statusCode,
+            status,
+        };
+        // Record latency histogram (record all requests, not just successful ones)
+        global.diagnosticsMetrics.recordLatency(total, attributes);
+        // Increment counter (status is an attribute, not in metric name)
+        global.diagnosticsMetrics.incrementCounter('http_handler_requests_total', 1, attributes);
+    }
+    else {
+        console.warn('DiagnosticsMetrics not available. HTTP handler metrics not reported.');
+    }
 }
 exports.timings = timings;

package/lib/service/worker/runtime/statusTrack.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.broadcastStatusTrack = exports.trackStatus = exports.statusTrackHandler = exports.isStatusTrackBroadcast = exports.isStatusTrack = void 0;
 const cluster_1 = __importDefault(require("cluster"));
 const constants_1 = require("../../../constants");
+const HttpAgentSingleton_1 = require("../../../HttpClient/middlewares/request/HttpAgentSingleton");
 const BROADCAST_STATUS_TRACK = 'broadcastStatusTrack';
 const STATUS_TRACK = 'statusTrack';
 const isStatusTrack = (message) => message === STATUS_TRACK;
@@ -23,6 +24,9 @@ const statusTrackHandler = async (ctx) => {
 };
 exports.statusTrackHandler = statusTrackHandler;
 const trackStatus = () => {
+    // Update diagnostics metrics (gauges for HTTP agent stats)
+    HttpAgentSingleton_1.HttpAgentSingleton.updateHttpAgentMetrics();
+    // Legacy status tracking (console.log export)
     global.metrics.statusTrack().forEach(status => {
         logStatus(status);
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vtex/api",
-  "version": "7.2.4",
+  "version": "7.2.5",
   "description": "VTEX I/O API client",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",