react-on-rails-pro-node-renderer 16.7.0-rc.2 → 16.7.0-rc.3

package/lib/worker/handleRenderRequest.js

@@ -9,6 +9,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.sumUploadedBytes = sumUploadedBytes;
 exports.handleNewBundlesProvided = handleNewBundlesProvided;
 exports.handleRenderRequest = handleRenderRequest;
 const cluster_1 = __importDefault(require("cluster"));
@@ -19,38 +20,62 @@ const fileExistsAsync_js_1 = __importDefault(require("../shared/fileExistsAsync.
 const log_js_1 = __importDefault(require("../shared/log.js"));
 const utils_js_1 = require("../shared/utils.js");
 const configBuilder_js_1 = require("../shared/configBuilder.js");
+const tracing_js_1 = require("../shared/tracing.js");
 const vm_js_1 = require("./vm.js");
-async function prepareResult(renderingRequest, bundleFilePathPerTimestamp, executionContext) {
-    try {
-        const result = await executionContext.runInVM(renderingRequest, bundleFilePathPerTimestamp, cluster_1.default);
-        let exceptionMessage = null;
-        if (!result) {
-            const error = new Error('INVALID NIL or NULL result for rendering. Ensure renderingRequest is a valid string and returns a value.');
-            exceptionMessage = (0, utils_js_1.formatExceptionMessage)({ renderingRequest }, error, 'INVALID result for prepareResult');
+async function sumUploadedBytes(assets) {
+    const sizes = await Promise.all(assets.map(async (asset) => {
+        try {
+            return (await (0, promises_1.stat)(asset.savedFilePath)).size;
         }
-        else if ((0, utils_js_1.isErrorRenderResult)(result)) {
-            ({ exceptionMessage } = result);
+        catch {
+            // Best-effort: a missing source means we record what we can rather than
+            // failing the request just to get a span attribute.
+            return 0;
         }
-        if (exceptionMessage) {
-            return (0, utils_js_1.errorResponseResult)(exceptionMessage);
-        }
-        if ((0, utils_js_1.isReadableStream)(result)) {
+    }));
+    return sizes.reduce((total, size) => total + size, 0);
+}
+async function prepareResult(renderingRequest, bundleTimestamp, bundleFilePathPerTimestamp, executionContext) {
+    return (0, tracing_js_1.subSpan)({ name: 'ror.result.prepare' }, async (resultSpan) => {
+        try {
+            const result = await (0, tracing_js_1.subSpan)({
+                name: 'ror.vm.execute',
+                attributes: { 'bundle.timestamp': String(bundleTimestamp) },
+            }, (_controller) => executionContext.runInVM(renderingRequest, bundleFilePathPerTimestamp, cluster_1.default));
+            let exceptionMessage = null;
+            if (!result) {
+                const error = new Error('INVALID NIL or NULL result for rendering. Ensure renderingRequest is a valid string and returns a value.');
+                exceptionMessage = (0, utils_js_1.formatExceptionMessage)({ renderingRequest }, error, 'INVALID result for prepareResult');
+            }
+            else if ((0, utils_js_1.isErrorRenderResult)(result)) {
+                ({ exceptionMessage } = result);
+            }
+            if (exceptionMessage) {
+                return (0, utils_js_1.errorResponseResult)(exceptionMessage);
+            }
+            if ((0, utils_js_1.isReadableStream)(result)) {
+                // Stream length is unknown until consumed; omit response.bytes rather
+                // than buffer the stream to compute it.
+                return {
+                    headers: { 'Cache-Control': 'public, max-age=31536000' },
+                    status: 200,
+                    stream: result,
+                };
+            }
+            if (typeof result === 'string') {
+                resultSpan.setAttributes({ 'response.bytes': Buffer.byteLength(result, 'utf8') });
+            }
             return {
                 headers: { 'Cache-Control': 'public, max-age=31536000' },
                 status: 200,
-                stream: result,
+                data: result,
             };
         }
-        return {
-            headers: { 'Cache-Control': 'public, max-age=31536000' },
-            status: 200,
-            data: result,
-        };
-    }
-    catch (err) {
-        const exceptionMessage = (0, utils_js_1.formatExceptionMessage)({ renderingRequest }, err, 'Unknown error calling runInVM');
-        return (0, utils_js_1.errorResponseResult)(exceptionMessage);
-    }
+        catch (err) {
+            const exceptionMessage = (0, utils_js_1.formatExceptionMessage)({ renderingRequest }, err, 'Unknown error calling runInVM');
+            return (0, utils_js_1.errorResponseResult)(exceptionMessage);
+        }
+    });
 }
 /**
  * @param bundleFilePathPerTimestamp
@@ -150,9 +175,16 @@ async function handleRenderRequest({ renderingRequest, bundleTimestamp, dependen
             };
         }
         try {
-            const executionContext = await (0, vm_js_1.buildExecutionContext)(allBundleFilePaths, /* buildVmsIfNeeded */ false);
+            const executionContext = await (0, tracing_js_1.subSpan)({
+                name: 'ror.bundle.build_execution_context',
+                attributes: {
+                    'bundle.timestamp': String(bundleTimestamp),
+                    'bundle.paths.count': allBundleFilePaths.length,
+                    'cache.strategy': 'cache-first',
+                },
+            }, () => (0, vm_js_1.buildExecutionContext)(allBundleFilePaths, /* buildVmsIfNeeded */ false));
             return {
-                response: await prepareResult(renderingRequest, entryBundleFilePath, executionContext),
+                response: await prepareResult(renderingRequest, bundleTimestamp, entryBundleFilePath, executionContext),
                 executionContext,
             };
         }
@@ -165,7 +197,21 @@ async function handleRenderRequest({ renderingRequest, bundleTimestamp, dependen
         }
         // If gem has posted updated bundle:
         if (providedNewBundles && providedNewBundles.length > 0) {
-            const result = await handleNewBundlesProvided({ renderingRequest }, providedNewBundles, assetsToCopy);
+            // Stat upload sources before they're moved by handleNewBundlesProvided.
+            // bytes.total reflects source file sizes at upload time, not compressed
+            // wire bytes.
+            const bytesTotal = await sumUploadedBytes([
+                ...providedNewBundles.map((b) => b.bundle),
+                ...(assetsToCopy ?? []),
+            ]);
+            const result = await (0, tracing_js_1.subSpan)({
+                name: 'ror.bundle.upload',
+                attributes: {
+                    'bundle.count': providedNewBundles.length,
+                    'assets.count': assetsToCopy?.length ?? 0,
+                    'bytes.total': bytesTotal,
+                },
+            }, () => handleNewBundlesProvided({ renderingRequest }, providedNewBundles, assetsToCopy));
             if (result) {
                 return { response: result };
             }
@@ -178,9 +224,16 @@ async function handleRenderRequest({ renderingRequest, bundleTimestamp, dependen
         // The bundle exists, but the VM has not yet been created.
         // Another worker must have written it or it was saved during deployment.
         log_js_1.default.info('Bundle %s exists. Building ExecutionContext for worker %s.', entryBundleFilePath, (0, utils_js_1.workerIdLabel)());
-        const executionContext = await (0, vm_js_1.buildExecutionContext)(allBundleFilePaths, /* buildVmsIfNeeded */ true);
+        const executionContext = await (0, tracing_js_1.subSpan)({
+            name: 'ror.bundle.build_execution_context',
+            attributes: {
+                'bundle.timestamp': String(bundleTimestamp),
+                'bundle.paths.count': allBundleFilePaths.length,
+                'cache.strategy': 'cache-miss',
+            },
+        }, () => (0, vm_js_1.buildExecutionContext)(allBundleFilePaths, /* buildVmsIfNeeded */ true));
         return {
-            response: await prepareResult(renderingRequest, entryBundleFilePath, executionContext),
+            response: await prepareResult(renderingRequest, bundleTimestamp, entryBundleFilePath, executionContext),
             executionContext,
         };
     }

package/lib/worker/shutdownHooks.d.ts

@@ -0,0 +1,12 @@
+export type WorkerShutdownHook = () => void | Promise<void>;
+/**
+ * Upper bound on how long the worker waits for all registered shutdown hooks
+ * to settle before forcibly destroying the worker. Integration shutdown
+ * timeouts (e.g. OpenTelemetry `shutdownTimeoutMs`) must stay below this so
+ * the worker doesn't kill an in-flight hook before it finishes flushing.
+ */
+export declare const WORKER_SHUTDOWN_HOOKS_TIMEOUT_MS = 10000;
+export declare function registerWorkerShutdownHook(hook: WorkerShutdownHook): () => void;
+export declare function runWorkerShutdownHooks(): Promise<void>;
+export declare function __resetWorkerShutdownHooksForTest(): void;
+//# sourceMappingURL=shutdownHooks.d.ts.map

package/lib/worker/shutdownHooks.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORKER_SHUTDOWN_HOOKS_TIMEOUT_MS = void 0;
+exports.registerWorkerShutdownHook = registerWorkerShutdownHook;
+exports.runWorkerShutdownHooks = runWorkerShutdownHooks;
+exports.__resetWorkerShutdownHooksForTest = __resetWorkerShutdownHooksForTest;
+/**
+ * Upper bound on how long the worker waits for all registered shutdown hooks
+ * to settle before forcibly destroying the worker. Integration shutdown
+ * timeouts (e.g. OpenTelemetry `shutdownTimeoutMs`) must stay below this so
+ * the worker doesn't kill an in-flight hook before it finishes flushing.
+ */
+exports.WORKER_SHUTDOWN_HOOKS_TIMEOUT_MS = 10000;
+const workerShutdownHooks = [];
+function registerWorkerShutdownHook(hook) {
+    workerShutdownHooks.push(hook);
+    return () => {
+        const index = workerShutdownHooks.indexOf(hook);
+        if (index >= 0) {
+            workerShutdownHooks.splice(index, 1);
+        }
+    };
+}
+async function runWorkerShutdownHooks() {
+    const results = await Promise.allSettled(workerShutdownHooks.map(async (hook) => {
+        await hook();
+    }));
+    const rejectedResults = results.filter((result) => result.status === 'rejected');
+    const firstRejectedResult = rejectedResults[0];
+    if (rejectedResults.length === 1 && firstRejectedResult) {
+        throw firstRejectedResult.reason;
+    }
+    if (rejectedResults.length > 1) {
+        throw new AggregateError(rejectedResults.map((result) => result.reason), 'Multiple worker shutdown hooks failed');
+    }
+}
+// eslint-disable-next-line no-underscore-dangle
+function __resetWorkerShutdownHooksForTest() {
+    workerShutdownHooks.length = 0;
+}
+//# sourceMappingURL=shutdownHooks.js.map

package/lib/worker.d.ts

@@ -3,8 +3,8 @@
  * @module worker
  */
 import { Config } from './shared/configBuilder.js';
-import type { FastifyInstance } from './worker/types.js';
 import { Asset } from './shared/utils.js';
+export { configureFastify, type FastifyConfigFunction } from './worker/fastifyConfig.js';
 declare module '@fastify/multipart' {
     interface MultipartFile {
         value: Asset;
@@ -15,14 +15,6 @@ declare module 'fastify' {
         uploadDir: string;
     }
 }
-export type FastifyConfigFunction = (app: FastifyInstance) => void;
-/**
- * Configures Fastify instance before starting the server.
- * @param configFunction The configuring function. Normally it will be something like `(app) => { app.register(...); }`
- *  or `(app) => { app.addHook(...); }` to report data from Fastify to an external service.
- *  Note that we call `await app.ready()` in our code, so you don't need to `await` the results.
- */
-export declare function configureFastify(configFunction: FastifyConfigFunction): void;
 export declare const disableHttp2: () => void;
 export default function run(config: Partial<Config>): import("fastify").FastifyInstance<import("http2").Http2Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse, typeof import("http2").Http2ServerRequest, typeof import("http2").Http2ServerResponse>, import("http2").Http2ServerRequest, import("http2").Http2ServerResponse<import("http2").Http2ServerRequest>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault> & PromiseLike<import("fastify").FastifyInstance<import("http2").Http2Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse, typeof import("http2").Http2ServerRequest, typeof import("http2").Http2ServerResponse>, import("http2").Http2ServerRequest, import("http2").Http2ServerResponse<import("http2").Http2ServerRequest>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>> & {
     __linterBrands: "SafePromiseLike";

package/lib/worker.js

@@ -40,8 +40,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.disableHttp2 = void 0;
-exports.configureFastify = configureFastify;
+exports.disableHttp2 = exports.configureFastify = void 0;
 exports.default = run;
 const path_1 = __importDefault(require("path"));
 const cluster_1 = __importDefault(require("cluster"));
@@ -64,16 +63,9 @@ const handleIncrementalRenderStream_js_1 = require("./worker/handleIncrementalRe
 const constants_js_1 = require("./shared/constants.js");
 const utils_js_1 = require("./shared/utils.js");
 const tracing_js_1 = require("./shared/tracing.js");
-const fastifyConfigFunctions = [];
-/**
- * Configures Fastify instance before starting the server.
- * @param configFunction The configuring function. Normally it will be something like `(app) => { app.register(...); }`
- *  or `(app) => { app.addHook(...); }` to report data from Fastify to an external service.
- *  Note that we call `await app.ready()` in our code, so you don't need to `await` the results.
- */
-function configureFastify(configFunction) {
-    fastifyConfigFunctions.push(configFunction);
-}
+const fastifyConfig_js_1 = require("./worker/fastifyConfig.js");
+var fastifyConfig_js_2 = require("./worker/fastifyConfig.js");
+Object.defineProperty(exports, "configureFastify", { enumerable: true, get: function () { return fastifyConfig_js_2.configureFastify; } });
 function setHeaders(headers, res) {
     // eslint-disable-next-line @typescript-eslint/no-misused-promises -- fixing it with `void` just violates no-void
     Object.entries(headers).forEach(([key, header]) => res.header(key, header));
@@ -346,68 +338,72 @@ function run(config) {
         // Track whether we've already started sending a response (streaming or otherwise)
         // If true, we can't send an error response on failure - headers are already sent
         let responseStarted = false;
+        let incrementalTracingContext;
         try {
-            // Handle the incremental render stream
-            await (0, handleIncrementalRenderStream_js_1.handleIncrementalRenderStream)({
-                request: req,
-                onRenderRequestReceived: async (obj) => {
-                    // Build a temporary FastifyRequest shape for protocol/auth check
-                    const tempReqBody = typeof obj === 'object' && obj !== null ? obj : {};
-                    // Perform request prechecks
-                    const precheckResult = (0, requestPrechecks_js_1.performRequestPrechecks)(tempReqBody);
-                    if (precheckResult) {
-                        return {
-                            response: precheckResult,
-                            shouldContinue: false,
-                        };
-                    }
-                    // Extract data for incremental render request
-                    const dependencyBundleTimestamps = extractBodyArrayField(tempReqBody, 'dependencyBundleTimestamps');
-                    const initial = {
-                        firstRequestChunk: obj,
-                        bundleTimestamp,
-                        dependencyBundleTimestamps,
-                    };
-                    try {
-                        const { response, sink } = await (0, handleIncrementalRenderRequest_js_1.handleIncrementalRenderRequest)(initial);
-                        incrementalSink = sink;
-                        return {
-                            response,
-                            shouldContinue: !!incrementalSink,
-                        };
-                    }
-                    catch (err) {
-                        const errorResponse = (0, utils_js_1.errorResponseResult)((0, utils_js_1.formatExceptionMessage)({ label: 'IncrementalRender', content: '' }, err, 'Error while handling incremental render request'));
-                        return {
-                            response: errorResponse,
-                            shouldContinue: false,
+            await (0, tracing_js_1.trace)(async (context) => {
+                incrementalTracingContext = context;
+                // Handle the incremental render stream
+                await (0, handleIncrementalRenderStream_js_1.handleIncrementalRenderStream)({
+                    request: req,
+                    onRenderRequestReceived: async (obj) => {
+                        // Build a temporary FastifyRequest shape for protocol/auth check
+                        const tempReqBody = typeof obj === 'object' && obj !== null ? obj : {};
+                        // Perform request prechecks
+                        const precheckResult = (0, requestPrechecks_js_1.performRequestPrechecks)(tempReqBody);
+                        if (precheckResult) {
+                            return {
+                                response: precheckResult,
+                                shouldContinue: false,
+                            };
+                        }
+                        // Extract data for incremental render request
+                        const dependencyBundleTimestamps = extractBodyArrayField(tempReqBody, 'dependencyBundleTimestamps');
+                        const initial = {
+                            firstRequestChunk: obj,
+                            bundleTimestamp,
+                            dependencyBundleTimestamps,
                         };
-                    }
-                },
-                onUpdateReceived: async (obj) => {
-                    if (!incrementalSink) {
-                        log_js_1.default.error({ msg: 'Unexpected update chunk received after rendering was aborted', obj });
-                        return;
-                    }
-                    try {
-                        await incrementalSink.add(obj);
-                    }
-                    catch (err) {
-                        // Log error but don't stop processing
-                        log_js_1.default.error({ err, msg: 'Error processing update chunk' });
-                    }
-                },
-                onResponseStart: async (response) => {
-                    responseStarted = true;
-                    await setResponse(response, res);
-                },
-                onRequestEnded: () => {
-                    if (!incrementalSink) {
-                        return;
-                    }
-                    incrementalSink.handleRequestClosed();
-                },
-            });
+                        try {
+                            const { response, sink } = await (0, handleIncrementalRenderRequest_js_1.handleIncrementalRenderRequest)(initial);
+                            incrementalSink = sink;
+                            return {
+                                response,
+                                shouldContinue: !!incrementalSink,
+                            };
+                        }
+                        catch (err) {
+                            const errorResponse = (0, utils_js_1.errorResponseResult)((0, utils_js_1.formatExceptionMessage)({ label: 'IncrementalRender', content: '' }, err, 'Error while handling incremental render request'), context);
+                            return {
+                                response: errorResponse,
+                                shouldContinue: false,
+                            };
+                        }
+                    },
+                    onUpdateReceived: async (obj) => {
+                        if (!incrementalSink) {
+                            log_js_1.default.error({ msg: 'Unexpected update chunk received after rendering was aborted', obj });
+                            return;
+                        }
+                        try {
+                            await incrementalSink.add(obj);
+                        }
+                        catch (err) {
+                            // Log error but don't stop processing
+                            log_js_1.default.error({ err, msg: 'Error processing update chunk' });
+                        }
+                    },
+                    onResponseStart: async (response) => {
+                        responseStarted = true;
+                        await setResponse(response, res);
+                    },
+                    onRequestEnded: () => {
+                        if (!incrementalSink) {
+                            return;
+                        }
+                        incrementalSink.handleRequestClosed();
+                    },
+                });
+            }, (0, tracing_js_1.startSsrRequestOptions)({ renderingRequest: 'ReactOnRails.incrementalRender' }));
         }
         catch (err) {
             // If an error occurred during stream processing, send error response
@@ -437,7 +433,7 @@ function run(config) {
             }
             else {
                 // Response hasn't started yet, we can send an error response
-                const errorResponse = (0, utils_js_1.errorResponseResult)(errorMessage);
+                const errorResponse = (0, utils_js_1.errorResponseResult)(errorMessage, incrementalTracingContext);
                 await setResponse(errorResponse, res);
             }
         }
@@ -469,7 +465,18 @@ function run(config) {
             // endpoint so that concurrent /upload-assets and render requests
             // targeting the same bundle directory are mutually exclusive.
             // See https://github.com/shakacode/react_on_rails/issues/2463
-            const result = await (0, handleRenderRequest_js_1.handleNewBundlesProvided)({ label: 'Request:', content: taskDescription }, providedNewBundles, assetsToCopy);
+            const bytesTotal = await (0, handleRenderRequest_js_1.sumUploadedBytes)([
+                ...providedNewBundles.map((b) => b.bundle),
+                ...(assetsToCopy ?? []),
+            ]);
+            const result = await (0, tracing_js_1.subSpan)({
+                name: 'ror.bundle.upload',
+                attributes: {
+                    'bundle.count': providedNewBundles.length,
+                    'assets.count': assetsToCopy.length,
+                    'bytes.total': bytesTotal,
+                },
+            }, () => (0, handleRenderRequest_js_1.handleNewBundlesProvided)({ label: 'Request:', content: taskDescription }, providedNewBundles, assetsToCopy));
             if (result) {
                 await setResponse(result, res);
                 return;
@@ -546,9 +553,9 @@ function run(config) {
             log_js_1.default.info({ workerName, address }, 'Node renderer listening');
         });
     }
-    fastifyConfigFunctions.forEach((configFunction) => {
-        configFunction(app);
-    });
+    // Integration hooks registered before the worker loads are applied here, immediately after
+    // listen() is scheduled and before Fastify finishes booting.
+    (0, fastifyConfig_js_1.applyFastifyConfigFunctions)(app);
     return app;
 }
 //# sourceMappingURL=worker.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-on-rails-pro-node-renderer",
-  "version": "16.7.0-rc.2",
+  "version": "16.7.0-rc.3",
   "protocolVersion": "2.0.0",
   "description": "React on Rails Pro Node Renderer for server-side rendering",
   "main": "lib/ReactOnRailsProNodeRenderer.js",
@@ -38,7 +38,7 @@
     "fs-extra": "^11.2.0",
     "jsonwebtoken": "^9.0.3",
     "lockfile": "^1.0.4",
-    "pino": "^9.0.0"
+    "pino": "^9.14.0 || ^10.1.0"
   },
   "devDependencies": {
     "@babel/core": "^7.26.10",
@@ -47,6 +47,15 @@
     "@babel/preset-react": "^7.26.3",
     "@babel/preset-typescript": "^7.27.1",
     "@honeybadger-io/js": "^6.10.1",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.214.0",
+    "@fastify/otel": "^0.18.1",
+    "@opentelemetry/instrumentation": "^0.214.0",
+    "@opentelemetry/instrumentation-http": "^0.214.0",
+    "@opentelemetry/resources": "^2.0.1",
+    "@opentelemetry/sdk-trace-base": "^2.0.1",
+    "@opentelemetry/sdk-trace-node": "^2.0.1",
+    "@opentelemetry/semantic-conventions": "^1.36.0",
     "@sentry/node": "^7.120.0",
     "@types/fs-extra": "^11.0.4",
     "@types/jest": "^29.5.12",
@@ -65,10 +74,19 @@
     "sentry-testkit": "^5.0.6",
     "touch": "^3.1.0",
     "typescript": "^5.4.3",
-    "react-on-rails": "16.7.0-rc.2"
+    "react-on-rails": "16.7.0-rc.3"
   },
   "peerDependencies": {
     "@honeybadger-io/js": ">=4.0.0",
+    "@opentelemetry/api": ">=1.9.0 <2.0.0",
+    "@opentelemetry/exporter-trace-otlp-http": ">=0.214.0 <1.0.0",
+    "@fastify/otel": ">=0.18.0 <1.0.0",
+    "@opentelemetry/instrumentation": ">=0.214.0 <1.0.0",
+    "@opentelemetry/instrumentation-http": ">=0.214.0 <1.0.0",
+    "@opentelemetry/resources": ">=2.0.0 <3.0.0",
+    "@opentelemetry/sdk-trace-base": ">=2.0.0 <3.0.0",
+    "@opentelemetry/sdk-trace-node": ">=2.0.0 <3.0.0",
+    "@opentelemetry/semantic-conventions": ">=1.36.0 <2.0.0",
     "@sentry/node": ">=5.0.0 <11.0.0",
     "@sentry/tracing": ">=5.0.0"
   },
@@ -76,6 +94,33 @@
     "@honeybadger-io/js": {
       "optional": true
     },
+    "@opentelemetry/api": {
+      "optional": true
+    },
+    "@opentelemetry/exporter-trace-otlp-http": {
+      "optional": true
+    },
+    "@fastify/otel": {
+      "optional": true
+    },
+    "@opentelemetry/instrumentation": {
+      "optional": true
+    },
+    "@opentelemetry/instrumentation-http": {
+      "optional": true
+    },
+    "@opentelemetry/resources": {
+      "optional": true
+    },
+    "@opentelemetry/sdk-trace-base": {
+      "optional": true
+    },
+    "@opentelemetry/sdk-trace-node": {
+      "optional": true
+    },
+    "@opentelemetry/semantic-conventions": {
+      "optional": true
+    },
     "@sentry/node": {
       "optional": true
     },