@vtex/api 6.49.8-beta.1 → 6.49.8-beta.2

package/lib/service/index.d.ts

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

package/lib/service/index.js

@@ -1,25 +1,51 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.appPath = exports.startApp = void 0;
+const telemetry_1 = require("./telemetry");
 const cluster_1 = __importDefault(require("cluster"));
 const constants_1 = require("../constants");
 const loaders_1 = require("./loaders");
 const logger_1 = require("./logger");
-const master_1 = require("./master");
-const worker_1 = require("./worker");
-const startApp = () => {
+const startApp = async () => {
+    await (0, telemetry_1.initializeTelemetry)();
     const serviceJSON = (0, loaders_1.getServiceJSON)();
     try {
         // if it is a master process then call setting up worker process
         if (cluster_1.default.isMaster) {
-            (0, master_1.startMaster)(serviceJSON);
+            const { startMaster } = await Promise.resolve().then(() => __importStar(require('./master')));
+            startMaster(serviceJSON);
         }
         else {
             // to setup server configurations and share port address for incoming requests
-            (0, worker_1.startWorker)(serviceJSON).listen(constants_1.HTTP_SERVER_PORT);
+            const { startWorker } = await Promise.resolve().then(() => __importStar(require('./worker')));
+            const app = await startWorker(serviceJSON);
+            app.listen(constants_1.HTTP_SERVER_PORT);
         }
     }
     catch (err) {

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

@@ -1,2 +1,2 @@
-import { LogClient } from '@vtex/diagnostics-nodejs/dist/types';
-export declare function getLogClient(account: string, workspace: string, appName: string): Promise<LogClient>;
+import { Types } from '@vtex/diagnostics-nodejs';
+export declare function getLogClient(): Promise<Types.LogClient>;

package/lib/service/logger/client.js

@@ -1,45 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLogClient = void 0;
-const diagnostics_nodejs_1 = require("@vtex/diagnostics-nodejs");
 const telemetry_1 = require("../telemetry");
-let logClient;
+let client;
 let isInitializing = false;
 let initPromise = undefined;
-async function getLogClient(account, workspace, appName) {
-    if (logClient) {
-        return logClient;
+async function getLogClient() {
+    if (client) {
+        return client;
     }
     if (initPromise) {
         return initPromise;
     }
     isInitializing = true;
-    initPromise = initializeClient(account, workspace, appName);
+    initPromise = initializeClient();
     return initPromise;
 }
 exports.getLogClient = getLogClient;
-async function initializeClient(account, workspace, appName) {
+async function initializeClient() {
     try {
-        const telemetryClient = await (0, telemetry_1.getTelemetryClient)();
-        const logsConfig = diagnostics_nodejs_1.Exporters.CreateLogsExporterConfig({
-            endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
-            path: process.env.OTEL_EXPORTER_OTLP_PATH || '/v1/logs',
-            protocol: 'http',
-            interval: 5,
-            timeoutSeconds: 5,
-            headers: { 'Content-Type': 'application/json' },
-        });
-        const logsExporter = diagnostics_nodejs_1.Exporters.CreateExporter(logsConfig, 'otlp');
-        await logsExporter.initialize();
-        const clientKey = `${account}-${workspace}-${appName}`;
-        logClient = await telemetryClient.newLogsClient({
-            exporter: logsExporter,
-            loggerName: `node-vtex-api-${clientKey}`,
-        });
-        return logClient;
+        const { logsClient } = await (0, telemetry_1.initializeTelemetry)();
+        client = logsClient;
+        initPromise = undefined;
+        return logsClient;
     }
     catch (error) {
         console.error('Failed to initialize logs client:', error);
+        initPromise = undefined;
         throw error;
     }
     finally {

package/lib/service/logger/logger.js

@@ -89,7 +89,7 @@ class Logger {
                     setTimeout(() => reject(new Error('Log client initialization timeout')), constants_1.LOG_CLIENT_INIT_TIMEOUT_MS);
                 });
                 this.logClient = await Promise.race([
-                    (0, client_1.getLogClient)(this.account, this.workspace, constants_1.APP.NAME),
+                    (0, client_1.getLogClient)(),
                     timeoutPromise
                 ]);
                 return this.logClient;

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

@@ -0,0 +1,2 @@
+import { Types } from "@vtex/diagnostics-nodejs";
+export declare function getMetricClient(): Promise<Types.MetricClient>;

package/lib/service/metrics/client.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMetricClient = void 0;
+const telemetry_1 = require("../telemetry");
+let client;
+let isInitializing = false;
+let initPromise = undefined;
+async function getMetricClient() {
+    if (client) {
+        return client;
+    }
+    if (initPromise) {
+        return initPromise;
+    }
+    isInitializing = true;
+    initPromise = initializeClient();
+    return initPromise;
+}
+exports.getMetricClient = getMetricClient;
+async function initializeClient() {
+    try {
+        const { metricsClient } = await (0, telemetry_1.initializeTelemetry)();
+        client = metricsClient;
+        initPromise = undefined;
+        return metricsClient;
+    }
+    catch (error) {
+        console.error('Failed to initialize metrics client:', error);
+        initPromise = undefined;
+        throw error;
+    }
+    finally {
+        isInitializing = false;
+    }
+}

package/lib/service/metrics/instruments/hostMetrics.d.ts

@@ -0,0 +1,14 @@
+import { InstrumentationBase, InstrumentationConfig } from "@opentelemetry/instrumentation";
+import { MeterProvider } from '@opentelemetry/api';
+interface HostMetricsInstrumentationConfig extends InstrumentationConfig {
+    name?: string;
+    meterProvider?: MeterProvider;
+}
+export declare class HostMetricsInstrumentation extends InstrumentationBase<HostMetricsInstrumentationConfig> {
+    private hostMetrics?;
+    constructor(config?: HostMetricsInstrumentationConfig);
+    init(): void;
+    enable(): void;
+    disable(): void;
+}
+export {};

package/lib/service/metrics/instruments/hostMetrics.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostMetricsInstrumentation = void 0;
+const instrumentation_1 = require("@opentelemetry/instrumentation");
+const host_metrics_1 = require("@opentelemetry/host-metrics");
+class HostMetricsInstrumentation extends instrumentation_1.InstrumentationBase {
+    constructor(config = {}) {
+        const instrumentation_name = config.name || 'host-metrics-instrumentation';
+        const instrumentation_version = '1.0.0';
+        super(instrumentation_name, instrumentation_version, config);
+    }
+    init() { }
+    enable() {
+        if (!this._config.meterProvider) {
+            throw new Error('MeterProvider is required for HostMetricsInstrumentation');
+        }
+        this.hostMetrics = new host_metrics_1.HostMetrics({
+            meterProvider: this._config.meterProvider,
+            name: this._config.name || 'host-metrics',
+        });
+        this.hostMetrics.start();
+        console.debug('HostMetricsInstrumentation enabled');
+    }
+    disable() {
+        if (this.hostMetrics) {
+            this.hostMetrics = undefined;
+            console.debug('HostMetricsInstrumentation disabled');
+        }
+    }
+}
+exports.HostMetricsInstrumentation = HostMetricsInstrumentation;

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

@@ -0,0 +1,13 @@
+import { Types } from '@vtex/diagnostics-nodejs';
+export declare const enum RequestsMetricLabels {
+    STATUS_CODE = "status_code",
+    REQUEST_HANDLER = "handler"
+}
+export interface OtelRequestInstruments {
+    concurrentRequests: Types.Gauge;
+    requestTimings: Types.Histogram;
+    totalRequests: Types.Counter;
+    responseSizes: Types.Histogram;
+    abortedRequests: Types.Counter;
+}
+export declare const getOtelInstruments: () => Promise<OtelRequestInstruments>;

package/lib/service/metrics/metrics.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOtelInstruments = void 0;
+const client_1 = require("./client");
+let instruments;
+let initializingPromise;
+const createOtelConcurrentRequestsInstrument = async () => {
+    const metricsClient = await (0, client_1.getMetricClient)();
+    return metricsClient.createGauge('io_http_requests_current', {
+        description: 'The current number of requests in course.',
+        unit: '1'
+    });
+};
+const createOtelRequestsTimingsInstrument = async () => {
+    const metricsClient = await (0, client_1.getMetricClient)();
+    return metricsClient.createHistogram('runtime_http_requests_duration_milliseconds', {
+        description: 'The incoming http requests total duration.',
+        unit: 'ms'
+    });
+};
+const createOtelTotalRequestsInstrument = async () => {
+    const metricsClient = await (0, client_1.getMetricClient)();
+    return metricsClient.createCounter('runtime_http_requests_total', {
+        description: 'The total number of HTTP requests.',
+        unit: '1'
+    });
+};
+const createOtelRequestsResponseSizesInstrument = async () => {
+    const metricsClient = await (0, client_1.getMetricClient)();
+    return metricsClient.createHistogram('runtime_http_response_size_bytes', {
+        description: 'The outgoing response sizes (only applicable when the response isn\'t a stream).',
+        unit: 'bytes'
+    });
+};
+const createOtelTotalAbortedRequestsInstrument = async () => {
+    const metricsClient = await (0, client_1.getMetricClient)();
+    return metricsClient.createCounter('runtime_http_aborted_requests_total', {
+        description: 'The total number of HTTP requests aborted.',
+        unit: '1'
+    });
+};
+const getOtelInstruments = async () => {
+    if (instruments) {
+        return instruments;
+    }
+    if (initializingPromise) {
+        return initializingPromise;
+    }
+    initializingPromise = initializeOtelInstruments();
+    try {
+        instruments = await initializingPromise;
+        return instruments;
+    }
+    finally {
+        initializingPromise = undefined;
+    }
+};
+exports.getOtelInstruments = getOtelInstruments;
+const initializeOtelInstruments = async () => {
+    const [concurrentRequests, requestTimings, totalRequests, responseSizes, abortedRequests] = await Promise.all([
+        createOtelConcurrentRequestsInstrument(),
+        createOtelRequestsTimingsInstrument(),
+        createOtelTotalRequestsInstrument(),
+        createOtelRequestsResponseSizesInstrument(),
+        createOtelTotalAbortedRequestsInstrument()
+    ]);
+    return {
+        concurrentRequests,
+        requestTimings,
+        totalRequests,
+        responseSizes,
+        abortedRequests
+    };
+};

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

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

package/lib/service/metrics/otelRequestMetricsMiddleware.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addOtelRequestMetricsMiddleware = void 0;
+const stream_1 = require("stream");
+const utils_1 = require("../../utils");
+const metrics_1 = require("./metrics");
+const INSTRUMENTS_INITIALIZATION_TIMEOUT = 500;
+const addOtelRequestMetricsMiddleware = () => {
+    let instruments;
+    return async function addOtelRequestMetrics(ctx, next) {
+        if (!instruments) {
+            try {
+                instruments = await Promise.race([
+                    (0, metrics_1.getOtelInstruments)(),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout waiting for OpenTelemetry instruments initialization')), INSTRUMENTS_INITIALIZATION_TIMEOUT))
+                ]);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                console.warn(`OpenTelemetry instruments not ready for request ${ctx.requestHandlerName}: ${errorMessage}`);
+                await next();
+                return;
+            }
+        }
+        const start = process.hrtime();
+        instruments.concurrentRequests.add(1);
+        ctx.req.once('aborted', () => {
+            if (instruments) {
+                instruments.abortedRequests.add(1, { ["handler" /* RequestsMetricLabels.REQUEST_HANDLER */]: ctx.requestHandlerName });
+            }
+        });
+        let responseClosed = false;
+        ctx.res.once('close', () => (responseClosed = true));
+        try {
+            await next();
+        }
+        finally {
+            const responseLength = ctx.response.length;
+            if (responseLength && instruments) {
+                instruments.responseSizes.record(responseLength, { ["handler" /* RequestsMetricLabels.REQUEST_HANDLER */]: ctx.requestHandlerName });
+            }
+            if (instruments) {
+                instruments.totalRequests.add(1, {
+                    ["handler" /* RequestsMetricLabels.REQUEST_HANDLER */]: ctx.requestHandlerName,
+                    ["status_code" /* RequestsMetricLabels.STATUS_CODE */]: ctx.response.status,
+                });
+            }
+            const onResFinished = () => {
+                if (instruments) {
+                    instruments.requestTimings.record((0, utils_1.hrToMillisFloat)(process.hrtime(start)), {
+                        ["handler" /* RequestsMetricLabels.REQUEST_HANDLER */]: ctx.requestHandlerName,
+                    });
+                    instruments.concurrentRequests.subtract(1);
+                }
+            };
+            if (responseClosed) {
+                onResFinished();
+            }
+            else {
+                (0, stream_1.finished)(ctx.res, onResFinished);
+            }
+        }
+    };
+};
+exports.addOtelRequestMetricsMiddleware = addOtelRequestMetricsMiddleware;

package/lib/service/telemetry/client.d.ts

@@ -1,3 +1,9 @@
-import { TelemetryClient } from '@vtex/diagnostics-nodejs/dist/telemetry';
-export declare function getTelemetryClient(): Promise<TelemetryClient>;
-export declare function resetTelemetryClient(): void;
+import { Logs, Metrics, Traces } from '@vtex/diagnostics-nodejs';
+interface TelemetryClients {
+    logsClient: Logs.LogClient;
+    metricsClient: Metrics.MetricsClient;
+    tracesClient: Traces.TraceClient;
+}
+export declare function initializeTelemetry(): Promise<TelemetryClients>;
+export declare function resetTelemetry(): void;
+export {};

package/lib/service/telemetry/client.js

@@ -1,11 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resetTelemetryClient = exports.getTelemetryClient = void 0;
+exports.resetTelemetry = exports.initializeTelemetry = void 0;
 const diagnostics_nodejs_1 = require("@vtex/diagnostics-nodejs");
 const constants_1 = require("../../constants");
+const instrumentation_koa_1 = require("@opentelemetry/instrumentation-koa");
+const hostMetrics_1 = require("../metrics/instruments/hostMetrics");
+const CLIENT_NAME = constants_1.APP.NAME || 'node-vtex-api';
+const APPLICATION_ID = constants_1.APP.ID || 'vtex-io-app';
+const EXPORTER_OTLP_ENDPOINT = process.env.EXPORTER_OTLP_ENDPOINT;
 class TelemetryClientSingleton {
     constructor() {
         this.initializationPromise = undefined;
+        this.initializeTracesClient = async (telemetryClient) => await telemetryClient.newTracesClient({
+            exporter: diagnostics_nodejs_1.Exporters.CreateExporter(diagnostics_nodejs_1.Exporters.CreateTracesExporterConfig({
+                endpoint: EXPORTER_OTLP_ENDPOINT,
+            }), 'otlp'),
+        });
+        this.initializeMetricsClient = async (telemetryClient) => await telemetryClient.newMetricsClient({
+            exporter: diagnostics_nodejs_1.Exporters.CreateExporter(diagnostics_nodejs_1.Exporters.CreateMetricsExporterConfig({
+                endpoint: EXPORTER_OTLP_ENDPOINT,
+                interval: 5,
+                timeoutSeconds: 5,
+            }), 'otlp'),
+        });
+        this.initializeLogsClient = async (telemetryClient) => await telemetryClient.newLogsClient({
+            exporter: diagnostics_nodejs_1.Exporters.CreateExporter(diagnostics_nodejs_1.Exporters.CreateLogsExporterConfig({
+                endpoint: EXPORTER_OTLP_ENDPOINT,
+            }), 'otlp'),
+            loggerName: `node-vtex-api-${APPLICATION_ID}`,
+        });
     }
     static getInstance() {
         if (!TelemetryClientSingleton.instance) {
@@ -13,45 +36,64 @@ class TelemetryClientSingleton {
         }
         return TelemetryClientSingleton.instance;
     }
-    async initTelemetryClient() {
+    async initializeTelemetryClients() {
         try {
-            const telemetryClient = await (0, diagnostics_nodejs_1.NewTelemetryClient)('node-vtex-api', constants_1.APP.ID || 'vtex-app', {
+            const telemetryClient = await (0, diagnostics_nodejs_1.NewTelemetryClient)(APPLICATION_ID, CLIENT_NAME, 'node-vtex-api', {
                 additionalAttrs: {
                     'version': constants_1.APP.VERSION || '',
                     'environment': process.env.VTEX_WORKSPACE || 'development',
                 },
             });
-            this.telemetryClient = telemetryClient;
-            return telemetryClient;
+            const [tracesClient, metricsClient, logsClient] = await Promise.all([
+                this.initializeTracesClient(telemetryClient),
+                this.initializeMetricsClient(telemetryClient),
+                this.initializeLogsClient(telemetryClient),
+            ]);
+            const instrumentations = [
+                ...diagnostics_nodejs_1.Instrumentation.CommonInstrumentations.minimal(),
+                new instrumentation_koa_1.KoaInstrumentation(),
+                new hostMetrics_1.HostMetricsInstrumentation({
+                    name: 'host-metrics-instrumentation',
+                    meterProvider: metricsClient.provider(),
+                }),
+            ];
+            telemetryClient.registerInstrumentations(instrumentations);
+            const clients = {
+                logsClient,
+                metricsClient,
+                tracesClient,
+            };
+            this.telemetryClients = clients;
+            return clients;
         }
         catch (error) {
-            console.error('Failed to initialize telemetry client:', error);
+            console.error('Failed to initialize telemetry clients:', error);
             throw error;
         }
         finally {
             this.initializationPromise = undefined;
         }
     }
-    async getClient() {
-        if (this.telemetryClient) {
-            return this.telemetryClient;
+    async getTelemetryClients() {
+        if (this.telemetryClients) {
+            return this.telemetryClients;
         }
         if (this.initializationPromise) {
             return this.initializationPromise;
         }
-        this.initializationPromise = this.initTelemetryClient();
+        this.initializationPromise = this.initializeTelemetryClients();
         return this.initializationPromise;
     }
     reset() {
-        this.telemetryClient = undefined;
+        this.telemetryClients = undefined;
         this.initializationPromise = undefined;
     }
 }
-async function getTelemetryClient() {
-    return TelemetryClientSingleton.getInstance().getClient();
+async function initializeTelemetry() {
+    return TelemetryClientSingleton.getInstance().getTelemetryClients();
 }
-exports.getTelemetryClient = getTelemetryClient;
-function resetTelemetryClient() {
+exports.initializeTelemetry = initializeTelemetry;
+function resetTelemetry() {
     TelemetryClientSingleton.getInstance().reset();
 }
-exports.resetTelemetryClient = resetTelemetryClient;
+exports.resetTelemetry = resetTelemetry;

package/lib/service/worker/index.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startWorker = void 0;
+const diagnostics_nodejs_1 = require("@vtex/diagnostics-nodejs");
 const http_1 = require("http");
 const koa_1 = __importDefault(require("koa"));
 const koa_compress_1 = __importDefault(require("koa-compress"));
@@ -15,6 +16,7 @@ const loaders_1 = require("../loaders");
 const console_1 = require("../logger/console");
 const loggerTypes_1 = require("../logger/loggerTypes");
 const requestMetricsMiddleware_1 = require("../metrics/requestMetricsMiddleware");
+const otelRequestMetricsMiddleware_1 = require("../metrics/otelRequestMetricsMiddleware");
 const TracerSingleton_1 = require("../tracing/TracerSingleton");
 const tracingMiddlewares_1 = require("../tracing/tracingMiddlewares");
 const listeners_1 = require("./listeners");
@@ -157,9 +159,11 @@ const startWorker = (serviceJSON) => {
     app.proxy = true;
     app
         .use(error_1.error)
+        .use(diagnostics_nodejs_1.Instrumentation.Middlewares.ContextMiddlewares.Koa.ContextPropagationMiddleware())
         .use((0, middlewares_1.prometheusLoggerMiddleware)())
         .use((0, tracingMiddlewares_1.addTracingMiddleware)(tracer))
         .use((0, requestMetricsMiddleware_1.addRequestMetricsMiddleware)())
+        .use((0, otelRequestMetricsMiddleware_1.addOtelRequestMetricsMiddleware)())
         .use((0, middlewares_1.addMetricsLoggerMiddleware)())
         .use((0, rateLimit_1.concurrentRateLimiter)((_a = serviceJSON === null || serviceJSON === void 0 ? void 0 : serviceJSON.rateLimitPerReplica) === null || _a === void 0 ? void 0 : _a.concurrent))
         .use((0, koa_compress_1.default)())

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vtex/api",
-  "version": "6.49.8-beta.1",
+  "version": "6.49.8-beta.2",
   "description": "VTEX I/O API client",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -47,15 +47,19 @@
   },
   "license": "MIT",
   "dependencies": {
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/host-metrics": "0.35.5",
+    "@opentelemetry/instrumentation": "0.57.2",
+    "@opentelemetry/instrumentation-koa": "0.47.1",
     "@types/koa": "^2.11.0",
     "@types/koa-compose": "^3.2.3",
-    "@vtex/diagnostics-nodejs": "0.1.0-beta.10",
+    "@vtex/diagnostics-nodejs": "0.1.0-io-beta.19",
     "@vtex/node-error-report": "^0.0.3",
     "@wry/equality": "^0.1.9",
     "agentkeepalive": "^4.0.2",
     "apollo-server-errors": "^2.2.1",
     "archiver": "^3.0.0",
-    "axios": "^1.11.0",
+    "axios": "^0.21.1",
     "axios-retry": "^3.1.2",
     "bluebird": "^3.5.4",
     "chalk": "^2.4.2",
@@ -124,5 +128,8 @@
     "typemoq": "^2.1.0",
     "typescript": "^4.4.4",
     "typescript-json-schema": "^0.52.0"
+  },
+  "resolutions": {
+    "@grpc/grpc-js": "^1.13.4"
   }
 }