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

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

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

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

@@ -0,0 +1,9 @@
+import { IOClients } from '../../../clients/IOClients';
+import { ParamsContext, RecorderState, RouteHandler, ServiceContext } from './typings';
+type HTTPMethods = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH' | 'DEFAULT';
+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;
@@ -8,7 +9,7 @@ function methodNotAllowed(ctx) {
     ctx.set('cache-control', `public, max-age=${TEN_SECONDS_S}`);
 }
 function method(options) {
-    const handlers = ramda_1.mapObjIndexed(handler => compose_1.compose(Array.isArray(handler) ? handler : [handler]), options);
+    const handlers = (0, ramda_1.mapObjIndexed)(handler => (0, compose_1.compose)(Array.isArray(handler) ? handler : [handler]), options);
     const inner = async function forMethod(ctx, next) {
         const verb = ctx.method.toUpperCase();
         const handler = handlers[verb] || handlers.DEFAULT || methodNotAllowed;

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

@@ -0,0 +1,14 @@
+import { ServiceContext } from './typings';
+export 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,43 @@
+"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';
+const isStatusTrack = (message) => message === STATUS_TRACK;
+exports.isStatusTrack = isStatusTrack;
+const isStatusTrackBroadcast = (message) => message === BROADCAST_STATUS_TRACK;
+exports.isStatusTrackBroadcast = isStatusTrackBroadcast;
+const 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.statusTrackHandler = statusTrackHandler;
+const trackStatus = () => {
+    global.metrics.statusTrack().forEach(status => {
+        logStatus(status);
+    });
+};
+exports.trackStatus = trackStatus;
+const broadcastStatusTrack = () => Object.values(cluster_1.default.workers).forEach(worker => worker === null || worker === void 0 ? void 0 : worker.send(STATUS_TRACK));
+exports.broadcastStatusTrack = broadcastStatusTrack;
+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,
+}));

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

