@vtex/api 6.48.0 → 6.48.1-beta

package/lib/HttpClient/middlewares/cache.js

@@ -1,22 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const url_1 = require("url");
 const constants_1 = require("../../constants");
-const tracing_1 = require("../../tracing");
+const constants_2 = require("./../../constants");
 const RANGE_HEADER_QS_KEY = '__range_header';
 const cacheableStatusCodes = [200, 203, 204, 206, 300, 301, 404, 405, 410, 414, 501]; // https://tools.ietf.org/html/rfc7231#section-6.1
 exports.cacheKey = (config) => {
     const { baseURL = '', url = '', params, headers } = config;
-    const locale = headers[constants_1.LOCALE_HEADER];
-    const encodedBaseURL = baseURL.replace(/\//g, '\\');
-    const encodedURL = url.replace(/\//g, '\\');
-    let key = `${locale}--${encodedBaseURL}--${encodedURL}?`;
-    if (params) {
-        Object.keys(params).sort().forEach(p => key = key.concat(`--${p}=${params[p]}`));
+    const locale = headers[constants_2.LOCALE_HEADER];
+    const fullURL = [baseURL, url].filter(str => str).join('/');
+    const urlObject = new url_1.URL(fullURL);
+    if (headers && headers.range) {
+        urlObject.searchParams.append(RANGE_HEADER_QS_KEY, headers.range);
     }
-    if (headers === null || headers === void 0 ? void 0 : headers.range) {
-        key = key.concat(`--${RANGE_HEADER_QS_KEY}=${headers.range}`);
+    if (params) {
+        for (const [key, value] of Object.entries(params)) {
+            urlObject.searchParams.append(key, value);
+        }
     }
-    return key;
+    // Replace forward slashes with backwards slashes for disk cache legibility
+    const encodedPath = `${locale}/${urlObject.pathname}${urlObject.search}`.replace(/\//g, '\\\\');
+    // Add hostname as top level directory on disk cache
+    return `${urlObject.hostname}/${encodedPath}`;
 };
 const parseCacheHeaders = (headers) => {
     const { 'cache-control': cacheControl = '', etag, age: ageStr } = headers;
@@ -46,77 +51,36 @@ var CacheType;
     CacheType[CacheType["Disk"] = 2] = "Disk";
     CacheType[CacheType["Any"] = 3] = "Any";
 })(CacheType = exports.CacheType || (exports.CacheType = {}));
-const CacheTypeNames = {
-    [CacheType.None]: 'none',
-    [CacheType.Memory]: 'memory',
-    [CacheType.Disk]: 'disk',
-    [CacheType.Any]: 'any',
-};
-exports.cacheMiddleware = ({ type, storage, asyncSet }) => {
-    const CACHE_RESULT_TAG = type === CacheType.Disk ? "http.cache.disk" /* HTTP_DISK_CACHE_RESULT */ : "http.cache.memory" /* HTTP_MEMORY_CACHE_RESULT */;
-    const cacheType = CacheTypeNames[type];
+exports.cacheMiddleware = ({ type, storage }) => {
     return async (ctx, next) => {
-        var _a;
         if (!isLocallyCacheable(ctx.config, type)) {
             return await next();
         }
-        const { rootSpan: span, tracer, logger } = (_a = ctx.tracing) !== null && _a !== void 0 ? _a : {};
         const key = exports.cacheKey(ctx.config);
         const segmentToken = ctx.config.headers[constants_1.SEGMENT_HEADER];
         const keyWithSegment = key + segmentToken;
-        span === null || span === void 0 ? void 0 : span.log({
-            event: "cache-key-created" /* CACHE_KEY_CREATE */,
-            ["cache-type" /* CACHE_TYPE */]: cacheType,
-            ["key" /* KEY */]: key,
-            ["key-with-segment" /* KEY_WITH_SEGMENT */]: keyWithSegment,
-        });
-        const cacheReadSpan = createCacheSpan(cacheType, 'read', tracer, span);
-        let cached;
-        try {
-            const cacheHasWithSegment = await storage.has(keyWithSegment);
-            cached = cacheHasWithSegment ? await storage.get(keyWithSegment) : await storage.get(key);
-        }
-        catch (error) {
-            tracing_1.ErrorReport.create({ originalError: error }).injectOnSpan(cacheReadSpan);
-            logger === null || logger === void 0 ? void 0 : logger.warn({ message: 'Error reading from the HttpClient cache', error });
-        }
-        finally {
-            cacheReadSpan === null || cacheReadSpan === void 0 ? void 0 : cacheReadSpan.finish();
-        }
-        if (cached && cached.response) {
+        const cacheHasWithSegment = await storage.has(keyWithSegment);
+        const cached = cacheHasWithSegment ? await storage.get(keyWithSegment) : await storage.get(key);
+        if (cached) {
             const { etag: cachedEtag, response, expiration, responseType, responseEncoding } = cached;
-            if (type === CacheType.Disk && responseType === 'arraybuffer') {
-                response.data = Buffer.from(response.data, responseEncoding);
-            }
-            const now = Date.now();
-            span === null || span === void 0 ? void 0 : span.log({
-                event: "local-cache-hit-info" /* LOCAL_CACHE_HIT_INFO */,
-                ["cache-type" /* CACHE_TYPE */]: cacheType,
-                ["etag" /* ETAG */]: cachedEtag,
-                ["expiration-time" /* EXPIRATION_TIME */]: (expiration - now) / 1000,
-                ["response-type" /* RESPONSE_TYPE */]: responseType,
-                ["response-encoding" /* RESPONSE_ENCONDING */]: responseEncoding,
-            });
-            if (expiration > now) {
+            if (expiration > Date.now() && response) {
+                if (type === CacheType.Disk && responseType === 'arraybuffer') {
+                    response.data = Buffer.from(response.data, responseEncoding);
+                }
                 ctx.response = response;
                 ctx.cacheHit = {
                     memory: 1,
                     revalidated: 0,
                     router: 0,
                 };
-                span === null || span === void 0 ? void 0 : span.setTag(CACHE_RESULT_TAG, "HIT" /* HIT */);
                 return;
             }
-            span === null || span === void 0 ? void 0 : span.setTag(CACHE_RESULT_TAG, "STALE" /* STALE */);
             const validateStatus = addNotModified(ctx.config.validateStatus);
             if (cachedEtag && validateStatus(response.status)) {
                 ctx.config.headers['if-none-match'] = cachedEtag;
                 ctx.config.validateStatus = validateStatus;
             }
         }
-        else {
-            span === null || span === void 0 ? void 0 : span.setTag(CACHE_RESULT_TAG, "MISS" /* MISS */);
-        }
         await next();
         if (!ctx.response) {
             return;
@@ -134,81 +98,28 @@ exports.cacheMiddleware = ({ type, storage, asyncSet }) => {
         const { age, etag, maxAge: headerMaxAge, noStore, noCache } = parseCacheHeaders(headers);
         const { forceMaxAge } = ctx.config;
         const maxAge = forceMaxAge && cacheableStatusCodes.includes(status) ? Math.max(forceMaxAge, headerMaxAge) : headerMaxAge;
-        span === null || span === void 0 ? void 0 : span.log({
-            event: "cache-config" /* CACHE_CONFIG */,
-            ["cache-type" /* CACHE_TYPE */]: cacheType,
-            ["age" /* AGE */]: age,
-            ["calculated-max-age" /* CALCULATED_MAX_AGE */]: maxAge,
-            ["max-age" /* MAX_AGE */]: headerMaxAge,
-            ["force-max-age" /* FORCE_MAX_AGE */]: forceMaxAge,
-            ["etag" /* ETAG */]: etag,
-            ["no-cache" /* NO_CACHE */]: noCache,
-            ["no-store" /* NO_STORE */]: noStore,
-        });
         // Indicates this should NOT be cached and this request will not be considered a miss.
         if (!forceMaxAge && (noStore || (noCache && !etag))) {
-            span === null || span === void 0 ? void 0 : span.log({ event: "no-local-cache-save" /* NO_LOCAL_CACHE_SAVE */, ["cache-type" /* CACHE_TYPE */]: cacheType });
             return;
         }
         const shouldCache = maxAge || etag;
         const varySession = ctx.response.headers.vary && ctx.response.headers.vary.includes(constants_1.SESSION_HEADER);
         if (shouldCache && !varySession) {
-            const { responseType, responseEncoding: configResponseEncoding } = ctx.config;
+            const { responseType, responseEncoding } = ctx.config;
             const currentAge = revalidated ? 0 : age;
             const varySegment = ctx.response.headers.vary && ctx.response.headers.vary.includes(constants_1.SEGMENT_HEADER);
             const setKey = varySegment ? keyWithSegment : key;
-            const responseEncoding = configResponseEncoding || (responseType === 'arraybuffer' ? 'base64' : undefined);
             const cacheableData = type === CacheType.Disk && responseType === 'arraybuffer'
                 ? data.toString(responseEncoding)
                 : data;
-            const now = Date.now();
-            const expiration = now + (maxAge - currentAge) * 1000;
-            const alreadyExpired = expiration <= now;
-            const reusingRevalidatedCache = cached && (ctx.response === cached.response);
-            const shouldSkipCacheUpdate = alreadyExpired && reusingRevalidatedCache;
-            if (shouldSkipCacheUpdate) {
-                return;
-            }
-            const cacheWriteSpan = createCacheSpan(cacheType, 'write', tracer, span);
-            try {
-                const storageSet = () => storage.set(setKey, {
-                    etag,
-                    expiration,
-                    response: { data: cacheableData, headers, status },
-                    responseEncoding,
-                    responseType,
-                });
-                if (asyncSet) {
-                    storageSet();
-                }
-                else {
-                    await storageSet();
-                    span === null || span === void 0 ? void 0 : span.log({
-                        event: "local-cache-saved" /* LOCAL_CACHE_SAVED */,
-                        ["cache-type" /* CACHE_TYPE */]: cacheType,
-                        ["key-set" /* KEY_SET */]: setKey,
-                        ["age" /* AGE */]: currentAge,
-                        ["etag" /* ETAG */]: etag,
-                        ["expiration-time" /* EXPIRATION_TIME */]: (expiration - Date.now()) / 1000,
-                        ["response-encoding" /* RESPONSE_ENCONDING */]: responseEncoding,
-                        ["response-type" /* RESPONSE_TYPE */]: responseType,
-                    });
-                }
-            }
-            catch (error) {
-                tracing_1.ErrorReport.create({ originalError: error }).injectOnSpan(cacheWriteSpan);
-                logger === null || logger === void 0 ? void 0 : logger.warn({ message: 'Error writing to the HttpClient cache', error });
-            }
-            finally {
-                cacheWriteSpan === null || cacheWriteSpan === void 0 ? void 0 : cacheWriteSpan.finish();
-            }
+            await storage.set(setKey, {
+                etag,
+                expiration: Date.now() + (maxAge - currentAge) * 1000,
+                response: { data: cacheableData, headers, status },
+                responseEncoding,
+                responseType,
+            });
             return;
         }
-        span === null || span === void 0 ? void 0 : span.log({ event: "no-local-cache-save" /* NO_LOCAL_CACHE_SAVE */, ["cache-type" /* CACHE_TYPE */]: cacheType });
     };
 };
-const createCacheSpan = (cacheType, operation, tracer, parentSpan) => {
-    if (tracer && tracer.isTraceSampled && cacheType === 'disk') {
-        return tracer.startSpan(`${operation}-disk-cache`, { childOf: parentSpan });
-    }
-};

package/lib/HttpClient/middlewares/cancellationToken.d.ts

@@ -1,3 +1,3 @@
-import { Cancellation } from '../../service/worker/runtime/typings';
+import { Cancellation } from '../../service/typings';
 import { MiddlewareContext } from '../typings';
 export declare const cancellationToken: (cancellation?: Cancellation | undefined) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;

package/lib/HttpClient/middlewares/cancellationToken.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const axios_1 = __importDefault(require("axios"));
-const constants_1 = require("../../constants");
 const production = process.env.VTEX_PRODUCTION === 'true';
 const handleCancellation = (ctx, cancellation) => {
     let cancellable = true;
@@ -47,7 +46,7 @@ exports.cancellationToken = (cancellation) => async (ctx, next) => {
     if (!cancellation) {
         return await next();
     }
-    if (method && !constants_1.cancellableMethods.has(method.toUpperCase())) {
+    if (method && method.toUpperCase() !== 'GET') {
         cancellation.cancelable = false;
     }
     if (!cancellation.cancelable || !cancellation.source) {

package/lib/HttpClient/middlewares/memoization.js

@@ -3,23 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const cache_1 = require("./cache");
 exports.memoizationMiddleware = ({ memoizedCache }) => {
     return async (ctx, next) => {
-        var _a;
         if (!cache_1.isLocallyCacheable(ctx.config, cache_1.CacheType.Any) || !ctx.config.memoizable) {
-            return next();
+            return await next();
         }
-        const span = (_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.rootSpan;
         const key = cache_1.cacheKey(ctx.config);
         const isMemoized = !!memoizedCache.has(key);
-        span === null || span === void 0 ? void 0 : span.log({ event: "cache-key-created" /* CACHE_KEY_CREATE */, ["cache-type" /* CACHE_TYPE */]: 'memoization', ["key" /* KEY */]: key });
         if (isMemoized) {
-            span === null || span === void 0 ? void 0 : span.setTag("http.cache.memoization" /* HTTP_MEMOIZATION_CACHE_RESULT */, "HIT" /* HIT */);
             const memoized = await memoizedCache.get(key);
             ctx.memoizedHit = isMemoized;
             ctx.response = memoized.response;
             return;
         }
         else {
-            span === null || span === void 0 ? void 0 : span.setTag("http.cache.memoization" /* HTTP_MEMOIZATION_CACHE_RESULT */, "MISS" /* MISS */);
             const promise = new Promise(async (resolve, reject) => {
                 try {
                     await next();
@@ -27,11 +22,9 @@ exports.memoizationMiddleware = ({ memoizedCache }) => {
                         cacheHit: ctx.cacheHit,
                         response: ctx.response,
                     });
-                    span === null || span === void 0 ? void 0 : span.log({ event: "memoization-cache-saved" /* MEMOIZATION_CACHE_SAVED */, ["key-set" /* KEY_SET */]: key });
                 }
                 catch (err) {
                     reject(err);
-                    span === null || span === void 0 ? void 0 : span.log({ event: "memoization-cache-saved-error" /* MEMOIZATION_CACHE_SAVED_ERROR */, ["key-set" /* KEY_SET */]: key });
                 }
             });
             memoizedCache.set(key, promise);

package/lib/HttpClient/middlewares/metrics.js

@@ -1,10 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const ramda_1 = require("ramda");
 const RequestCancelledError_1 = require("../../errors/RequestCancelledError");
-const requestStats_1 = require("../../service/worker/runtime/http/middlewares/requestStats");
+const requestStats_1 = require("../../service/http/middlewares/requestStats");
 const utils_1 = require("../../utils");
 const retry_1 = require("../../utils/retry");
 const status_1 = require("../../utils/status");
+const parseServerTiming = (serverTimingsHeaderValue) => ramda_1.compose(ramda_1.reduce((acc, rawHeader) => {
+    const [name, durStr] = rawHeader.split(';');
+    const [_, dur] = durStr ? durStr.split('=') : [null, null];
+    const { hopNumber, source, target } = utils_1.parseTimingName(name);
+    const formatted = utils_1.formatTimingName({
+        hopNumber: Number.isNaN(hopNumber) ? null : hopNumber + 1,
+        source,
+        target,
+    });
+    if (dur && formatted) {
+        acc.push([formatted, dur]);
+    }
+    return acc;
+}, []), ramda_1.split(','), ramda_1.replace(/\s/g, ''))(serverTimingsHeaderValue);
 exports.metricsMiddleware = ({ metrics, serverTiming, name }) => {
     const serverTimingStart = process.hrtime();
     const serverTimingLabel = utils_1.shrinkTimings(utils_1.formatTimingName({
@@ -69,9 +84,9 @@ exports.metricsMiddleware = ({ metrics, serverTiming, name }) => {
                 if (ctx.memoizedHit) {
                     Object.assign(extensions, { [`${status}-memoized`]: 1 });
                 }
-                if (ctx.config.retryCount) {
-                    const retryCount = ctx.config.retryCount;
-                    if (retryCount > 0) {
+                if (ctx.config['axios-retry']) {
+                    const { retryCount } = ctx.config['axios-retry'];
+                    if (retryCount && retryCount > 0) {
                         extensions[`retry-${status}-${retryCount}`] = 1;
                     }
                 }
@@ -80,17 +95,11 @@ exports.metricsMiddleware = ({ metrics, serverTiming, name }) => {
                     : undefined;
                 metrics.batch(label, end, extensions);
                 if (ctx.config.verbose) {
-                    console.log(`VERBOSE: ${name}.${ctx.config.label}`, {
-                        ...extensions,
-                        ...errorCode || errorStatus ? { errorCode, errorStatus } : null,
-                        millis: end
+                    console.log(`VERBOSE: ${name}.${ctx.config.label}`, Object.assign({}, extensions, errorCode || errorStatus ? { errorCode, errorStatus } : null, { millis: end
                             ? utils_1.hrToMillis(end)
                             : extensions.revalidated || extensions.router || status !== 'success'
                                 ? utils_1.hrToMillis(process.hrtime(start))
-                                : '(from cache)',
-                        status: ctx.response && ctx.response.status,
-                        headers: ctx.response && ctx.response.headers,
-                    });
+                                : '(from cache)', status: ctx.response && ctx.response.status, headers: ctx.response && ctx.response.headers }));
                 }
             }
             else {
@@ -104,6 +113,16 @@ exports.metricsMiddleware = ({ metrics, serverTiming, name }) => {
                 if (!serverTiming[serverTimingLabel] || Number(serverTiming[serverTimingLabel]) < dur) {
                     serverTiming[serverTimingLabel] = `${dur}`;
                 }
+                // Forward server timings
+                const serverTimingsHeader = ramda_1.path(['response', 'headers', 'server-timing'], ctx);
+                if (!ctx.cacheHit && !ctx.inflightHit && !ctx.memoizedHit && serverTimingsHeader) {
+                    const parsedServerTiming = parseServerTiming(serverTimingsHeader);
+                    ramda_1.forEach(([timingsName, timingsDur]) => {
+                        if (!serverTiming[timingsName] || Number(serverTiming[timingsName]) < Number(timingsDur)) {
+                            serverTiming[timingsName] = timingsDur;
+                        }
+                    }, parsedServerTiming);
+                }
             }
         }
     };

package/lib/HttpClient/middlewares/recorder.d.ts

@@ -1,3 +1,3 @@
 import { MiddlewareContext } from '../typings';
-import { Recorder } from './../../service/worker/runtime/utils/recorder';
 export declare const recorderMiddleware: (recorder: Recorder) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
+export declare type Recorder = (headers: any) => void;

package/lib/HttpClient/middlewares/recorder.js

@@ -1,21 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.recorderMiddleware = (recorder) => async (ctx, next) => {
-    var _a;
-    if ((_a = ctx.config) === null || _a === void 0 ? void 0 : _a.ignoreRecorder) {
-        await next();
-        return;
-    }
-    try {
-        await next();
-        if (ctx.response) {
-            recorder.record(ctx.response.headers);
+exports.recorderMiddleware = (recorder) => {
+    return async (ctx, next) => {
+        try {
+            await next();
+            if (ctx.response) {
+                recorder(ctx.response.headers);
+            }
         }
-    }
-    catch (err) {
-        if (err.response && err.response.headers && err.response.status === 404) {
-            recorder.record(err.response.headers);
+        catch (err) {
+            if (err.response && err.response.headers && err.response.status === 404) {
+                recorder(err.response.headers);
+            }
+            throw err;
         }
-        throw err;
-    }
+    };
 };

package/lib/HttpClient/middlewares/request.d.ts

@@ -0,0 +1,10 @@
+import { Limit } from 'p-limit';
+import { MiddlewareContext } from '../typings';
+export declare const defaultsMiddleware: (baseURL: string | undefined, rawHeaders: Record<string, string>, params: Record<string, string> | undefined, timeout: number, retries?: number | undefined, verbose?: boolean | undefined) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
+export declare const routerCacheMiddleware: (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
+export declare const requestMiddleware: (limit?: Limit | undefined) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
+export declare function httpAgentStats(): {
+    freeSockets: number;
+    pendingRequests: number;
+    sockets: number;
+};

package/lib/HttpClient/middlewares/request.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const agentkeepalive_1 = __importDefault(require("agentkeepalive"));
+const axios_1 = __importDefault(require("axios"));
+const axios_retry_1 = __importStar(require("axios-retry"));
+const qs_1 = require("qs");
+const ramda_1 = require("ramda");
+const renameBy_1 = require("../../utils/renameBy");
+const retry_1 = require("../../utils/retry");
+const httpAgent = new agentkeepalive_1.default({
+    freeSocketTimeout: 30 * 1000,
+    keepAlive: true,
+    maxFreeSockets: 256,
+    socketActiveTTL: 120 * 1000,
+});
+const http = axios_1.default.create({
+    httpAgent,
+});
+axios_retry_1.default(http, {
+    retries: 0,
+    retryCondition: retry_1.isAbortedOrNetworkErrorOrRouterTimeout,
+    retryDelay: axios_retry_1.exponentialDelay,
+    shouldResetTimeout: true,
+});
+const paramsSerializer = (params) => {
+    return qs_1.stringify(params, { arrayFormat: 'repeat' });
+};
+exports.defaultsMiddleware = (baseURL, rawHeaders, params, timeout, retries, verbose) => {
+    const countByMetric = {};
+    const headers = renameBy_1.renameBy(ramda_1.toLower, rawHeaders);
+    return async (ctx, next) => {
+        ctx.config = Object.assign({ 'axios-retry': retries ? { retries } : undefined, baseURL, maxRedirects: 0, timeout, validateStatus: status => (status >= 200 && status < 300), verbose }, ctx.config, { headers: Object.assign({}, headers, renameBy_1.renameBy(ramda_1.toLower, ctx.config.headers)), params: Object.assign({}, params, ctx.config.params), paramsSerializer });
+        if (ctx.config.verbose && ctx.config.metric) {
+            const current = countByMetric[ctx.config.metric];
+            countByMetric[ctx.config.metric] = (current || 0) + 1;
+            ctx.config.count = countByMetric[ctx.config.metric];
+            ctx.config.label = `${ctx.config.metric}#${ctx.config.count}`;
+        }
+        await next();
+    };
+};
+const ROUTER_CACHE_KEY = 'x-router-cache';
+const ROUTER_CACHE_HIT = 'HIT';
+const ROUTER_CACHE_REVALIDATED = 'REVALIDATED';
+const ROUTER_CACHE_KEY_PATH = ['response', 'headers', ROUTER_CACHE_KEY];
+const ROUTER_RESPONSE_STATUS_PATH = ['response', 'status'];
+exports.routerCacheMiddleware = async (ctx, next) => {
+    await next();
+    const routerCacheHit = ramda_1.path(ROUTER_CACHE_KEY_PATH, ctx);
+    const status = ramda_1.path(ROUTER_RESPONSE_STATUS_PATH, ctx);
+    if (routerCacheHit === ROUTER_CACHE_HIT || (routerCacheHit === ROUTER_CACHE_REVALIDATED && status !== 304)) {
+        ctx.cacheHit = Object.assign({ memory: 0, revalidated: 0 }, ctx.cacheHit, { router: 1 });
+    }
+};
+exports.requestMiddleware = (limit) => async (ctx, next) => {
+    const makeRequest = () => http.request(ctx.config);
+    ctx.response = await (limit ? limit(makeRequest) : makeRequest());
+};
+function count(obj) {
+    try {
+        return Object.values(obj).reduce((acc, val) => acc += val.length, 0);
+    }
+    catch (_) {
+        return 0;
+    }
+}
+function httpAgentStats() {
+    const sockets = count(httpAgent.sockets);
+    const freeSockets = count(httpAgent.freeSockets);
+    const pendingRequests = count(httpAgent.requests);
+    return {
+        freeSockets,
+        pendingRequests,
+        sockets,
+    };
+}
+exports.httpAgentStats = httpAgentStats;

package/lib/HttpClient/typings.d.ts

@@ -1,28 +1,13 @@
 /// <reference types="node" />
 import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { IAxiosRetryConfig } from 'axios-retry';
 import { Middleware } from 'koa-compose';
-import { Span } from 'opentracing';
 import { CacheLayer } from '../caches/CacheLayer';
 import { MetricsAccumulator } from '../metrics/MetricsAccumulator';
-import { IOContext } from '../service/worker/runtime/typings';
-import { SpanReferenceTypes } from '../tracing';
-import { IUserLandTracer } from '../tracing/UserLandTracer';
 import { Cached, CacheType } from './middlewares/cache';
 export declare type InflightKeyGenerator = (x: RequestConfig) => string;
-interface RequestTracingUserConfig {
-    rootSpan?: Span;
-    referenceType?: SpanReferenceTypes;
-    requestSpanNameSuffix?: string;
-}
-export interface RequestTracingConfig {
-    tracing?: RequestTracingUserConfig;
-}
-export interface RequestConfig extends AxiosRequestConfig, RequestTracingConfig {
-    retries?: number;
-    exponentialTimeoutCoefficient?: number;
-    initialBackoffDelay?: number;
-    exponentialBackoffCoefficient?: number;
-    retryCount?: number;
+export interface RequestConfig extends AxiosRequestConfig {
+    'axios-retry'?: IAxiosRetryConfig;
     /**
      * Identifies the type of request for metrification purposes. Should vary with client method.
      */
@@ -46,7 +31,6 @@ export interface RequestConfig extends AxiosRequestConfig, RequestTracingConfig
     forceMaxAge?: number;
     responseEncoding?: BufferEncoding;
     nullIfNotFound?: boolean;
-    ignoreRecorder?: boolean;
 }
 export interface CacheHit {
     disk?: 0 | 1;
@@ -54,42 +38,27 @@ export interface CacheHit {
     revalidated?: 0 | 1;
     router?: 0 | 1;
 }
-export interface MiddlewaresTracingContext extends Omit<RequestTracingUserConfig, 'rootSpan'> {
-    tracer: IUserLandTracer;
-    logger: IOContext['logger'];
-    rootSpan?: Span;
-    isSampled: boolean;
-}
 export interface MiddlewareContext {
     config: RequestConfig;
-    tracing?: MiddlewaresTracingContext;
     response?: AxiosResponse;
     cacheHit?: CacheHit;
     inflightHit?: boolean;
     memoizedHit?: boolean;
 }
 export declare type CacheStorage = CacheLayer<string, Cached>;
+export { Recorder } from './middlewares/recorder';
 export interface InstanceOptions {
     authType?: AuthType;
     timeout?: number;
     memoryCache?: CacheLayer<string, Cached>;
     diskCache?: CacheLayer<string, Cached>;
-    asyncSetCache?: boolean;
-    /**
-     * Enables memoization, ephemeral within each request, for all requests of this client.
-     * Useful for services that makes recursive requests, like graphql resolvers, which
-     * might fetch the same endpoint more than once.
-     * If that's not the case for your service, disabling it might improve the CPU and
-     * memory usage.
-     *
-     * Default value: true
-     */
-    memoizable?: boolean;
     baseURL?: string;
     retries?: number;
-    exponentialTimeoutCoefficient?: number;
-    initialBackoffDelay?: number;
-    exponentialBackoffCoefficient?: number;
+    /**
+     * @deprecated use retries instead.
+     * @memberof InstanceOptions
+     */
+    retryConfig?: void;
     metrics?: MetricsAccumulator;
     /**
      * Maximum number of concurrent requests
@@ -116,8 +85,6 @@ export interface InstanceOptions {
     verbose?: boolean;
     name?: string;
     serverTimings?: Record<string, string>;
-    httpsAgent?: AxiosRequestConfig['httpsAgent'];
-    cacheableType?: CacheType;
 }
 export interface IOResponse<T> {
     data: T;
@@ -132,4 +99,3 @@ export declare enum AuthType {
      */
     token = "token"
 }
-export {};

package/lib/IODataSource.d.ts

@@ -0,0 +1,27 @@
+import { DataSource, DataSourceConfig } from 'apollo-datasource';
+import { HttpClient, InstanceOptions } from './HttpClient';
+import { IOContext, ServiceContext } from './service/typings';
+interface HttpClientFactoryOptions {
+    service: string | void;
+    context: IOContext | void;
+    options: InstanceOptions | void;
+}
+export declare type HttpClientFactory = (opts: HttpClientFactoryOptions) => HttpClient | void;
+/**
+ * @deprecated Extend one of the subclasses of IOClient instead.
+ */
+export declare abstract class IODataSource extends DataSource<ServiceContext> {
+    protected context?: IOContext | undefined;
+    private options;
+    protected abstract httpClientFactory: HttpClientFactory;
+    protected service: string | void;
+    private httpClient;
+    private initialized;
+    constructor(context?: IOContext | undefined, options?: InstanceOptions);
+    initialize(config: DataSourceConfig<ServiceContext>): void;
+    readonly http: HttpClient;
+}
+export declare const forWorkspace: HttpClientFactory;
+export declare const forRoot: HttpClientFactory;
+export declare const forExternal: HttpClientFactory;
+export {};