react-on-rails-pro-node-renderer 17.0.0-rc.2 → 17.0.0-rc.4

package/lib/worker.js

@@ -51,6 +51,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.disableHttp2 = exports.configureFastify = void 0;
+exports.releaseExecutionContextWhenStreamFinishes = releaseExecutionContextWhenStreamFinishes;
 exports.default = run;
 /**
  * Entry point for worker process that handles requests.
@@ -60,6 +61,7 @@ const path_1 = __importDefault(require("path"));
 const cluster_1 = __importDefault(require("cluster"));
 const crypto_1 = require("crypto");
 const promises_1 = require("fs/promises");
+const stream_1 = require("stream");
 const fastify_1 = __importDefault(require("fastify"));
 const formbody_1 = __importDefault(require("@fastify/formbody"));
 const multipart_1 = __importDefault(require("@fastify/multipart"));
@@ -80,17 +82,52 @@ 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 fastifyConfig_js_1 = require("./worker/fastifyConfig.js");
+const vm_js_1 = require("./worker/vm.js");
 var fastifyConfig_js_2 = require("./worker/fastifyConfig.js");
 Object.defineProperty(exports, "configureFastify", { enumerable: true, get: function () { return fastifyConfig_js_2.configureFastify; } });
+const INCREMENTAL_REQUEST_CLOSE_TIMEOUT_MS = 1000;
+// Standard response streams use this only to release retained renderer context;
+// they are not aborted. Incremental responses may still close after request EOF.
+// These release/finish windows are intentionally equal so both stream paths
+// retain VM source-map registrations for the same idle period.
+const STREAM_CONTEXT_RELEASE_TIMEOUT_MS = constants_js_1.STREAM_CHUNK_TIMEOUT_MS;
+const INCREMENTAL_RESPONSE_FINISH_TIMEOUT_MS = STREAM_CONTEXT_RELEASE_TIMEOUT_MS;
+const HEALTH_ENDPOINT_ROUTES = ['/health', '/ready'];
+// TODO: Reassess the duplicated-route message format when upgrading Fastify.
+const FASTIFY_DUPLICATED_ROUTE_ERROR_CODE = 'FST_ERR_DUPLICATED_ROUTE';
+const READY_RETRY_AFTER_SECONDS = 5;
 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));
 }
+function hasHeader(headers, headerName) {
+    const lowerHeaderName = headerName.toLowerCase();
+    return Object.keys(headers).some((key) => key.toLowerCase() === lowerHeaderName);
+}
+function setStringResponseHeaders(headers, res) {
+    if (!hasHeader(headers, 'Content-Type')) {
+        res.type('text/plain; charset=utf-8');
+    }
+    if (!hasHeader(headers, 'X-Content-Type-Options')) {
+        res.header('X-Content-Type-Options', 'nosniff');
+    }
+}
 const setResponse = async (result, res) => {
     const { status, data, headers, stream } = result;
     if (status !== 200 && status !== 410) {
         log_js_1.default.info({ msg: 'Sending non-200, non-410 data back', data });
     }
+    if (!stream && typeof data === 'string' && status >= 400) {
+        setHeaders(headers, res);
+        res.header('Content-Type', 'text/plain; charset=utf-8');
+        res.header('X-Content-Type-Options', 'nosniff');
+        res.status(status);
+        res.send(data);
+        return;
+    }
+    if (!stream && typeof data === 'string') {
+        setStringResponseHeaders(headers, res);
+    }
     setHeaders(headers, res);
     res.status(status);
     if (stream) {
@@ -100,7 +137,142 @@ const setResponse = async (result, res) => {
         res.send(data);
     }
 };
+function runWhenStreamFinishes(stream, res, onFinished) {
+    let finished = false;
+    const finish = () => {
+        if (finished) {
+            return;
+        }
+        finished = true;
+        stream.off('close', finish);
+        stream.off('end', finish);
+        stream.off('error', finish);
+        res.raw.off('close', finish);
+        onFinished();
+    };
+    stream.once('close', finish);
+    stream.once('end', finish);
+    stream.once('error', finish);
+    res.raw.once('close', finish);
+    return finish;
+}
+/** @internal Used in tests */
+function releaseExecutionContextWhenStreamFinishes(stream, res, executionContext) {
+    let timeoutId;
+    let executionContextReleased = false;
+    const clearResponseFinishTimeout = () => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            timeoutId = undefined;
+        }
+    };
+    const releaseExecutionContext = () => {
+        if (executionContextReleased) {
+            return;
+        }
+        executionContextReleased = true;
+        clearResponseFinishTimeout();
+        executionContext.release();
+    };
+    const refreshResponseFinishTimeout = () => {
+        if (executionContextReleased) {
+            return;
+        }
+        const timeoutMs = STREAM_CONTEXT_RELEASE_TIMEOUT_MS;
+        clearResponseFinishTimeout();
+        timeoutId = setTimeout(() => {
+            timeoutId = undefined;
+            log_js_1.default.warn({
+                msg: 'Timed out waiting for render response stream to finish; releasing retained execution context',
+                timeoutMs,
+            });
+            releaseExecutionContext();
+        }, timeoutMs);
+    };
+    const progressStream = new stream_1.Transform({
+        transform(chunk, encoding, callback) {
+            refreshResponseFinishTimeout();
+            callback(null, chunk);
+        },
+    });
+    const forwardSourceError = (error) => progressStream.destroy(error);
+    const endProgressStream = () => {
+        if (!progressStream.writableEnded && !progressStream.destroyed) {
+            progressStream.end();
+        }
+    };
+    const release = runWhenStreamFinishes(progressStream, res, () => {
+        stream.off('close', endProgressStream);
+        stream.off('error', forwardSourceError);
+        releaseExecutionContext();
+    });
+    stream.once('close', endProgressStream);
+    stream.once('error', forwardSourceError);
+    stream.pipe(progressStream);
+    refreshResponseFinishTimeout();
+    return {
+        release,
+        stream: progressStream,
+    };
+}
+const setResponseAndReleaseExecutionContext = async (result, res, executionContext) => {
+    if (!executionContext) {
+        await setResponse(result, res);
+        return;
+    }
+    if (result.stream) {
+        const releaseHandle = releaseExecutionContextWhenStreamFinishes(result.stream, res, executionContext);
+        try {
+            await setResponse({ ...result, stream: releaseHandle.stream }, res);
+        }
+        catch (error) {
+            releaseHandle.release();
+            throw error;
+        }
+        return;
+    }
+    try {
+        await setResponse(result, res);
+    }
+    finally {
+        executionContext.release();
+    }
+};
 const isAsset = (value) => value.type === 'asset';