@@ -0,0 +1,173 @@
+/// <reference types="node" />
+import { CancelTokenSource } from 'axios';
+import DataLoader from 'dataloader';
+import { GraphQLFieldConfig, GraphQLFieldResolver, GraphQLScalarType } from 'graphql';
+import { SchemaDirectiveVisitor } from 'graphql-tools';
+import { ParameterizedContext } from 'koa';
+import { Middleware } from 'koa-compose';
+import { Span, Tracer } from 'opentracing';
+import { ParsedUrlQuery } from 'querystring';
+import { ClientsImplementation, IOClients } from '../../../clients/IOClients';
+import { InstanceOptions } from '../../../HttpClient';
+import { IUserLandTracer } from '../../../tracing/UserLandTracer';
+import { BindingHeader } from '../../../utils/binding';
+import { IOMessage } from '../../../utils/message';
+import { TenantHeader } from '../../../utils/tenant';
+import { Logger } from '../../logger';
+import { MetricsLogger } from '../../logger/metricsLogger';
+import { MessagesLoaderV2 } from './graphql/schema/messagesLoaderV2';
+import { Recorder } from './utils/recorder';
+type ServerTiming = Record<string, string>;
+export type Maybe<T> = T | null | undefined;
+export interface TracingContext {
+    tracer: Tracer;
+    currentSpan: Span | undefined;
+}
+export interface Context<T extends IOClients> {
+    clients: T;
+    vtex: IOContext;
+    timings: Record<string, [number, number]>;
+    metrics: Record<string, [number, number]>;
+    previousTimerStart: [number, number];
+    requestHandlerName?: string;
+    serverTiming?: ServerTiming;
+    tracing?: TracingContext;
+}
+export interface EventContext<T extends IOClients, StateT = any> {
+    clients: T;
+    state: StateT;
+    vtex: IOContext;
+    body: any;
+    timings: Record<string, [number, number]>;
+    metrics: Record<string, [number, number]>;
+    key: string;
+    sender: string;
+    subject: string;
+}
+type KnownKeys<T> = {
+    [K in keyof T]: string extends K ? never : number extends K ? never : K;
+} extends {
+    [_ in keyof T]: infer U;
+} ? U : never;
+interface Loaders {
+    messages?: DataLoader<IOMessage, string>;
+    messagesV2?: MessagesLoaderV2;
+    immutableMessagesV2?: MessagesLoaderV2;
+}
+export type ServiceContext<ClientsT extends IOClients = IOClients, StateT extends RecorderState = RecorderState, CustomT extends ParamsContext = ParamsContext> = Pick<ParameterizedContext<StateT, Context<ClientsT>>, KnownKeys<ParameterizedContext<StateT, Context<ClientsT>>>> & CustomT & {
+    loaders?: Loaders;
+};
+export type RouteHandler<ClientsT extends IOClients = IOClients, StateT extends RecorderState = RecorderState, CustomT extends ParamsContext = ParamsContext> = Middleware<ServiceContext<ClientsT, StateT, CustomT>>;
+export type EventHandler<ClientsT extends IOClients = IOClients, StateT = void> = Middleware<EventContext<ClientsT, StateT>>;
+export type Resolver<ClientsT extends IOClients = IOClients, StateT extends RecorderState = RecorderState, CustomT extends ParamsContext = ParamsContext> = GraphQLFieldResolver<any, ServiceContext<ClientsT, StateT, CustomT>, any> | GraphQLFieldConfig<any, ServiceContext<ClientsT, StateT, CustomT>, any>;
+export type Handler = RouteHandler<IOClients, RecorderState, ParamsContext>;
+export interface HttpRoute {
+    handler: RouteHandler;
+    path: string;
+}
+export interface RecorderState {
+    recorder: Recorder;
+    body: any;
+}
+export interface ParamsContext {
+    params: any;
+    metricsLogger: MetricsLogger;
+}
+export interface ClientsConfig<ClientsT extends IOClients = IOClients> {
+    implementation?: ClientsImplementation<ClientsT>;
+    options: Record<string, InstanceOptions>;
+}
+export interface GraphQLOptions<ClientsT extends IOClients = IOClients, StateT extends RecorderState = RecorderState, CustomT extends ParamsContext = ParamsContext> {
+    resolvers: Record<string, Record<string, Resolver<ClientsT, StateT, CustomT>> | GraphQLScalarType>;
+    schema?: string;
+    schemaDirectives?: Record<string, typeof SchemaDirectiveVisitor>;
+}
+export interface ServiceConfig<ClientsT extends IOClients = IOClients, StateT extends RecorderState = RecorderState, CustomT extends ParamsContext = ParamsContext> {
+    clients?: ClientsConfig<ClientsT>;
+    events?: Record<string, EventHandler<ClientsT, StateT> | Array<EventHandler<ClientsT, StateT>>>;
+    graphql?: GraphQLOptions<ClientsT, StateT, CustomT>;
+    routes?: Record<string, RouteHandler<ClientsT, StateT, CustomT> | Array<RouteHandler<ClientsT, StateT, CustomT>>>;
+}
+export interface Cancellation {
+    cancelable: boolean;
+    cancelled: boolean;
+    source: CancelTokenSource;
+}
+export interface IOContext {
+    account: string;
+    platform: string;
+    authToken: string;
+    adminUserAuthToken?: string;
+    storeUserAuthToken?: string;
+    locale?: string;
+    production: boolean;
+    product: string;
+    recorder?: Recorder;
+    region: string;
+    route: {
+        declarer?: string;
+        id: string;
+        params: ParsedUrlQuery;
+        type: 'public' | 'private' | 'event';
+    };
+    userAgent: string;
+    workspace: string;
+    segmentToken?: string;
+    sessionToken?: string;
+    requestId: string;
+    operationId: string;
+    janusEnv?: JanusEnv;
+    serverTiming?: ServerTiming;
+    logger: Logger;
+    eventInfo?: EventBody;
+    host?: string;
+    tenant?: TenantHeader;
+    binding?: BindingHeader;
+    cancellation?: Cancellation;
+    settings?: any;
+    tracer: IUserLandTracer;
+}
+export interface EventBody {
+    sender: string;
+    subject: string;
+    key: string;
+}
+export type RouteSettingsType = 'pure' | 'workspace' | 'userAndWorkspace';
+export interface ServiceRoute {
+    path: string;
+    public?: boolean;
+    smartcache?: boolean;
+    extensible?: boolean;
+    settingsType?: RouteSettingsType;
+    rateLimitPerReplica?: RateLimitOptions;
+}
+export interface ServiceEvent {
+    keys?: string[];
+    sender?: string;
+    subject?: string;
+    settingsType?: RouteSettingsType;
+    rateLimitPerReplica?: RateLimitOptions;
+}
+export interface RateLimitOptions {
+    perMinute?: number;
+    concurrent?: number;
+}
+export interface RawServiceJSON {
+    stack: 'nodejs';
+    memory: number;
+    ttl?: number;
+    timeout?: number;
+    runtimeArgs?: string[];
+    routes?: Record<string, ServiceRoute>;
+    rateLimitPerReplica?: RateLimitOptions;
+    events?: Record<string, ServiceEvent>;
+    minReplicas?: number;
+    maxReplicas?: number;
+    workers?: number;
+    deterministicVary?: boolean;
+}
+export interface ServiceJSON extends RawServiceJSON {
+    workers: number;
+}
+export type JanusEnv = string;
+export {};

