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

package/lib/index.js

@@ -1,19 +1,30 @@
 "use strict";
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 process.env.FORCE_COLOR = '1';
-__export(require("./caches"));
-__export(require("./clients"));
-__export(require("./clients/IOClients"));
-__export(require("./errors"));
-__export(require("./HttpClient"));
-__export(require("./IODataSource"));
-__export(require("./metrics/MetricsAccumulator"));
-__export(require("./service/Runtime"));
-__export(require("./service/Service"));
-__export(require("./service/method"));
-__export(require("./service/graphql/schema/schemaDirectives"));
-__export(require("./utils"));
-__export(require("./constants"));
+__exportStar(require("./caches"), exports);
+__exportStar(require("./clients"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./HttpClient"), exports);
+__exportStar(require("./metrics/MetricsAccumulator"), exports);
+__exportStar(require("./responses"), exports);
+__exportStar(require("./service/worker/runtime/Service"), exports);
+__exportStar(require("./service/worker/runtime/method"), exports);
+__exportStar(require("./service/worker/runtime/typings"), exports);
+__exportStar(require("./service/worker/runtime/graphql/schema/schemaDirectives"), exports);
+__exportStar(require("./service/worker/runtime/graphql/schema/messagesLoaderV2"), exports);
+__exportStar(require("./service/worker/runtime/utils/recorder"), exports);
+__exportStar(require("./service"), exports);
+__exportStar(require("./service/logger"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./tracing"), exports);

package/lib/metrics/MetricsAccumulator.d.ts

@@ -1,36 +1,19 @@
+import { EnvMetric } from '../service/worker/runtime/statusTrack';
 export interface Metric {
     name: string;
     [key: string]: number | string | null;
 }
-interface NamedMetric {
-    name: string;
-    [key: string]: any;
-}
-export interface EnvMetric extends NamedMetric {
-    production: boolean;
-}
 interface GetStats {
     getStats(): {
         [key: string]: number | boolean | string | undefined;
     };
 }
-export declare type StatusTrack = () => EnvMetric[];
 export declare class MetricsAccumulator {
     private metricsMillis;
     private extensions;
     private cacheMap;
     private onFlushMetrics;
     constructor();
-    /**
-     * @deprecated in favor of MetricsAccumulator.batch(name, diffNs, cacheHit)
-     * @see batch
-     */
-    batchHrTimeMetricFromEnd: (name: string, end?: [number, number] | undefined) => void;
-    /**
-     * @deprecated in favor of MetricsAccumulator.batch(name, diffNs, cacheHit)
-     * @see batch
-     */
-    batchHrTimeMetric: (name: string, start: [number, number]) => void;
     batchMetric: (name: string, timeMillis?: number | undefined, extensions?: Record<string, string | number> | undefined) => void;
     /**
      * Batches a named metric which took `diffNs`.

package/lib/metrics/MetricsAccumulator.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsAccumulator = void 0;
 const ramda_1 = require("ramda");
 const stats_lite_1 = require("stats-lite");
-const request_1 = require("../HttpClient/middlewares/request");
-const requestStats_1 = require("../service/http/middlewares/requestStats");
+const HttpAgentSingleton_1 = require("../HttpClient/middlewares/request/HttpAgentSingleton");
+const requestStats_1 = require("../service/worker/runtime/http/middlewares/requestStats");
 const time_1 = require("../utils/time");
 // Production pods never handle development workspaces and vice-versa.
 const production = process.env.VTEX_PRODUCTION === 'true';
@@ -23,20 +24,6 @@ function getIncomingRequestStats() {
 }
 class MetricsAccumulator {
     constructor() {
-        /**
-         * @deprecated in favor of MetricsAccumulator.batch(name, diffNs, cacheHit)
-         * @see batch
-         */
-        this.batchHrTimeMetricFromEnd = (name, end) => {
-            this.batchMetric(name, end ? time_1.hrToMillis(end) : undefined);
-        };
-        /**
-         * @deprecated in favor of MetricsAccumulator.batch(name, diffNs, cacheHit)
-         * @see batch
-         */
-        this.batchHrTimeMetric = (name, start) => {
-            this.batchMetric(name, time_1.hrToMillis(process.hrtime(start)));
-        };
         this.batchMetric = (name, timeMillis, extensions) => {
             if (!this.metricsMillis[name]) {
                 this.metricsMillis[name] = [];
@@ -81,19 +68,49 @@ class MetricsAccumulator {
             return this.flushMetrics();
         };
         this.metricToAggregate = (value, key) => {
-            const aggregate = Object.assign({ name: key, count: value.length, max: Math.max(...value), mean: stats_lite_1.mean(value), median: stats_lite_1.median(value), percentile95: stats_lite_1.percentile(value, 0.95), percentile99: stats_lite_1.percentile(value, 0.99), production }, this.extensions[key]);
+            const aggregate = {
+                name: key,
+                count: value.length,
+                max: Math.max(...value),
+                mean: stats_lite_1.mean(value),
+                median: stats_lite_1.median(value),
+                percentile95: stats_lite_1.percentile(value, 0.95),
+                percentile99: stats_lite_1.percentile(value, 0.99),
+                production,
+                ...this.extensions[key],
+            };
             delete this.metricsMillis[key];
             delete this.extensions[key];
             return aggregate;
         };
-        this.cacheToMetric = (value, key) => (Object.assign({}, value.getStats(), { name: `${key}-cache`, production }));
+        this.cacheToMetric = (value, key) => ({
+            ...value.getStats(),
+            name: `${key}-cache`,
+            production,
+        });
         this.flushMetrics = () => {
             const aggregateMetrics = ramda_1.values(ramda_1.mapObjIndexed(this.metricToAggregate, this.metricsMillis));
             const systemMetrics = [
-                Object.assign({}, cpuUsage(), { name: 'cpu', production }),
-                Object.assign({}, process.memoryUsage(), { name: 'memory', production }),
-                Object.assign({}, request_1.httpAgentStats(), { name: 'httpAgent', production }),
-                Object.assign({}, getIncomingRequestStats(), { name: 'incomingRequest', production }),
+                {
+                    ...cpuUsage(),
+                    name: 'cpu',
+                    production,
+                },
+                {
+                    ...process.memoryUsage(),
+                    name: 'memory',
+                    production,
+                },
+                {
+                    ...HttpAgentSingleton_1.HttpAgentSingleton.httpAgentStats(),
+                    name: 'httpAgent',
+                    production,
+                },
+                {
+                    ...getIncomingRequestStats(),
+                    name: 'incomingRequest',
+                    production,
+                },
             ];
             const onFlushMetrics = ramda_1.flatten(ramda_1.map(getMetric => getMetric(), this.onFlushMetrics));
             const envFlushMetric = ramda_1.map(ramda_1.assoc('production', production), onFlushMetrics);

package/lib/responses.d.ts

@@ -1,3 +1,4 @@
+import { BillingOptions } from './utils/billingOptions';
 export interface Policy {
     name: string;
     attrs?: {
@@ -45,50 +46,6 @@ export interface BucketMetadata {
     lastModified: string;
     hash: string;
 }
-export interface RootBillingOptions {
-    termsURL: string;
-    support: Support;
-}
-export interface FreeBillingOptions extends RootBillingOptions {
-    free: boolean;
-}
-export interface ChargeableBillingOptions extends RootBillingOptions {
-    policies: BillingPolicy[];
-}
-export interface Support {
-    url: string;
-    email: string;
-}
-export declare type BillingOptions = FreeBillingOptions | ChargeableBillingOptions;
-export interface BillingPolicy {
-    currency: string;
-    billing: BillingChargeElements;
-}
-export interface BillingChargeElements {
-    taxClassification: string;
-    items: CalculationItem[];
-}
-export interface RootCalculationItem {
-    itemCurrency: string;
-}
-export interface FixedCalculationItem extends RootCalculationItem {
-    fixed: number;
-}
-export interface MetricBasedCalculationItem extends RootCalculationItem {
-    calculatedByMetricUnit: CalculatedByMetricUnit;
-}
-export declare type CalculationItem = FixedCalculationItem | MetricBasedCalculationItem;
-export interface CalculatedByMetricUnit {
-    metricId: string;
-    metricName: string;
-    ranges: Range[];
-    route?: string;
-}
-export interface Range {
-    exclusiveFrom: number;
-    inclusiveTo?: number;
-    multiplier: number;
-}
 export interface AppBundleResponse {
     message: string;
     id: string;
@@ -99,6 +56,7 @@ export declare type AppBundlePublished = AppBundleResponse & {
 export declare type AppBundleLinked = AppBundleResponse & {
     bundleSize?: number;
 };
+export declare type AppState = 'stable' | 'releaseCandidate';
 export interface HouseKeeperState {
     infra: string[];
     edition: string[];
@@ -118,4 +76,5 @@ export interface HousekeeperStatesAndUpdates {
     state: HouseKeeperState;
     updates: HouseKeeperUpdates;
 }
+export declare type VBaseSaveResponse = FileListItem[];
 export {};

package/lib/service/index.d.ts

@@ -0,0 +1,2 @@
+export declare const startApp: () => void;
+export { appPath } from './loaders';

package/lib/service/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startApp = void 0;
+const cluster_1 = __importDefault(require("cluster"));
+const constants_1 = require("../constants");
+const loaders_1 = require("./loaders");
+const logger_1 = require("./logger");
+const master_1 = require("./master");
+const worker_1 = require("./worker");
+exports.startApp = () => {
+    const serviceJSON = loaders_1.getServiceJSON();
+    try {
+        // if it is a master process then call setting up worker process
+        if (cluster_1.default.isMaster) {
+            master_1.startMaster(serviceJSON);
+        }
+        else {
+            // to setup server configurations and share port address for incoming requests
+            worker_1.startWorker(serviceJSON).listen(constants_1.HTTP_SERVER_PORT);
+        }
+    }
+    catch (err) {
+        if (!(err instanceof Error)) {
+            throw err;
+        }
+        logger_1.logOnceToDevConsole(err.stack || err.message, logger_1.LogLevel.Error);
+        process.exit(2);
+    }
+};
+var loaders_2 = require("./loaders");
+Object.defineProperty(exports, "appPath", { enumerable: true, get: function () { return loaders_2.appPath; } });

package/lib/service/loaders.d.ts

@@ -0,0 +1,8 @@
+import { IOClients } from '../clients/IOClients';
+import { Service } from './worker/runtime/Service';
+import { ParamsContext, RecorderState, ServiceJSON } from './worker/runtime/typings';
+export declare const appPath: string;
+export declare const bundlePath: string;
+export declare const serviceJsonPath: string;
+export declare const getServiceJSON: () => ServiceJSON;
+export declare const getService: () => Service<IOClients, RecorderState, ParamsContext>;

package/lib/service/loaders.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getService = exports.getServiceJSON = exports.serviceJsonPath = exports.bundlePath = exports.appPath = void 0;
+const os_1 = require("os");
+const path_1 = require("path");
+const IOClients_1 = require("../clients/IOClients");
+const constants_1 = require("../constants");
+exports.appPath = path_1.join(process.cwd(), './service/src/node/');
+exports.bundlePath = path_1.join(exports.appPath, 'index');
+exports.serviceJsonPath = path_1.join(process.cwd(), './service/service.json');
+const getWorkers = (workers) => {
+    // We need to have only one worker while linking so the debugger
+    // works properly
+    if (constants_1.LINKED) {
+        return 1;
+    }
+    // If user didn't set workers property, let's use the cpu count
+    const workersFromUser = workers && Number.isInteger(workers) ? workers : os_1.cpus().length;
+    // never spawns more than MAX_WORKERS
+    return Math.min(workersFromUser, constants_1.MAX_WORKERS);
+};
+exports.getServiceJSON = () => {
+    const service = require(exports.serviceJsonPath);
+    return {
+        ...service,
+        workers: getWorkers(service.workers),
+    };
+};
+const defaultClients = {
+    options: {
+        messages: {
+            concurrency: 10,
+            retries: 2,
+            timeout: 1000,
+        },
+        messagesGraphQL: {
+            concurrency: 12,
+            retries: 2,
+            timeout: 2000,
+        },
+    },
+};
+exports.getService = () => {
+    var _a;
+    const { default: service } = require(exports.bundlePath);
+    const { config: { clients } } = service;
+    service.config.clients = {
+        implementation: (_a = clients === null || clients === void 0 ? void 0 : clients.implementation) !== null && _a !== void 0 ? _a : IOClients_1.IOClients,
+        options: {
+            ...defaultClients.options,
+            ...clients === null || clients === void 0 ? void 0 : clients.options,
+        },
+    };
+    return service;
+};

package/lib/service/logger/console.d.ts

@@ -0,0 +1,10 @@
+import { LogLevel } from './logger';
+export interface LogMessage {
+    cmd: typeof LOG_ONCE;
+    message: string;
+    level: LogLevel;
+}
+export declare const LOG_ONCE = "logOnce";
+export declare const isLog: (message: any) => message is LogMessage;
+export declare const log: (message: any, level: LogLevel) => void;
+export declare const logOnceToDevConsole: (message: any, level: LogLevel) => void;

package/lib/service/logger/console.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logOnceToDevConsole = exports.log = exports.isLog = exports.LOG_ONCE = void 0;
+const cluster_1 = require("cluster");
+const caches_1 = require("../../caches");
+const history = new caches_1.LRUCache({
+    max: 42,
+});
+exports.LOG_ONCE = 'logOnce';
+exports.isLog = (message) => (message === null || message === void 0 ? void 0 : message.cmd) === exports.LOG_ONCE;
+exports.log = (message, level) => {
+    const logger = console[level];
+    if (typeof logger === 'function') {
+        logger(message);
+    }
+};
+// Since we are now using clusters, if we simply console.log something,
+// it may overwhelm the programmer's console with lots of repeated info.
+// This function should be used when you want to warn about something
+// only once
+exports.logOnceToDevConsole = (message, level) => {
+    const strigified = JSON.stringify(message);
+    if (!history.has(strigified)) {
+        history.set(strigified, true);
+        if (cluster_1.isMaster) {
+            exports.log(message, level);
+        }
+        else if (cluster_1.isWorker && process.send) {
+            const logMessage = {
+                cmd: exports.LOG_ONCE,
+                level,
+                message,
+            };
+            process.send(logMessage);
+        }
+    }
+};

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

@@ -1,28 +1,2 @@
-import { IOContext } from '../../service/typings';
-export declare enum LogLevel {
-    Debug = "debug",
-    Info = "info",
-    Warn = "warn",
-    Error = "error"
-}
-export declare class Logger {
-    private account;
-    private workspace;
-    private operationId;
-    private requestId;
-    private production;
-    private executed;
-    constructor(ctx: Pick<IOContext, 'account' | 'workspace' | 'requestId' | 'operationId' | 'production'>);
-    debug: (message: any) => void;
-    info: (message: any) => void;
-    warn: (warning: any) => void;
-    error: (error: any) => void;
-    log: (message: any, level: LogLevel) => void;
-    private isThirdPartyApp;
-    /**
-     * Logs splunk query so the developer can search for the errors in splunk.
-     * This function runs only once in the lifetime of the Logger class so we
-     * don't mess up with the developer's terminal
-     */
-    private logSplunkQuery;
-}
+export * from './console';
+export * from './logger';

package/lib/service/logger/index.js

@@ -1,70 +1,14 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const error_1 = require("../../utils/error");
-const log_1 = require("../../utils/log");
-const linked = !!process.env.VTEX_APP_LINK;
-const app = process.env.VTEX_APP_ID;
-const EMPTY_MESSAGE = 'Logger.log was called with null or undefined message';
-const appName = process.env.VTEX_APP_NAME;
-const vendor = process.env.VTEX_APP_VENDOR;
-var LogLevel;
-(function (LogLevel) {
-    LogLevel["Debug"] = "debug";
-    LogLevel["Info"] = "info";
-    LogLevel["Warn"] = "warn";
-    LogLevel["Error"] = "error";
-})(LogLevel = exports.LogLevel || (exports.LogLevel = {}));
-class Logger {
-    constructor(ctx) {
-        this.executed = false;
-        this.debug = (message) => this.log(message, LogLevel.Debug);
-        this.info = (message) => this.log(message, LogLevel.Info);
-        this.warn = (warning) => this.log(warning, LogLevel.Warn);
-        this.error = (error) => this.log(error, LogLevel.Error);
-        this.log = (message, level) => {
-            const data = message ? error_1.cleanError(message) : EMPTY_MESSAGE;
-            log_1.cleanLog(data);
-            /* tslint:disable:object-literal-sort-keys */
-            const inflatedLog = {
-                __VTEX_IO_LOG: true,
-                level,
-                app,
-                account: this.account,
-                workspace: this.workspace,
-                production: this.production,
-                data,
-                operationId: this.operationId,
-                requestId: this.requestId,
-            };
-            if (this.isThirdPartyApp()) {
-                Object.assign(inflatedLog, {
-                    __SKIDDER_TOPIC_1: `skidder.vendor.${vendor}`,
-                    __SKIDDER_TOPIC_2: `skidder.app.${vendor}.${appName}`,
-                });
-            }
-            console.log(JSON.stringify(inflatedLog));
-            // Warn the developer how to retrieve the error in splunk
-            this.logSplunkQuery();
-        };
-        /**
-         * Logs splunk query so the developer can search for the errors in splunk.
-         * This function runs only once in the lifetime of the Logger class so we
-         * don't mess up with the developer's terminal
-         */
-        this.logSplunkQuery = () => {
-            if (!this.executed && linked) {
-                console.log(`Try this query at Splunk to retrieve error log: 'index=io_vtex_logs app="${app}" account=${this.account} workspace=${this.workspace} level=error OR level=warn'`);
-                this.executed = true;
-            }
-        };
-        this.account = ctx.account;
-        this.workspace = ctx.workspace;
-        this.requestId = ctx.requestId;
-        this.operationId = ctx.operationId;
-        this.production = ctx.production;
-    }
-    isThirdPartyApp() {
-        return 'vtex' !== vendor && 'gocommerce' !== vendor;
-    }
-}
-exports.Logger = Logger;
+__exportStar(require("./console"), exports);
+__exportStar(require("./logger"), exports);

package/lib/service/logger/logger.d.ts

@@ -0,0 +1,29 @@
+import { IUserLandTracer } from '../../tracing';
+import { IOContext } from '../worker/runtime/typings';
+export interface LoggerTracingContext {
+    requestTracer: IUserLandTracer;
+}
+export declare enum LogLevel {
+    Debug = "debug",
+    Info = "info",
+    Warn = "warn",
+    Error = "error"
+}
+interface LoggerContext extends Pick<IOContext, 'account' | 'workspace' | 'requestId' | 'operationId' | 'production'> {
+    tracer?: IOContext['tracer'];
+}
+export declare class Logger {
+    private account;
+    private workspace;
+    private operationId;
+    private requestId;
+    private production;
+    private tracingState?;
+    constructor(ctx: LoggerContext);
+    debug: (message: any) => void;
+    info: (message: any) => void;
+    warn: (warning: any) => void;
+    error: (error: any) => void;
+    log: (message: any, level: LogLevel) => void;
+}
+export {};

package/lib/service/logger/logger.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.LogLevel = void 0;
+const constants_1 = require("../../constants");
+const error_1 = require("../../utils/error");
+const log_1 = require("../../utils/log");
+const linked = !!process.env.VTEX_APP_LINK;
+const app = constants_1.APP.ID;
+const EMPTY_MESSAGE = 'Logger.log was called with null or undefined message';
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["Debug"] = "debug";
+    LogLevel["Info"] = "info";
+    LogLevel["Warn"] = "warn";
+    LogLevel["Error"] = "error";
+})(LogLevel = exports.LogLevel || (exports.LogLevel = {}));
+class Logger {
+    constructor(ctx) {
+        this.debug = (message) => this.log(message, LogLevel.Debug);
+        this.info = (message) => this.log(message, LogLevel.Info);
+        this.warn = (warning) => this.log(warning, LogLevel.Warn);
+        this.error = (error) => this.log(error, LogLevel.Error);
+        this.log = (message, level) => {
+            var _a;
+            const data = message ? error_1.cleanError(message) : EMPTY_MESSAGE;
+            log_1.cleanLog(data);
+            /* tslint:disable:object-literal-sort-keys */
+            const inflatedLog = {
+                __VTEX_IO_LOG: true,
+                level,
+                app,
+                account: this.account,
+                workspace: this.workspace,
+                production: this.production,
+                data,
+                operationId: this.operationId,
+                requestId: this.requestId,
+                ...(((_a = this.tracingState) === null || _a === void 0 ? void 0 : _a.isTraceSampled) ? { traceId: this.tracingState.traceId } : null),
+            };
+            // Mark third-party apps logs to send to skidder
+            if (constants_1.APP.IS_THIRD_PARTY()) {
+                Object.assign(inflatedLog, {
+                    __SKIDDER_TOPIC_1: `skidder.vendor.${constants_1.APP.VENDOR}`,
+                    __SKIDDER_TOPIC_2: `skidder.app.${constants_1.APP.VENDOR}.${constants_1.APP.NAME}`,
+                });
+            }
+            console.log(JSON.stringify(inflatedLog));
+        };
+        this.account = ctx.account;
+        this.workspace = ctx.workspace;
+        this.requestId = ctx.requestId;
+        this.operationId = ctx.operationId;
+        this.production = ctx.production;
+        if (ctx.tracer) {
+            this.tracingState = {
+                isTraceSampled: ctx.tracer.isTraceSampled,
+                traceId: ctx.tracer.traceId,
+            };
+        }
+    }
+}
+exports.Logger = Logger;

package/lib/service/logger/metricsLogger.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="node" />
+interface ProcessEnv {
+    appName: string;
+    appVersion: string;
+    region: string;
+    vendor: string;
+    production: boolean;
+}
+interface Key {
+    name: string;
+}
+interface Metric {
+    Count: number;
+    Data: {
+        key: Key;
+        processEnv: ProcessEnv;
+        summary: NumericSummary | NodeJS.MemoryUsage | NodeJS.CpuUsage;
+    };
+    Max: number;
+    Min: number;
+    Name: string;
+    Sum: number;
+    Timestamp: number;
+    Unit: string;
+}
+interface NumericSummary {
+    count: number;
+    max: number;
+    median: number;
+    min: number;
+    percentile95: number;
+    percentile99: number;
+    sum: number;
+}
+export declare class MetricsLogger {
+    add: (key: Key, value: number) => void;
+    getSummaries: () => Metric[];
+    constructor();
+}
+export {};