+function conflictingHealthEndpointPath(error) {
+    if (typeof error !== 'object' || error === null) {
+        return undefined;
+    }
+    const { code, message } = error;
+    if (code !== FASTIFY_DUPLICATED_ROUTE_ERROR_CODE || typeof message !== 'string') {
+        return undefined;
+    }
+    // Format-dependent: Fastify's FST_ERR_DUPLICATED_ROUTE message currently
+    // includes `route '/health'` or `route '/ready'`. If that wording changes,
+    // this safely returns undefined and the caller rethrows the raw Fastify error,
+    // losing only the migration hint; verify this when upgrading Fastify.
+    return HEALTH_ENDPOINT_ROUTES.find((routePath) => message.includes(`route '${routePath}'`));
+}
+function applyFastifyConfigWithHealthEndpointMigrationHint(app, enableHealthEndpoints) {
+    // This wraps synchronous configureFastify route registration only. Async
+    // Fastify plugins still surface Fastify's duplicate-route error during boot.
+    try {
+        (0, fastifyConfig_js_1.applyFastifyConfigFunctions)(app);
+    }
+    catch (error) {
+        const conflictingPath = enableHealthEndpoints ? conflictingHealthEndpointPath(error) : undefined;
+        if (conflictingPath) {
+            const message = `enableHealthEndpoints registers built-in GET ${conflictingPath} before configureFastify callbacks run, ` +
+                `and a configureFastify callback also tried to register that route. Remove or rename the custom ${conflictingPath} route when migrating ` +
+                'to the built-in health endpoints. See docs/oss/building-features/node-renderer/health-checks.md.';
+            log_js_1.default.error({ err: error, route: conflictingPath }, message);
+            const migrationError = new Error(message);
+            migrationError.cause = error;
+            throw migrationError;
+        }
+        throw error;
+    }
+}
 function assertAsset(value, key) {
     if (!isAsset(value)) {
         throw new Error(`React On Rails Error: Expected an asset for key: ${key}`);
@@ -188,7 +360,7 @@ function run(config) {
     // Store config in app state. From now it can be loaded by any module using
     // getConfig():
     (0, configBuilder_js_1.buildConfig)(config);
-    const { serverBundleCachePath, logHttpLevel, port, host, fastifyServerOptions, workersCount } = (0, configBuilder_js_1.getConfig)();
+    const { serverBundleCachePath, logHttpLevel, port, host, fastifyServerOptions, workersCount, enableHealthEndpoints, } = (0, configBuilder_js_1.getConfig)();
     // The renderer uses cleartext HTTP/2 (h2c). Node's `allowHTTP1` option only
     // applies to TLS servers (http2.createSecureServer), so it cannot enable
     // HTTP/1.1 Kubernetes httpGet probes on this listener.
@@ -318,7 +490,7 @@ function run(config) {
                         assetsToCopy,
                         tracingContext: context,
                     });
-                    await setResponse(result.response, res);
+                    await setResponseAndReleaseExecutionContext(result.response, res, result.executionContext);
                 }
                 catch (err) {
                     const exceptionMessage = (0, utils_js_1.formatExceptionMessage)({ renderingRequest }, err, 'UNHANDLED error in handleRenderRequest');
@@ -339,7 +511,93 @@ 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 incrementalRequestClosed = false;
+        let incrementalResponseFinished = false;
+        let incrementalExecutionContextReleased = false;
+        let incrementalResponseFinishTimeoutId;
         let incrementalTracingContext;
+        const clearIncrementalResponseFinishTimeout = () => {
+            if (!incrementalResponseFinishTimeoutId) {
+                return;
+            }
+            clearTimeout(incrementalResponseFinishTimeoutId);
+            incrementalResponseFinishTimeoutId = undefined;
+        };
+        const releaseIncrementalExecutionContextWhenDone = () => {
+            if (incrementalExecutionContextReleased ||
+                !incrementalRequestClosed ||
+                !incrementalResponseFinished ||
+                !incrementalSink) {
+                return;
+            }
+            clearIncrementalResponseFinishTimeout();
+            incrementalExecutionContextReleased = true;
+            incrementalSink.executionContext.release();
+        };
+        const markIncrementalResponseFinished = () => {
+            clearIncrementalResponseFinishTimeout();
+            incrementalResponseFinished = true;
+            releaseIncrementalExecutionContextWhenDone();
+        };
+        const scheduleIncrementalResponseFinishTimeout = () => {
+            if (incrementalResponseFinishTimeoutId ||
+                incrementalResponseFinished ||
+                incrementalExecutionContextReleased ||
+                !incrementalSink) {
+                return;
+            }
+            incrementalResponseFinishTimeoutId = setTimeout(() => {
+                incrementalResponseFinishTimeoutId = undefined;
+                if (incrementalResponseFinished || incrementalExecutionContextReleased) {
+                    return;
+                }
+                log_js_1.default.warn({
+                    msg: 'Timed out waiting for incremental render response stream to finish after request closed',
+                    timeoutMs: INCREMENTAL_RESPONSE_FINISH_TIMEOUT_MS,
+                });
+                if (!res.raw.destroyed) {
+                    res.raw.destroy();
+                }
+                markIncrementalResponseFinished();
+            }, INCREMENTAL_RESPONSE_FINISH_TIMEOUT_MS);
+        };
+        const waitForIncrementalRequestClose = async (closeRequestPromise, timeoutMs) => {
+            let timeoutId;
+            const timeoutPromise = new Promise((resolve) => {
+                timeoutId = setTimeout(() => resolve('timeout'), timeoutMs);
+            });
+            const result = await Promise.race([closeRequestPromise.then(() => 'closed'), timeoutPromise]);
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            if (result === 'timeout') {
+                log_js_1.default.warn({
+                    msg: 'Timed out waiting for incremental render close hook after response started',
+                    timeoutMs,
+                });
+            }
+        };
+        const closeIncrementalRequest = async ({ timeoutMs = INCREMENTAL_REQUEST_CLOSE_TIMEOUT_MS, } = {}) => {
+            if (!incrementalSink || incrementalRequestClosed) {
+                return;
+            }
+            const sink = incrementalSink;
+            try {
+                await waitForIncrementalRequestClose(Promise.resolve()
+                    .then(() => sink.handleRequestClosed())
+                    .catch((closeError) => {
+                    log_js_1.default.error({
+                        msg: 'Error while closing incremental render request after response started',
+                        error: closeError,
+                    });
+                }), timeoutMs);
+            }
+            finally {
+                incrementalRequestClosed = true;
+                scheduleIncrementalResponseFinishTimeout();
+                releaseIncrementalExecutionContextWhenDone();
+            }
+        };
         try {
             await (0, tracing_js_1.trace)(async (context) => {
                 incrementalTracingContext = context;
@@ -395,13 +653,26 @@ function run(config) {
                     },
                     onResponseStart: async (response) => {
                         responseStarted = true;
-                        await setResponse(response, res);
-                    },
-                    onRequestEnded: () => {
-                        if (!incrementalSink) {
+                        if (response.stream) {
+                            const markFinished = runWhenStreamFinishes(response.stream, res, markIncrementalResponseFinished);
+                            try {
+                                await setResponse(response, res);
+                            }
+                            catch (error) {
+                                markFinished();
+                                throw error;
+                            }
                             return;
                         }
-                        incrementalSink.handleRequestClosed();
+                        try {
+                            await setResponse(response, res);
+                        }
+                        finally {
+                            markIncrementalResponseFinished();
+                        }
+                    },
+                    onRequestEnded: async () => {
+                        await closeIncrementalRequest();
                     },
                 });
             }, (0, tracing_js_1.startSsrRequestOptions)({ renderingRequest: 'ReactOnRails.incrementalRender' }));
@@ -421,9 +692,9 @@ function run(config) {
                 // The React stream is waiting for async props (e.g., asyncPropsManager.getProp("researches")).
                 // If we don't call endStream(), the stream will hang forever waiting for props that will never arrive.
                 // This causes onResponse to never fire, leaving activeRequestsCount stuck and preventing worker shutdown.
-                if (incrementalSink) {
-                    incrementalSink.handleRequestClosed();
-                }
+                const closeRequestPromise = closeIncrementalRequest({
+                    timeoutMs: INCREMENTAL_REQUEST_CLOSE_TIMEOUT_MS,
+                });
                 // CRITICAL: Destroy the response connection to immediately close it.
                 // Without this, the response stream stays open waiting for the client (httpx) to timeout,
                 // which can take 30+ seconds. This delays worker shutdown during graceful termination.
@@ -431,11 +702,21 @@ function run(config) {
                 if (!res.raw.destroyed) {
                     res.raw.destroy();
                 }
+                await closeRequestPromise;
             }
             else {
                 // Response hasn't started yet, we can send an error response
+                const closeRequestPromise = closeIncrementalRequest({
+                    timeoutMs: INCREMENTAL_REQUEST_CLOSE_TIMEOUT_MS,
+                });
                 const errorResponse = (0, utils_js_1.errorResponseResult)(errorMessage, incrementalTracingContext);
-                await setResponse(errorResponse, res);
+                try {
+                    await setResponse(errorResponse, res);
+                }
+                finally {
+                    markIncrementalResponseFinished();
+                    await closeRequestPromise;
+                }
             }
         }
     });