package/lib/service/worker/runtime/utils/compose.d.ts

@@ -0,0 +1,5 @@
+import koaCompose from 'koa-compose';
+import { IOClients } from '../../../../clients/IOClients';
+import { EventHandler, ParamsContext, RecorderState, RouteHandler } from '../typings';
+export declare const compose: <ClientsT extends IOClients, StateT extends RecorderState, CustomT extends ParamsContext>(middlewares: RouteHandler<ClientsT, StateT, CustomT>[]) => koaCompose.ComposedMiddleware<import("../typings").ServiceContext<ClientsT, StateT, CustomT>>;
+export declare const composeForEvents: <ClientsT extends IOClients, StateT extends RecorderState>(middlewares: EventHandler<ClientsT, StateT>[]) => koaCompose.ComposedMiddleware<import("../typings").EventContext<ClientsT, StateT>>;

package/lib/service/worker/runtime/utils/compose.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeForEvents = exports.compose = void 0;
+const koa_compose_1 = __importDefault(require("koa-compose"));
+const ramda_1 = require("ramda");
+const cancel_1 = require("../../../../utils/cancel");
+const time_1 = require("../../../../utils/time");
+const compose = (middlewares) => (0, koa_compose_1.default)(middlewares.map((0, ramda_1.pipe)(time_1.timer, cancel_1.cancel)));
+exports.compose = compose;
+const composeForEvents = (middlewares) => (0, koa_compose_1.default)(middlewares.map(time_1.timerForEvents));
+exports.composeForEvents = composeForEvents;

package/lib/service/worker/runtime/utils/context.d.ts

@@ -0,0 +1,5 @@
+import { Context } from 'koa';
+import { IOContext, TracingContext } from '../typings';
+type HandlerContext = Omit<IOContext, 'route'>;
+export declare const prepareHandlerCtx: (header: Context['request']['header'], tracingContext?: TracingContext) => HandlerContext;
+export {};

