@vtex/api 6.45.4

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

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

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+exports.compose = (middlewares) => koa_compose_1.default(middlewares.map(ramda_1.pipe(time_1.timer, cancel_1.cancel)));
+exports.composeForEvents = (middlewares) => koa_compose_1.default(middlewares.map(time_1.timerForEvents));

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

@@ -0,0 +1,2 @@
+import { IOContext, TracingContext } from '../typings';
+export declare const prepareHandlerCtx: (header: any, tracingContext: TracingContext) => Pick<IOContext, "host" | "logger" | "account" | "workspace" | "requestId" | "operationId" | "production" | "platform" | "authToken" | "adminUserAuthToken" | "storeUserAuthToken" | "locale" | "product" | "recorder" | "region" | "userAgent" | "segmentToken" | "sessionToken" | "janusEnv" | "serverTiming" | "eventInfo" | "tenant" | "binding" | "cancellation" | "settings" | "tracer">;

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

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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';
+};
+exports.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] ? 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] || 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] ? tenant_1.parseTenantHeaderValue(header[constants_1.TENANT_HEADER]) : undefined,
+        tracer: new UserLandTracer_1.UserLandTracer(tracingContext.tracer, tracingContext.currentSpan),
+        userAgent: process.env.VTEX_APP_ID || '',
+        workspace: header[constants_1.WORKSPACE_HEADER],
+    };
+    return {
+        ...partialContext,
+        logger: new logger_1.Logger(partialContext),
+    };
+};

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,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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(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.d.ts

@@ -0,0 +1 @@
+export declare const toArray: <T>(x: T | T[]) => T[];

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

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

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,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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/tracing/LogEvents.js

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

package/lib/tracing/LogFields.d.ts

@@ -0,0 +1,61 @@
+/**
+ * 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",
+    /**
+     * 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,79 @@
+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"
+}
+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";
+};

package/lib/tracing/Tags.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const opentracing_1 = require("opentracing");
+exports.OpentracingTags = opentracing_1.Tags;
+exports.UserlandTags = {
+    ...opentracing_1.Tags,
+};

package/lib/tracing/UserLandTracer.d.ts

@@ -0,0 +1,27 @@
+import { Span, SpanContext, SpanOptions, Tracer } from 'opentracing';
+export interface IUserLandTracer {
+    traceId: string;
+    isTraceSampled: boolean;
+    startSpan: Tracer['startSpan'];
+    inject: Tracer['inject'];
+    fallbackSpanContext: () => SpanContext;
+}
+export declare const createTracingContextFromCarrier: (newSpanName: string, carrier: Record<string, any>) => {
+    span: Span;
+    tracer: IUserLandTracer;
+};
+export declare class UserLandTracer implements IUserLandTracer {
+    private tracer;
+    private fallbackSpan;
+    private fallbackSpanLock;
+    private _isSampled;
+    private _traceId;
+    constructor(tracer: Tracer, fallbackSpan: Span);
+    get traceId(): string;
+    get isTraceSampled(): boolean;
+    lockFallbackSpan(): void;
+    setFallbackSpan(newSpan: Span): void;
+    startSpan(name: string, options?: SpanOptions): Span;
+    inject(spanContext: SpanContext | Span, format: string, carrier: any): void;
+    fallbackSpanContext(): SpanContext;
+}

package/lib/tracing/UserLandTracer.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const opentracing_1 = require("opentracing");
+const TracerSingleton_1 = require("../service/tracing/TracerSingleton");
+const utils_1 = require("./utils");
+exports.createTracingContextFromCarrier = (newSpanName, carrier) => {
+    const tracer = TracerSingleton_1.TracerSingleton.getTracer();
+    const rootSpan = tracer.extract(opentracing_1.FORMAT_HTTP_HEADERS, carrier);
+    if (rootSpan == null) {
+        throw new Error('Missing span context data on carrier');
+    }
+    const span = tracer.startSpan(newSpanName, { childOf: rootSpan });
+    const userlandTracer = new UserLandTracer(tracer, span);
+    userlandTracer.lockFallbackSpan();
+    return { span, tracer: userlandTracer };
+};
+class UserLandTracer {
+    constructor(tracer, fallbackSpan) {
+        this.tracer = tracer;
+        this.fallbackSpan = fallbackSpan;
+        this.fallbackSpanLock = false;
+        const { traceId, isSampled } = utils_1.getTraceInfo(fallbackSpan);
+        this._traceId = traceId;
+        this._isSampled = isSampled;
+    }
+    get traceId() {
+        return this._traceId;
+    }
+    get isTraceSampled() {
+        return this._isSampled;
+    }
+    lockFallbackSpan() {
+        this.fallbackSpanLock = true;
+    }
+    setFallbackSpan(newSpan) {
+        if (this.fallbackSpanLock) {
+            throw new Error(`FallbackSpan is locked, can't change it`);
+        }
+        this.fallbackSpan = newSpan;
+    }
+    startSpan(name, options) {
+        var _a;
+        if (options && (options.childOf || ((_a = options.references) === null || _a === void 0 ? void 0 : _a.length))) {
+            return this.tracer.startSpan(name, options);
+        }
+        return this.tracer.startSpan(name, { ...options, childOf: this.fallbackSpan });
+    }
+    inject(spanContext, format, carrier) {
+        return this.tracer.inject(spanContext, format, carrier);
+    }
+    fallbackSpanContext() {
+        return this.fallbackSpan.context();
+    }
+}
+exports.UserLandTracer = UserLandTracer;