@@ -540,6 +821,49 @@ function run(config) {
             renderer_version: packageJson_js_1.default.version,
         });
     });
+    // Built-in, opt-in probe endpoints (enableHealthEndpoints config option).
+    // Like /info, they are plain GET routes outside the authenticated render and
+    // asset endpoints: orchestrator probes cannot carry the renderer password.
+    // Both intentionally return status-only bodies — no versions, paths, or
+    // license details — so leaving them reachable exposes nothing sensitive.
+    // NOTE: this listener speaks cleartext HTTP/2 (h2c), so HTTP/1.1-only probes
+    // (e.g. Kubernetes httpGet) cannot reach these routes. Use tcpSocket or exec
+    // probes (`curl --http2-prior-knowledge`). See
+    // docs/oss/building-features/node-renderer/health-checks.md.
+    if (enableHealthEndpoints) {
+        // Liveness: 200 whenever this process can answer — i.e. the event loop is
+        // responsive. Intentionally checks no dependencies (no bundle, Rails, or
+        // license state) so a transient dependency issue never restarts the pod.
+        // Safe from a rate-limiting perspective (CodeQL js/missing-rate-limiting):
+        // this is an internal renderer service not exposed to the internet, returns
+        // a static status string, and exposes no sensitive runtime data.
+        // codeql[js/missing-rate-limiting]
+        // lgtm[js/missing-rate-limiting]
+        app.get('/health', (_req, res) => {
+            res.send({ status: 'ok' });
+        });
+        // Readiness: 200 only when this process can actually serve render requests.
+        // Answering at all proves the worker is online; additionally require at
+        // least one bundle compiled into the VM pool, because a renderer with zero
+        // bundles responds 410 to renders until the Rails client uploads one.
+        // With workersCount > 1 the cluster module distributes probe connections
+        // across workers, so a probe checks one worker per request.
+        // Safe from a rate-limiting perspective (CodeQL js/missing-rate-limiting):
+        // same rationale as /health; this returns only a static readiness status.
+        // codeql[js/missing-rate-limiting]
+        // lgtm[js/missing-rate-limiting]
+        app.get('/ready', (_req, res) => {
+            if ((0, vm_js_1.hasAnyVMContext)()) {
+                res.send({ status: 'ready' });
+            }
+            else {
+                res
+                    .status(503)
+                    .header('Retry-After', String(READY_RETRY_AFTER_SECONDS))
+                    .send({ status: 'waiting_for_bundle' });
+            }
+        });
+    }
     // In tests we will run worker in master thread, so we need to ensure server
     // will not listen:
     // we are extracting worker from cluster to avoid false TS error
@@ -556,7 +880,7 @@ function run(config) {
     }
     // 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);
+    applyFastifyConfigWithHealthEndpointMigrationHint(app, enableHealthEndpoints);
     return app;
 }
 //# sourceMappingURL=worker.js.map

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "react-on-rails-pro-node-renderer",
-  "version": "17.0.0-rc.2",
+  "version": "17.0.0-rc.4",
   "protocolVersion": "2.0.0",
   "description": "React on Rails Pro Node Renderer for server-side rendering",
+  "engines": {
+    "node": ">=18.19.0"
+  },
   "main": "lib/ReactOnRailsProNodeRenderer.js",
   "directories": {
     "doc": "docs"
@@ -74,7 +77,7 @@
     "sentry-testkit": "^5.0.6",
     "touch": "^3.1.0",
     "typescript": "^5.4.3",
-    "react-on-rails": "17.0.0-rc.2"
+    "react-on-rails": "17.0.0-rc.4"
   },
   "peerDependencies": {
     "@honeybadger-io/js": ">=4.0.0",