package/lib/service/worker/runtime/utils/context.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareHandlerCtx = void 0;
+const v4_1 = __importDefault(require("uuid/v4"));
+const constants_1 = require("../../../../constants");
+const UserLandTracer_1 = require("../../../../tracing/UserLandTracer");
+const tenant_1 = require("../../../../utils/tenant");
+const logger_1 = require("../../../logger");
+const binding_1 = require("./../../../../utils/binding");
+const getPlatform = (account) => {
+    return account.startsWith('gc-') ? 'gocommerce' : 'vtex';
+};
+const prepareHandlerCtx = (header, tracingContext) => {
+    var _a;
+    const partialContext = {
+        account: header[constants_1.ACCOUNT_HEADER],
+        authToken: header[constants_1.CREDENTIAL_HEADER],
+        binding: header[constants_1.BINDING_HEADER] ? (0, binding_1.parseBindingHeaderValue)(header[constants_1.BINDING_HEADER]) : undefined,
+        host: header[constants_1.FORWARDED_HOST_HEADER],
+        locale: header[constants_1.LOCALE_HEADER],
+        operationId: header[constants_1.OPERATION_ID_HEADER] || (0, v4_1.default)(),
+        platform: header[constants_1.PLATFORM_HEADER] || getPlatform(header[constants_1.ACCOUNT_HEADER]),
+        product: header[constants_1.PRODUCT_HEADER],
+        production: ((_a = header[constants_1.WORKSPACE_IS_PRODUCTION_HEADER]) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === 'true' || false,
+        region: constants_1.REGION,
+        requestId: header[constants_1.REQUEST_ID_HEADER],
+        segmentToken: header[constants_1.SEGMENT_HEADER],
+        sessionToken: header[constants_1.SESSION_HEADER],
+        tenant: header[constants_1.TENANT_HEADER] ? (0, tenant_1.parseTenantHeaderValue)(header[constants_1.TENANT_HEADER]) : undefined,
+        tracer: new UserLandTracer_1.UserLandTracer(tracingContext === null || tracingContext === void 0 ? void 0 : tracingContext.tracer, tracingContext === null || tracingContext === void 0 ? void 0 : tracingContext.currentSpan),
+        userAgent: process.env.VTEX_APP_ID || '',
+        workspace: header[constants_1.WORKSPACE_HEADER],
+    };
+    return {
+        ...partialContext,
+        logger: new logger_1.Logger(partialContext),
+    };
+};
+exports.prepareHandlerCtx = prepareHandlerCtx;

package/lib/service/worker/runtime/utils/diff.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+export interface Snapshot {
+    usage: NodeJS.CpuUsage;
+    time: number;
+}
+interface CpuUsage {
+    user: number;
+    system: number;
+}
+export declare function cpuSnapshot(): Snapshot;
+export declare function snapshotDiff(curr: Snapshot, last: Snapshot): CpuUsage;
+export {};

package/lib/service/worker/runtime/utils/diff.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snapshotDiff = exports.cpuSnapshot = void 0;
+function cpuSnapshot() {
+    return {
+        time: microtime(),
+        usage: process.cpuUsage(),
+    };
+}
+exports.cpuSnapshot = cpuSnapshot;
+function snapshotDiff(curr, last) {
+    const timeDiff = curr.time - last.time;
+    return {
+        system: (curr.usage.system - last.usage.system) / timeDiff,
+        user: (curr.usage.user - last.usage.user) / timeDiff,
+    };
+}
+exports.snapshotDiff = snapshotDiff;
+function microtime() {
+    const hrTime = process.hrtime();
+    return hrTime[0] * 1000000 + hrTime[1] / 1000;
+}

package/lib/service/worker/runtime/utils/recorder.d.ts

@@ -0,0 +1,8 @@
+import { Context } from 'koa';
+export declare class Recorder {
+    private _record;
+    constructor();
+    clear(): void;
+    record(headers?: Record<string, string>): void;
+    flush(ctx: Context): void;
+}

package/lib/service/worker/runtime/utils/recorder.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Recorder = void 0;
+const ramda_1 = require("ramda");
+const constants_1 = require("./../../../../constants");
+const HEADERS = [constants_1.META_HEADER, constants_1.META_HEADER_BUCKET];
+class Recorder {
+    constructor() {
+        this._record = HEADERS.reduce((acc, headerName) => {
+            acc[headerName] = new Set();
+            return acc;
+        }, {});
+    }
+    clear() {
+        HEADERS.forEach(headerName => this._record[headerName].clear());
+    }
+    record(headers) {
+        HEADERS.forEach(headerName => {
+            const h = headers === null || headers === void 0 ? void 0 : headers[headerName];
+            if (h) {
+                h.split(',').map(ramda_1.trim).forEach(hh => this._record[headerName].add(hh));
+            }
+        });
+    }
+    flush(ctx) {
+        HEADERS.forEach(headerName => {
+            const newValueSet = new Set(this._record[headerName]);
+            const currentValue = ctx.response.get(headerName);
+            const parsedCurrentValue = typeof currentValue === 'string' ? currentValue.split(',') : currentValue;
+            parsedCurrentValue.forEach(cur => newValueSet.add((0, ramda_1.trim)(cur)));
+            const deduped = Array.from(newValueSet).filter(x => !!x);
+            if (deduped.length > 0) {
+                ctx.set(headerName, deduped);
+            }
+        });
+    }
+}
+exports.Recorder = Recorder;

package/lib/service/worker/runtime/utils/toArray.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toArray = void 0;
+const toArray = (x) => Array.isArray(x) ? x : [x];
+exports.toArray = toArray;

package/lib/service/worker/runtime/utils/tokenBucket.d.ts

@@ -0,0 +1,2 @@
+import TokenBucket from 'tokenbucket';
+export declare function createTokenBucket(rateLimit?: number, globalRateTokenBucket?: TokenBucket): TokenBucket;

package/lib/service/worker/runtime/utils/tokenBucket.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTokenBucket = void 0;
+const tokenbucket_1 = __importDefault(require("tokenbucket"));
+function createTokenBucket(rateLimit, globalRateTokenBucket) {
+    return rateLimit ? new tokenbucket_1.default({
+        interval: 'minute',
+        parentBucket: globalRateTokenBucket,
+        size: Math.ceil(rateLimit / 2.0),
+        spread: true,
+        tokensToAddPerInterval: rateLimit,
+    }) : globalRateTokenBucket;
+}
+exports.createTokenBucket = createTokenBucket;

package/lib/tracing/LogEvents.d.ts

@@ -0,0 +1,31 @@
+/**
+ * This file has all events logged by the runtime's distributed tracing
+ * instrumentation. In the code you would see something like:
+ * ```
+ * span.log({ event: HttpEvents.CACHE_KEY_CREATE })
+ * ```
+ */
+export declare const enum HttpLogEvents {
+    /** Event holding the cache key created */
+    CACHE_KEY_CREATE = "cache-key-created",
+    /** Event representing that the memoization cache has just saved a response */
+    MEMOIZATION_CACHE_SAVED = "memoization-cache-saved",
+    /** Event representing that the memoization cache has just saved a error response */
+    MEMOIZATION_CACHE_SAVED_ERROR = "memoization-cache-saved-error",
+    /** Event holding information on a local cache hit that just happened */
+    LOCAL_CACHE_HIT_INFO = "local-cache-hit-info",
+    /** Event holding information on the cache config that will be used to decide whether or not to update the local cache */
+    CACHE_CONFIG = "cache-config",
+    /** Event informing the decision to not update or save to local cache */
+    NO_LOCAL_CACHE_SAVE = "no-local-cache-save",
+    /** Event holding information on the local cache save that just happened */
+    LOCAL_CACHE_SAVED = "local-cache-saved",
+    /** A request that is retryable just failed - this event will hold info on the retry that may happen */
+    SETUP_REQUEST_RETRY = "setup-request-retry"
+}
+export declare const enum RuntimeLogEvents {
+    /** Event representing that userland middlewares are about to start */
+    USER_MIDDLEWARES_START = "user-middlewares-start",
+    /** Event representing that userland middlewares just finished */
+    USER_MIDDLEWARES_FINISH = "user-middlewares-finish"
+}

package/lib/{service/graphql/utils/array.js → tracing/LogEvents.js}

@@ -1,3 +1,3 @@
 "use strict";
+/* tslint:disable:object-literal-sort-keys */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toArray = (x) => Array.isArray(x) ? x : [x];

package/lib/tracing/LogFields.d.ts

@@ -0,0 +1,66 @@
+/**
+ * When using span.log({ field1: string1, field2: object2, ... })
+ * The jaeger backend indexes for search the first-level fields that hold strings
+ * These fields then can be searched on jaeger-ui using: 'field1=string'
+ * This file concentrates all log fields used in node-vtex-api that hold
+ * strings and can be searched in the jaeger-ui
+ */
+export declare const enum ErrorReportLogFields {
+    /**
+     * ErrorReport class has some meta info on the error
+     * The following log fields hold this meta info
+     */
+    ERROR_KIND = "error.kind",
+    ERROR_ID = "error.id",
+    ERROR_MESSAGE = "error.message",
+    ERROR_CODE = "error.code",
+    ERROR_STACK = "error.stack",
+    ERROR_METADATA_REPORT_COUNT = "error.metadata.reportCount",
+    ERROR_METADATA_METRICS_INSTANTIATION_TIME = "error.metadata.metrics.InstantiationTime",
+    /**
+     * VTEX's Infra errors adds error details to the response
+     * The following log fields are supposed to hold these fields
+     */
+    ERROR_SERVER_CODE = "error.server.code",
+    ERROR_SERVER_REQUEST_ID = "error.server.request_id"
+}
+export declare const enum RuntimeLogFields {
+    /** Time in ms spent to run the user middlewares */
+    USER_MIDDLEWARES_DURATION = "user-middlewares-duration"
+}
+export declare const enum HttpCacheLogFields {
+    /** The generated cache key for Memoization or Local caches */
+    KEY = "key",
+    /** The generated cache key for local cache with the segment added to it */
+    KEY_WITH_SEGMENT = "key-with-segment",
+    /** The key that was just set on the cache */
+    KEY_SET = "key-set",
+    /** The type of cache: 'disk', 'memory' or 'memoization' */
+    CACHE_TYPE = "cache-type",
+    /** The etag for the current request used for caching decisions. Can be undefined. */
+    ETAG = "etag",
+    /** The expiration time in seconds of the current cache entry (either just saved or fetched from the storage) */
+    EXPIRATION_TIME = "expiration-time",
+    /** The http response type. Can be undefined. */
+    RESPONSE_TYPE = "response-type",
+    /** The http response encoding. Can be undefined. */
+    RESPONSE_ENCONDING = "response-encoding",
+    /**
+     * The forceMaxAge option on the incoming RequestConfig. This can be set to override no-cache or no-store headers.
+     * Can be undefined.
+     */
+    FORCE_MAX_AGE = "force-max-age",
+    /** The calculated max-age the current response will have if stored */
+    CALCULATED_MAX_AGE = "calculated-max-age",
+    /** Content parsed from the incoming response headers */
+    AGE = "age",
+    NO_CACHE = "no-cache",
+    NO_STORE = "no-store",
+    MAX_AGE = "max-age"
+}
+export declare const enum HttpRetryLogFields {
+    /** The retry number scheduled (e.g, 1, 2, meaning that is the first or second retry) */
+    RETRY_NUMBER = "retry-number",
+    /** How much time in ms will be waited until this retry happens */
+    RETRY_IN = "retry-in"
+}

package/lib/tracing/LogFields.js

@@ -0,0 +1,3 @@
+"use strict";
+/* tslint:disable:object-literal-sort-keys */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/tracing/Tags.d.ts

@@ -0,0 +1,81 @@
+import { Tags as OpentracingTags } from 'opentracing';
+export { OpentracingTags };
+/**
+ * The following tags are process tags - defined when the tracer is instantiated.
+ * Those will annotate all spans created
+ */
+export declare const enum AppTags {
+    /** Boolean indicating if the app is linked or not */
+    VTEX_APP_LINKED = "app.linked",
+    /** The value of the NODE_ENV environment variable */
+    VTEX_APP_NODE_ENV = "app.node_env",
+    /** The @vtex/api version used (e.g. '6.1.2') */
+    VTEX_APP_NODE_VTEX_API_VERSION = "app.node_vtex_api_version",
+    /** The value of the VTEX_PRODUCTION environment variable - whether the app is in a production workspace */
+    VTEX_APP_PRODUCTION = "app.production",
+    /** The value of the VTEX_REGION environment variable (e.g. 'aws-us-east-1') */
+    VTEX_APP_REGION = "app.region",
+    /** The app version (e.g. '1.2.0') */
+    VTEX_APP_VERSION = "app.version",
+    /** The workspace in which the app is installed or linked */
+    VTEX_APP_WORKSPACE = "app.workspace"
+}
+/** The following tags annotate the entrypoint span on incoming requests */
+export declare const enum VTEXIncomingRequestTags {
+    /** The account being served by the request */
+    VTEX_ACCOUNT = "vtex.incoming.account",
+    /** The request id header value */
+    VTEX_REQUEST_ID = "vtex.request_id",
+    /** The workspace being served by the request */
+    VTEX_WORKSPACE = "vtex.incoming.workspace"
+}
+export declare const enum CustomHttpTags {
+    HTTP_PATH = "http.path",
+    /** Set to true when the client had no response, probably meaning that there was a client error */
+    HTTP_NO_RESPONSE = "http.no_response",
+    /** The HTTP client name (e.g. Apps, Registry, Router) */
+    HTTP_CLIENT_NAME = "http.client.name",
+    /**
+     * CACHE_ENABLED tags indicate if the Cache strategy is enabled
+     * for the specific request.
+     */
+    HTTP_MEMOIZATION_CACHE_ENABLED = "http.cache.memoization.enabled",
+    HTTP_DISK_CACHE_ENABLED = "http.cache.disk.enabled",
+    HTTP_MEMORY_CACHE_ENABLED = "http.cache.memory.enabled",
+    /**
+     * CACHE_RESULT tags indicate the result for that cache strategy
+     * (HIT or MISS for example). Since there may be many layers
+     * of cache a ENABLED flag for a strategy may be 'true', but
+     * the RESULT for that strategy may not be present.
+     */
+    HTTP_MEMORY_CACHE_RESULT = "http.cache.memory",
+    HTTP_MEMOIZATION_CACHE_RESULT = "http.cache.memoization",
+    HTTP_DISK_CACHE_RESULT = "http.cache.disk",
+    HTTP_ROUTER_CACHE_RESULT = "http.cache.router",
+    HTTP_RETRY_ERROR_CODE = "http.retry.error.code",
+    HTTP_RETRY_COUNT = "http.retry.count"
+}
+export declare const UserlandTags: {
+    SPAN_KIND: "span.kind";
+    SPAN_KIND_RPC_CLIENT: "client";
+    SPAN_KIND_RPC_SERVER: "server";
+    SPAN_KIND_MESSAGING_PRODUCER: "producer";
+    SPAN_KIND_MESSAGING_CONSUMER: "consumer";
+    ERROR: "error";
+    COMPONENT: "component";
+    SAMPLING_PRIORITY: "sampling.priority";
+    PEER_SERVICE: "peer.service";
+    PEER_HOSTNAME: "peer.hostname";
+    PEER_ADDRESS: "peer.address";
+    PEER_HOST_IPV4: "peer.ipv4";
+    PEER_HOST_IPV6: "peer.ipv6";
+    PEER_PORT: "peer.port";
+    HTTP_URL: "http.url";
+    HTTP_METHOD: "http.method";
+    HTTP_STATUS_CODE: "http.status_code";
+    MESSAGE_BUS_DESTINATION: "message_bus.destination";
+    DB_INSTANCE: "db.instance";
+    DB_STATEMENT: "db.statement";
+    DB_TYPE: "db.type";
+    DB_USER: "db.user";
+};