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

package/lib/service/{http → worker/runtime/http}/middlewares/clients.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.clients = void 0;
 function clients(ClientsImpl, clientOptions) {
     return async function withClients(ctx, next) {
         if (ctx.serverTiming) {

package/lib/service/worker/runtime/http/middlewares/context.d.ts

@@ -0,0 +1,4 @@
+import { IOClients } from '../../../../../clients/IOClients';
+import { ParamsContext, RecorderState, ServiceContext, ServiceRoute } from './../../typings';
+export declare const createPvtContextMiddleware: (routeId: string, { smartcache }: ServiceRoute) => <T extends IOClients, U extends RecorderState, V extends ParamsContext>(ctx: ServiceContext<T, U, V>, next: () => Promise<void>) => Promise<void>;
+export declare const createPubContextMiddleware: (routeId: string, { smartcache }: ServiceRoute) => <T extends IOClients, U extends RecorderState, V extends ParamsContext>(ctx: ServiceContext<T, U, V>, next: () => Promise<void>) => Promise<void>;

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPubContextMiddleware = exports.createPvtContextMiddleware = void 0;
+const querystring_1 = require("querystring");
+const constants_1 = require("../../../../../constants");
+const context_1 = require("../../utils/context");
+exports.createPvtContextMiddleware = (routeId, { smartcache }) => {
+    return async function pvtContext(ctx, next) {
+        const { params, request: { header }, } = ctx;
+        ctx.vtex = {
+            ...context_1.prepareHandlerCtx(header, ctx.tracing),
+            ...(smartcache && { recorder: ctx.state.recorder }),
+            route: {
+                id: routeId,
+                params,
+                type: 'private',
+            },
+        };
+        await next();
+    };
+};
+exports.createPubContextMiddleware = (routeId, { smartcache }) => {
+    return async function pubContext(ctx, next) {
+        const { request: { header }, } = ctx;
+        ctx.vtex = {
+            ...context_1.prepareHandlerCtx(header, ctx.tracing),
+            ...(smartcache && { recorder: ctx.state.recorder }),
+            route: {
+                declarer: header[constants_1.COLOSSUS_ROUTE_DECLARER_HEADER],
+                id: routeId,
+                params: querystring_1.parse(header[constants_1.COLOSSUS_PARAMS_HEADER]),
+                type: 'public',
+            },
+        };
+        await next();
+    };
+};

package/lib/service/worker/runtime/http/middlewares/error.d.ts

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

package/lib/service/{http → worker/runtime/http}/middlewares/error.js

@@ -1,23 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const Logger_1 = require("../../../clients/Logger");
-const constants_1 = require("../../../constants");
-const RequestCancelledError_1 = require("../../../errors/RequestCancelledError");
-const TooManyRequestsError_1 = require("../../../errors/TooManyRequestsError");
-const error_1 = require("../../../utils/error");
+exports.error = void 0;
+const axios_1 = require("axios");
+const constants_1 = require("../../../../../constants");
+const RequestCancelledError_1 = require("../../../../../errors/RequestCancelledError");
+const TooManyRequestsError_1 = require("../../../../../errors/TooManyRequestsError");
+const error_1 = require("../../../../../utils/error");
+const logger_1 = require("../../../../logger");
 const CACHE_CONTROL_HEADER = 'cache-control';
 const META_HEADER = 'x-vtex-meta';
 const ETAG_HEADER = 'etag';
 const TWO_SECONDS_S = 2;
 const production = process.env.VTEX_PRODUCTION === 'true';
+// todo: unify GraphQL and REST exception treatment
 const logAndRemoveSensitiveData = (ctx, err) => {
-    const { method, status, query, vtex: { operationId, requestId, route: { id, params, }, }, headers: { 'x-forwarded-path': forwardedPath, 'x-forwarded-host': forwardedHost, 'x-forwarded-proto': forwardedProto, 'x-vtex-caller': caller, 'x-vtex-platform': platform, 'x-vtex-product': product, 'x-vtex-locale': locale, }, } = ctx;
+    const { method, status, query, vtex: { operationId, requestId, route: { id, params, }, serverTiming, }, headers: { 'x-forwarded-path': forwardedPath, 'x-forwarded-host': forwardedHost, 'x-forwarded-proto': forwardedProto, 'x-vtex-caller': caller, 'x-vtex-platform': platform, 'x-vtex-product': product, 'x-vtex-locale': locale, }, } = ctx;
     // Grab level from originalError, default to "error" level.
     let level = err && err.level;
-    if (!level || !(level === Logger_1.LogLevel.Error || level === Logger_1.LogLevel.Warn)) {
-        level = Logger_1.LogLevel.Error;
+    if (!level || !(level === logger_1.LogLevel.Error || level === logger_1.LogLevel.Warn)) {
+        level = logger_1.LogLevel.Error;
     }
-    const log = Object.assign({}, err, { caller,
+    const log = {
+        ...err,
+        caller,
         forwardedHost,
         forwardedPath,
         forwardedProto,
@@ -28,7 +33,11 @@ const logAndRemoveSensitiveData = (ctx, err) => {
         platform,
         product,
         query,
-        requestId, routeId: id, status });
+        requestId,
+        routeId: id,
+        serverTiming,
+        status,
+    };
     // Use sendLog directly to avoid cleaning error twice.
     ctx.vtex.logger.log(log, level);
     if (!constants_1.LINKED) {
@@ -38,6 +47,7 @@ const logAndRemoveSensitiveData = (ctx, err) => {
     }
 };
 async function error(ctx, next) {
+    var _a;
     try {
         await next();
     }
@@ -53,14 +63,17 @@ async function error(ctx, next) {
         console.error('[node-vtex-api error]', e);
         const err = error_1.cleanError(e);
         // Add response
-        ctx.status = e && e.status >= 400 && e.status <= 599
-            ? e.status
-            : ctx.status >= 500 && ctx.status <= 599
-                ? ctx.status
-                : 500;
+        if (e instanceof axios_1.AxiosError) {
+            ctx.status = (e === null || e === void 0 ? void 0 : e.status) && e.status >= 400 && e.status <= 599
+                ? e.status
+                : ctx.status >= 500 && ctx.status <= 599
+                    ? ctx.status
+                    : 500;
+        }
         // Do not generate etag for errors
         ctx.remove(META_HEADER);
         ctx.remove(ETAG_HEADER);
+        (_a = ctx.vtex.recorder) === null || _a === void 0 ? void 0 : _a.clear();
         // In production errors, add two second cache
         if (production) {
             ctx.set(CACHE_CONTROL_HEADER, `public, max-age=${TWO_SECONDS_S}`);

package/lib/service/worker/runtime/http/middlewares/rateLimit.d.ts

@@ -0,0 +1,6 @@
+import TokenBucket from 'tokenbucket';
+import { ServiceContext } from '../../typings';
+declare function noopMiddleware(_: ServiceContext, next: () => Promise<void>): Promise<void>;
+export declare function perMinuteRateLimiter(rateLimit?: number, globalLimiter?: TokenBucket): typeof noopMiddleware;
+export declare function concurrentRateLimiter(rateLimit?: number): typeof noopMiddleware;
+export {};

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concurrentRateLimiter = exports.perMinuteRateLimiter = void 0;
+const errors_1 = require("../../../../../errors");
+const tokenBucket_1 = require("../../utils/tokenBucket");
+const responseMessageConcurrent = 'Rate Exceeded: Too many requests in execution';
+const responseMessagePerMinute = 'Rate Exceeded: Too many requests per minute';
+function noopMiddleware(_, next) {
+    return next();
+}
+function perMinuteRateLimiter(rateLimit, globalLimiter) {
+    if (!rateLimit && !globalLimiter) {
+        return noopMiddleware;
+    }
+    const tokenBucket = tokenBucket_1.createTokenBucket(rateLimit, globalLimiter);
+    return function perMinuteRateMiddleware(ctx, next) {
+        if (!tokenBucket.removeTokensSync(1)) {
+            throw new errors_1.TooManyRequestsError(responseMessagePerMinute);
+        }
+        return next();
+    };
+}
+exports.perMinuteRateLimiter = perMinuteRateLimiter;
+function concurrentRateLimiter(rateLimit) {
+    if (!rateLimit) {
+        return noopMiddleware;
+    }
+    let reqsInExecution = 0;
+    const maxRequests = rateLimit;
+    return async function concurrentRateMiddleware(ctx, next) {
+        if (reqsInExecution >= maxRequests) {
+            throw new errors_1.TooManyRequestsError(responseMessageConcurrent);
+        }
+        reqsInExecution++;
+        try {
+            await next();
+        }
+        finally {
+            reqsInExecution--;
+        }
+    };
+}
+exports.concurrentRateLimiter = concurrentRateLimiter;

package/lib/service/{http → worker/runtime/http}/middlewares/requestStats.d.ts

@@ -1,5 +1,5 @@
-import { IOClients } from '../../../clients/IOClients';
-import { ServiceContext } from '../../typings';
+import { IOClients } from '../../../../../clients/IOClients';
+import { ParamsContext, RecorderState, ServiceContext } from '../../typings';
 export declare const cancelMessage = "Request cancelled";
 declare class IncomingRequestStats {
     aborted: number;
@@ -13,5 +13,5 @@ declare class IncomingRequestStats {
     clear(): void;
 }
 export declare const incomingRequestStats: IncomingRequestStats;
-export declare function trackIncomingRequestStats<T extends IOClients, U, V>(ctx: ServiceContext<T, U, V>, next: () => Promise<any>): Promise<void>;
+export declare function trackIncomingRequestStats<T extends IOClients, U extends RecorderState, V extends ParamsContext>(ctx: ServiceContext<T, U, V>, next: () => Promise<void>): Promise<void>;
 export {};

package/lib/service/{http → worker/runtime/http}/middlewares/requestStats.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackIncomingRequestStats = exports.incomingRequestStats = exports.cancelMessage = void 0;
 exports.cancelMessage = 'Request cancelled';
 class IncomingRequestStats {
     constructor() {

package/lib/service/worker/runtime/http/middlewares/setCookie.d.ts

@@ -0,0 +1,3 @@
+import { IOClients } from '../../../../../clients/IOClients';
+import { ParamsContext, RecorderState, ServiceContext } from '../../typings';
+export declare function removeSetCookie<T extends IOClients, U extends RecorderState, V extends ParamsContext>(ctx: ServiceContext<T, U, V>, next: () => Promise<void>): Promise<void>;

package/lib/service/{http → worker/runtime/http}/middlewares/setCookie.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeSetCookie = void 0;
 const ramda_1 = require("ramda");
 const BLACKLISTED_COOKIES = new Set(['checkout.vtex.com']);
 const warnMessage = (keys) => `Removing set-cookie from response since cache-control has as public scope.

package/lib/service/worker/runtime/http/middlewares/settings.d.ts

@@ -0,0 +1,9 @@
+import { AppMetaInfo, Apps } from '../../../../../clients/infra/Apps';
+import { IOClients } from '../../../../../clients/IOClients';
+import { RequestTracingConfig } from '../../../../../HttpClient';
+import { Assets } from './../../../../../clients/infra/Assets';
+import { ParamsContext, RecorderState, ServiceContext } from './../../typings';
+export declare const getFilteredDependencies: (appAtMajor: string, dependencies: AppMetaInfo[]) => AppMetaInfo[];
+export declare const getDependenciesHash: (dependencies: AppMetaInfo[]) => string;
+export declare const getDependenciesSettings: (apps: Apps, assets: Assets, tracingConfig?: RequestTracingConfig | undefined) => Promise<Record<string, any>[]>;
+export declare const getServiceSettings: () => <T extends IOClients, U extends RecorderState, V extends ParamsContext>(ctx: ServiceContext<T, U, V>, next: () => Promise<void>) => Promise<void>;

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServiceSettings = exports.getDependenciesSettings = exports.getDependenciesHash = exports.getFilteredDependencies = void 0;
+const crypto_1 = require("crypto");
+const ramda_1 = require("ramda");
+const constants_1 = require("../../../../../constants");
+const app_1 = require("./../../../../../utils/app");
+const joinIds = ramda_1.join('');
+const dependsOnApp = (appAtMajor) => (a) => {
+    const [name, major] = appAtMajor.split('@');
+    const majorInt = major.includes('.') ? major.split('.')[0] : major;
+    const version = a._resolvedDependencies[name];
+    if (!version) {
+        return false;
+    }
+    const [depMajor] = version.split('.');
+    return majorInt === depMajor;
+};
+exports.getFilteredDependencies = (appAtMajor, dependencies) => {
+    const depends = dependsOnApp(appAtMajor);
+    return dependencies.filter(depends);
+};
+exports.getDependenciesHash = (dependencies) => {
+    const dependingApps = ramda_1.pluck('id', dependencies);
+    return crypto_1.createHash('md5')
+        .update(joinIds(dependingApps))
+        .digest('hex');
+};
+exports.getDependenciesSettings = async (apps, assets, tracingConfig) => {
+    const appId = constants_1.APP.ID;
+    const metaInfos = await apps.getAppsMetaInfos(undefined, undefined, tracingConfig);
+    const appAtMajor = app_1.appIdToAppAtMajor(appId);
+    return await assets.getSettings(metaInfos, appAtMajor, undefined, tracingConfig);
+};
+exports.getServiceSettings = () => {
+    return async function settingsContext(ctx, next) {
+        var _a;
+        const { clients: { apps, assets }, } = ctx;
+        const rootSpan = (_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.currentSpan;
+        const dependenciesSettings = await exports.getDependenciesSettings(apps, assets, { tracing: { rootSpan } });
+        // TODO: for now returning all settings, but the ideia is to do merge
+        ctx.vtex.settings = dependenciesSettings;
+        await next();
+    };
+};

package/lib/service/worker/runtime/http/middlewares/timings.d.ts

@@ -0,0 +1,3 @@
+import { IOClients } from '../../../../../clients/IOClients';
+import { ParamsContext, RecorderState, ServiceContext } from '../../typings';
+export declare function timings<T extends IOClients, U extends RecorderState, V extends ParamsContext>(ctx: ServiceContext<T, U, V>, next: () => Promise<void>): Promise<void>;

package/lib/service/{http → worker/runtime/http}/middlewares/timings.js

@@ -3,30 +3,44 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.timings = void 0;
 const chalk_1 = __importDefault(require("chalk"));
-const status_1 = require("../../../utils/status");
-const time_1 = require("../../../utils/time");
+const constants_1 = require("../../../../../constants");
+const status_1 = require("../../../../../utils/status");
+const time_1 = require("../../../../../utils/time");
 const APP_ELAPSED_TIME_LOCATOR = time_1.shrinkTimings(time_1.formatTimingName({
     hopNumber: 0,
     source: process.env.VTEX_APP_NAME,
     target: '',
 }));
+const pid = chalk_1.default.magenta('[' + constants_1.PID + ']');
 const formatDate = (date) => chalk_1.default.dim('[' + date.toISOString().split('T')[1] + ']');
 const formatStatus = (status) => status >= 500 ? chalk_1.default.red(status.toString()) : (status >= 200 && status < 300 ? chalk_1.default.green(status.toString()) : status);
 const formatMillis = (millis) => millis >= 500 ? chalk_1.default.red(millis.toString()) : millis >= 200 ? chalk_1.default.yellow(millis.toString()) : chalk_1.default.green(millis.toString());
-const log = ({ vtex: { account, workspace, route: { id } }, path, method, status }, millis) => `${formatDate(new Date())}\t${account}/${workspace}:${id}\t${formatStatus(status)}\t${method}\t${path}\t${formatMillis(millis)} ms`;
+const log = ({ vtex: { account, workspace, route: { id } }, path, method, status }, millis) => `${formatDate(new Date())}\t${pid}\t${account}/${workspace}:${id}\t${formatStatus(status)}\t${method}\t${path}\t${formatMillis(millis)} ms`;
+const logBillingInfo = ({ account, workspace, production, route: { id, type } }, millis) => JSON.stringify({
+    '__VTEX_IO_BILLING': 'true',
+    'account': account,
+    'app': constants_1.APP.ID,
+    'handler': id,
+    'isLink': constants_1.LINKED,
+    'production': production,
+    'routeType': type === 'public' ? 'public_route' : 'private_route',
+    'timestamp': Date.now(),
+    'type': 'process-time',
+    'value': millis,
+    'vendor': constants_1.APP.VENDOR,
+    '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 } } = ctx;
+    const { status: statusCode, vtex: { route: { id } }, timings: { total }, vtex } = ctx;
     const totalMillis = time_1.hrToMillis(total);
     console.log(log(ctx, totalMillis));
+    console.log(logBillingInfo(vtex, totalMillis));
     const status = 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 });
-    if (ctx.serverTiming) {
-        ctx.serverTiming[APP_ELAPSED_TIME_LOCATOR] = `${totalMillis}`;
-        ctx.set('Server-Timing', time_1.reduceTimings(ctx.serverTiming));
-    }
 }
 exports.timings = timings;

package/lib/service/worker/runtime/http/middlewares/vary.d.ts

@@ -0,0 +1,3 @@
+import { IOClients } from '../../../../../clients/IOClients';
+import { ParamsContext, RecorderState, ServiceContext } from '../../typings';
+export declare function vary<T extends IOClients, U extends RecorderState, V extends ParamsContext>(ctx: ServiceContext<T, U, V>, next: () => Promise<void>): Promise<void>;

package/lib/service/{http → worker/runtime/http}/middlewares/vary.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = require("../../../constants");
+exports.vary = void 0;
+const constants_1 = require("../../../../../constants");
 const cachingStrategies = [
     {
         forbidden: [],
@@ -29,9 +30,9 @@ const shouldVaryByHeader = (ctx, header, strategy) => {
 };
 async function vary(ctx, next) {
     const { method, path } = ctx;
-    const strategy = cachingStrategies.find(cachingStrategy => path.indexOf(cachingStrategy.path) === 0);
+    const strategy = cachingStrategies.find((cachingStrategy) => path.indexOf(cachingStrategy.path) === 0);
     if (strategy) {
-        strategy.forbidden.forEach(headerName => {
+        strategy.forbidden.forEach((headerName) => {
             delete ctx.headers[headerName];
         });
     }

package/lib/service/worker/runtime/http/router.d.ts

@@ -0,0 +1,2 @@
+import { HttpRoute, ServiceContext } from '../typings';
+export declare const routerFromPublicHttpHandlers: (routes: Record<string, HttpRoute>) => (ctx: ServiceContext, next: () => Promise<void>) => Promise<void>;

package/lib/service/worker/runtime/http/router.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routerFromPublicHttpHandlers = void 0;
+const constants_1 = require("../../../../constants");
+const logger_1 = require("../../../logger");
+const console_1 = require("./../../../logger/console");
+exports.routerFromPublicHttpHandlers = (routes) => {
+    return async (ctx, next) => {
+        var _a;
+        const routeId = ctx.get(constants_1.COLOSSUS_ROUTE_ID_HEADER);
+        if (!routeId) {
+            return next();
+        }
+        const handler = (_a = routes[routeId]) === null || _a === void 0 ? void 0 : _a.handler;
+        if (!handler) {
+            const msg = `Handler with id '${routeId}' not implemented.`;
+            ctx.status = 501;
+            ctx.body = msg;
+            console_1.logOnceToDevConsole(msg, logger_1.LogLevel.Error);
+            return;
+        }
+        await handler(ctx, next);
+    };
+};

package/lib/service/worker/runtime/http/routes.d.ts

@@ -0,0 +1,19 @@
+import { ServiceJSON } from '../typings';
+interface PrivateRouteInfo {
+    protocol?: 'http' | 'https';
+    vendor: string;
+    name: string;
+    major: string | number;
+    account: string;
+    workspace: string;
+    path?: string;
+}
+export declare const formatPrivateRoute: ({ protocol, vendor, name, major, account, workspace, path }: PrivateRouteInfo) => string;
+export declare const formatPublicRoute: ({ workspace, account, endpoint, path }: {
+    workspace: string;
+    account: string;
+    endpoint: string;
+    path: string;
+}) => string;
+export declare const logAvailableRoutes: (service: ServiceJSON) => void;
+export {};

package/lib/service/worker/runtime/http/routes.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logAvailableRoutes = exports.formatPublicRoute = exports.formatPrivateRoute = void 0;
+const constants_1 = require("../../../../constants");
+exports.formatPrivateRoute = ({ protocol = 'https', vendor, name, major, account, workspace, path }) => `${protocol}://app.io.vtex.com/${vendor}.${name}/v${major}/${account}/${workspace}${path || ''}`;
+exports.formatPublicRoute = ({ workspace, account, endpoint, path }) => `https://${workspace}--${account}.${endpoint}${path}`;
+const getPath = ({ public: publicRoute, path }) => publicRoute
+    ? exports.formatPublicRoute({ workspace: constants_1.WORKSPACE, account: constants_1.ACCOUNT, endpoint: constants_1.PUBLIC_ENDPOINT, path })
+    : exports.formatPrivateRoute({ protocol: 'https', vendor: constants_1.APP.VENDOR, name: constants_1.APP.NAME, major: constants_1.APP.MAJOR, account: constants_1.ACCOUNT, workspace: constants_1.WORKSPACE, path });
+exports.logAvailableRoutes = (service) => {
+    const available = Object.values(service.routes || {}).reduce((acc, route) => `${acc}\n${getPath(route)}`, 'Available service routes:');
+    console.info(available);
+};

package/lib/service/worker/runtime/method.d.ts

@@ -0,0 +1,9 @@
+import { IOClients } from '../../../clients/IOClients';
+import { ParamsContext, RecorderState, RouteHandler, ServiceContext } from './typings';
+declare type HTTPMethods = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH' | 'DEFAULT';
+declare type MethodOptions<ClientsT extends IOClients = IOClients, StateT extends RecorderState = RecorderState, CustomT extends ParamsContext = ParamsContext> = Partial<Record<HTTPMethods, RouteHandler<ClientsT, StateT, CustomT> | Array<RouteHandler<ClientsT, StateT, CustomT>>>>;
+export declare function method<T extends IOClients, U extends RecorderState, V extends ParamsContext>(options: MethodOptions<T, U, V>): {
+    (ctx: ServiceContext<T, U, V>, next: () => Promise<void>): Promise<void>;
+    skipTimer: boolean;
+};
+export {};

package/lib/service/{method.js → worker/runtime/method.js}

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.method = void 0;
 const ramda_1 = require("ramda");
 const compose_1 = require("./utils/compose");
 const TEN_SECONDS_S = 10;

package/lib/service/worker/runtime/statusTrack.d.ts

@@ -0,0 +1,14 @@
+import { ServiceContext } from './typings';
+export declare type StatusTrack = () => EnvMetric[];
+export interface NamedMetric {
+    name: string;
+    [key: string]: any;
+}
+export interface EnvMetric extends NamedMetric {
+    production: boolean;
+}
+export declare const isStatusTrack: (message: any) => message is "statusTrack";
+export declare const isStatusTrackBroadcast: (message: any) => message is "broadcastStatusTrack";
+export declare const statusTrackHandler: (ctx: ServiceContext) => Promise<void>;
+export declare const trackStatus: () => void;
+export declare const broadcastStatusTrack: () => void;

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

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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 constants_1 = require("../../../constants");
+const BROADCAST_STATUS_TRACK = 'broadcastStatusTrack';
+const STATUS_TRACK = 'statusTrack';
+exports.isStatusTrack = (message) => message === STATUS_TRACK;
+exports.isStatusTrackBroadcast = (message) => message === BROADCAST_STATUS_TRACK;
+exports.statusTrackHandler = async (ctx) => {
+    var _a, _b, _c;
+    (_b = (_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.currentSpan) === null || _b === void 0 ? void 0 : _b.setOperationName('builtin:status-track');
+    if (!constants_1.LINKED) {
+        (_c = process.send) === null || _c === void 0 ? void 0 : _c.call(process, BROADCAST_STATUS_TRACK);
+    }
+    ctx.body = [];
+    return;
+};
+exports.trackStatus = () => {
+    global.metrics.statusTrack().forEach(status => {
+        logStatus(status);
+    });
+};
+exports.broadcastStatusTrack = () => Object.values(cluster_1.default.workers).forEach(worker => worker === null || worker === void 0 ? void 0 : worker.send(STATUS_TRACK));
+const logStatus = (status) => console.log(JSON.stringify({
+    __VTEX_IO_LOG: true,
+    account: constants_1.ACCOUNT,
+    app: constants_1.APP.ID,
+    isLink: constants_1.LINKED,
+    pid: process.pid,
+    production: constants_1.PRODUCTION,
+    status,
+    type: 'metric/status',
+    workspace: constants_1.WORKSPACE,
+}));