@vtex/api 6.46.0-beta.0 → 6.46.1

package/CHANGELOG.md

@@ -7,9 +7,72 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## [Unreleased]
 
-## [6.46.0-beta.0] - 2023-03-07
+## [6.46.1] - 2024-01-31
 
-## [6.46.0-beta] - 2023-03-07
+### Fixed
+- Return type for the saveJSON method of VBase client
+
+### Changed
+- Increase timeout for messagesGraphQL client
+
+## [6.46.0] - 2023-10-25
+### Added
+- Add disk cache steps and retry count to tracing
+
+### Changed
+- Stop updating client cache when revalidated and still expired
+
+## [6.45.24] - 2023-10-05
+### Added
+
+- Allow disabling memoization for all requests of a client
+
+## [6.45.23] - 2023-10-04
+
+### Fixed
+- Fix metrics being restricted by tracing restrictions
+
+## [6.45.22] - 2023-09-20
+
+### Removed
+
+- Remove reference of how to search for the app's errors on now-defunct Splunk.
+
+### Fixed
+
+- Error tracing spans not logging the details.
+
+## [6.45.21] - 2023-09-19
+### Changed
+- Fix tracingMiddleware shouldTrace decision
+- Fix HttpClient tracing based on sampling decision
+
+## [6.45.21-beta.2] - 2023-09-19
+
+## [6.45.21-beta.1] - 2023-09-07
+
+## [6.45.21-beta.0] - 2023-09-04
+
+## [6.45.21-beta] - 2023-09-04
+
+## [6.45.20] - 2023-08-30
+### Changed
+- Remove sampling decision from runtime
+- Only create tracing spans when they come from router
+
+## [6.45.20-beta] - 2023-08-30
+
+## [6.45.19] - 2023-07-12
+### Changed
+- Bump `graphql-upload` version
+
+## [6.45.18] - 2023-07-07
+### Fixed
+- Metrics to prometheus
+
+## [6.45.16] - 2023-07-03
+### Changed
+- Bump `prom-client` version
 
 ## [6.45.15] - 2023-02-01
 ### Changed
@@ -1761,9 +1824,16 @@ instead
 - `HttpClient` now adds `'Accept-Encoding': 'gzip'` header by default.
 
 
-[Unreleased]: https://github.com/vtex/node-vtex-api/compare/v6.46.0-beta.0...HEAD
-[6.46.0-beta.0]: https://github.com/vtex/node-vtex-api/compare/v6.46.0-beta...v6.46.0-beta.0
-[6.46.0-beta]: https://github.com/vtex/node-vtex-api/compare/v6.45.15...v6.46.0-beta
+[Unreleased]: https://github.com/vtex/node-vtex-api/compare/v6.45.22...HEAD
 [6.45.15]: https://github.com/vtex/node-vtex-api/compare/v6.45.14...v6.45.15
 [6.45.14]: https://github.com/vtex/node-vtex-api/compare/v6.45.13...v6.45.14
 [6.45.13]: https://github.com/vtex/node-vtex-api/compare/v6.45.12...v6.45.13
+
+[6.45.22]: https://github.com/vtex/node-vtex-api/compare/v6.45.21...v6.45.22
+[6.45.21]: https://github.com/vtex/node-vtex-api/compare/v6.45.21-beta.2...v6.45.21
+[6.45.21-beta.2]: https://github.com/vtex/node-vtex-api/compare/v6.45.21-beta.1...v6.45.21-beta.2
+[6.45.21-beta.1]: https://github.com/vtex/node-vtex-api/compare/v6.45.21-beta.0...v6.45.21-beta.1
+[6.45.21-beta.0]: https://github.com/vtex/node-vtex-api/compare/v6.45.21-beta...v6.45.21-beta.0
+[6.45.21-beta]: https://github.com/vtex/node-vtex-api/compare/v6.45.20...v6.45.21-beta
+[6.45.20]: https://github.com/vtex/node-vtex-api/compare/v6.45.20-beta...v6.45.20
+[6.45.20-beta]: https://github.com/vtex/node-vtex-api/compare/v6.45.19...v6.45.20-beta

package/lib/HttpClient/HttpClient.d.ts

