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

package/lib/shared/tracing.js

@@ -1,8 +1,18 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startSsrRequestOptions = void 0;
 exports.setupTracing = setupTracing;
 exports.trace = trace;
+exports.resetTracing = resetTracing;
+exports.__resetTracingForTest = __resetTracingForTest;
+exports.setupSubSpan = setupSubSpan;
+exports.subSpan = subSpan;
+exports.resetSubSpan = resetSubSpan;
+exports.__resetSubSpanForTest = __resetSubSpanForTest;
+const log_js_1 = __importDefault(require("./log.js"));
 const errorReporter_js_1 = require("./errorReporter.js");
 /* eslint-enable @typescript-eslint/no-empty-object-type */
 let setupRun = false;
@@ -18,17 +28,19 @@ exports.startSsrRequestOptions = startSsrRequestOptions;
  * @param options.startSsrRequestOptions - Options used to start a new unit of work for an SSR request.
  *   Should be an object with your integration name as the only property.
  *   It will be passed to the executor.
+ * @returns true when this call installed the tracing integration.
  */
 function setupTracing(options) {
     if (setupRun) {
         (0, errorReporter_js_1.message)('setupTracing called more than once. Currently only one tracing integration can be enabled.');
-        return;
+        return false;
     }
     executor = options.executor;
     if (options.startSsrRequestOptions) {
         mutableStartSsrRequestOptions = options.startSsrRequestOptions;
     }
     setupRun = true;
+    return true;
 }
 /**
  * Reports a unit of work to the tracing service, if any.
@@ -36,4 +48,106 @@ function setupTracing(options) {
 function trace(fn, unitOfWorkOptions) {
     return executor(fn, unitOfWorkOptions);
 }
+/**
+ * Resets the installed tracing executor + startSsrRequestOptions back to
+ * defaults. Integrations use this during lifecycle teardown or failed initialization cleanup.
+ *
+ * Caller contract: only integrations that own the active tracing lifecycle
+ * should call this, and only while tearing that lifecycle down.
+ */
+function resetTracing() {
+    executor = (fn) => fn();
+    mutableStartSsrRequestOptions = () => ({});
+    setupRun = false;
+}
+/**
+ * Test-only: reset the installed tracing executor + startSsrRequestOptions back
+ * to defaults. Not part of the public api — do not re-export from
+ * `integrations/api.ts`.
+ */
+// eslint-disable-next-line no-underscore-dangle
+function __resetTracingForTest() {
+    resetTracing();
+}
+const noOpSubSpanController = {
+    setAttributes() { },
+};
+const defaultSubSpan = (_opts, fn) => fn(noOpSubSpanController);
+let subSpanImpl = defaultSubSpan;
+let subSpanSetupRun = false;
+/**
+ * Install a sub-span implementation. Integrations call this from their `init()`
+ * to start receiving sub-span events. If never called, sub-spans are no-ops.
+ * @returns true when this call installed the sub-span integration.
+ */
+function setupSubSpan(impl) {
+    if (subSpanSetupRun) {
+        (0, errorReporter_js_1.message)('setupSubSpan called more than once. Only one sub-span integration can be enabled.');
+        return false;
+    }
+    subSpanImpl = impl;
+    subSpanSetupRun = true;
+    return true;
+}
+/**
+ * Wrap an async function in a named sub-span. Safe to call even when no
+ * integration is installed — defaults to passing through to `fn`.
+ *
+ * The wrapped function receives a {@link SubSpanController} it can use to
+ * attach attributes that are only known after the work runs (e.g., response
+ * byte counts). With no integration installed, attribute updates are dropped.
+ *
+ * If the installed implementation throws or rejects before invoking `fn`, the
+ * caller is shielded: `fn` is still executed outside any sub-span (with the
+ * no-op controller) and its result returned. If the implementation fails
+ * after invoking `fn`, the error is rethrown so `fn` is never run twice.
+ */
+function subSpan(opts, fn) {
+    let invoked = false;
+    const wrappedFn = (controller) => {
+        invoked = true;
+        return fn(controller);
+    };
+    try {
+        return Promise.resolve(subSpanImpl(opts, wrappedFn)).catch((err) => {
+            if (invoked) {
+                return Promise.reject(err instanceof Error ? err : new Error(String(err)));
+            }
+            // log.warn (not message) for the silent-fallback path. message() goes to
+            // log.error + external notifiers (Sentry/Bugsnag/etc.) on every request,
+            // which is too noisy for a per-request recoverable failure where fn() is
+            // still executed. log.warn surfaces the broken integration without
+            // paging the on-call team for every render.
+            log_js_1.default.warn({ err }, 'subSpan implementation rejected before invoking fn(); running fn() without a span');
+            return wrappedFn(noOpSubSpanController);
+        });
+    }
+    catch (err) {
+        if (invoked) {
+            return Promise.reject(err instanceof Error ? err : new Error(String(err)));
+        }
+        log_js_1.default.warn({ err }, 'subSpan implementation threw before invoking fn(); running fn() without a span');
+        return wrappedFn(noOpSubSpanController);
+    }
+}
+/**
+ * Resets the installed sub-span implementation back to the default pass-through.
+ * Integrations use this during lifecycle teardown or failed initialization cleanup.
+ *
+ * Caller contract: only integrations that own the active sub-span lifecycle
+ * should call this, and only while tearing that lifecycle down.
+ */
+function resetSubSpan() {
+    subSpanImpl = defaultSubSpan;
+    subSpanSetupRun = false;
+}
+/**
+ * Test-only: reset the installed sub-span implementation back to the default
+ * pass-through. Not part of the public api — do not re-export from
+ * `integrations/api.ts`.
+ */
+// eslint-disable-next-line no-underscore-dangle
+function __resetSubSpanForTest() {
+    resetSubSpan();
+}
 //# sourceMappingURL=tracing.js.map

package/lib/testUtils/opentelemetry.d.ts

@@ -0,0 +1,2 @@
+export declare function resetOpenTelemetryForTest(): Promise<void>;
+//# sourceMappingURL=opentelemetry.d.ts.map

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/checkProtocolVersionHandler.js

@@ -10,6 +10,7 @@ exports.checkProtocolVersion = checkProtocolVersion;
  */
 const packageJson_js_1 = __importDefault(require("../shared/packageJson.js"));
 const log_js_1 = __importDefault(require("../shared/log.js"));
+const sensitiveKeys_js_1 = require("../shared/sensitiveKeys.js");
 const NODE_ENV = process.env.NODE_ENV || 'production';
 // Cache to store version comparison results to avoid repeated normalization and logging
 // Key: gemVersion string, Value: boolean (true if matches, false if mismatch)
@@ -43,7 +44,7 @@ function checkProtocolVersion(body) {
             status: 412,
             data: `Unsupported renderer protocol version ${reqProtocolVersion
                 ? `request protocol ${reqProtocolVersion}`
-                : `MISSING with body ${JSON.stringify(body)}`} does not match installed renderer protocol ${packageJson_js_1.default.protocolVersion} for version ${packageJson_js_1.default.version}.
+                : `MISSING (received fields: ${(0, sensitiveKeys_js_1.sanitizeBodyKeys)(body).join(', ') || '(none)'})`} does not match installed renderer protocol ${packageJson_js_1.default.protocolVersion} for version ${packageJson_js_1.default.version}.
 Update either the renderer or the Rails server`,
         };
     }

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: () => {