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

package/lib/HttpClient/middlewares/inflight.js

@@ -1,5 +1,6 @@
 "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;

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 }) => {
     return async (ctx, next) => {
+        var _a;
         if (!cache_1.isLocallyCacheable(ctx.config, cache_1.CacheType.Any) || !ctx.config.memoizable) {
-            return await next();
+            return 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();
@@ -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" /* 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,25 +1,12 @@
 "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);
+const axios_1 = require("axios");
 exports.metricsMiddleware = ({ metrics, serverTiming, name }) => {
     const serverTimingStart = process.hrtime();
     const serverTimingLabel = utils_1.shrinkTimings(utils_1.formatTimingName({
@@ -42,6 +29,9 @@ exports.metricsMiddleware = ({ metrics, serverTiming, name }) => {
             }
         }
         catch (err) {
+            if (!(err instanceof axios_1.AxiosError)) {
+                throw err;
+            }
             const isCancelled = (err.message === requestStats_1.cancelMessage);
             if (ctx.config.metric) {
                 errorCode = err.code;
@@ -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
+                    console.log(`VERBOSE: ${name}.${ctx.config.label}`, {
+                        ...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 {
@@ -113,16 +109,6 @@ 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/notFound.js

@@ -1,5 +1,6 @@
 "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;

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,26 @@
 "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");
+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);
         }
-        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;
+    }
 };

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 = 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 | undefined) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;

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

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestMiddleware = exports.routerCacheMiddleware = exports.defaultsMiddleware = void 0;
+const buildFullPath_1 = __importDefault(require("../../../utils/buildFullPath"));
+const qs_1 = require("qs");
+const ramda_1 = require("ramda");
+const Tags_1 = require("../../../tracing/Tags");
+const renameBy_1 = require("../../../utils/renameBy");
+const setupAxios_1 = require("./setupAxios");
+const http = setupAxios_1.getConfiguredAxios();
+const paramsSerializer = (params) => {
+    return qs_1.stringify(params, { arrayFormat: 'repeat' });
+};
+exports.defaultsMiddleware = ({ baseURL, rawHeaders, params, timeout, retries, verbose, exponentialTimeoutCoefficient, initialBackoffDelay, exponentialBackoffCoefficient, httpsAgent }) => {
+    const countByMetric = {};
+    const headers = renameBy_1.renameBy(ramda_1.toLower, rawHeaders);
+    return (ctx, next) => {
+        var _a, _b, _c;
+        ctx.config = {
+            baseURL,
+            exponentialBackoffCoefficient,
+            exponentialTimeoutCoefficient,
+            httpsAgent: ctx.config.httpsAgent || httpsAgent,
+            initialBackoffDelay,
+            maxRedirects: 0,
+            retries,
+            timeout,
+            validateStatus: status => (status >= 200 && status < 300),
+            verbose,
+            ...ctx.config,
+            headers: {
+                ...headers,
+                ...renameBy_1.renameBy(ramda_1.toLower, ctx.config.headers),
+            },
+            params: {
+                ...params,
+                ...ctx.config.params,
+            },
+            paramsSerializer,
+            retryCount: 0,
+        };
+        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}`;
+        }
+        if ((_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.isSampled) {
+            const { config } = ctx;
+            const fullUrl = buildFullPath_1.default(config.baseURL, http.getUri(config));
+            (_c = (_b = ctx.tracing) === null || _b === void 0 ? void 0 : _b.rootSpan) === null || _c === void 0 ? void 0 : _c.addTags({
+                [Tags_1.OpentracingTags.HTTP_METHOD]: config.method || 'get',
+                [Tags_1.OpentracingTags.HTTP_URL]: fullUrl,
+            });
+        }
+        return next();
+    };
+};
+const ROUTER_CACHE_KEY = 'x-router-cache';
+const ROUTER_CACHE_HIT = 'HIT';
+const ROUTER_CACHE_REVALIDATED = 'REVALIDATED';
+exports.routerCacheMiddleware = async (ctx, next) => {
+    var _a, _b, _c, _d, _e;
+    await next();
+    const routerCacheHit = (_b = (_a = ctx.response) === null || _a === void 0 ? void 0 : _a.headers) === null || _b === void 0 ? void 0 : _b[ROUTER_CACHE_KEY];
+    const status = (_c = ctx.response) === null || _c === void 0 ? void 0 : _c.status;
+    if (routerCacheHit) {
+        (_e = (_d = ctx.tracing) === null || _d === void 0 ? void 0 : _d.rootSpan) === null || _e === void 0 ? void 0 : _e.setTag("http.cache.router" /* HTTP_ROUTER_CACHE_RESULT */, routerCacheHit);
+    }
+    if (routerCacheHit === ROUTER_CACHE_HIT || (routerCacheHit === ROUTER_CACHE_REVALIDATED && status !== 304)) {
+        ctx.cacheHit = {
+            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());
+};

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

@@ -0,0 +1,2 @@
+/// <reference types="axios" />
+export declare const getConfiguredAxios: () => import("axios").AxiosInstance;

package/lib/HttpClient/middlewares/request/setupAxios/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfiguredAxios = void 0;
+const axios_1 = __importDefault(require("axios"));
+const HttpAgentSingleton_1 = require("../HttpAgentSingleton");
+const interceptors_1 = require("./interceptors");
+exports.getConfiguredAxios = () => {
+    const httpAgent = HttpAgentSingleton_1.HttpAgentSingleton.getHttpAgent();
+    const http = axios_1.default.create({
+        httpAgent,
+    });
+    interceptors_1.addTracingPreRequestInterceptor(http);
+    // Do not change this order, otherwise each request span will
+    // wait all retries to finish before finishing the span 
+    interceptors_1.addTracingResponseInterceptor(http);
+    interceptors_1.addExponentialBackoffResponseInterceptor(http);
+    return http;
+};

package/lib/HttpClient/middlewares/request/setupAxios/interceptors/exponentialBackoff.d.ts

@@ -0,0 +1,2 @@
+import { AxiosInstance } from 'axios';
+export declare const addExponentialBackoffResponseInterceptor: (http: AxiosInstance) => void;

package/lib/HttpClient/middlewares/request/setupAxios/interceptors/exponentialBackoff.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addExponentialBackoffResponseInterceptor = void 0;
+const retry_1 = require("../../../../../utils/retry");
+function fixConfig(axiosInstance, config) {
+    if (axiosInstance.defaults.httpAgent === config.httpAgent) {
+        delete config.httpAgent;
+    }
+    if (axiosInstance.defaults.httpsAgent === config.httpsAgent) {
+        delete config.httpsAgent;
+    }
+}
+const exponentialDelay = (initialBackoffDelay, exponentialBackoffCoefficient, retryNumber) => {
+    const delay = initialBackoffDelay *
+        Math.pow(exponentialBackoffCoefficient, retryNumber - 1);
+    const randomSum = delay * 0.2 * Math.random();
+    return delay + randomSum;
+};
+// A lot of this code is based on:
+// https://github.com/softonic/axios-retry/blob/ffd4327f31d063522e58c525d28d4c5053d0ea7b/es/index.js#L109
+const onResponseError = (http) => (error) => {
+    var _a, _b, _c, _d;
+    if (error.config == null) {
+        return Promise.reject(error);
+    }
+    const config = error.config;
+    if (config.retries == null || config.retries === 0) {
+        return Promise.reject(error);
+    }
+    const { initialBackoffDelay = 200, exponentialBackoffCoefficient = 2, exponentialTimeoutCoefficient, } = config;
+    const retryCount = config.retryCount || 0;
+    const shouldRetry = retry_1.isAbortedOrNetworkErrorOrRouterTimeout(error) && retryCount < config.retries;
+    if (shouldRetry) {
+        config.retryCount = retryCount + 1;
+        const delay = exponentialDelay(initialBackoffDelay, exponentialBackoffCoefficient, config.retryCount);
+        // Axios fails merging this configuration to the default configuration because it has an issue
+        // with circular structures: https://github.com/mzabriskie/axios/issues/370
+        fixConfig(http, config);
+        config.timeout = exponentialTimeoutCoefficient
+            ? config.timeout * exponentialTimeoutCoefficient
+            : config.timeout;
+        config.transformRequest = [data => data];
+        (_b = (_a = config.tracing) === null || _a === void 0 ? void 0 : _a.rootSpan) === null || _b === void 0 ? void 0 : _b.log({ event: "setup-request-retry" /* SETUP_REQUEST_RETRY */, ["retry-number" /* RETRY_NUMBER */]: config.retryCount, ["retry-in" /* RETRY_IN */]: delay });
+        (_d = (_c = config.tracing) === null || _c === void 0 ? void 0 : _c.rootSpan) === null || _d === void 0 ? void 0 : _d.addTags({
+            ["http.retry.count" /* HTTP_RETRY_COUNT */]: config.retryCount,
+            ["http.retry.error.code" /* HTTP_RETRY_ERROR_CODE */]: error.code,
+        });
+        return new Promise(resolve => setTimeout(() => resolve(http(config)), delay));
+    }
+    return Promise.reject(error);
+};
+exports.addExponentialBackoffResponseInterceptor = (http) => {
+    http.interceptors.response.use(undefined, onResponseError(http));
+};

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

@@ -0,0 +1,2 @@
+export { addExponentialBackoffResponseInterceptor } from './exponentialBackoff';
+export { addTracingPreRequestInterceptor, addTracingResponseInterceptor } from './tracing';

package/lib/HttpClient/middlewares/request/setupAxios/interceptors/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var exponentialBackoff_1 = require("./exponentialBackoff");
+Object.defineProperty(exports, "addExponentialBackoffResponseInterceptor", { enumerable: true, get: function () { return exponentialBackoff_1.addExponentialBackoffResponseInterceptor; } });
+var tracing_1 = require("./tracing");
+Object.defineProperty(exports, "addTracingPreRequestInterceptor", { enumerable: true, get: function () { return tracing_1.addTracingPreRequestInterceptor; } });
+Object.defineProperty(exports, "addTracingResponseInterceptor", { enumerable: true, get: function () { return tracing_1.addTracingResponseInterceptor; } });

package/lib/HttpClient/middlewares/request/setupAxios/interceptors/tracing/index.d.ts

@@ -0,0 +1,8 @@
+import { AxiosInstance } from 'axios';
+export declare const requestSpanPrefix = "http-request";
+export declare const addTracingPreRequestInterceptor: (http: AxiosInstance) => {
+    requestTracingInterceptor: number;
+};
+export declare const addTracingResponseInterceptor: (http: AxiosInstance) => {
+    responseTracingInterceptor: number;
+};

package/lib/HttpClient/middlewares/request/setupAxios/interceptors/tracing/index.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addTracingResponseInterceptor = exports.addTracingPreRequestInterceptor = exports.requestSpanPrefix = void 0;
+const opentracing_1 = require("opentracing");
+const tracing_1 = require("../../../../../../tracing");
+const SpanReferenceTypes_1 = require("../../../../../../tracing/spanReference/SpanReferenceTypes");
+const spanSetup_1 = require("./spanSetup");
+exports.requestSpanPrefix = 'http-request';
+const preRequestInterceptor = (http) => (config) => {
+    var _a;
+    if (!config.tracing || !((_a = config.tracing) === null || _a === void 0 ? void 0 : _a.isSampled)) {
+        return config;
+    }
+    const { tracer, rootSpan, requestSpanNameSuffix } = config.tracing;
+    const spanName = requestSpanNameSuffix ? `${exports.requestSpanPrefix}:${requestSpanNameSuffix}` : exports.requestSpanPrefix;
+    const span = rootSpan
+        ? tracer.startSpan(spanName, {
+            references: [tracing_1.createSpanReference(rootSpan, SpanReferenceTypes_1.SpanReferenceTypes.CHILD_OF)],
+        })
+        : tracer.startSpan(spanName);
+    spanSetup_1.injectRequestInfoOnSpan(span, http, config);
+    config.tracing.requestSpan = span;
+    tracer.inject(span, opentracing_1.FORMAT_HTTP_HEADERS, config.headers);
+    return config;
+};
+const onResponseSuccess = (response) => {
+    var _a, _b;
+    if (!response.config.tracing || !((_a = response.config.tracing) === null || _a === void 0 ? void 0 : _a.isSampled)) {
+        return response;
+    }
+    const requestSpan = (_b = response.config.tracing) === null || _b === void 0 ? void 0 : _b.requestSpan;
+    spanSetup_1.injectResponseInfoOnSpan(requestSpan, response);
+    requestSpan === null || requestSpan === void 0 ? void 0 : requestSpan.finish();
+    return response;
+};
+const onResponseError = (err) => {
+    var _a, _b, _c;
+    if (!((_b = (_a = err === null || err === void 0 ? void 0 : err.config) === null || _a === void 0 ? void 0 : _a.tracing) === null || _b === void 0 ? void 0 : _b.requestSpan) || !((_c = err.config.tracing) === null || _c === void 0 ? void 0 : _c.isSampled)) {
+        return Promise.reject(err);
+    }
+    const { requestSpan } = err.config.tracing;
+    spanSetup_1.injectResponseInfoOnSpan(requestSpan, err.response);
+    tracing_1.ErrorReport.create({ originalError: err }).injectOnSpan(requestSpan, err.config.tracing.logger);
+    requestSpan.finish();
+    return Promise.reject(err);
+};
+exports.addTracingPreRequestInterceptor = (http) => {
+    // Usando type assertion para compatibilidade com TypeScript 3.9.7
+    const requestTracingInterceptor = http.interceptors.request.use(preRequestInterceptor(http), undefined);
+    return { requestTracingInterceptor };
+};
+exports.addTracingResponseInterceptor = (http) => {
+    // Usando type assertion para compatibilidade com TypeScript 3.9.7
+    const responseTracingInterceptor = http.interceptors.response.use(onResponseSuccess, onResponseError);
+    return { responseTracingInterceptor };
+};

package/lib/HttpClient/middlewares/request/setupAxios/interceptors/tracing/spanSetup.d.ts

@@ -0,0 +1,4 @@
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
+import { Span } from 'opentracing';
+export declare const injectRequestInfoOnSpan: (span: Span | undefined, http: AxiosInstance, config: AxiosRequestConfig) => void;
+export declare const injectResponseInfoOnSpan: (span: Span | undefined, response: AxiosResponse<any> | undefined) => void;

package/lib/HttpClient/middlewares/request/setupAxios/interceptors/tracing/spanSetup.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectResponseInfoOnSpan = exports.injectRequestInfoOnSpan = void 0;
+const buildFullPath_1 = __importDefault(require("../../../../../../utils/buildFullPath"));
+const constants_1 = require("../../../../../../constants");
+const Tags_1 = require("../../../../../../tracing/Tags");
+const utils_1 = require("../../../../../../tracing/utils");
+exports.injectRequestInfoOnSpan = (span, http, config) => {
+    span === null || span === void 0 ? void 0 : span.addTags({
+        [Tags_1.OpentracingTags.SPAN_KIND]: Tags_1.OpentracingTags.SPAN_KIND_RPC_CLIENT,
+        [Tags_1.OpentracingTags.HTTP_METHOD]: config.method,
+        [Tags_1.OpentracingTags.HTTP_URL]: buildFullPath_1.default(config.baseURL, http.getUri(config)),
+    });
+    span === null || span === void 0 ? void 0 : span.log({ 'request-headers': utils_1.cloneAndSanitizeHeaders(config.headers) });
+};
+// Response may be undefined in case of client timeout, invalid URL, ...
+exports.injectResponseInfoOnSpan = (span, response) => {
+    if (!response) {
+        span === null || span === void 0 ? void 0 : span.setTag("http.no_response" /* HTTP_NO_RESPONSE */, 'true');
+        return;
+    }
+    span === null || span === void 0 ? void 0 : span.log({ 'response-headers': utils_1.cloneAndSanitizeHeaders(response.headers) });
+    span === null || span === void 0 ? void 0 : span.setTag(Tags_1.OpentracingTags.HTTP_STATUS_CODE, response.status);
+    if (response.headers[constants_1.ROUTER_CACHE_HEADER]) {
+        span === null || span === void 0 ? void 0 : span.setTag("http.cache.router" /* HTTP_ROUTER_CACHE_RESULT */, response.headers[constants_1.ROUTER_CACHE_HEADER]);
+    }
+};

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

@@ -0,0 +1,15 @@
+import { MiddlewaresTracingContext, RequestConfig } from '..';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { MiddlewareContext } from '../typings';
+interface HttpClientTracingMiddlewareConfig {
+    clientName: string;
+    tracer: IOContext['tracer'];
+    logger: IOContext['logger'];
+    hasMemoryCacheMiddleware: boolean;
+    hasDiskCacheMiddleware: boolean;
+}
+export interface TraceableRequestConfig extends RequestConfig {
+    tracing: MiddlewaresTracingContext;
+}
+export declare const createHttpClientTracingMiddleware: ({ tracer, logger, clientName, hasMemoryCacheMiddleware, hasDiskCacheMiddleware, }: HttpClientTracingMiddlewareConfig) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
+export {};

package/lib/HttpClient/middlewares/tracing.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHttpClientTracingMiddleware = void 0;
+const axios_1 = require("axios");
+const tracing_1 = require("../../tracing");
+const Tags_1 = require("../../tracing/Tags");
+const cache_1 = require("./cache");
+exports.createHttpClientTracingMiddleware = ({ tracer, logger, clientName, hasMemoryCacheMiddleware, hasDiskCacheMiddleware, }) => {
+    return async function tracingMiddleware(ctx, next) {
+        var _a;
+        if (!tracer.isTraceSampled) {
+            await next();
+            return;
+        }
+        const rootSpan = tracer.fallbackSpanContext();
+        const { requestSpanNameSuffix } = ctx.config.tracing || {};
+        const spanName = requestSpanNameSuffix ? `request:${requestSpanNameSuffix}` : 'request';
+        const span = tracer.startSpan(spanName, { childOf: rootSpan });
+        ctx.tracing = {
+            ...ctx.config.tracing,
+            isSampled: tracing_1.getTraceInfo(span).isSampled,
+            logger,
+            rootSpan: span,
+            tracer,
+        };
+        ctx.config.tracing = ctx.tracing;
+        const hasMemoCache = !(!cache_1.isLocallyCacheable(ctx.config, cache_1.CacheType.Any) || !ctx.config.memoizable);
+        const hasMemoryCache = hasMemoryCacheMiddleware && !!cache_1.isLocallyCacheable(ctx.config, cache_1.CacheType.Memory);
+        const hasDiskCache = hasDiskCacheMiddleware && !!cache_1.isLocallyCacheable(ctx.config, cache_1.CacheType.Disk);
+        span === null || span === void 0 ? void 0 : span.addTags({
+            ["http.cache.memoization.enabled" /* HTTP_MEMOIZATION_CACHE_ENABLED */]: hasMemoCache,
+            ["http.cache.memory.enabled" /* HTTP_MEMORY_CACHE_ENABLED */]: hasMemoryCache,
+            ["http.cache.disk.enabled" /* HTTP_DISK_CACHE_ENABLED */]: hasDiskCache,
+            ["http.client.name" /* HTTP_CLIENT_NAME */]: clientName,
+        });
+        let response;
+        try {
+            await next();
+            response = ctx.response;
+        }
+        catch (err) {
+            if (!(err instanceof axios_1.AxiosError)) {
+                throw err;
+            }
+            response = err.response;
+            if ((_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.isSampled) {
+                tracing_1.ErrorReport.create({ originalError: err }).injectOnSpan(span, logger);
+            }
+            throw err;
+        }
+        finally {
+            if (response) {
+                span === null || span === void 0 ? void 0 : span.setTag(Tags_1.OpentracingTags.HTTP_STATUS_CODE, response.status);
+            }
+            else {
+                span === null || span === void 0 ? void 0 : span.setTag("http.no_response" /* HTTP_NO_RESPONSE */, true);
+            }
+            span === null || span === void 0 ? void 0 : span.finish();
+        }
+    };
+};