@@ -7,6 +7,8 @@ declare type ClientOptions = IOContext & Partial<InstanceOptions>;
 export declare class HttpClient {
     name: string;
     private logger;
+    private cacheableType;
+    private memoizable;
     private runMiddlewares;
     constructor(opts: ClientOptions);
     get: <T = any>(url: string, config?: RequestConfig) => Promise<T>;
@@ -24,7 +26,7 @@ export declare class HttpClient {
     patch: <T = void>(url: string, data?: any, config?: RequestConfig) => Promise<T>;
     head: (url: string, config?: RequestConfig) => Promise<IOResponse<void>>;
     delete: <T = void>(url: string, config?: RequestConfig | undefined) => Promise<IOResponse<T>>;
-    protected request: (config: RequestConfig) => Promise<AxiosResponse<any, any>>;
+    protected request: (config: RequestConfig) => Promise<AxiosResponse<any>>;
     private getConfig;
 }
 export {};

package/lib/HttpClient/HttpClient.js

@@ -96,14 +96,16 @@ class HttpClient {
             return context.response;
         };
         this.getConfig = (url, config = {}) => ({
-            cacheable: cache_1.CacheType.Memory,
-            memoizable: true,
+            cacheable: this.cacheableType,
+            memoizable: this.memoizable,
             ...config,
             url,
         });
-        const { baseURL, authToken, authType, memoryCache, diskCache, locale, name, metrics, product, serverTiming, recorder, userAgent, timeout = DEFAULT_TIMEOUT_MS, segmentToken, sessionToken, retries, concurrency, headers: defaultHeaders, host, params, operationId, tenant, binding, verbose, cancellation, exponentialTimeoutCoefficient, initialBackoffDelay, exponentialBackoffCoefficient, httpsAgent, tracer, logger, } = opts;
+        const { baseURL, authToken, authType, memoryCache, diskCache, memoizable = true, locale, name, metrics, product, serverTiming, recorder, userAgent, timeout = DEFAULT_TIMEOUT_MS, segmentToken, sessionToken, retries, concurrency, headers: defaultHeaders, host, params, operationId, tenant, binding, verbose, cancellation, exponentialTimeoutCoefficient, initialBackoffDelay, exponentialBackoffCoefficient, httpsAgent, tracer, logger, cacheableType = cache_1.CacheType.Memory, } = opts;
         this.name = name || baseURL || 'unknown';
         this.logger = logger;
+        this.cacheableType = cacheableType;
+        this.memoizable = memoizable;
         const limit = concurrency && concurrency > 0 && p_limit_1.default(concurrency) || undefined;
         const headers = {
             ...defaultHeaders,

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

@@ -2,7 +2,7 @@
 import { AxiosRequestConfig, AxiosResponse } from 'axios';
 import { CacheLayer } from '../../caches/CacheLayer';
 import { MiddlewareContext, RequestConfig } from '../typings';
-export declare const cacheKey: (config: AxiosRequestConfig<any>) => string;
+export declare const cacheKey: (config: AxiosRequestConfig) => string;
 export declare function isLocallyCacheable(arg: RequestConfig, type: CacheType): arg is CacheableRequestConfig;
 export declare enum CacheType {
     None = 0,

package/lib/HttpClient/middlewares/cache.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const constants_1 = 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 { baseURL = '', url = '', params, headers } = config;
-    const locale = headers === null || headers === void 0 ? void 0 : headers[constants_1.LOCALE_HEADER];
+    const locale = headers[constants_1.LOCALE_HEADER];
     const encodedBaseURL = baseURL.replace(/\//g, '\\');
     const encodedURL = url.replace(/\//g, '\\');
     let key = `${locale}--${encodedBaseURL}--${encodedURL}?`;
@@ -59,25 +60,36 @@ exports.cacheMiddleware = ({ type, storage }) => {
         if (!isLocallyCacheable(ctx.config, type)) {
             return await next();
         }
-        const span = ctx.tracing.rootSpan;
+        const { rootSpan: span, tracer, logger } = (_a = ctx.tracing) !== null && _a !== void 0 ? _a : {};
         const key = exports.cacheKey(ctx.config);
-        const segmentToken = (_a = ctx.config.headers) === null || _a === void 0 ? void 0 : _a[constants_1.SEGMENT_HEADER];
+        const segmentToken = ctx.config.headers[constants_1.SEGMENT_HEADER];
         const keyWithSegment = key + segmentToken;
-        span.log({
+        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 cacheHasWithSegment = await storage.has(keyWithSegment);
-        const cached = cacheHasWithSegment ? await storage.get(keyWithSegment) : await storage.get(key);
+        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 { 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.log({
+            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,
@@ -92,21 +104,18 @@ exports.cacheMiddleware = ({ type, storage }) => {
                     revalidated: 0,
                     router: 0,
                 };
-                span.setTag(CACHE_RESULT_TAG, "HIT" /* HIT */);
+                span === null || span === void 0 ? void 0 : span.setTag(CACHE_RESULT_TAG, "HIT" /* HIT */);
                 return;
             }
-            span.setTag(CACHE_RESULT_TAG, "STALE" /* STALE */);
+            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)) {
-                if (!ctx.config.headers) {
-                    ctx.config.headers = {};
-                }
                 ctx.config.headers['if-none-match'] = cachedEtag;
                 ctx.config.validateStatus = validateStatus;
             }
         }
         else {
-            span.setTag(CACHE_RESULT_TAG, "MISS" /* MISS */);
+            span === null || span === void 0 ? void 0 : span.setTag(CACHE_RESULT_TAG, "MISS" /* MISS */);
         }
         await next();
         if (!ctx.response) {
@@ -125,7 +134,7 @@ 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.log({
+        span === null || span === void 0 ? void 0 : span.log({
             event: "cache-config" /* CACHE_CONFIG */,
             ["cache-type" /* CACHE_TYPE */]: cacheType,
             ["age" /* AGE */]: age,
@@ -138,7 +147,7 @@ exports.cacheMiddleware = ({ type, storage }) => {
         });
         // Indicates this should NOT be cached and this request will not be considered a miss.
         if (!forceMaxAge && (noStore || (noCache && !etag))) {
-            span.log({ event: "no-local-cache-save" /* NO_LOCAL_CACHE_SAVE */, ["cache-type" /* CACHE_TYPE */]: cacheType });
+            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;
@@ -148,30 +157,52 @@ exports.cacheMiddleware = ({ type, storage }) => {
             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 responseEncoding = configResponseEncoding || (responseType === 'arraybuffer' ? 'base64' : undefined);
             const cacheableData = type === CacheType.Disk && responseType === 'arraybuffer'
                 ? data.toString(responseEncoding)
                 : data;
-            const expiration = Date.now() + (maxAge - currentAge) * 1000;
-            await storage.set(setKey, {
-                etag,
-                expiration,
-                response: { data: cacheableData, headers, status },
-                responseEncoding,
-                responseType,
-            });
-            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,
-            });
+            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 {
+                await storage.set(setKey, {
+                    etag,
+                    expiration,
+                    response: { data: cacheableData, headers, status },
+                    responseEncoding,
+                    responseType,
+                });
+                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();
+            }
             return;
         }
-        span.log({ event: "no-local-cache-save" /* NO_LOCAL_CACHE_SAVE */, ["cache-type" /* CACHE_TYPE */]: cacheType });
+        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/memoization.js

@@ -3,22 +3,23 @@ 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();
         }
-        const span = ctx.tracing.rootSpan;
+        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.log({ event: "cache-key-created" /* CACHE_KEY_CREATE */, ["cache-type" /* CACHE_TYPE */]: 'memoization', ["key" /* KEY */]: 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.setTag("http.cache.memoization" /* HTTP_MEMOIZATION_CACHE_RESULT */, "HIT" /* HIT */);
+            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.setTag("http.cache.memoization" /* HTTP_MEMOIZATION_CACHE_RESULT */, "MISS" /* MISS */);
+            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();
@@ -26,11 +27,11 @@ exports.memoizationMiddleware = ({ memoizedCache }) => {
                         cacheHit: ctx.cacheHit,
                         response: ctx.response,
                     });
-                    span.log({ event: "memoization-cache-saved" /* MEMOIZATION_CACHE_SAVED */, ["key-set" /* KEY_SET */]: key });
+                    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.log({ event: "memoization-cache-saved-error" /* MEMOIZATION_CACHE_SAVED_ERROR */, ["key-set" /* KEY_SET */]: key });
+                    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/request/index.js

@@ -17,6 +17,7 @@ exports.defaultsMiddleware = ({ baseURL, rawHeaders, params, timeout, retries, v
     const countByMetric = {};
     const headers = renameBy_1.renameBy(ramda_1.toLower, rawHeaders);
     return (ctx, next) => {
+        var _a, _b, _c;
         ctx.config = {
             baseURL,
             exponentialBackoffCoefficient,
@@ -46,10 +47,10 @@ exports.defaultsMiddleware = ({ baseURL, rawHeaders, params, timeout, retries, v
             ctx.config.count = countByMetric[ctx.config.metric];
             ctx.config.label = `${ctx.config.metric}#${ctx.config.count}`;
         }
-        if (ctx.tracing.isSampled) {
+        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));
-            ctx.tracing.rootSpan.addTags({
+            (_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,
             });
@@ -61,12 +62,12 @@ 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;
+    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) {
-        ctx.tracing.rootSpan.setTag("http.cache.router" /* HTTP_ROUTER_CACHE_RESULT */, 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 = {

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

@@ -18,6 +18,7 @@ const exponentialDelay = (initialBackoffDelay, exponentialBackoffCoefficient, re
 // 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);
     }
@@ -38,7 +39,11 @@ const onResponseError = (http) => (error) => {
             ? config.timeout * exponentialTimeoutCoefficient
             : config.timeout;
         config.transformRequest = [data => data];
-        config.tracing.rootSpan.log({ event: "setup-request-retry" /* SETUP_REQUEST_RETRY */, ["retry-number" /* RETRY_NUMBER */]: config.retryCount, ["retry-in" /* RETRY_IN */]: delay });
+        (_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);

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

@@ -6,7 +6,8 @@ const SpanReferenceTypes_1 = require("../../../../../../tracing/spanReference/Sp
 const spanSetup_1 = require("./spanSetup");
 exports.requestSpanPrefix = 'http-request';
 const preRequestInterceptor = (http) => (config) => {
-    if (!config.tracing || !config.tracing.isSampled) {
+    var _a;
+    if (!config.tracing || !((_a = config.tracing) === null || _a === void 0 ? void 0 : _a.isSampled)) {
         return config;
     }
     const { tracer, rootSpan, requestSpanNameSuffix } = config.tracing;
@@ -22,17 +23,18 @@ const preRequestInterceptor = (http) => (config) => {
     return config;
 };
 const onResponseSuccess = (response) => {
-    if (!response.config.tracing || !response.config.tracing.isSampled) {
+    var _a, _b;
+    if (!response.config.tracing || !((_a = response.config.tracing) === null || _a === void 0 ? void 0 : _a.isSampled)) {
         return response;
     }
-    const requestSpan = response.config.tracing.requestSpan;
+    const requestSpan = (_b = response.config.tracing) === null || _b === void 0 ? void 0 : _b.requestSpan;
     spanSetup_1.injectResponseInfoOnSpan(requestSpan, response);
-    requestSpan.finish();
+    requestSpan === null || requestSpan === void 0 ? void 0 : requestSpan.finish();
     return response;
 };
 const onResponseError = (err) => {
-    var _a, _b;
-    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) || !err.config.tracing.isSampled) {
+    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;

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

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

@@ -8,22 +8,22 @@ const constants_1 = require("../../../../../../constants");
 const Tags_1 = require("../../../../../../tracing/Tags");
 const utils_1 = require("../../../../../../tracing/utils");
 exports.injectRequestInfoOnSpan = (span, http, config) => {
-    span.addTags({
+    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.log({ 'request-headers': utils_1.cloneAndSanitizeHeaders(config.headers) });
+    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.setTag("http.no_response" /* HTTP_NO_RESPONSE */, 'true');
+        span === null || span === void 0 ? void 0 : span.setTag("http.no_response" /* HTTP_NO_RESPONSE */, 'true');
         return;
     }
-    span.log({ 'response-headers': utils_1.cloneAndSanitizeHeaders(response.headers) });
-    span.setTag(Tags_1.OpentracingTags.HTTP_STATUS_CODE, response.status);
+    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.setTag("http.cache.router" /* HTTP_ROUTER_CACHE_RESULT */, 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.js

@@ -5,13 +5,15 @@ const Tags_1 = require("../../tracing/Tags");
 const cache_1 = require("./cache");
 exports.createHttpClientTracingMiddleware = ({ tracer, logger, clientName, hasMemoryCacheMiddleware, hasDiskCacheMiddleware, }) => {
     return async function tracingMiddleware(ctx, next) {
-        const { rootSpan, requestSpanNameSuffix, referenceType = tracing_1.SpanReferenceTypes.CHILD_OF } = ctx.config.tracing || {};
+        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 = rootSpan
-            ? tracer.startSpan(spanName, {
-                references: [tracing_1.createSpanReference(rootSpan, referenceType)],
-            })
-            : tracer.startSpan(spanName);
+        const span = tracer.startSpan(spanName, { childOf: rootSpan });
         ctx.tracing = {
             ...ctx.config.tracing,
             isSampled: tracing_1.getTraceInfo(span).isSampled,
@@ -23,7 +25,7 @@ exports.createHttpClientTracingMiddleware = ({ tracer, logger, clientName, hasMe
         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.addTags({
+        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,
@@ -36,19 +38,19 @@ exports.createHttpClientTracingMiddleware = ({ tracer, logger, clientName, hasMe
         }
         catch (err) {
             response = err.response;
-            if (ctx.tracing.isSampled) {
+            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.setTag(Tags_1.OpentracingTags.HTTP_STATUS_CODE, response.status);
+                span === null || span === void 0 ? void 0 : span.setTag(Tags_1.OpentracingTags.HTTP_STATUS_CODE, response.status);
             }
             else {
-                span.setTag("http.no_response" /* HTTP_NO_RESPONSE */, true);
+                span === null || span === void 0 ? void 0 : span.setTag("http.no_response" /* HTTP_NO_RESPONSE */, true);
             }
-            span.finish();
+            span === null || span === void 0 ? void 0 : span.finish();
         }
     };
 };

package/lib/HttpClient/typings.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { AxiosRequestConfig, AxiosResponse } from 'axios';
 import { Middleware } from 'koa-compose';
 import { Span } from 'opentracing';
@@ -43,6 +44,7 @@ export interface RequestConfig extends AxiosRequestConfig, RequestTracingConfig
     memoizeable?: boolean;
     inflightKey?: InflightKeyGenerator;
     forceMaxAge?: number;
+    responseEncoding?: BufferEncoding;
     nullIfNotFound?: boolean;
     ignoreRecorder?: boolean;
 }
@@ -55,7 +57,7 @@ export interface CacheHit {
 export interface MiddlewaresTracingContext extends Omit<RequestTracingUserConfig, 'rootSpan'> {
     tracer: IUserLandTracer;
     logger: IOContext['logger'];
-    rootSpan: Span;
+    rootSpan?: Span;
     isSampled: boolean;
 }
 export interface MiddlewareContext {
@@ -72,6 +74,16 @@ export interface InstanceOptions {
     timeout?: number;
     memoryCache?: CacheLayer<string, Cached>;
     diskCache?: CacheLayer<string, Cached>;
+    /**
+     * 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;
@@ -104,6 +116,7 @@ export interface InstanceOptions {
     name?: string;
     serverTimings?: Record<string, string>;
     httpsAgent?: AxiosRequestConfig['httpsAgent'];
+    cacheableType?: CacheType;
 }
 export interface IOResponse<T> {
     data: T;

package/lib/clients/infra/VBase.d.ts

@@ -3,7 +3,7 @@ import { IncomingMessage } from 'http';
 import { Readable } from 'stream';
 import { Logger } from './../../service/logger/logger';
 import { InstanceOptions, IOResponse, RequestTracingConfig } from '../../HttpClient';
-import { BucketMetadata, FileListItem } from '../../responses';
+import { BucketMetadata, FileListItem, VBaseSaveResponse } from '../../responses';
 import { IOContext } from '../../service/worker/runtime/typings';
 import { InfraClient } from './InfraClient';
 export declare class VBase extends InfraClient {
@@ -20,7 +20,7 @@ export declare class VBase extends InfraClient {
     getFileStream: (bucket: string, path: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<IncomingMessage>;
     saveFile: (bucket: string, path: string, stream: Readable, gzip?: boolean, ttl?: number | undefined, tracingConfig?: RequestTracingConfig | undefined, ifMatch?: string | undefined) => Promise<void>;
     getFileMetadata: (bucket: string, path: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<IOResponse<void>>;
-    saveJSON: <T>(bucket: string, path: string, data: T, tracingConfig?: RequestTracingConfig | undefined, ifMatch?: string | undefined) => Promise<void>;
+    saveJSON: <T>(bucket: string, path: string, data: T, tracingConfig?: RequestTracingConfig | undefined, ifMatch?: string | undefined) => Promise<VBaseSaveResponse>;
     saveZippedContent: (bucket: string, path: string, stream: Readable, tracingConfig?: RequestTracingConfig | undefined, ifMatch?: string | undefined) => Promise<void>;
     deleteFile: (bucket: string, path: string, tracingConfig?: RequestTracingConfig | undefined, ifMatch?: string | undefined) => Promise<IOResponse<void>>;
     getConflicts: <T>(bucket: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<T>;

package/lib/clients/infra/VBase.js

@@ -138,7 +138,7 @@ class VBase extends InfraClient_1.InfraClient {
             return this.saveContent(bucket, path, stream, { unzip: true }, tracingConfig, ifMatch);
         };
         this.deleteFile = (bucket, path, tracingConfig, ifMatch) => {
-            const headers = ifMatch ? { 'If-Match': ifMatch } : {};
+            const headers = ifMatch ? { 'If-Match': ifMatch } : null;
             const metric = 'vbase-delete-file';
             return this.http.delete(routes.File(bucket, path), { headers, metric, tracing: {
                     requestSpanNameSuffix: metric,

package/lib/responses.d.ts

@@ -76,4 +76,5 @@ export interface HousekeeperStatesAndUpdates {
     state: HouseKeeperState;
     updates: HouseKeeperUpdates;
 }
+export declare type VBaseSaveResponse = FileListItem[];
 export {};

package/lib/service/loaders.js

@@ -33,9 +33,9 @@ const defaultClients = {
             timeout: 1000,
         },
         messagesGraphQL: {
-            concurrency: 10,
+            concurrency: 12,
             retries: 2,
-            timeout: 1000,
+            timeout: 2000,
         },
     },
 };

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

@@ -25,11 +25,5 @@ export declare class Logger {
     warn: (warning: any) => void;
     error: (error: any) => void;
     log: (message: any, level: LogLevel) => void;
-    /**
-     * Logs splunk query so the developer can search for the errors in splunk.
-     * This function runs only once in the lifetime of the Logger class so we
-     * don't mess up with the developer's terminal
-     */
-    private logSplunkQuery;
 }
 export {};

package/lib/service/logger/logger.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const constants_1 = require("../../constants");
 const error_1 = require("../../utils/error");
 const log_1 = require("../../utils/log");
-const console_1 = require("./console");
 const linked = !!process.env.VTEX_APP_LINK;
 const app = constants_1.APP.ID;
 const EMPTY_MESSAGE = 'Logger.log was called with null or undefined message';
@@ -45,19 +44,6 @@ class Logger {
                 });
             }
             console.log(JSON.stringify(inflatedLog));
-            // Warn the developer how to retrieve the error in splunk
-            this.logSplunkQuery();
-        };
-        /**
-         * Logs splunk query so the developer can search for the errors in splunk.
-         * This function runs only once in the lifetime of the Logger class so we
-         * don't mess up with the developer's terminal
-         */
-        this.logSplunkQuery = () => {
-            if (linked) {
-                const message = `Try this query at Splunk to retrieve error log: 'index=io_vtex_logs app="${app}" account=${this.account} workspace=${this.workspace} level=error OR level=warn'`;
-                console_1.logOnceToDevConsole(message, LogLevel.Info);
-            }
         };
         this.account = ctx.account;
         this.workspace = ctx.workspace;

package/lib/service/metrics/requestMetricsMiddleware.d.ts

@@ -0,0 +1,2 @@
+import { ServiceContext } from '../worker/runtime/typings';
+export declare const addRequestMetricsMiddleware: () => (ctx: ServiceContext<import("../..").IOClients, import("../worker/runtime/typings").RecorderState, import("../worker/runtime/typings").ParamsContext>, next: () => Promise<void>) => Promise<void>;

package/lib/service/metrics/requestMetricsMiddleware.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("stream");
+const utils_1 = require("../../utils");
+const instruments_1 = require("../tracing/metrics/instruments");
+exports.addRequestMetricsMiddleware = () => {
+    const concurrentRequests = instruments_1.createConcurrentRequestsInstrument();
+    const requestTimings = instruments_1.createRequestsTimingsInstrument();
+    const totalRequests = instruments_1.createTotalRequestsInstrument();
+    const responseSizes = instruments_1.createRequestsResponseSizesInstrument();
+    const abortedRequests = instruments_1.createTotalAbortedRequestsInstrument();
+    return async function addRequestMetrics(ctx, next) {
+        const start = process.hrtime();
+        concurrentRequests.inc(1);
+        ctx.req.once('aborted', () => abortedRequests.inc({ ["handler" /* REQUEST_HANDLER */]: ctx.requestHandlerName }, 1));
+        let responseClosed = false;
+        ctx.res.once('close', () => (responseClosed = true));
+        try {
+            await next();
+        }
+        finally {
+            const responseLength = ctx.response.length;
+            if (responseLength) {
+                responseSizes.observe({ ["handler" /* REQUEST_HANDLER */]: ctx.requestHandlerName }, responseLength);
+            }
+            totalRequests.inc({
+                ["handler" /* REQUEST_HANDLER */]: ctx.requestHandlerName,
+                ["status_code" /* STATUS_CODE */]: ctx.response.status,
+            }, 1);
+            const onResFinished = () => {
+                requestTimings.observe({
+                    ["handler" /* REQUEST_HANDLER */]: ctx.requestHandlerName,
+                }, utils_1.hrToMillisFloat(process.hrtime(start)));
+                concurrentRequests.dec(1);
+            };
+            if (responseClosed) {
+                onResFinished();
+            }
+            else {
+                stream_1.finished(ctx.res, onResFinished);
+            }
+        }
+    };
+};

package/lib/service/tracing/TracerSingleton.js

@@ -30,12 +30,6 @@ class TracerSingleton {
             reporter: {
                 agentHost: process.env.VTEX_OWN_NODE_IP,
             },
-            sampler: {
-                host: process.env.VTEX_OWN_NODE_IP,
-                param: 0.05,
-                refreshIntervalMs: 60 * 1000,
-                type: 'remote',
-            },
             serviceName,
         };
         const options = {

package/lib/service/tracing/tracingMiddlewares.js

@@ -7,31 +7,22 @@ const tracing_1 = require("../../tracing");
 const Tags_1 = require("../../tracing/Tags");
 const utils_1 = require("../../tracing/utils");
 const utils_2 = require("../../utils");
-const instruments_1 = require("./metrics/instruments");
 const PATHS_BLACKLISTED_FOR_TRACING = ['/_status', '/healthcheck'];
 exports.addTracingMiddleware = (tracer) => {
-    const concurrentRequests = instruments_1.createConcurrentRequestsInstrument();
-    const requestTimings = instruments_1.createRequestsTimingsInstrument();
-    const totalRequests = instruments_1.createTotalRequestsInstrument();
-    const responseSizes = instruments_1.createRequestsResponseSizesInstrument();
-    const abortedRequests = instruments_1.createTotalAbortedRequestsInstrument();
     return async function addTracing(ctx, next) {
         var _a;
-        const start = process.hrtime();
-        concurrentRequests.inc(1);
-        if (PATHS_BLACKLISTED_FOR_TRACING.includes(ctx.request.path)) {
+        const rootSpan = tracer.extract(opentracing_1.FORMAT_HTTP_HEADERS, ctx.request.headers);
+        ctx.tracing = { tracer, currentSpan: undefined };
+        if (!shouldTrace(ctx, rootSpan)) {
             await next();
-            concurrentRequests.dec(1);
             return;
         }
-        const rootSpan = tracer.extract(opentracing_1.FORMAT_HTTP_HEADERS, ctx.request.headers);
         const currentSpan = tracer.startSpan('unknown-operation', {
             childOf: rootSpan,
             tags: { [Tags_1.OpentracingTags.SPAN_KIND]: Tags_1.OpentracingTags.SPAN_KIND_RPC_SERVER },
         });
         const initialSamplingDecision = tracing_1.getTraceInfo(currentSpan).isSampled;
         ctx.tracing = { currentSpan, tracer };
-        ctx.req.once('aborted', () => abortedRequests.inc({ ["handler" /* REQUEST_HANDLER */]: currentSpan.operationName }, 1));
         let responseClosed = false;
         ctx.res.once('close', () => (responseClosed = true));
         try {
@@ -42,20 +33,12 @@ exports.addTracingMiddleware = (tracer) => {
             throw err;
         }
         finally {
-            const responseLength = ctx.response.length;
-            if (responseLength) {
-                responseSizes.observe({ ["handler" /* REQUEST_HANDLER */]: currentSpan.operationName }, responseLength);
-            }
-            totalRequests.inc({
-                ["handler" /* REQUEST_HANDLER */]: currentSpan.operationName,
-                ["status_code" /* STATUS_CODE */]: ctx.response.status,
-            }, 1);
             const traceInfo = tracing_1.getTraceInfo(currentSpan);
-            if (traceInfo.isSampled) {
+            if (traceInfo === null || traceInfo === void 0 ? void 0 : traceInfo.isSampled) {
                 if (!initialSamplingDecision) {
-                    currentSpan.setTag(Tags_1.OpentracingTags.SPAN_KIND, Tags_1.OpentracingTags.SPAN_KIND_RPC_SERVER);
+                    currentSpan === null || currentSpan === void 0 ? void 0 : currentSpan.setTag(Tags_1.OpentracingTags.SPAN_KIND, Tags_1.OpentracingTags.SPAN_KIND_RPC_SERVER);
                 }
-                currentSpan.addTags({
+                currentSpan === null || currentSpan === void 0 ? void 0 : currentSpan.addTags({
                     [Tags_1.OpentracingTags.HTTP_URL]: ctx.request.href,
                     [Tags_1.OpentracingTags.HTTP_METHOD]: ctx.request.method,
                     [Tags_1.OpentracingTags.HTTP_STATUS_CODE]: ctx.response.status,
@@ -64,16 +47,12 @@ exports.addTracingMiddleware = (tracer) => {
                     ["vtex.incoming.workspace" /* VTEX_WORKSPACE */]: ctx.get(constants_1.WORKSPACE_HEADER),
                     ["vtex.incoming.account" /* VTEX_ACCOUNT */]: ctx.get(constants_1.ACCOUNT_HEADER),
                 });
-                currentSpan.log(utils_1.cloneAndSanitizeHeaders(ctx.request.headers, 'req.headers.'));
-                currentSpan.log(utils_1.cloneAndSanitizeHeaders(ctx.response.headers, 'res.headers.'));
+                currentSpan === null || currentSpan === void 0 ? void 0 : currentSpan.log(utils_1.cloneAndSanitizeHeaders(ctx.request.headers, 'req.headers.'));
+                currentSpan === null || currentSpan === void 0 ? void 0 : currentSpan.log(utils_1.cloneAndSanitizeHeaders(ctx.response.headers, 'res.headers.'));
                 ctx.set(constants_1.TRACE_ID_HEADER, traceInfo.traceId);
             }
             const onResFinished = () => {
-                requestTimings.observe({
-                    ["handler" /* REQUEST_HANDLER */]: currentSpan.operationName,
-                }, utils_2.hrToMillisFloat(process.hrtime(start)));
-                concurrentRequests.dec(1);
-                currentSpan.finish();
+                currentSpan === null || currentSpan === void 0 ? void 0 : currentSpan.finish();
             };
             if (responseClosed) {
                 onResFinished();
@@ -86,8 +65,9 @@ exports.addTracingMiddleware = (tracer) => {
 };
 exports.nameSpanOperationMiddleware = (operationType, operationName) => {
     return function nameSpanOperation(ctx, next) {
-        var _a;
-        (_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.currentSpan.setOperationName(`${operationType}:${operationName}`);
+        var _a, _b;
+        ctx.requestHandlerName = `${operationType}:${operationName}`;
+        (_b = (_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.currentSpan) === null || _b === void 0 ? void 0 : _b.setOperationName(ctx.requestHandlerName);
         return next();
     };
 };
@@ -95,13 +75,13 @@ exports.traceUserLandRemainingPipelineMiddleware = () => {
     return async function traceUserLandRemainingPipeline(ctx, next) {
         const tracingCtx = ctx.tracing;
         ctx.tracing = undefined;
-        const span = tracingCtx.currentSpan;
+        const span = tracingCtx === null || tracingCtx === void 0 ? void 0 : tracingCtx.currentSpan;
         const userLandTracer = ctx.vtex.tracer;
         userLandTracer.setFallbackSpan(span);
         userLandTracer.lockFallbackSpan();
         const startTime = process.hrtime();
         try {
-            span.log({ event: "user-middlewares-start" /* USER_MIDDLEWARES_START */ });
+            span === null || span === void 0 ? void 0 : span.log({ event: "user-middlewares-start" /* USER_MIDDLEWARES_START */ });
             await next();
         }
         catch (err) {
@@ -109,7 +89,7 @@ exports.traceUserLandRemainingPipelineMiddleware = () => {
             throw err;
         }
         finally {
-            span.log({
+            span === null || span === void 0 ? void 0 : span.log({
                 event: "user-middlewares-finish" /* USER_MIDDLEWARES_FINISH */,
                 ["user-middlewares-duration" /* USER_MIDDLEWARES_DURATION */]: utils_2.hrToMillis(process.hrtime(startTime)),
             });
@@ -117,3 +97,11 @@ exports.traceUserLandRemainingPipelineMiddleware = () => {
         }
     };
 };
+function shouldTrace(ctx, rootSpan) {
+    var _a, _b, _c;
+    /** Should trace if path isnt blacklisted and sampling decision came from the edge
+     * ((rootSpan as any).isSampled. returns whether or not this span context was sampled
+     * There is a cast to bypass opentracing typescript
+     */
+    return !PATHS_BLACKLISTED_FOR_TRACING.includes(ctx.request.path) && ((_c = (_b = (_a = rootSpan).isSampled) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : false);
+}

package/lib/service/worker/index.js

@@ -13,6 +13,7 @@ const MetricsAccumulator_1 = require("../../metrics/MetricsAccumulator");
 const loaders_1 = require("../loaders");
 const console_1 = require("../logger/console");
 const logger_1 = require("../logger/logger");
+const requestMetricsMiddleware_1 = require("../metrics/requestMetricsMiddleware");
 const TracerSingleton_1 = require("../tracing/TracerSingleton");
 const tracingMiddlewares_1 = require("../tracing/tracingMiddlewares");
 const listeners_1 = require("./listeners");
@@ -157,6 +158,7 @@ exports.startWorker = (serviceJSON) => {
         .use(error_1.error)
         .use(middlewares_1.prometheusLoggerMiddleware())
         .use(tracingMiddlewares_1.addTracingMiddleware(tracer))
+        .use(requestMetricsMiddleware_1.addRequestMetricsMiddleware())
         .use(middlewares_1.addMetricsLoggerMiddleware())
         .use(rateLimit_1.concurrentRateLimiter((_a = serviceJSON === null || serviceJSON === void 0 ? void 0 : serviceJSON.rateLimitPerReplica) === null || _a === void 0 ? void 0 : _a.concurrent))
         .use(koa_compress_1.default())

package/lib/service/worker/runtime/builtIn/handlers.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.whoAmIHandler = ({ events, routes, }) => (ctx) => {
-    var _a;
-    (_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.currentSpan.setOperationName('builtin:whoami');
+    var _a, _b;
+    (_b = (_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.currentSpan) === null || _b === void 0 ? void 0 : _b.setOperationName('builtin:whoami');
     ctx.status = 200;
     ctx.body = {
         events,
@@ -11,8 +11,8 @@ exports.whoAmIHandler = ({ events, routes, }) => (ctx) => {
     ctx.set('Cache-Control', 'public, max-age=86400'); // cache for 24 hours
 };
 exports.healthcheckHandler = ({ events, routes, }) => (ctx) => {
-    var _a;
-    (_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.currentSpan.setOperationName('builtin:healthcheck');
+    var _a, _b;
+    (_b = (_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.currentSpan) === null || _b === void 0 ? void 0 : _b.setOperationName('builtin:healthcheck');
     ctx.status = 200;
     ctx.body = {
         events,
@@ -20,8 +20,8 @@ exports.healthcheckHandler = ({ events, routes, }) => (ctx) => {
     };
 };
 exports.metricsLoggerHandler = (ctx) => {
-    var _a;
-    (_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.currentSpan.setOperationName('builtin:metrics-logger');
+    var _a, _b;
+    (_b = (_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.currentSpan) === null || _b === void 0 ? void 0 : _b.setOperationName('builtin:metrics-logger');
     ctx.status = 200;
     ctx.body = ctx.metricsLogger.getSummaries();
 };

package/lib/service/worker/runtime/builtIn/middlewares.js

@@ -34,7 +34,7 @@ exports.prometheusLoggerMiddleware = () => {
         }
         await eventLoopLagMeasurer.updateInstrumentsAndReset();
         ctx.set('Content-Type', prom_client_1.register.contentType);
-        ctx.body = prom_client_1.register.metrics();
+        ctx.body = await prom_client_1.register.metrics();
         ctx.status = 200;
     };
 };

package/lib/service/worker/runtime/http/middlewares/settings.js

@@ -33,8 +33,9 @@ exports.getDependenciesSettings = async (apps, assets, tracingConfig) => {
 };
 exports.getServiceSettings = () => {
     return async function settingsContext(ctx, next) {
+        var _a;
         const { clients: { apps, assets }, } = ctx;
-        const rootSpan = ctx.tracing.currentSpan;
+        const rootSpan = (_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.currentSpan;
         const dependenciesSettings = await exports.getDependenciesSettings(apps, assets, { tracing: { rootSpan } });
         // TODO: for now returning all settings, but the ideia is to do merge
         ctx.vtex.settings = dependenciesSettings;

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

@@ -10,10 +10,10 @@ const STATUS_TRACK = 'statusTrack';
 exports.isStatusTrack = (message) => message === STATUS_TRACK;
 exports.isStatusTrackBroadcast = (message) => message === BROADCAST_STATUS_TRACK;
 exports.statusTrackHandler = async (ctx) => {
-    var _a, _b;
-    (_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.currentSpan.setOperationName('builtin:status-track');
+    var _a, _b, _c;
+    (_b = (_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.currentSpan) === null || _b === void 0 ? void 0 : _b.setOperationName('builtin:status-track');
     if (!constants_1.LINKED) {
-        (_b = process.send) === null || _b === void 0 ? void 0 : _b.call(process, BROADCAST_STATUS_TRACK);
+        (_c = process.send) === null || _c === void 0 ? void 0 : _c.call(process, BROADCAST_STATUS_TRACK);
     }
     ctx.body = [];
     return;

package/lib/service/worker/runtime/typings.d.ts

@@ -21,7 +21,7 @@ declare type ServerTiming = Record<string, string>;
 export declare type Maybe<T> = T | null | undefined;
 export interface TracingContext {
     tracer: Tracer;
-    currentSpan: Span;
+    currentSpan: Span | undefined;
 }
 export interface Context<T extends IOClients> {
     clients: T;
@@ -29,6 +29,7 @@ export interface Context<T extends IOClients> {
     timings: Record<string, [number, number]>;
     metrics: Record<string, [number, number]>;
     previousTimerStart: [number, number];
+    requestHandlerName?: string;
     serverTiming?: ServerTiming;
     tracing?: TracingContext;
 }

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

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

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

@@ -29,7 +29,7 @@ exports.prepareHandlerCtx = (header, tracingContext) => {
         segmentToken: header[constants_1.SEGMENT_HEADER],
         sessionToken: header[constants_1.SESSION_HEADER],
         tenant: header[constants_1.TENANT_HEADER] ? tenant_1.parseTenantHeaderValue(header[constants_1.TENANT_HEADER]) : undefined,
-        tracer: new UserLandTracer_1.UserLandTracer(tracingContext.tracer, tracingContext.currentSpan),
+        tracer: new UserLandTracer_1.UserLandTracer(tracingContext === null || tracingContext === void 0 ? void 0 : tracingContext.tracer, tracingContext === null || tracingContext === void 0 ? void 0 : tracingContext.currentSpan),
         userAgent: process.env.VTEX_APP_ID || '',
         workspace: header[constants_1.WORKSPACE_HEADER],
     };

package/lib/tracing/LogFields.d.ts

@@ -12,6 +12,11 @@ export declare const enum ErrorReportLogFields {
      */
     ERROR_KIND = "error.kind",
     ERROR_ID = "error.id",
+    ERROR_MESSAGE = "error.message",
+    ERROR_CODE = "error.code",
+    ERROR_STACK = "error.stack",
+    ERROR_METADATA_REPORT_COUNT = "error.metadata.reportCount",
+    ERROR_METADATA_METRICS_INSTANTIATION_TIME = "error.metadata.metrics.InstantiationTime",
     /**
      * VTEX's Infra errors adds error details to the response
      * The following log fields are supposed to hold these fields

package/lib/tracing/Tags.d.ts

@@ -51,7 +51,9 @@ export declare const enum CustomHttpTags {
     HTTP_MEMORY_CACHE_RESULT = "http.cache.memory",
     HTTP_MEMOIZATION_CACHE_RESULT = "http.cache.memoization",
     HTTP_DISK_CACHE_RESULT = "http.cache.disk",
-    HTTP_ROUTER_CACHE_RESULT = "http.cache.router"
+    HTTP_ROUTER_CACHE_RESULT = "http.cache.router",
+    HTTP_RETRY_ERROR_CODE = "http.retry.error.code",
+    HTTP_RETRY_COUNT = "http.retry.count"
 }
 export declare const UserlandTags: {
     SPAN_KIND: "span.kind";

package/lib/tracing/UserLandTracer.d.ts

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

package/lib/tracing/UserLandTracer.js

@@ -49,7 +49,8 @@ class UserLandTracer {
         return this.tracer.inject(spanContext, format, carrier);
     }
     fallbackSpanContext() {
-        return this.fallbackSpan.context();
+        var _a;
+        return (_a = this.fallbackSpan) === null || _a === void 0 ? void 0 : _a.context();
     }
 }
 exports.UserLandTracer = UserLandTracer;

package/lib/tracing/errorReporting/ErrorReport.d.ts

@@ -26,6 +26,6 @@ export declare class ErrorReport extends ErrorReportBase {
      * instance on the provided Span. If a logger is provided and the
      * span is part of a **sampled** trace, then the error will be logged.
      */
-    injectOnSpan(span: Span, logger?: IOContext['logger']): this;
+    injectOnSpan(span?: Span, logger?: IOContext['logger']): this;
     private shouldLogToSplunk;
 }

package/lib/tracing/errorReporting/ErrorReport.js

@@ -34,8 +34,8 @@ class ErrorReport extends node_error_report_1.ErrorReportBase {
      * span is part of a **sampled** trace, then the error will be logged.
      */
     injectOnSpan(span, logger) {
-        var _a;
-        span.setTag(__1.TracingTags.ERROR, 'true');
+        var _a, _b, _c, _d;
+        span === null || span === void 0 ? void 0 : span.setTag(__1.TracingTags.ERROR, 'true');
         const indexedLogs = {
             ["error.kind" /* ERROR_KIND */]: this.kind,
             ["error.id" /* ERROR_ID */]: this.metadata.errorId,
@@ -47,7 +47,15 @@ class ErrorReport extends node_error_report_1.ErrorReportBase {
             indexedLogs["error.server.request_id" /* ERROR_SERVER_REQUEST_ID */] = this.parsedInfo.response.data.requestId;
         }
         const serializableError = this.toObject();
-        span.log({ event: 'error', ...indexedLogs, error: serializableError });
+        span === null || span === void 0 ? void 0 : span.log({
+            event: 'error',
+            ...indexedLogs,
+            ["error.message" /* ERROR_MESSAGE */]: serializableError.message,
+            ["error.metadata.metrics.InstantiationTime" /* ERROR_METADATA_METRICS_INSTANTIATION_TIME */]: (_b = serializableError.metadata) === null || _b === void 0 ? void 0 : _b.reportCount,
+            ["error.metadata.reportCount" /* ERROR_METADATA_REPORT_COUNT */]: (_d = (_c = serializableError.metadata) === null || _c === void 0 ? void 0 : _c.metrics) === null || _d === void 0 ? void 0 : _d.instantiationTime,
+            ["error.stack" /* ERROR_STACK */]: serializableError.stack,
+            ["error.code" /* ERROR_CODE */]: serializableError.code,
+        });
         if (logger && this.shouldLogToSplunk(span)) {
             logger.error(serializableError);
             this.markErrorAsReported();
@@ -55,7 +63,8 @@ class ErrorReport extends node_error_report_1.ErrorReportBase {
         return this;
     }
     shouldLogToSplunk(span) {
-        return !this.isErrorReported() && utils_1.getTraceInfo(span).isSampled;
+        var _a;
+        return !this.isErrorReported() && ((_a = utils_1.getTraceInfo(span)) === null || _a === void 0 ? void 0 : _a.isSampled);
     }
 }
 exports.ErrorReport = ErrorReport;

package/lib/tracing/utils.d.ts

@@ -1,9 +1,9 @@
 import { Span } from 'opentracing';
 export interface TraceInfo {
-    traceId: string;
+    traceId?: string;
     isSampled: boolean;
 }
-export declare function getTraceInfo(span: Span): TraceInfo;
+export declare function getTraceInfo(span?: Span): TraceInfo;
 /**
  * Do a shallow copy of a headers object and redacts sensitive information.
  *

package/lib/tracing/utils.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const node_error_report_1 = require("@vtex/node-error-report");
 function getTraceInfo(span) {
     var _a, _b, _c;
-    const spanContext = span.context();
+    const spanContext = span === null || span === void 0 ? void 0 : span.context();
     return {
-        isSampled: (_c = (_b = (_a = spanContext).isSampled) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : false,
-        traceId: spanContext.toTraceId(),
+        isSampled: (_c = (_b = (_a = spanContext) === null || _a === void 0 ? void 0 : _a.isSampled) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : false,
+        traceId: spanContext === null || spanContext === void 0 ? void 0 : spanContext.toTraceId(),
     };
 }
 exports.getTraceInfo = getTraceInfo;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vtex/api",
-  "version": "6.46.0-beta.0",
+  "version": "6.46.1",
   "description": "VTEX I/O API client",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -54,7 +54,7 @@
     "agentkeepalive": "^4.0.2",
     "apollo-server-errors": "^2.2.1",
     "archiver": "^3.0.0",
-    "axios": "0.27.2",
+    "axios": "^0.21.1",
     "axios-retry": "^3.1.2",
     "bluebird": "^3.5.4",
     "chalk": "^2.4.2",
@@ -65,7 +65,7 @@
     "fs-extra": "^7.0.0",
     "graphql": "^14.5.8",
     "graphql-tools": "^4.0.6",
-    "graphql-upload": "^8.1.0",
+    "graphql-upload": "^13.0.0",
     "jaeger-client": "^3.18.0",
     "js-base64": "^2.5.1",
     "koa": "^2.11.0",
@@ -76,7 +76,7 @@
     "mime-types": "^2.1.12",
     "opentracing": "^0.14.4",
     "p-limit": "^2.2.0",
-    "prom-client": "^12.0.0",
+    "prom-client": "^14.2.0",
     "qs": "^6.5.1",
     "querystring": "^0.2.0",
     "ramda": "^0.26.0",