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

package/lib/testUtils/opentelemetry.js

@@ -0,0 +1,66 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetOpenTelemetryForTest = resetOpenTelemetryForTest;
+const opentelemetryState_js_1 = require("../shared/opentelemetryState.js");
+const tracing_js_1 = require("../shared/tracing.js");
+const fastifyConfig = __importStar(require("../worker/fastifyConfig.js"));
+const shutdownHooks = __importStar(require("../worker/shutdownHooks.js"));
+async function resetOpenTelemetryForTest() {
+    const tracerProvider = (0, opentelemetryState_js_1.getOpenTelemetryTracerProvider)();
+    if (tracerProvider) {
+        await tracerProvider.shutdown();
+        (0, opentelemetryState_js_1.setOpenTelemetryTracerProvider)(null);
+    }
+    (0, tracing_js_1.resetSubSpan)();
+    (0, tracing_js_1.resetTracing)();
+    // eslint-disable-next-line no-underscore-dangle
+    fastifyConfig.__resetFastifyConfigFunctionsForTest();
+    // eslint-disable-next-line no-underscore-dangle
+    shutdownHooks.__resetWorkerShutdownHooksForTest();
+    /* eslint-disable @typescript-eslint/no-require-imports, global-require */
+    try {
+        const otelApi = require('@opentelemetry/api');
+        otelApi.trace.disable();
+        otelApi.context.disable();
+        otelApi.propagation.disable();
+        otelApi.diag.disable();
+    }
+    catch {
+        // OTel API not installed - nothing to disable.
+    }
+    /* eslint-enable @typescript-eslint/no-require-imports, global-require */
+}
+//# sourceMappingURL=opentelemetry.js.map

package/lib/worker/fastifyConfig.d.ts

@@ -0,0 +1,19 @@
+import type { FastifyInstance } from './types.js';
+export type FastifyConfigFunction = (app: FastifyInstance) => void;
+/**
+ * Configures the Fastify instance before starting the server.
+ *
+ * This module intentionally has no runtime dependency on `worker.ts` or
+ * `fastify`, so integrations can register instrumentation before Fastify is
+ * required by the worker module graph.
+ */
+export declare function registerFastifyConfigFunction(configFunction: FastifyConfigFunction): () => void;
+/**
+ * Public one-way registration API for custom entrypoints and integrations.
+ * Internal callers use registerFastifyConfigFunction() when they need the
+ * unregister callback during failed initialization or shutdown cleanup.
+ */
+export declare function configureFastify(configFunction: FastifyConfigFunction): void;
+export declare function applyFastifyConfigFunctions(app: FastifyInstance): void;
+export declare function __resetFastifyConfigFunctionsForTest(): void;
+//# sourceMappingURL=fastifyConfig.d.ts.map

package/lib/worker/fastifyConfig.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerFastifyConfigFunction = registerFastifyConfigFunction;
+exports.configureFastify = configureFastify;
+exports.applyFastifyConfigFunctions = applyFastifyConfigFunctions;
+exports.__resetFastifyConfigFunctionsForTest = __resetFastifyConfigFunctionsForTest;
+const fastifyConfigFunctions = [];
+/**
+ * Configures the Fastify instance before starting the server.
+ *
+ * This module intentionally has no runtime dependency on `worker.ts` or
+ * `fastify`, so integrations can register instrumentation before Fastify is
+ * required by the worker module graph.
+ */
+function registerFastifyConfigFunction(configFunction) {
+    fastifyConfigFunctions.push(configFunction);
+    return () => {
+        const index = fastifyConfigFunctions.indexOf(configFunction);
+        if (index >= 0) {
+            fastifyConfigFunctions.splice(index, 1);
+        }
+    };
+}
+/**
+ * Public one-way registration API for custom entrypoints and integrations.
+ * Internal callers use registerFastifyConfigFunction() when they need the
+ * unregister callback during failed initialization or shutdown cleanup.
+ */
+function configureFastify(configFunction) {
+    registerFastifyConfigFunction(configFunction);
+}
+function applyFastifyConfigFunctions(app) {
+    fastifyConfigFunctions.forEach((configFunction) => {
+        configFunction(app);
+    });
+}
+// eslint-disable-next-line no-underscore-dangle
+function __resetFastifyConfigFunctionsForTest() {
+    fastifyConfigFunctions.length = 0;
+}
+//# sourceMappingURL=fastifyConfig.js.map

package/lib/worker/handleGracefulShutdown.js

@@ -6,6 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const cluster_1 = __importDefault(require("cluster"));
 const utils_js_1 = require("../shared/utils.js");
 const log_js_1 = __importDefault(require("../shared/log.js"));
