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

package/lib/HttpClient/middlewares/cache.js

@@ -1,28 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const url_1 = require("url");
+exports.cacheMiddleware = exports.CacheType = exports.isLocallyCacheable = exports.cacheKey = void 0;
 const constants_1 = require("../../constants");
-const constants_2 = require("./../../constants");
+const tracing_1 = require("../../tracing");
 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 cacheKey = (config) => {
     const { baseURL = '', url = '', params, headers } = config;
-    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);
-    }
+    const locale = headers === null || headers === void 0 ? void 0 : headers[constants_1.LOCALE_HEADER];
+    const encodedBaseURL = baseURL.replace(/\//g, '\\');
+    const encodedURL = url.replace(/\//g, '\\');
+    let key = `${locale}--${encodedBaseURL}--${encodedURL}?`;
     if (params) {
-        for (const [key, value] of Object.entries(params)) {
-            urlObject.searchParams.append(key, value);
-        }
+        Object.keys(params).sort().forEach(p => key = key.concat(`--${p}=${params[p]}`));
+    }
+    if (headers === null || headers === void 0 ? void 0 : headers.range) {
+        key = key.concat(`--${RANGE_HEADER_QS_KEY}=${headers.range}`);
     }
-    // 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}`;
+    return key;
 };
+exports.cacheKey = cacheKey;
 const parseCacheHeaders = (headers) => {
     const { 'cache-control': cacheControl = '', etag, age: ageStr } = headers;
     const cacheDirectives = cacheControl.split(',').map(d => d.trim());
@@ -51,36 +48,80 @@ var CacheType;
     CacheType[CacheType["Disk"] = 2] = "Disk";
     CacheType[CacheType["Any"] = 3] = "Any";
 })(CacheType = exports.CacheType || (exports.CacheType = {}));
