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

package/lib/service/tracing/tracingMiddlewares.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traceUserLandRemainingPipelineMiddleware = exports.nameSpanOperationMiddleware = exports.addTracingMiddleware = void 0;
+const opentracing_1 = require("opentracing");
+const stream_1 = require("stream");
+const constants_1 = require("../../constants");
+const tracing_1 = require("../../tracing");
+const Tags_1 = require("../../tracing/Tags");
+const utils_1 = require("../../tracing/utils");
+const utils_2 = require("../../utils");
+const PATHS_BLACKLISTED_FOR_TRACING = ['/_status', '/healthcheck'];
+const addTracingMiddleware = (tracer) => {
+    return async function addTracing(ctx, next) {
+        var _a;
+        const rootSpan = tracer.extract(opentracing_1.FORMAT_HTTP_HEADERS, ctx.request.headers);
+        ctx.tracing = { tracer, currentSpan: undefined };
+        if (!shouldTrace(ctx, rootSpan)) {
+            await next();
+            return;
+        }
+        const currentSpan = tracer.startSpan('unknown-operation', {
+            childOf: rootSpan,
+            tags: { [Tags_1.OpentracingTags.SPAN_KIND]: Tags_1.OpentracingTags.SPAN_KIND_RPC_SERVER },
+        });
+        const initialSamplingDecision = (0, tracing_1.getTraceInfo)(currentSpan).isSampled;
+        ctx.tracing = { currentSpan, tracer };
+        let responseClosed = false;
+        ctx.res.once('close', () => (responseClosed = true));
+        try {
+            await next();
+        }
+        catch (err) {
+            if (!(err instanceof Error)) {
+                throw err;
+            }
+            tracing_1.ErrorReport.create({ originalError: err }).injectOnSpan(currentSpan, (_a = ctx.vtex) === null || _a === void 0 ? void 0 : _a.logger);
+            throw err;
+        }
+        finally {
+            const traceInfo = (0, tracing_1.getTraceInfo)(currentSpan);
+            if (traceInfo === null || traceInfo === void 0 ? void 0 : traceInfo.isSampled) {
+                if (!initialSamplingDecision) {
+                    currentSpan === null || currentSpan === void 0 ? void 0 : currentSpan.setTag(Tags_1.OpentracingTags.SPAN_KIND, Tags_1.OpentracingTags.SPAN_KIND_RPC_SERVER);
+                }
+                currentSpan === null || currentSpan === void 0 ? void 0 : currentSpan.addTags({
+                    [Tags_1.OpentracingTags.HTTP_URL]: ctx.request.href,
+                    [Tags_1.OpentracingTags.HTTP_METHOD]: ctx.request.method,
+                    [Tags_1.OpentracingTags.HTTP_STATUS_CODE]: ctx.response.status,
+                    ["http.path" /* CustomHttpTags.HTTP_PATH */]: ctx.request.path,
+                    ["vtex.request_id" /* VTEXIncomingRequestTags.VTEX_REQUEST_ID */]: ctx.get(constants_1.REQUEST_ID_HEADER),
+                    ["vtex.incoming.workspace" /* VTEXIncomingRequestTags.VTEX_WORKSPACE */]: ctx.get(constants_1.WORKSPACE_HEADER),
+                    ["vtex.incoming.account" /* VTEXIncomingRequestTags.VTEX_ACCOUNT */]: ctx.get(constants_1.ACCOUNT_HEADER),
+                });
+                currentSpan === null || currentSpan === void 0 ? void 0 : currentSpan.log((0, utils_1.cloneAndSanitizeHeaders)(ctx.request.headers, 'req.headers.'));
+                currentSpan === null || currentSpan === void 0 ? void 0 : currentSpan.log((0, utils_1.cloneAndSanitizeHeaders)(ctx.response.headers, 'res.headers.'));
+                ctx.set(constants_1.TRACE_ID_HEADER, traceInfo.traceId);
+            }
+            const onResFinished = () => {
+                currentSpan === null || currentSpan === void 0 ? void 0 : currentSpan.finish();
+            };
+            if (responseClosed) {
+                onResFinished();
+            }
+            else {
+                (0, stream_1.finished)(ctx.res, onResFinished);
+            }
+        }
+    };
+};
+exports.addTracingMiddleware = addTracingMiddleware;
+const nameSpanOperationMiddleware = (operationType, operationName) => {
+    return function nameSpanOperation(ctx, next) {
+        var _a, _b;
+        ctx.requestHandlerName = `${operationType}:${operationName}`;
+        (_b = (_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.currentSpan) === null || _b === void 0 ? void 0 : _b.setOperationName(ctx.requestHandlerName);
+        return next();
+    };
+};
+exports.nameSpanOperationMiddleware = nameSpanOperationMiddleware;
+const traceUserLandRemainingPipelineMiddleware = () => {
+    return async function traceUserLandRemainingPipeline(ctx, next) {
+        const tracingCtx = ctx.tracing;
+        ctx.tracing = undefined;
+        const span = tracingCtx === null || tracingCtx === void 0 ? void 0 : tracingCtx.currentSpan;
+        const userLandTracer = ctx.vtex.tracer;
+        userLandTracer.setFallbackSpan(span);
+        userLandTracer.lockFallbackSpan();
+        const startTime = process.hrtime();
+        try {
+            span === null || span === void 0 ? void 0 : span.log({ event: "user-middlewares-start" /* RuntimeLogEvents.USER_MIDDLEWARES_START */ });
+            await next();
+        }
+        catch (err) {
+            if (!(err instanceof Error)) {
+                throw err;
+            }
+            tracing_1.ErrorReport.create({ originalError: err }).injectOnSpan(span, ctx.vtex.logger);
+            throw err;
+        }
+        finally {
+            span === null || span === void 0 ? void 0 : span.log({
+                event: "user-middlewares-finish" /* RuntimeLogEvents.USER_MIDDLEWARES_FINISH */,
+                ["user-middlewares-duration" /* RuntimeLogFields.USER_MIDDLEWARES_DURATION */]: (0, utils_2.hrToMillis)(process.hrtime(startTime)),
+            });
+            ctx.tracing = tracingCtx;
+        }
+    };
+};
+exports.traceUserLandRemainingPipelineMiddleware = traceUserLandRemainingPipelineMiddleware;
+function shouldTrace(ctx, rootSpan) {
+    var _a, _b, _c;
+    /** Should trace if path isnt blacklisted and sampling decision came from the edge
+     * ((rootSpan as any).isSampled. returns whether or not this span context was sampled
+     * There is a cast to bypass opentracing typescript
+     */
+    return !PATHS_BLACKLISTED_FOR_TRACING.includes(ctx.request.path) && ((_c = (_b = (_a = rootSpan).isSampled) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : false);
+}

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

@@ -0,0 +1,11 @@
+import Koa from 'koa';
+import { MetricsAccumulator } from '../../metrics/MetricsAccumulator';
+import { ServiceJSON } from './runtime/typings';
+export declare const startWorker: (serviceJSON: ServiceJSON) => Koa<Koa.DefaultState, Koa.DefaultContext>;
+declare global {
+    namespace NodeJS {
+        interface Global {
+            metrics: MetricsAccumulator;
+        }
+    }
+}

package/lib/service/worker/index.js

@@ -0,0 +1,197 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startWorker = void 0;
+const http_1 = require("http");
+const koa_1 = __importDefault(require("koa"));
+const koa_compress_1 = __importDefault(require("koa-compress"));
+const koa_router_1 = __importDefault(require("koa-router"));
+const ramda_1 = require("ramda");
+const constants_1 = require("../../constants");
+const MetricsAccumulator_1 = require("../../metrics/MetricsAccumulator");
+const loaders_1 = require("../loaders");
+const console_1 = require("../logger/console");
+const logger_1 = require("../logger/logger");
+const requestMetricsMiddleware_1 = require("../metrics/requestMetricsMiddleware");
+const TracerSingleton_1 = require("../tracing/TracerSingleton");
+const tracingMiddlewares_1 = require("../tracing/tracingMiddlewares");
+const listeners_1 = require("./listeners");
+const handlers_1 = require("./runtime/builtIn/handlers");
+const middlewares_1 = require("./runtime/builtIn/middlewares");
+const events_1 = require("./runtime/events");
+const router_1 = require("./runtime/events/router");
+const graphql_1 = require("./runtime/graphql");
+const http_2 = require("./runtime/http");
+const error_1 = require("./runtime/http/middlewares/error");
+const rateLimit_1 = require("./runtime/http/middlewares/rateLimit");
+const router_2 = require("./runtime/http/router");
+const routes_1 = require("./runtime/http/routes");
+const statusTrack_1 = require("./runtime/statusTrack");
+const tokenBucket_1 = require("./runtime/utils/tokenBucket");
+const upSignal = () => {
+    const data = JSON.stringify({ statusTrack: true });
+    const options = {
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        host: 'localhost',
+        method: 'POST',
+        path: '/_up',
+        port: 5000,
+    };
+    const req = (0, http_1.request)(options);
+    req.write(data);
+    req.end();
+};
+const isUpSignal = (message) => message === constants_1.UP_SIGNAL;
+const onMessage = (service) => (message) => {
+    if (isUpSignal(message)) {
+        upSignal();
+        (0, routes_1.logAvailableRoutes)(service);
+    }
+    else if ((0, statusTrack_1.isStatusTrack)(message)) {
+        (0, statusTrack_1.trackStatus)();
+    }
+    else {
+        listeners_1.logger.warn({
+            content: message,
+            message: 'Master sent message',
+            pid: process.pid,
+        });
+    }
+};
+const createAppHttpHandlers = ({ config: { routes, clients } }, serviceJSON, globalLimiter) => {
+    if (routes && clients) {
+        return Object.keys(routes).reduce((acc, routeId) => {
+            var _a;
+            const serviceRoute = (_a = serviceJSON.routes) === null || _a === void 0 ? void 0 : _a[routeId];
+            if (!serviceRoute) {
+                throw new Error(`Could not find route: ${routeId}. Please add ${routeId} route in your service.json file`);
+            }
+            const { path: servicePath, public: publicRoute = false, extensible = false, } = serviceRoute;
+            if (publicRoute || extensible) {
+                acc.pub[routeId] = {
+                    handler: (0, http_2.createPublicHttpRoute)(clients, routes[routeId], serviceRoute, routeId, globalLimiter),
+                    path: servicePath,
+                };
+            }
+            else {
+                acc.pvt[routeId] = {
+                    handler: (0, http_2.createPrivateHttpRoute)(clients, routes[routeId], serviceRoute, routeId, globalLimiter),
+                    path: `/:account/:workspace${servicePath.replace(/\*([^/]*)/g, ':$1*')}`,
+                };
+            }
+            return acc;
+        }, {
+            pub: {},
+            pvt: {},
+        });
+    }
+    return null;
+};
+const routerFromPrivateHttpHandlers = (routes) => Object.values(routes).reduce((router, { handler, path }) => router.all(path, handler), new koa_router_1.default());
+const createAppGraphQLHandler = ({ config: { graphql, clients } }, { routes }, globalLimiter) => {
+    const route = routes === null || routes === void 0 ? void 0 : routes[graphql_1.GRAPHQL_ROUTE];
+    if (graphql && route && clients) {
+        return {
+            pvt: {
+                [graphql_1.GRAPHQL_ROUTE]: {
+                    handler: (0, graphql_1.createGraphQLRoute)(graphql, clients, route, graphql_1.GRAPHQL_ROUTE, globalLimiter),
+                    path: `/:account/:workspace${route.path}`,
+                },
+            },
+        };
+    }
+    return null;
+};
+const createAppEventHandlers = ({ config: { events, clients } }, serviceJSON, globalLimiter) => {
+    if (events && clients) {
+        return Object.keys(events).reduce((acc, eventId) => {
+            var _a;
+            const serviceEvent = (_a = serviceJSON.events) === null || _a === void 0 ? void 0 : _a[eventId];
+            acc[eventId] = (0, events_1.createEventHandler)(clients, eventId, events[eventId], serviceEvent, globalLimiter);
+            return acc;
+        }, {});
+    }
+    return null;
+};
+const createRuntimeHttpHandlers = (appEventHandlers, serviceJSON) => ({
+    pvt: {
+        __events: {
+            handler: (0, router_1.routerFromEventHandlers)(appEventHandlers),
+            path: '/:account/:workspace/_events',
+        },
+        __healthCheck: {
+            handler: (0, handlers_1.healthcheckHandler)(serviceJSON),
+            path: '/healthcheck',
+        },
+        __metricsLogger: {
+            handler: handlers_1.metricsLoggerHandler,
+            path: '/_metrics',
+        },
+        __statusTrack: {
+            handler: statusTrack_1.statusTrackHandler,
+            path: '/_status',
+        },
+        __whoami: {
+            handler: (0, handlers_1.whoAmIHandler)(serviceJSON),
+            path: '/:account/:workspace/_whoami',
+        },
+    },
+});
+const scaleClientCaches = (scaleFactor, options) => Object.entries(options || {}).forEach(([name, opts]) => {
+    if (opts && opts.memoryCache && scaleFactor > 1) {
+        const previous = opts.memoryCache.storage.max;
+        const current = previous / scaleFactor;
+        opts.memoryCache.storage.max = current;
+        (0, console_1.logOnceToDevConsole)(`Scaling ${name} cache capacity from ${previous} to ${current}`, logger_1.LogLevel.Warn);
+    }
+});
+const startWorker = (serviceJSON) => {
+    var _a, _b;
+    (0, listeners_1.addProcessListeners)();
+    const tracer = TracerSingleton_1.TracerSingleton.getTracer();
+    const app = new koa_1.default();
+    app.proxy = true;
+    app
+        .use(error_1.error)
+        .use((0, middlewares_1.prometheusLoggerMiddleware)())
+        .use((0, tracingMiddlewares_1.addTracingMiddleware)(tracer))
+        .use((0, requestMetricsMiddleware_1.addRequestMetricsMiddleware)())
+        .use((0, middlewares_1.addMetricsLoggerMiddleware)())
+        .use((0, rateLimit_1.concurrentRateLimiter)((_a = serviceJSON === null || serviceJSON === void 0 ? void 0 : serviceJSON.rateLimitPerReplica) === null || _a === void 0 ? void 0 : _a.concurrent))
+        .use((0, koa_compress_1.default)())
+        .use(middlewares_1.recorderMiddleware);
+    const service = (0, loaders_1.getService)();
+    const { config: { clients } } = service;
+    if (clients) {
+        scaleClientCaches(serviceJSON.workers, clients.options);
+    }
+    const globalLimiter = (0, tokenBucket_1.createTokenBucket)((_b = serviceJSON === null || serviceJSON === void 0 ? void 0 : serviceJSON.rateLimitPerReplica) === null || _b === void 0 ? void 0 : _b.perMinute);
+    const appHttpHandlers = createAppHttpHandlers(service, serviceJSON, globalLimiter);
+    const appEventHandlers = createAppEventHandlers(service, serviceJSON, globalLimiter);
+    const appGraphQLHandlers = createAppGraphQLHandler(service, serviceJSON, globalLimiter);
+    const runtimeHttpHandlers = createRuntimeHttpHandlers(appEventHandlers, serviceJSON);
+    const httpHandlers = [
+        appHttpHandlers,
+        appGraphQLHandlers,
+        runtimeHttpHandlers,
+    ]
+        .filter(x => x != null)
+        // TODO: Fix ramda typings. Apparently there was an update that broke things
+        .reduce(ramda_1.mergeDeepRight);
+    if (httpHandlers === null || httpHandlers === void 0 ? void 0 : httpHandlers.pub) {
+        const publicHandlersRouter = (0, router_2.routerFromPublicHttpHandlers)(httpHandlers.pub);
+        app.use(publicHandlersRouter);
+    }
+    if (httpHandlers === null || httpHandlers === void 0 ? void 0 : httpHandlers.pvt) {
+        const privateHandlersRouter = routerFromPrivateHttpHandlers(httpHandlers.pvt);
+        app.use(privateHandlersRouter.routes());
+    }
+    process.on('message', onMessage(serviceJSON));
+    return app;
+};
+exports.startWorker = startWorker;
+global.metrics = new MetricsAccumulator_1.MetricsAccumulator();

package/lib/service/worker/listeners.d.ts

@@ -0,0 +1,3 @@
+import { Logger } from '../logger';
+export declare const logger: Logger;
+export declare const addProcessListeners: () => void;

package/lib/{utils/unhandled.js → service/worker/listeners.js}

@@ -1,29 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.addProcessListeners = exports.logger = void 0;
 const os_1 = require("os");
-const RequestCancelledError_1 = require("../errors/RequestCancelledError");
-const logger_1 = require("../service/logger");
-const logger = new logger_1.Logger({ account: 'unhandled', workspace: 'unhandled', requestId: 'unhandled', operationId: 'unhandled', production: process.env.VTEX_PRODUCTION === 'true' });
+const RequestCancelledError_1 = require("../../errors/RequestCancelledError");
+const logger_1 = require("../logger");
+exports.logger = new logger_1.Logger({ account: 'unhandled', workspace: 'unhandled', requestId: 'unhandled', operationId: 'unhandled', production: process.env.VTEX_PRODUCTION === 'true' });
 let watched;
-// Remove the any typings once we move to nodejs 10.x
-const handleSignal = (signal) => {
-    console.warn('Received signal', signal);
-    logger.warn({
-        signal,
-    });
-    // Default node behaviour
-    process.exit(128 + os_1.constants.signals[signal]);
+const handleSignal = signal => {
+    process.exit(os_1.constants.signals[signal]);
 };
-exports.addProcessListeners = () => {
+const addProcessListeners = () => {
     // Listeners already set up
     if (watched) {
         return;
     }
     watched = process.on('uncaughtException', (err) => {
         console.error('uncaughtException', err);
-        if (err && logger) {
+        if (err && exports.logger) {
             err.type = 'uncaughtException';
-            logger.error(err);
+            exports.logger.error(err);
         }
         process.exit(420);
     });
@@ -32,9 +27,9 @@ exports.addProcessListeners = () => {
             return;
         }
         console.error('unhandledRejection', reason, promise);
-        if (reason && logger) {
+        if (reason && exports.logger) {
             reason.type = 'unhandledRejection';
-            logger.error(reason);
+            exports.logger.error(reason);
         }
     });
     process.on('warning', (warning) => {
@@ -43,3 +38,4 @@ exports.addProcessListeners = () => {
     process.on('SIGINT', handleSignal);
     process.on('SIGTERM', handleSignal);
 };
+exports.addProcessListeners = addProcessListeners;

package/lib/service/{Service.d.ts → worker/runtime/Service.d.ts}

@@ -1,5 +1,5 @@
-import { IOClients } from '../clients/IOClients';
-import { ServiceConfig } from './typings';
+import { IOClients } from '../../../clients/IOClients';
+import { ParamsContext, RecorderState, ServiceConfig } from './typings';
 /**
  * This is the client definition to allow type checking on code editors.
  * In you `index.ts`, you must `export default new Service({...})` with your
@@ -11,7 +11,7 @@ import { ServiceConfig } from './typings';
  * @template StateT The state bag in `ctx.state`
  * @template CustomT Any custom fields in `ctx`. THIS IS NOT RECOMMENDED. Use StateT instead.
  */
-export declare class Service<ClientsT extends IOClients = IOClients, StateT = void, CustomT = void> {
-    config: ServiceConfig<ClientsT, StateT, CustomT>;
-    constructor(config: ServiceConfig<ClientsT, StateT, CustomT>);
+export declare class Service<T extends IOClients, U extends RecorderState, V extends ParamsContext> {
+    config: ServiceConfig<T, U, V>;
+    constructor(config: ServiceConfig<T, U, V>);
 }

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

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Service = void 0;
+const logger_1 = require("../../logger");
 /**
  * This is the client definition to allow type checking on code editors.
  * In you `index.ts`, you must `export default new Service({...})` with your
@@ -15,7 +17,7 @@ class Service {
     constructor(config) {
         this.config = config;
         if (config.routes && config.routes.graphql) {
-            console.warn('Route id "graphql" is reserved and apps containing this routes will stop working in the near future. To create a GraphQL app, export a "graphql" key with {resolvers}.');
+            (0, logger_1.logOnceToDevConsole)(`Route id "graphql" is reserved and apps containing this routes will stop working in the near future. To create a GraphQL app, export a "graphql" key with {resolvers}.`, logger_1.LogLevel.Warn);
         }
     }
 }

package/lib/service/worker/runtime/builtIn/handlers.d.ts

@@ -0,0 +1,4 @@
+import { ServiceContext, ServiceJSON } from '../typings';
+export declare const whoAmIHandler: ({ events, routes, }: ServiceJSON) => (ctx: ServiceContext) => void;
+export declare const healthcheckHandler: ({ events, routes, }: ServiceJSON) => (ctx: ServiceContext) => void;
+export declare const metricsLoggerHandler: (ctx: ServiceContext) => void;

package/lib/service/worker/runtime/builtIn/handlers.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metricsLoggerHandler = exports.healthcheckHandler = exports.whoAmIHandler = void 0;
+const whoAmIHandler = ({ events, routes, }) => (ctx) => {
+    var _a, _b;
+    ctx.requestHandlerName = 'builtin:whoami';
+    (_b = (_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.currentSpan) === null || _b === void 0 ? void 0 : _b.setOperationName(ctx.requestHandlerName);
+    ctx.status = 200;
+    ctx.body = {
+        events,
+        routes,
+    };
+    ctx.set('Cache-Control', 'public, max-age=86400'); // cache for 24 hours
+};
+exports.whoAmIHandler = whoAmIHandler;
+const healthcheckHandler = ({ events, routes, }) => (ctx) => {
+    var _a, _b;
+    ctx.requestHandlerName = 'builtin:healthcheck';
+    (_b = (_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.currentSpan) === null || _b === void 0 ? void 0 : _b.setOperationName(ctx.requestHandlerName);
+    ctx.status = 200;
+    ctx.body = {
+        events,
+        routes,
+    };
+};
+exports.healthcheckHandler = healthcheckHandler;
+const metricsLoggerHandler = (ctx) => {
+    var _a, _b;
+    ctx.requestHandlerName = 'builtin:metrics-logger';
+    (_b = (_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.currentSpan) === null || _b === void 0 ? void 0 : _b.setOperationName(ctx.requestHandlerName);
+    ctx.status = 200;
+    ctx.body = ctx.metricsLogger.getSummaries();
+};
+exports.metricsLoggerHandler = metricsLoggerHandler;

package/lib/service/worker/runtime/builtIn/middlewares.d.ts

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

package/lib/service/worker/runtime/builtIn/middlewares.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prometheusLoggerMiddleware = exports.addMetricsLoggerMiddleware = exports.recorderMiddleware = void 0;
+const prom_client_1 = require("prom-client");
+const constants_1 = require("../../../../constants");
+const metricsLogger_1 = require("../../../logger/metricsLogger");
+const EventLoopLagMeasurer_1 = require("../../../tracing/metrics/measurers/EventLoopLagMeasurer");
+const recorder_1 = require("../utils/recorder");
+async function recorderMiddleware(ctx, next) {
+    const recorder = new recorder_1.Recorder();
+    ctx.state.recorder = recorder;
+    await next();
+    recorder.flush(ctx);
+    return;
+}
+exports.recorderMiddleware = recorderMiddleware;
+const addMetricsLoggerMiddleware = () => {
+    const metricsLogger = new metricsLogger_1.MetricsLogger();
+    return (ctx, next) => {
+        ctx.metricsLogger = metricsLogger;
+        return next();
+    };
+};
+exports.addMetricsLoggerMiddleware = addMetricsLoggerMiddleware;
+const prometheusLoggerMiddleware = () => {
+    (0, prom_client_1.collectDefaultMetrics)();
+    const eventLoopLagMeasurer = new EventLoopLagMeasurer_1.EventLoopLagMeasurer();
+    eventLoopLagMeasurer.start();
+    return async (ctx, next) => {
+        if (ctx.request.path !== '/metrics') {
+            return next();
+        }
+        const routeId = ctx.get(constants_1.COLOSSUS_ROUTE_ID_HEADER);
+        if (routeId) {
+            return next();
+        }
+        await eventLoopLagMeasurer.updateInstrumentsAndReset();
+        ctx.set('Content-Type', prom_client_1.register.contentType);
+        ctx.body = await prom_client_1.register.metrics();
+        ctx.status = 200;
+    };
+};
+exports.prometheusLoggerMiddleware = prometheusLoggerMiddleware;

package/lib/service/worker/runtime/events/index.d.ts

@@ -0,0 +1,4 @@
+import TokenBucket from 'tokenbucket';
+import { IOClients } from '../../../../clients/IOClients';
+import { ClientsConfig, EventHandler, ParamsContext, RecorderState, ServiceContext, ServiceEvent } from '../typings';
+export declare const createEventHandler: <T extends IOClients, U extends RecorderState, V extends ParamsContext>(clientsConfig: ClientsConfig<T>, eventId: string, handler: EventHandler<T, U> | EventHandler<T, U>[], serviceEvent: ServiceEvent | undefined, globalLimiter: TokenBucket | undefined) => import("koa-compose").ComposedMiddleware<ServiceContext<T, U, V>>;

package/lib/service/worker/runtime/events/index.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEventHandler = void 0;
+const tracingMiddlewares_1 = require("../../../tracing/tracingMiddlewares");
+const clients_1 = require("../http/middlewares/clients");
+const rateLimit_1 = require("../http/middlewares/rateLimit");
+const settings_1 = require("../http/middlewares/settings");
+const timings_1 = require("../http/middlewares/timings");
+const compose_1 = require("../utils/compose");
+const toArray_1 = require("../utils/toArray");
+const body_1 = require("./middlewares/body");
+const context_1 = require("./middlewares/context");
+const createEventHandler = (clientsConfig, eventId, handler, serviceEvent, globalLimiter) => {
+    var _a, _b;
+    const { implementation, options } = clientsConfig;
+    const middlewares = (0, toArray_1.toArray)(handler);
+    const pipeline = [
+        (0, tracingMiddlewares_1.nameSpanOperationMiddleware)('event-handler', eventId),
+        context_1.eventContextMiddleware,
+        body_1.parseBodyMiddleware,
+        (0, clients_1.clients)(implementation, options),
+        ...((serviceEvent === null || serviceEvent === void 0 ? void 0 : serviceEvent.settingsType) === 'workspace' || (serviceEvent === null || serviceEvent === void 0 ? void 0 : serviceEvent.settingsType) === 'userAndWorkspace' ? [(0, settings_1.getServiceSettings)()] : []),
+        timings_1.timings,
+        (0, rateLimit_1.concurrentRateLimiter)((_a = serviceEvent === null || serviceEvent === void 0 ? void 0 : serviceEvent.rateLimitPerReplica) === null || _a === void 0 ? void 0 : _a.concurrent),
+        (0, rateLimit_1.perMinuteRateLimiter)((_b = serviceEvent === null || serviceEvent === void 0 ? void 0 : serviceEvent.rateLimitPerReplica) === null || _b === void 0 ? void 0 : _b.perMinute, globalLimiter),
+        (0, tracingMiddlewares_1.traceUserLandRemainingPipelineMiddleware)(),
+        contextAdapter(middlewares),
+    ];
+    return (0, compose_1.compose)(pipeline);
+};
+exports.createEventHandler = createEventHandler;
+function contextAdapter(middlewares) {
+    return async function middlewareCascade(ctx) {
+        const ctxEvent = {
+            body: ctx.state.body,
+            clients: ctx.clients,
+            key: ctx.vtex.eventInfo ? ctx.vtex.eventInfo.key : '',
+            metrics: ctx.metrics,
+            sender: ctx.vtex.eventInfo ? ctx.vtex.eventInfo.sender : '',
+            state: ctx.state,
+            subject: ctx.vtex.eventInfo ? ctx.vtex.eventInfo.subject : '',
+            timings: ctx.timings,
+            vtex: ctx.vtex,
+        };
+        await (0, compose_1.composeForEvents)(middlewares)(ctxEvent);
+        ctx.status = 204;
+    };
+}

package/lib/service/worker/runtime/events/middlewares/body.d.ts

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

package/lib/service/worker/runtime/events/middlewares/body.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBodyMiddleware = void 0;
+const co_body_1 = __importDefault(require("co-body"));
+const logger_1 = require("../../../../logger");
+const console_1 = require("./../../../../logger/console");
+async function parseBodyMiddleware(ctx, next) {
+    try {
+        ctx.state.body = await (0, co_body_1.default)(ctx.req);
+    }
+    catch (err) {
+        if (!(err instanceof Error)) {
+            throw err;
+        }
+        const msg = `Error parsing event body: ${err.message || err}`;
+        ctx.status = 500;
+        ctx.body = msg;
+        (0, console_1.logOnceToDevConsole)(msg, logger_1.LogLevel.Error);
+        return;
+    }
+    await next();
+}
+exports.parseBodyMiddleware = parseBodyMiddleware;

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

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

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventContextMiddleware = void 0;
+const constants_1 = require("../../../../../constants");
+const context_1 = require("../../utils/context");
+async function eventContextMiddleware(ctx, next) {
+    const { request: { header } } = ctx;
+    ctx.vtex = {
+        ...(0, context_1.prepareHandlerCtx)(header, ctx.tracing),
+        eventInfo: {
+            key: header[constants_1.EVENT_KEY_HEADER],
+            sender: header[constants_1.EVENT_SENDER_HEADER],
+            subject: header[constants_1.EVENT_SUBJECT_HEADER],
+        },
+        route: {
+            id: header[constants_1.EVENT_HANDLER_ID_HEADER],
+            params: {},
+            type: 'event',
+        },
+    };
+    await next();
+}
+exports.eventContextMiddleware = eventContextMiddleware;

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

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