@vtex/api 6.52.0 → 6.53.0-beta.1

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

@@ -21,11 +21,29 @@ 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 = {
+                    [__1.AttributeKeys.VTEX_ACCOUNT_NAME]: ctx.vtex.account,
+                    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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.trackIncomingRequestStats = exports.incomingRequestStats = exports.cancelMessage = void 0;
+const constants_1 = require("../../../../../constants");
 exports.cancelMessage = 'Request cancelled';
 class IncomingRequestStats {
     constructor() {
@@ -22,20 +23,59 @@ class IncomingRequestStats {
     }
 }
 exports.incomingRequestStats = new IncomingRequestStats();
-const requestClosed = () => {
+const requestClosed = (ctx) => () => {
     exports.incomingRequestStats.closed++;
+    // Report to diagnostics metrics (cumulative counter)
+    const { status: statusCode, vtex: { account, route: { id, type } } } = ctx;
+    if (global.diagnosticsMetrics) {
+        global.diagnosticsMetrics.incrementCounter('http_server_requests_closed_total', 1, {
+            [constants_1.AttributeKeys.VTEX_ACCOUNT_NAME]: account,
+            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: { account, route: { id, type } } } = ctx;
+    if (global.diagnosticsMetrics) {
+        global.diagnosticsMetrics.incrementCounter('http_server_requests_aborted_total', 1, {
+            [constants_1.AttributeKeys.VTEX_ACCOUNT_NAME]: account,
+            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: { account, route: { id, type } } } = ctx;
+    if (global.diagnosticsMetrics) {
+        global.diagnosticsMetrics.incrementCounter('http_server_requests_total', 1, {
+            [constants_1.AttributeKeys.VTEX_ACCOUNT_NAME]: account,
+            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

@@ -33,14 +33,54 @@ const logBillingInfo = ({ account, workspace, production, route: { id, type } },
     'workspace': workspace,
 });
 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 totalMillis = (0, time_1.hrToMillis)(total);
-    console.log(log(ctx, totalMillis));
-    console.log(logBillingInfo(vtex, totalMillis));
-    const status = (0, status_1.statusLabel)(statusCode);
-    // Only batch successful responses so metrics don't consider errors
-    metrics.batch(`http-handler-${id}`, status === 'success' ? total : undefined, { [status]: 1 });
+    const { vtex: { route: { id, type } }, vtex } = ctx;
+    // Set base attributes for all metrics recorded during this request.
+    // This includes metrics recorded by VTEX IO apps during handler execution.
+    // These attributes will be automatically merged with custom attributes.
+    const baseAttributes = {
+        [constants_1.AttributeKeys.VTEX_ACCOUNT_NAME]: vtex.account,
+        component: 'http-handler',
+        route_id: id,
+        route_type: type,
+    };
+    // Wrap the request handling with base attributes context.
+    // All metrics recorded during next() will automatically include these attributes.
+    const executeWithBaseAttributes = async () => {
+        // Errors will be caught by the next middleware so we don't have to catch.
+        await next();
+        const { status: statusCode, timings: { total } } = 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
+        // Note: base attributes (account, route_id, route_type) are automatically merged
+        // We only need to provide the response-specific attributes here
+        if (global.diagnosticsMetrics) {
+            const responseAttributes = {
+                status,
+                status_code: statusCode,
+            };
+            // Record latency histogram (record all requests, not just successful ones)
+            global.diagnosticsMetrics.recordLatency(total, responseAttributes);
+            // Increment counter (status is an attribute, not in metric name)
+            global.diagnosticsMetrics.incrementCounter('http_handler_requests_total', 1, responseAttributes);
+        }
+        else {
+            console.warn('DiagnosticsMetrics not available. HTTP handler metrics not reported.');
+        }
+    };
+    // If diagnosticsMetrics is available, run with base attributes context
+    // Otherwise, run without context (fallback for graceful degradation)
+    if (global.diagnosticsMetrics) {
+        await global.diagnosticsMetrics.runWithBaseAttributes(baseAttributes, executeWithBaseAttributes);
+    }
+    else {
+        console.warn('DiagnosticsMetrics not available. HTTP handler metrics not reported.');
+        await executeWithBaseAttributes();
+    }
 }
 exports.timings = timings;

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

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 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 HttpAgentSingleton_1 = require("../../../HttpClient/middlewares/request/HttpAgentSingleton");
 const constants_1 = require("../../../constants");
 const BROADCAST_STATUS_TRACK = 'broadcastStatusTrack';
 const STATUS_TRACK = 'statusTrack';
@@ -26,6 +27,8 @@ const statusTrackHandler = async (ctx) => {
 };
 exports.statusTrackHandler = statusTrackHandler;
 const trackStatus = () => {
+    // Update diagnostics metrics (gauges for HTTP agent stats)
+    HttpAgentSingleton_1.HttpAgentSingleton.updateHttpAgentMetrics();
     // Flushing resets the metric accumulators, the CPU usage baseline and the
     // incoming request stats, so it must keep running even though nothing
     // consumes the returned metrics anymore.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vtex/api",
-  "version": "6.52.0",
+  "version": "6.53.0-beta.1",
   "description": "VTEX I/O API client",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -47,9 +47,14 @@
   },
   "license": "MIT",
   "dependencies": {
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/host-metrics": "0.35.5",
+    "@opentelemetry/instrumentation": "0.57.2",
+    "@opentelemetry/instrumentation-koa": "0.47.1",
     "@types/koa": "^2.11.0",
     "@types/koa-compose": "^3.2.3",
-    "@vtex/diagnostics-nodejs": "0.1.0-beta.10",
+    "@vtex/diagnostics-nodejs": "0.1.8-io",
+    "@vtex/diagnostics-semconv": "5.5.2",
     "@vtex/node-error-report": "^0.0.3",
     "@wry/equality": "^0.1.9",
     "agentkeepalive": "^4.0.2",