-exports.cacheMiddleware = ({ type, storage }) => {
+const CacheTypeNames = {
+    [CacheType.None]: 'none',
+    [CacheType.Memory]: 'memory',
+    [CacheType.Disk]: 'disk',
+    [CacheType.Any]: 'any',
+};
+const cacheMiddleware = ({ type, storage, asyncSet }) => {
+    const CACHE_RESULT_TAG = type === CacheType.Disk ? "http.cache.disk" /* CustomHttpTags.HTTP_DISK_CACHE_RESULT */ : "http.cache.memory" /* CustomHttpTags.HTTP_MEMORY_CACHE_RESULT */;
+    const cacheType = CacheTypeNames[type];
     return async (ctx, next) => {
+        var _a, _b;
         if (!isLocallyCacheable(ctx.config, type)) {
             return await next();
         }
-        const key = exports.cacheKey(ctx.config);
-        const segmentToken = ctx.config.headers[constants_1.SEGMENT_HEADER];
+        const { rootSpan: span, tracer, logger } = (_a = ctx.tracing) !== null && _a !== void 0 ? _a : {};
+        const key = (0, exports.cacheKey)(ctx.config);
+        const segmentToken = (_b = ctx.config.headers) === null || _b === void 0 ? void 0 : _b[constants_1.SEGMENT_HEADER];
         const keyWithSegment = key + segmentToken;
-        const cacheHasWithSegment = await storage.has(keyWithSegment);
-        const cached = cacheHasWithSegment ? await storage.get(keyWithSegment) : await storage.get(key);
-        if (cached) {
+        span === null || span === void 0 ? void 0 : span.log({
+            event: "cache-key-created" /* HttpLogEvents.CACHE_KEY_CREATE */,
+            ["cache-type" /* HttpCacheLogFields.CACHE_TYPE */]: cacheType,
+            ["key" /* HttpCacheLogFields.KEY */]: key,
+            ["key-with-segment" /* HttpCacheLogFields.KEY_WITH_SEGMENT */]: keyWithSegment,
+        });
+        const cacheReadSpan = createCacheSpan(cacheType, 'read', tracer, span);
+        let cached = undefined;
+        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 { etag: cachedEtag, response, expiration, responseType, responseEncoding } = cached;
-            if (expiration > Date.now() && response) {
-                if (type === CacheType.Disk && responseType === 'arraybuffer') {
-                    response.data = Buffer.from(response.data, responseEncoding);
-                }
+            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" /* HttpLogEvents.LOCAL_CACHE_HIT_INFO */,
+                ["cache-type" /* HttpCacheLogFields.CACHE_TYPE */]: cacheType,
+                ["etag" /* HttpCacheLogFields.ETAG */]: cachedEtag,
+                ["expiration-time" /* HttpCacheLogFields.EXPIRATION_TIME */]: (expiration - now) / 1000,
+                ["response-type" /* HttpCacheLogFields.RESPONSE_TYPE */]: responseType,
+                ["response-encoding" /* HttpCacheLogFields.RESPONSE_ENCONDING */]: responseEncoding,
+            });
+            if (expiration > now) {
                 ctx.response = response;
                 ctx.cacheHit = {
                     memory: 1,
                     revalidated: 0,
                     router: 0,
                 };
+                span === null || span === void 0 ? void 0 : span.setTag(CACHE_RESULT_TAG, "HIT" /* CacheResult.HIT */);
                 return;
             }
+            span === null || span === void 0 ? void 0 : span.setTag(CACHE_RESULT_TAG, "STALE" /* CacheResult.STALE */);
             const validateStatus = addNotModified(ctx.config.validateStatus);
             if (cachedEtag && validateStatus(response.status)) {
-                ctx.config.headers['if-none-match'] = cachedEtag;
+                ctx.config.headers = {
+                    ...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" /* CacheResult.MISS */);
+        }
         await next();
         if (!ctx.response) {
             return;
@@ -98,28 +139,82 @@ exports.cacheMiddleware = ({ type, storage }) => {
         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" /* HttpLogEvents.CACHE_CONFIG */,
+            ["cache-type" /* HttpCacheLogFields.CACHE_TYPE */]: cacheType,
+            ["age" /* HttpCacheLogFields.AGE */]: age,
+            ["calculated-max-age" /* HttpCacheLogFields.CALCULATED_MAX_AGE */]: maxAge,
+            ["max-age" /* HttpCacheLogFields.MAX_AGE */]: headerMaxAge,
+            ["force-max-age" /* HttpCacheLogFields.FORCE_MAX_AGE */]: forceMaxAge,
+            ["etag" /* HttpCacheLogFields.ETAG */]: etag,
+            ["no-cache" /* HttpCacheLogFields.NO_CACHE */]: noCache,
+            ["no-store" /* HttpCacheLogFields.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" /* HttpLogEvents.NO_LOCAL_CACHE_SAVE */, ["cache-type" /* HttpCacheLogFields.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 } = ctx.config;
+            const { responseType, responseEncoding: configResponseEncoding } = 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;
-            await storage.set(setKey, {
-                etag,
-                expiration: Date.now() + (maxAge - currentAge) * 1000,
-                response: { data: cacheableData, headers, status },
-                responseEncoding,
-                responseType,
-            });
+            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: responseEncoding,
+                    responseType,
+                });
+                if (asyncSet) {
+                    storageSet();
+                }
+                else {
+                    await storageSet();
+                    span === null || span === void 0 ? void 0 : span.log({
+                        event: "local-cache-saved" /* HttpLogEvents.LOCAL_CACHE_SAVED */,
+                        ["cache-type" /* HttpCacheLogFields.CACHE_TYPE */]: cacheType,
+                        ["key-set" /* HttpCacheLogFields.KEY_SET */]: setKey,
+                        ["age" /* HttpCacheLogFields.AGE */]: currentAge,
+                        ["etag" /* HttpCacheLogFields.ETAG */]: etag,
+                        ["expiration-time" /* HttpCacheLogFields.EXPIRATION_TIME */]: (expiration - Date.now()) / 1000,
+                        ["response-encoding" /* HttpCacheLogFields.RESPONSE_ENCONDING */]: responseEncoding,
+                        ["response-type" /* HttpCacheLogFields.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();
+            }
             return;
         }
+        span === null || span === void 0 ? void 0 : span.log({ event: "no-local-cache-save" /* HttpLogEvents.NO_LOCAL_CACHE_SAVE */, ["cache-type" /* HttpCacheLogFields.CACHE_TYPE */]: cacheType });
     };
 };
+exports.cacheMiddleware = cacheMiddleware;
+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/typings';
+import { Cancellation } from '../../service/worker/runtime/typings';
 import { MiddlewareContext } from '../typings';
-export declare const cancellationToken: (cancellation?: Cancellation | undefined) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
+export declare const cancellationToken: (cancellation?: Cancellation) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;

package/lib/HttpClient/middlewares/cancellationToken.js

@@ -3,7 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.cancellationToken = void 0;
 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;
@@ -41,12 +43,12 @@ const handleCancellation = (ctx, cancellation) => {
         },
     };
 };
-exports.cancellationToken = (cancellation) => async (ctx, next) => {
+const cancellationToken = (cancellation) => async (ctx, next) => {
     const { config: { method } } = ctx;
     if (!cancellation) {
         return await next();
     }
-    if (method && method.toUpperCase() !== 'GET') {
+    if (method && !constants_1.cancellableMethods.has(method.toUpperCase())) {
         cancellation.cancelable = false;
     }
     if (!cancellation.cancelable || !cancellation.source) {
@@ -69,3 +71,4 @@ exports.cancellationToken = (cancellation) => async (ctx, next) => {
         onRequestFinish();
     }
 };
+exports.cancellationToken = cancellationToken;

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

@@ -1,5 +1,5 @@
 import { InflightKeyGenerator, MiddlewareContext } from '../typings';
-export declare type Inflight = Required<Pick<MiddlewareContext, 'cacheHit' | 'response'>>;
+export type Inflight = Required<Pick<MiddlewareContext, 'cacheHit' | 'response'>>;
 export declare const singleFlightMiddleware: (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
 export declare const inflightURL: InflightKeyGenerator;
 export declare const inflightUrlWithQuery: InflightKeyGenerator;

package/lib/HttpClient/middlewares/inflight.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.inflightUrlWithQuery = exports.inflightURL = exports.singleFlightMiddleware = void 0;
 const qs_1 = require("qs");
 const inflight = new Map();
 let metricsAdded = false;
-exports.singleFlightMiddleware = async (ctx, next) => {
+const singleFlightMiddleware = async (ctx, next) => {
     const { inflightKey } = ctx.config;
     if (!inflightKey) {
         return await next();
@@ -46,5 +47,8 @@ exports.singleFlightMiddleware = async (ctx, next) => {
         await promise;
     }
 };
-exports.inflightURL = ({ baseURL, url }) => baseURL + url;
-exports.inflightUrlWithQuery = ({ baseURL, url, params }) => baseURL + url + qs_1.stringify(params, { arrayFormat: 'repeat', addQueryPrefix: true });
+exports.singleFlightMiddleware = singleFlightMiddleware;
+const inflightURL = ({ baseURL, url }) => baseURL + url;
+exports.inflightURL = inflightURL;
+const inflightUrlWithQuery = ({ baseURL, url, params }) => baseURL + url + (0, qs_1.stringify)(params, { arrayFormat: 'repeat', addQueryPrefix: true });
+exports.inflightUrlWithQuery = inflightUrlWithQuery;

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

@@ -1,5 +1,5 @@
 import { MiddlewareContext } from '../typings';
-export declare type Memoized = Required<Pick<MiddlewareContext, 'cacheHit' | 'response'>>;
+export type Memoized = Required<Pick<MiddlewareContext, 'cacheHit' | 'response'>>;
 interface MemoizationOptions {
     memoizedCache: Map<string, Promise<Memoized>>;
 }

package/lib/HttpClient/middlewares/memoization.js

@@ -1,20 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoizationMiddleware = void 0;
 const cache_1 = require("./cache");
-exports.memoizationMiddleware = ({ memoizedCache }) => {
+const memoizationMiddleware = ({ memoizedCache }) => {
     return async (ctx, next) => {
-        if (!cache_1.isLocallyCacheable(ctx.config, cache_1.CacheType.Any) || !ctx.config.memoizable) {
-            return await next();
+        var _a;
+        if (!(0, cache_1.isLocallyCacheable)(ctx.config, cache_1.CacheType.Any) || !ctx.config.memoizable) {
+            return next();
         }
-        const key = cache_1.cacheKey(ctx.config);
+        const span = (_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.rootSpan;
+        const key = (0, cache_1.cacheKey)(ctx.config);
         const isMemoized = !!memoizedCache.has(key);
+        span === null || span === void 0 ? void 0 : span.log({ event: "cache-key-created" /* HttpLogEvents.CACHE_KEY_CREATE */, ["cache-type" /* HttpCacheLogFields.CACHE_TYPE */]: 'memoization', ["key" /* HttpCacheLogFields.KEY */]: key });
         if (isMemoized) {
+            span === null || span === void 0 ? void 0 : span.setTag("http.cache.memoization" /* CustomHttpTags.HTTP_MEMOIZATION_CACHE_RESULT */, "HIT" /* CacheResult.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" /* CustomHttpTags.HTTP_MEMOIZATION_CACHE_RESULT */, "MISS" /* CacheResult.MISS */);
             const promise = new Promise(async (resolve, reject) => {
                 try {
                     await next();
@@ -22,9 +28,11 @@ exports.memoizationMiddleware = ({ memoizedCache }) => {
                         cacheHit: ctx.cacheHit,
                         response: ctx.response,
                     });
+                    span === null || span === void 0 ? void 0 : span.log({ event: "memoization-cache-saved" /* HttpLogEvents.MEMOIZATION_CACHE_SAVED */, ["key-set" /* HttpCacheLogFields.KEY_SET */]: key });
                 }
                 catch (err) {
                     reject(err);
+                    span === null || span === void 0 ? void 0 : span.log({ event: "memoization-cache-saved-error" /* HttpLogEvents.MEMOIZATION_CACHE_SAVED_ERROR */, ["key-set" /* HttpCacheLogFields.KEY_SET */]: key });
                 }
             });
             memoizedCache.set(key, promise);
@@ -32,3 +40,4 @@ exports.memoizationMiddleware = ({ memoizedCache }) => {
         }
     };
 };
+exports.memoizationMiddleware = memoizationMiddleware;

package/lib/HttpClient/middlewares/metrics.js

@@ -1,28 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const ramda_1 = require("ramda");
+exports.metricsMiddleware = void 0;
 const RequestCancelledError_1 = require("../../errors/RequestCancelledError");
-const requestStats_1 = require("../../service/http/middlewares/requestStats");
+const requestStats_1 = require("../../service/worker/runtime/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 axios_1 = require("axios");
+const metricsMiddleware = ({ metrics, serverTiming, name }) => {
     const serverTimingStart = process.hrtime();
-    const serverTimingLabel = utils_1.shrinkTimings(utils_1.formatTimingName({
+    const serverTimingLabel = (0, utils_1.shrinkTimings)((0, utils_1.formatTimingName)({
         hopNumber: 0,
         source: process.env.VTEX_APP_NAME,
         target: name || 'unknown',
@@ -38,10 +25,13 @@ exports.metricsMiddleware = ({ metrics, serverTiming, name }) => {
             }
             await next();
             if (ctx.config.metric && ctx.response && ctx.response.status) {
-                status = status_1.statusLabel(ctx.response.status);
+                status = (0, status_1.statusLabel)(ctx.response.status);
             }
         }
         catch (err) {
+            if (!(err instanceof axios_1.AxiosError)) {
+                throw err;
+            }
             const isCancelled = (err.message === requestStats_1.cancelMessage);
             if (ctx.config.metric) {
                 errorCode = err.code;
@@ -53,7 +43,7 @@ exports.metricsMiddleware = ({ metrics, serverTiming, name }) => {
                     status = 'timeout';
                 }
                 else if (err.response && err.response.status) {
-                    status = status_1.statusLabel(err.response.status);
+                    status = (0, status_1.statusLabel)(err.response.status);
                 }
                 else if (isCancelled) {
                     status = 'cancelled';
@@ -84,9 +74,9 @@ exports.metricsMiddleware = ({ metrics, serverTiming, name }) => {
                 if (ctx.memoizedHit) {
                     Object.assign(extensions, { [`${status}-memoized`]: 1 });
                 }
-                if (ctx.config['axios-retry']) {
-                    const { retryCount } = ctx.config['axios-retry'];
-                    if (retryCount && retryCount > 0) {
+                if (ctx.config.retryCount) {
+                    const retryCount = ctx.config.retryCount;
+                    if (retryCount > 0) {
                         extensions[`retry-${status}-${retryCount}`] = 1;
                     }
                 }
@@ -95,11 +85,17 @@ exports.metricsMiddleware = ({ metrics, serverTiming, name }) => {
                     : undefined;
                 metrics.batch(label, end, extensions);
                 if (ctx.config.verbose) {
-                    console.log(`VERBOSE: ${name}.${ctx.config.label}`, Object.assign({}, extensions, errorCode || errorStatus ? { errorCode, errorStatus } : null, { millis: end
-                            ? utils_1.hrToMillis(end)
+                    console.log(`VERBOSE: ${name}.${ctx.config.label}`, {
+                        ...extensions,
+                        ...errorCode || errorStatus ? { errorCode, errorStatus } : null,
+                        millis: end
+                            ? (0, 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 }));
+                                ? (0, utils_1.hrToMillis)(process.hrtime(start))
+                                : '(from cache)',
+                        status: ctx.response && ctx.response.status,
+                        headers: ctx.response && ctx.response.headers,
+                    });
                 }
             }
             else {
@@ -109,21 +105,12 @@ exports.metricsMiddleware = ({ metrics, serverTiming, name }) => {
             }
             if (serverTiming) {
                 // Timings in the client's perspective
-                const dur = utils_1.hrToMillis(process.hrtime(serverTimingStart));
+                const dur = (0, utils_1.hrToMillis)(process.hrtime(serverTimingStart));
                 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);
-                }
             }
         }
     };
 };
+exports.metricsMiddleware = metricsMiddleware;

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

@@ -2,6 +2,6 @@ import { AxiosRequestConfig } from 'axios';
 import { MiddlewareContext } from '../typings';
 export declare const acceptNotFoundMiddleware: (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
 export declare const notFoundFallbackMiddleware: (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
-export declare type IgnoreNotFoundRequestConfig = AxiosRequestConfig & {
+export type IgnoreNotFoundRequestConfig = AxiosRequestConfig & {
     nullIfNotFound?: boolean;
 };

package/lib/HttpClient/middlewares/notFound.js

@@ -1,20 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.notFoundFallbackMiddleware = exports.acceptNotFoundMiddleware = void 0;
 const addNotFound = (validateStatus) => (status) => validateStatus(status) || status === 404;
 function nullIfNotFound(config) {
     return config && config.nullIfNotFound;
 }
-exports.acceptNotFoundMiddleware = async (ctx, next) => {
+const acceptNotFoundMiddleware = async (ctx, next) => {
     const { config } = ctx;
     if (nullIfNotFound(config)) {
         ctx.config.validateStatus = addNotFound(config.validateStatus);
     }
     await next();
 };
-exports.notFoundFallbackMiddleware = async (ctx, next) => {
+exports.acceptNotFoundMiddleware = acceptNotFoundMiddleware;
+const notFoundFallbackMiddleware = async (ctx, next) => {
     await next();
     const { config } = ctx;
     if (nullIfNotFound(config) && ctx.response && ctx.response.status === 404) {
         ctx.response.data = null;
     }
 };
+exports.notFoundFallbackMiddleware = notFoundFallbackMiddleware;

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,18 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.recorderMiddleware = (recorder) => {
-    return async (ctx, next) => {
-        try {
-            await next();
-            if (ctx.response) {
-                recorder(ctx.response.headers);
-            }
+exports.recorderMiddleware = void 0;
+const axios_1 = require("axios");
+const 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);
         }
-        catch (err) {
-            if (err.response && err.response.headers && err.response.status === 404) {
-                recorder(err.response.headers);
-            }
+    }
+    catch (err) {
+        if (!(err instanceof axios_1.AxiosError)) {
             throw err;
         }
-    };
+        if (err.response && err.response.headers && err.response.status === 404) {
+            recorder.record(err.response.headers);
+        }
+        throw err;
+    }
 };
+exports.recorderMiddleware = recorderMiddleware;

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

@@ -0,0 +1,11 @@
+import HttpAgent from 'agentkeepalive';
+export declare class HttpAgentSingleton {
+    static getHttpAgent(): HttpAgent;
+    static httpAgentStats(): {
+        freeSockets: number;
+        pendingRequests: number;
+        sockets: number;
+    };
+    private static httpAgent;
+    private static count;
+}

package/lib/HttpClient/middlewares/request/HttpAgentSingleton.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpAgentSingleton = void 0;
+const agents_1 = require("../../agents");
+class HttpAgentSingleton {
+    static getHttpAgent() {
+        if (!HttpAgentSingleton.httpAgent) {
+            HttpAgentSingleton.httpAgent = (0, agents_1.createHttpAgent)();
+        }
+        return HttpAgentSingleton.httpAgent;
+    }
+    static httpAgentStats() {
+        const sockets = HttpAgentSingleton.count(HttpAgentSingleton.httpAgent.sockets);
+        const freeSockets = HttpAgentSingleton.count(HttpAgentSingleton.httpAgent.freeSockets);
+        const pendingRequests = HttpAgentSingleton.count(HttpAgentSingleton.httpAgent.requests);
+        return {
+            freeSockets,
+            pendingRequests,
+            sockets,
+        };
+    }
+    static count(obj) {
+        try {
+            return Object.values(obj).reduce((acc, val) => acc += val.length, 0);
+        }
+        catch (_) {
+            return 0;
+        }
+    }
+}
+exports.HttpAgentSingleton = HttpAgentSingleton;

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

@@ -0,0 +1,18 @@
+import { AxiosRequestConfig } from 'axios';
+import { Limit } from 'p-limit';
+import { MiddlewareContext } from '../../typings';
+export interface DefaultMiddlewareArgs {
+    baseURL: string | undefined;
+    rawHeaders: Record<string, string>;
+    params: Record<string, string> | undefined;
+    timeout: number;
+    retries?: number;
+    verbose?: boolean;
+    exponentialTimeoutCoefficient?: number;
+    initialBackoffDelay?: number;
+    exponentialBackoffCoefficient?: number;
+    httpsAgent?: AxiosRequestConfig['httpsAgent'];
+}
+export declare const defaultsMiddleware: ({ baseURL, rawHeaders, params, timeout, retries, verbose, exponentialTimeoutCoefficient, initialBackoffDelay, exponentialBackoffCoefficient, httpsAgent }: DefaultMiddlewareArgs) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
+export declare const routerCacheMiddleware: (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
+export declare const requestMiddleware: (limit?: Limit) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;