+const shutdownHooks_js_1 = require("./shutdownHooks.js");
+function errorCode(error) {
+    const code = error?.code;
+    return typeof code === 'string' ? code : undefined;
+}
 const handleGracefulShutdown = (app) => {
     const { worker } = cluster_1.default;
     if (!worker) {
@@ -14,12 +19,54 @@ const handleGracefulShutdown = (app) => {
     }
     let activeRequestsCount = 0;
     let isShuttingDown = false;
+    let isDestroying = false;
+    const destroyWorkerAfterShutdownHooks = (context) => {
+        if (isDestroying) {
+            return;
+        }
+        isDestroying = true;
+        log_js_1.default.debug('Worker #%d running shutdown hooks before shutdown after %s', worker.id, context);
+        let workerDestroyed = false;
+        const destroyWorker = () => {
+            if (workerDestroyed) {
+                return;
+            }
+            workerDestroyed = true;
+            worker.destroy();
+        };
+        const shutdownTimeout = setTimeout(() => {
+            log_js_1.default.warn('Worker #%d: shutdown hooks timed out, forcing worker.destroy()', worker.id);
+            destroyWorker();
+        }, shutdownHooks_js_1.WORKER_SHUTDOWN_HOOKS_TIMEOUT_MS);
+        const shutdownHooksPromise = (0, shutdownHooks_js_1.runWorkerShutdownHooks)();
+        void shutdownHooksPromise
+            .catch((error) => {
+            log_js_1.default.warn({ msg: 'Error running worker shutdown hooks before worker shutdown', error });
+        })
+            .finally(() => {
+            clearTimeout(shutdownTimeout);
+            destroyWorker();
+        });
+    };
+    const disconnectWorker = () => {
+        try {
+            worker.disconnect();
+        }
+        catch (error) {
+            if (errorCode(error) === 'ERR_IPC_DISCONNECTED') {
+                log_js_1.default.debug('Worker #%d IPC channel was already disconnected during graceful shutdown', worker.id);
+            }
+            else {
+                log_js_1.default.warn({ msg: 'Error disconnecting worker during graceful shutdown', error });
+            }
+        }
+    };
     // Helper to decrement counter and potentially kill worker
     const decrementAndMaybeShutdown = (context) => {
         activeRequestsCount -= 1;
         if (isShuttingDown && activeRequestsCount === 0) {
             log_js_1.default.debug('Worker #%d has no active requests after %s, killing the worker', worker.id, context);
-            worker.destroy();
+            destroyWorkerAfterShutdownHooks(context);
         }
     };
     process.on('message', (msg) => {
@@ -28,11 +75,11 @@ const handleGracefulShutdown = (app) => {
             isShuttingDown = true;
             if (activeRequestsCount === 0) {
                 log_js_1.default.debug('Worker #%d has no active requests, killing the worker', worker.id);
-                worker.destroy();
+                destroyWorkerAfterShutdownHooks('shutdown message');
             }
             else {
                 log_js_1.default.debug('Worker #%d has "%d" active requests, disconnecting the worker', worker.id, activeRequestsCount);
-                worker.disconnect();
+                disconnectWorker();
             }
         }
     });

package/lib/worker/handleIncrementalRenderRequest.js

@@ -7,6 +7,13 @@ exports.handleIncrementalRenderRequest = handleIncrementalRenderRequest;
 const handleRenderRequest_1 = require("./handleRenderRequest");
 const log_1 = __importDefault(require("../shared/log"));
 const utils_1 = require("../shared/utils");
+const tracing_js_1 = require("../shared/tracing.js");
+class InvalidIncrementalRenderChunkError extends Error {
+    constructor() {
+        super('Invalid incremental render chunk received, missing properties');
+        this.name = 'InvalidIncrementalRenderChunkError';
+    }
+}
 function assertIsUpdateChunk(value) {
     if (typeof value !== 'object' ||
         value === null ||
@@ -14,7 +21,7 @@ function assertIsUpdateChunk(value) {
         !('updateChunk' in value) ||
         (typeof value.bundleTimestamp !== 'string' && typeof value.bundleTimestamp !== 'number') ||
         typeof value.updateChunk !== 'string') {
-        throw new Error('Invalid incremental render chunk received, missing properties');
+        throw new InvalidIncrementalRenderChunkError();
     }
 }
 function assertFirstIncrementalRenderRequestChunk(chunk) {
@@ -63,6 +70,8 @@ async function handleIncrementalRenderRequest(initial) {
     const { renderingRequest, onRequestClosedUpdateChunk } = firstRequestChunk;
     try {
         // Call handleRenderRequest internally to handle all validation and VM execution
+        // handleRenderRequest is called directly without a TracingContext from worker.ts's
+        // trace() wrapper, so there is no tracingContext to forward for its error path.
         const { response, executionContext } = await (0, handleRenderRequest_1.handleRenderRequest)({
             renderingRequest,
             bundleTimestamp,
@@ -82,13 +91,21 @@ async function handleIncrementalRenderRequest(initial) {
                 add: async (chunk) => {
                     try {
                         assertIsUpdateChunk(chunk);
-                        const bundlePath = (0, utils_1.getRequestBundleFilePath)(chunk.bundleTimestamp);
-                        await executionContext.runInVM(chunk.updateChunk, bundlePath).catch((err) => {
-                            log_1.default.error({ msg: 'Error running incremental render chunk', err, chunk });
+                        await (0, tracing_js_1.subSpan)({ name: 'ror.incremental.process_chunk' }, async () => {
+                            const bundlePath = (0, utils_1.getRequestBundleFilePath)(chunk.bundleTimestamp);
+                            const result = await executionContext.runInVM(chunk.updateChunk, bundlePath);
+                            if ((0, utils_1.isErrorRenderResult)(result)) {
+                                throw new Error(result.exceptionMessage);
+                            }
                         });
                     }
                     catch (err) {
-                        log_1.default.error({ msg: 'Invalid incremental render chunk', err, chunk });
+                        if (err instanceof InvalidIncrementalRenderChunkError) {
+                            log_1.default.error({ msg: 'Invalid incremental render chunk', err, chunk });
+                        }
+                        else {
+                            log_1.default.error({ msg: 'Error running incremental render chunk', err, chunk });
+                        }
                     }
                 },
                 handleRequestClosed: () => {

package/lib/worker/handleIncrementalRenderStream.js

@@ -38,6 +38,7 @@ exports.handleIncrementalRenderStream = handleIncrementalRenderStream;
 const string_decoder_1 = require("string_decoder");
 const errorReporter = __importStar(require("../shared/errorReporter"));
 const constants_1 = require("../shared/constants");
+const tracing_js_1 = require("../shared/tracing.js");
 /**
  * Error thrown when waiting for a stream chunk times out.
  */
@@ -87,116 +88,118 @@ async function* withChunkTimeout(iterator, timeoutMs) {
  * The first object triggers rendering, subsequent objects provide incremental updates.
  */
 async function handleIncrementalRenderStream(options) {
-    const { request, onRenderRequestReceived, onResponseStart, onUpdateReceived, onRequestEnded } = options;
-    let hasReceivedFirstObject = false;
-    const decoder = new string_decoder_1.StringDecoder('utf8');
-    let buffer = '';
-    let totalBytesReceived = 0;
-    let onResponseStartPromise = null;
-    try {
-        for await (const chunk of withChunkTimeout(request.raw, constants_1.STREAM_CHUNK_TIMEOUT_MS)) {
-            const chunkBuffer = chunk instanceof Buffer ? chunk : Buffer.from(chunk);
-            totalBytesReceived += chunkBuffer.length;
-            // Check total request size limit
-            if (totalBytesReceived > constants_1.BODY_SIZE_LIMIT) {
-                throw new Error(`NDJSON request exceeds maximum size of ${constants_1.BODY_SIZE_LIMIT} bytes (${Math.round(constants_1.BODY_SIZE_LIMIT / 1024 / 1024)}MB). ` +
-                    `Received ${totalBytesReceived} bytes.`);
-            }
-            const str = decoder.write(chunkBuffer);
-            buffer += str;
-            // Check single line size limit (protects against missing newlines)
-            if (buffer.length > constants_1.FIELD_SIZE_LIMIT) {
-                throw new Error(`NDJSON line exceeds maximum size of ${constants_1.FIELD_SIZE_LIMIT} bytes (${Math.round(constants_1.FIELD_SIZE_LIMIT / 1024 / 1024)}MB). ` +
-                    `Current buffer: ${buffer.length} bytes. Ensure each JSON object is followed by a newline.`);
-            }
-            // Process all complete JSON objects in the buffer
-            let boundary = buffer.indexOf('\n');
-            while (boundary !== -1) {
-                const rawObject = buffer.slice(0, boundary).trim();
-                buffer = buffer.slice(boundary + 1);
-                boundary = buffer.indexOf('\n');
-                if (rawObject) {
-                    let parsed;
-                    try {
-                        parsed = JSON.parse(rawObject);
-                    }
-                    catch (err) {
-                        const errorMessage = `Invalid JSON chunk: ${err instanceof Error ? err.message : String(err)}`;
-                        if (!hasReceivedFirstObject) {
-                            // Error in first chunk - throw error to stop processing
-                            throw new Error(errorMessage);
-                        }
-                        else {
-                            // Error in subsequent chunks - log and report but continue processing
-                            const reportedMessage = `JSON parsing error in update chunk: ${err instanceof Error ? err.message : String(err)}`;
-                            errorReporter.message(reportedMessage);
-                            // Skip this malformed chunk and continue with next ones
-                            // eslint-disable-next-line no-continue
-                            continue;
-                        }
-                    }
-                    if (!hasReceivedFirstObject) {
-                        hasReceivedFirstObject = true;
+    return (0, tracing_js_1.subSpan)({ name: 'ror.incremental.stream' }, async () => {
+        const { request, onRenderRequestReceived, onResponseStart, onUpdateReceived, onRequestEnded } = options;
+        let hasReceivedFirstObject = false;
+        const decoder = new string_decoder_1.StringDecoder('utf8');
+        let buffer = '';
+        let totalBytesReceived = 0;
+        let onResponseStartPromise = null;
+        try {
+            for await (const chunk of withChunkTimeout(request.raw, constants_1.STREAM_CHUNK_TIMEOUT_MS)) {
+                const chunkBuffer = chunk instanceof Buffer ? chunk : Buffer.from(chunk);
+                totalBytesReceived += chunkBuffer.length;
+                // Check total request size limit
+                if (totalBytesReceived > constants_1.BODY_SIZE_LIMIT) {
+                    throw new Error(`NDJSON request exceeds maximum size of ${constants_1.BODY_SIZE_LIMIT} bytes (${Math.round(constants_1.BODY_SIZE_LIMIT / 1024 / 1024)}MB). ` +
+                        `Received ${totalBytesReceived} bytes.`);
+                }
+                const str = decoder.write(chunkBuffer);
+                buffer += str;
+                // Check single line size limit (protects against missing newlines)
+                if (buffer.length > constants_1.FIELD_SIZE_LIMIT) {
+                    throw new Error(`NDJSON line exceeds maximum size of ${constants_1.FIELD_SIZE_LIMIT} bytes (${Math.round(constants_1.FIELD_SIZE_LIMIT / 1024 / 1024)}MB). ` +
+                        `Current buffer: ${buffer.length} bytes. Ensure each JSON object is followed by a newline.`);
+                }
+                // Process all complete JSON objects in the buffer
+                let boundary = buffer.indexOf('\n');
+                while (boundary !== -1) {
+                    const rawObject = buffer.slice(0, boundary).trim();
+                    buffer = buffer.slice(boundary + 1);
+                    boundary = buffer.indexOf('\n');
+                    if (rawObject) {
+                        let parsed;
                         try {
-                            // eslint-disable-next-line no-await-in-loop
-                            const result = await onRenderRequestReceived(parsed);
-                            const { response, shouldContinue: continueFlag } = result;
-                            onResponseStartPromise = Promise.resolve(onResponseStart(response));
-                            if (!continueFlag) {
-                                return;
-                            }
+                            parsed = JSON.parse(rawObject);
                         }
                         catch (err) {
-                            // Error in first chunk processing - throw error to stop processing
-                            const error = err instanceof Error ? err : new Error(String(err));
-                            error.message = `Error processing initial render request: ${error.message}`;
-                            throw error;
+                            const errorMessage = `Invalid JSON chunk: ${err instanceof Error ? err.message : String(err)}`;
+                            if (!hasReceivedFirstObject) {
+                                // Error in first chunk - throw error to stop processing
+                                throw new Error(errorMessage);
+                            }
+                            else {
+                                // Error in subsequent chunks - log and report but continue processing
+                                const reportedMessage = `JSON parsing error in update chunk: ${err instanceof Error ? err.message : String(err)}`;
+                                errorReporter.message(reportedMessage);
+                                // Skip this malformed chunk and continue with next ones
+                                // eslint-disable-next-line no-continue
+                                continue;
+                            }
                         }
-                    }
-                    else {
-                        try {
-                            // eslint-disable-next-line no-await-in-loop
-                            await onUpdateReceived(parsed);
-                            // Yield to the event loop after each update chunk so React's
-                            // setImmediate(performWork) can fire. Without this, all setProp()
-                            // calls batch into React's pingedTasks and are processed in a
-                            // single performWork → single flushCompletedQueues, merging all
-                            // resolved Suspense boundaries into one chunk.
-                            // With this yield, each setProp triggers its own performWork →
-                            // flushCompletedQueues → destination.flush(), producing a
-                            // separate output chunk per resolved Suspense boundary.
-                            //
-                            // Tradeoff: adds one event-loop tick (~0.1ms) per update chunk.
-                            // For N async props this costs N extra ticks, but the streaming
-                            // granularity gain far outweighs it (see PR #3196 benchmarks).
-                            //
-                            // Note: on the error path (catch block below), the yield is
-                            // skipped — intentional, as there's no React work to process
-                            // when the update failed.
-                            // eslint-disable-next-line no-await-in-loop
-                            await new Promise((resolve) => {
-                                setImmediate(resolve);
-                            });
+                        if (!hasReceivedFirstObject) {
+                            hasReceivedFirstObject = true;
+                            try {
+                                // eslint-disable-next-line no-await-in-loop
+                                const result = await onRenderRequestReceived(parsed);
+                                const { response, shouldContinue: continueFlag } = result;
+                                onResponseStartPromise = Promise.resolve(onResponseStart(response));
+                                if (!continueFlag) {
+                                    return;
+                                }
+                            }
+                            catch (err) {
+                                // Error in first chunk processing - throw error to stop processing
+                                const error = err instanceof Error ? err : new Error(String(err));
+                                error.message = `Error processing initial render request: ${error.message}`;
+                                throw error;
+                            }
                         }
-                        catch (err) {
-                            // Error in update chunk processing - log and report but continue processing
-                            const errorMessage = `Error processing update chunk: ${err instanceof Error ? err.message : String(err)}`;
-                            errorReporter.message(errorMessage);
-                            // Continue processing other chunks
+                        else {
+                            try {
+                                // eslint-disable-next-line no-await-in-loop
+                                await onUpdateReceived(parsed);
+                                // Yield to the event loop after each update chunk so React's
+                                // setImmediate(performWork) can fire. Without this, all setProp()
+                                // calls batch into React's pingedTasks and are processed in a
+                                // single performWork → single flushCompletedQueues, merging all
+                                // resolved Suspense boundaries into one chunk.
+                                // With this yield, each setProp triggers its own performWork →
+                                // flushCompletedQueues → destination.flush(), producing a
+                                // separate output chunk per resolved Suspense boundary.
+                                //
+                                // Tradeoff: adds one event-loop tick (~0.1ms) per update chunk.
+                                // For N async props this costs N extra ticks, but the streaming
+                                // granularity gain far outweighs it (see PR #3196 benchmarks).
+                                //
+                                // Note: on the error path (catch block below), the yield is
+                                // skipped — intentional, as there's no React work to process
+                                // when the update failed.
+                                // eslint-disable-next-line no-await-in-loop
+                                await new Promise((resolve) => {
+                                    setImmediate(resolve);
+                                });
+                            }
+                            catch (err) {
+                                // Error in update chunk processing - log and report but continue processing
+                                const errorMessage = `Error processing update chunk: ${err instanceof Error ? err.message : String(err)}`;
+                                errorReporter.message(errorMessage);
+                                // Continue processing other chunks
+                            }
                         }
                     }
                 }
             }
         }
-    }
-    catch (err) {
-        const error = err instanceof Error ? err : new Error(String(err));
-        // Update the error message in place to retain the original stack trace, rather than creating a new error object
-        error.message = `Error while handling the request stream: ${error.message}`;
-        throw error;
-    }
-    // Stream ended normally
-    await onRequestEnded();
-    await onResponseStartPromise;
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            // Update the error message in place to retain the original stack trace, rather than creating a new error object
+            error.message = `Error while handling the request stream: ${error.message}`;
+            throw error;
+        }
+        // Stream ended normally
+        await onRequestEnded();
+        await onResponseStartPromise;
+    });
 }
 //# sourceMappingURL=handleIncrementalRenderStream.js.map

package/lib/worker/handleRenderRequest.d.ts

@@ -5,8 +5,9 @@
  * @module worker/handleRenderRequest
  */
 import { Asset, ResponseResult, type RequestInfo } from '../shared/utils.js';
-import type { TracingContext } from '../shared/tracing.js';
+import { type TracingContext } from '../shared/tracing.js';
 import { ExecutionContext } from './vm.js';
+export declare function sumUploadedBytes(assets: Asset[]): Promise<number>;
 export type ProvidedNewBundle = {
     timestamp: string | number;
     bundle: Asset;