react_on_rails 16.2.0.beta.3 → 16.2.0.beta.8

data/react_on_rails_pro/docs/installation.md

@@ -1,183 +1,203 @@
 # Installation
-Since the repository is private, you will get a **GitHub Personal Access Token** and an account that can access the packages. Substitute that value in the commands below. If you dont' have this, ask [justin@shakacode.com](mailto:justin@shakacode.com) to give you one.
 
-Check the [CHANGELOG](https://github.com/shakacode/react_on_rails_pro/blob/master/CHANGELOG.md) to see what version you want.
+React on Rails Pro packages are published publicly on npmjs.org and RubyGems.org. Installation requires a valid **license token** for runtime validation. Contact [justin@shakacode.com](mailto:justin@shakacode.com) to purchase a license.
 
-# Version
+**Upgrading from GitHub Packages?** See the [Upgrading Guide](./updating.md) for migration instructions.
 
-For the below docs, find the desired `<version>` in the CHANGELOG. Note, for pre-release versions, gems have all periods, and node packages uses a dash, like gem `3.0.0.rc.0` and node package `3.0.0-rc.0`.
+Check the [CHANGELOG](https://github.com/shakacode/react_on_rails/blob/master/CHANGELOG.md) to see what version you want.
 
-# Ruby
-## Gem Installation
-1. Ensure your **Rails** app is using the **react_on_rails** gem, version greater than 11.0.7.
-1. Add the `react_on_rails_pro` gem to your **Gemfile**. Substitute the appropriate version number. 
-   
-## Gemfile Change
+## Version Format
 
-Replace the following in the snippet for the Gemfile
-1. `<account>` for the api key
-2. `<api-key>`
-3. `<version>` desired
+For the below docs, find the desired `<version>` in the CHANGELOG. Note that for pre-release versions:
+
+- Gems use all periods: `16.2.0.beta.1`
+- NPM packages use dashes: `16.2.0-beta.1`
+
+# Ruby Gem Installation
+
+## Prerequisites
+
+Ensure your **Rails** app is using the **react_on_rails** gem, version 16.0.0 or higher.
+
+## Install react_on_rails_pro Gem
+
+Add the `react_on_rails_pro` gem to your **Gemfile**:
 
 ```ruby
-source "https://<rorp-account>:<token>@"\
-  "rubygems.pkg.github.com/shakacode-tools" do
-  gem "react_on_rails_pro", "<version>"
-end
+gem "react_on_rails_pro", "~> 16.2"
 ```
 
-## Alternate installation keeping the key out of your Gemfile
+Then run:
 
-```ruby
-source "https://rubygems.pkg.github.com/shakacode-tools" do
-  gem "react_on_rails_pro", "<version>"
-end
+```bash
+bundle install
 ```
-Or use the `gem install` command:
+
+Or install directly:
 
 ```bash
-gem install react_on_rails_pro --version "<version>> --source "https://rubygems.pkg.github.com/shakacode-tools"
+gem install react_on_rails_pro --version "<version>"
 ```
 
-Then edit your permissions for bundler at the command line:
+## License Configuration
 
+Set your license token as an environment variable:
+
+```bash
+export REACT_ON_RAILS_PRO_LICENSE="your-license-token-here"
 ```
-bundle config set rubygems.pkg.github.com <username>:<token>
+
+Or configure it in your Rails initializer (not recommended for production):
+
+```ruby
+# config/initializers/react_on_rails_pro.rb
+ReactOnRailsPro.configure do |config|
+  config.license_token = ENV["REACT_ON_RAILS_PRO_LICENSE"]
+end
 ```
 
-## Using a branch in your Gemfile
-Note, you should probably use an ENV value for the token so that you don't check this into your source code.
-   ```ruby
-   gem "react_on_rails_pro", version: "<version>", git: "https://[your-github-token]:x-oauth-basic@github.com/shakacode/react_on_rails_pro.git", tag: "<version>"
-   ```
+⚠️ **Security Warning**: Never commit your license token to version control. Always use environment variables or secure secret management systems (like Rails credentials, Heroku config vars, AWS Secrets Manager, etc.).
 
 ## Rails Configuration
-You don't need to create an initializer if you are satisfied with the default as described in 
-[Configuration](./configuration.md)
 
-# Node Package
-Note, you only need to install the Node Package if you are using the standalone node renderer, `NodeRenderer`.
+You don't need to create an initializer if you are satisfied with the defaults as described in [Configuration](./configuration.md).
 
-## Installation
+For basic setup:
 
-1. Create a subdirectory of your rails project for the Node renderer. Let's use `react-on-rails-pro`.
-   
-2. Create a file `react-on-rails-pro/.npmrc` with the following
+```ruby
+# config/initializers/react_on_rails_pro.rb
+ReactOnRailsPro.configure do |config|
+  # Your configuration here
+  # See docs/configuration.md for all options
+end
 ```
-always-auth=true
-//npm.pkg.github.com/:_authToken=<token>
-@shakacode-tools:registry=https://npm.pkg.github.com
+
+# Node Package Installation
+
+**Note:** You only need to install the Node Package if you are using the standalone node renderer (`NodeRenderer`). If you're using `ExecJS` (the default), skip this section.
+
+## Install react-on-rails-pro-node-renderer
+
+### Using npm:
+
+```bash
+npm install react-on-rails-pro-node-renderer
+```
+
+### Using yarn:
+
+```bash
+yarn add react-on-rails-pro-node-renderer
 ```
 
-3. Create a `react-on-rails-pro/package.json`
+### Add to package.json:
+
 ```json
 {
-  "private": true,
   "dependencies": {
-    "@shakacode-tools/react-on-rails-pro-node-renderer": "<version>"
-  },
-  "scripts": {
-    "node-renderer": "echo 'Starting React on Rails Pro Node Renderer.' && node ./react-on-rails-pro-node-renderer.js"
+    "react-on-rails-pro-node-renderer": "^16.2.0"
   }
 }
 ```
 
-4. Be sure to run `npm i` **and not** `yarn` as only npm seems to work with the private github packages.
+## Node Renderer Setup
 
-If you really want to use yarn, see [Yarn can't find private Github npm registry](https://stackoverflow.com/questions/58316109/yarn-cant-find-private-github-npm-registry)
-
-5. You can start the renderer with either the executable `node-renderer` or, preferably, with 
-   a startup JS file, say called `react-on-rails-pro/react-on-rails-pro-node-renderer.js` with
-   these contents. _Note the use of the namespaced **`@shakacode-tools/react-on-rails-pro-node-renderer`** for the package.
+Create a JavaScript file to configure and launch the node renderer, for example `react-on-rails-pro-node-renderer.js`:
 
 ```js
-const path = require('path')
-const {
-  reactOnRailsProNodeRenderer,
-} = require('@shakacode-tools/react-on-rails-pro-node-renderer')
+const path = require('path');
+const { reactOnRailsProNodeRenderer } = require('react-on-rails-pro-node-renderer');
 
-const env = process.env
+const env = process.env;
 
 const config = {
-  bundlePath: path.resolve(__dirname, '../.node-renderer-bundles'),
+  serverBundleCachePath: path.resolve(__dirname, '../.node-renderer-bundles'),
 
   // Listen at RENDERER_PORT env value or default port 3800
   logLevel: env.RENDERER_LOG_LEVEL || 'debug', // show all logs
 
-  // See value in /config/initializers/react_on_rails_pro.rb. Should use env
-  // value in real app.
-  password: 'myPassword1',
+  // Password for Rails <-> Node renderer communication
+  // See value in /config/initializers/react_on_rails_pro.rb
+  password: env.RENDERER_PASSWORD || 'changeme',
 
-  // Save bundle to "tmp/bundles" dir of our dummy app
-  // This is the default
   port: env.RENDERER_PORT || 3800,
 
   // supportModules should be set to true to allow the server-bundle code to
-  // see require, exports, etc.
-  // `false` is like the ExecJS behavior
-  // this option is required to equal `true` in order to use loadable components
+  // see require, exports, etc. (`false` is like the ExecJS behavior)
+  // This option is required to equal `true` in order to use loadable components
   supportModules: true,
 
   // workersCount defaults to the number of CPUs minus 1
-  workersCount: Number(process.env.NODE_RENDERER_CONCURRENCY || 3),
-
-  // Next 2 params, allWorkersRestartInterval and
-  // delayBetweenIndividualWorkerRestarts must both should be set if you wish
-  // to have automatic worker restarting, say to clear memory leaks.
-  // time is in minutes between restarting all workers
-  // Enable next 2 if the renderer is running out of memory
-  // allWorkersRestartInterval: 15,
-  // time in minutes between each worker restarting when restarting all workers
-  // delayBetweenIndividualWorkerRestarts: 2,
-}
+  workersCount: Number(env.NODE_RENDERER_CONCURRENCY || 3),
+
+  // Optional: Automatic worker restarting (for memory leak mitigation)
+  // allWorkersRestartInterval: 15, // minutes between restarting all workers
+  // delayBetweenIndividualWorkerRestarts: 2, // minutes between each worker restart
+  // gracefulWorkerRestartTimeout: undefined, // timeout for graceful worker restart; forces restart if worker stuck
+};
 
 // Renderer detects a total number of CPUs on virtual hostings like Heroku
 // or CircleCI instead of CPUs number allocated for current container. This
 // results in spawning many workers while only 1-2 of them really needed.
 if (env.CI) {
-  config.workersCount = 2
+  config.workersCount = 2;
 }
 
-reactOnRailsProNodeRenderer(config)
+reactOnRailsProNodeRenderer(config);
 ```
 
-## Instructions for using a branch
+Add a script to your `package.json`:
 
-Install the node-renderer executable, possibly globally. Substitute the branch name or tag for `master`
+```json
+{
+  "scripts": {
+    "node-renderer": "node ./react-on-rails-pro-node-renderer.js"
+  }
+}
 ```
-yarn global add https://<your-github-token>:x-oauth-basic@github.com/shakacode/react_on_rails_pro.git\#master
+
+Start the renderer:
+
+```bash
+npm run node-renderer
 ```
 
-This installs a binary `node-renderer`.
+## Rails Configuration for Node Renderer
 
-### Using Github packages
+Configure Rails to use the remote node renderer:
 
-Login into npm
+```ruby
+# config/initializers/react_on_rails_pro.rb
+ReactOnRailsPro.configure do |config|
+  config.server_renderer = "NodeRenderer"
 
-```bash
-npm install @shakacode-tools/react-on-rails-pro-node-renderer@<version>
-```                      
+  # Configure renderer connection
+  config.renderer_url = ENV["REACT_RENDERER_URL"] || "http://localhost:3800"
+  config.renderer_password = ENV["RENDERER_PASSWORD"] || "changeme"
 
-or edit package.json directly
-```json
-"@shakacode-tools/react-on-rails-pro-node-renderer": "<version>"
-```                     
+  # Enable prerender caching (recommended)
+  config.prerender_caching = true
+end
+```
 
-### Configuration
-See [NodeRenderer JavaScript Configuration](./node-renderer/js-configuration.md).
+### Configuration Options
 
-#### Webpack Configuration
-Set your server bundle webpack configuration to use a target of `node` per the [Webpack docs](https://webpack.js.org/concepts/targets/#usage).
+See [Rails Configuration Options](./configuration.md) for all available settings.
 
-## Authentication when using Github packages
-[Auth for the npm package](https://docs.github.com/en/packages/using-github-packages-with-your-projects-ecosystem/configuring-npm-for-use-with-github-packages#authenticating-to-github-packages)
+Pay attention to:
 
-Create a new ~/.npmrc file if one doesn't exist.
-```
-//npm.pkg.github.com/:_authToken=TOKEN
-```                  
+- `config.server_renderer = "NodeRenderer"` - Required to use node renderer
+- `config.renderer_url` - URL where your node renderer is running
+- `config.renderer_password` - Shared secret for authentication
+- `config.prerender_caching` - Enable caching (recommended)
 
-To configure bundler if you don't want the token in your Gemfile:
-```
-bundle config https://rubygems.pkg.github.com/OWNER USERNAME:TOKEN
-``` 
+## Webpack Configuration
+
+Set your server bundle webpack configuration to use a target of `node` per the [Webpack docs](https://webpack.js.org/concepts/targets/#usage).
+
+## Additional Documentation
+
+- [Node Renderer Basics](./node-renderer/basics.md)
+- [Node Renderer JavaScript Configuration](./node-renderer/js-configuration.md)
+- [Rails Configuration Options](./configuration.md)
+- [Error Reporting and Tracing](./node-renderer/error-reporting-and-tracing.md)

data/react_on_rails_pro/docs/node-renderer/basics.md

@@ -1,23 +1,26 @@
 # Requirements
-* You must use React on Rails v11.0.7 or higher.
+
+- You must use React on Rails v11.0.7 or higher.
 
 # Install the Gem and the Node Module
+
 See [Installation](../installation.md).
 
 # Setup Node Renderer Server
+
 **node-renderer** is a standalone Node application to serve React SSR requests from a **Rails** client. You don't need any **Ruby** code to setup and launch it. You can configure with the command line or with a launch file.
 
 ## Simple Command Line for node-renderer
 
 1. ENV values for the default config are (See [JS Configuration](./js-configuration.md) for more details):
-    * `RENDERER_PORT`
-    * `RENDERER_LOG_LEVEL`
-    * `RENDERER_BUNDLE_PATH`
-    * `RENDERER_WORKERS_COUNT`
-    * `RENDERER_PASSWORD`
-    * `RENDERER_ALL_WORKERS_RESTART_INTERVAL`
-    * `RENDERER_DELAY_BETWEEN_INDIVIDUAL_WORKER_RESTARTS`
-    * `RENDERER_SUPPORT_MODULES`
+   - `RENDERER_PORT`
+   - `RENDERER_LOG_LEVEL`
+   - `RENDERER_BUNDLE_PATH`
+   - `RENDERER_WORKERS_COUNT`
+   - `RENDERER_PASSWORD`
+   - `RENDERER_ALL_WORKERS_RESTART_INTERVAL`
+   - `RENDERER_DELAY_BETWEEN_INDIVIDUAL_WORKER_RESTARTS`
+   - `RENDERER_SUPPORT_MODULES`
 2. Configure ENV values and run the command. Note, you can set port with args `-p <PORT>`. For example, assuming node-renderer is in your path:
    ```
    RENDERER_BUNDLE_PATH=/app/.node-renderer-bundles node-renderer
@@ -25,6 +28,7 @@ See [Installation](../installation.md).
 3. You can use a command line argument of `-p SOME_PORT` to override any ENV value for the PORT.
 
 ## JavaScript Configuration File
+
 For the most control over the setup, create a JavaScript file to start the NodeRenderer.
 
 1. Create some project directory, let's say `renderer-app`:
@@ -33,27 +37,29 @@ For the most control over the setup, create a JavaScript file to start the NodeR
    cd renderer-app
    ```
 2. Make sure you have **Node.js** version **14** or higher and **Yarn** installed.
-3. Init node application and yarn add to install `@shakacode-tools/react-on-rails-pro-node-renderer` package.
+3. Init node application and install the `react-on-rails-pro-node-renderer` package.
    ```sh
    yarn init
-   yarn add https://[your-github-token]:x-oauth-basic@github.com/shakacode/react_on_rails_pro.git\#master
+   yarn add react-on-rails-pro-node-renderer
    ```
-4. Configure a JavaScript file that will launch the rendering server per the docs in [Node Renderer JavaScript Configuration](./js-configuration.md). For example, create a file `node-renderer.js`. Here is a simple example that uses all the defaults except for bundlePath:
+4. Configure a JavaScript file that will launch the rendering server per the docs in [Node Renderer JavaScript Configuration](./js-configuration.md). For example, create a file `node-renderer.js`. Here is a simple example that uses all the defaults except for serverBundleCachePath:
 
    ```javascript
    import path from 'path';
-   import reactOnRailsProNodeRenderer from '@shakacode-tools/react-on-rails-pro-node-renderer';
+   import reactOnRailsProNodeRenderer from 'react-on-rails-pro-node-renderer';
 
    const config = {
-     bundlePath: path.resolve(__dirname, '../.node-renderer-bundles'),
+     serverBundleCachePath: path.resolve(__dirname, '../.node-renderer-bundles'),
    };
 
    reactOnRailsProNodeRenderer(config);
    ```
+
 5. Now you can launch your renderer server with `node node-renderer.js`. You will probably add a script to your `package.json`.
 6. You can use a command line argument of `-p SOME_PORT` to override any configured or ENV value for the port.
 
 # Setup Rails Application
+
 Create `config/initializers/react_on_rails_pro.rb` and configure the **renderer server**. See configuration values in [Configuration](../configuration.md). Pay attention to:
 
 1. Set `config.server_renderer = "NodeRenderer"`
@@ -61,25 +67,26 @@ Create `config/initializers/react_on_rails_pro.rb` and configure the **renderer
 3. Configure values beginning with `renderer_`
 4. Use ENV values for values like `renderer_url` so that your deployed server is properly configured. If the ENV value is unset, the default for the renderer_url is `localhost:3800`.
 5. Here's a tiny example using mostly defaults:
+
 ```ruby
 ReactOnRailsPro.configure do |config|
  config.server_renderer = "NodeRenderer"
- 
- # when this ENV value is not defined, the local server at localhost:3800 is used 
- config.renderer_url = ENV["REACT_RENDERER_URL"] 
+
+ # when this ENV value is not defined, the local server at localhost:3800 is used
+ config.renderer_url = ENV["REACT_RENDERER_URL"]
 end
 ```
 
 ## Troublshooting
 
-* See [JS Memory Leaks](../js-memory-leaks.md).
-  
+- See [JS Memory Leaks](../js-memory-leaks.md).
+
 ## Upgrading
 
 The NodeRenderer has a protocol version on both the Rails and Node sides. If the Rails server sends a protocol version that does not match the Node side, an error is returned. Ideally, you want to keep both the Rails and Node sides at the same version.
 
 ## References
 
-* [Installation](../installation.md).
-* [Rails Options for node-renderer](../configuration.md)
-* [JS Options for node-renderer](./js-configuration.md)
+- [Installation](../installation.md).
+- [Rails Options for node-renderer](../configuration.md)
+- [JS Options for node-renderer](./js-configuration.md)

data/react_on_rails_pro/docs/node-renderer/error-reporting-and-tracing.md

@@ -14,10 +14,10 @@ It should initialize the services according to your requirements and then enable
 3. Then load the integration:
 
     ```js
-    require('@shakacode-tools/react-on-rails-pro-node-renderer/integrations/sentry').init();
+    require('react-on-rails-pro-node-renderer/integrations/sentry').init();
    ```
 
-   - Use `@shakacode-tools/react-on-rails-pro-node-renderer/integrations/sentry6` instead of `.../sentry` for versions of Sentry SDK older than 7.63.0.
+   - Use `react-on-rails-pro-node-renderer/integrations/sentry6` instead of `.../sentry` for versions of Sentry SDK older than 7.63.0.
    - For Sentry SDK v8+ you can use `.init({ fastify: true })` to capture additional Fastify-related information.
 
 ### Sentry Tracing
@@ -40,7 +40,7 @@ To enable Sentry Tracing:
 2. Then load the integration:
 
     ```js
-    require('@shakacode-tools/react-on-rails-pro-node-renderer/integrations/honeybadger').init();
+    require('react-on-rails-pro-node-renderer/integrations/honeybadger').init();
     ```
 
     Use `init({ fastify: true })` to capture additional Fastify-related information.
@@ -49,7 +49,7 @@ To enable Sentry Tracing:
 You can create your own integrations in the same way as the provided ones.
 If you have access to the React on Rails Pro repository,
 you can use [their implementations](https://github.com/shakacode/react_on_rails_pro/tree/master/packages/node-renderer/src/integrations) as examples.
-Import these functions from `@shakacode-tools/react-on-rails-pro-node-renderer/integrations/api`:
+Import these functions from `react-on-rails-pro-node-renderer/integrations/api`:
 
 ### Error reporting services
 
@@ -59,7 +59,7 @@ Import these functions from `@shakacode-tools/react-on-rails-pro-node-renderer/i
 For example, integrating with BugSnag can be as simple as
 ```js
 const Bugsnag = require('@bugsnag/js');
-const { addNotifier } = require('@shakacode-tools/react-on-rails-pro-node-renderer/integrations/api');
+const { addNotifier } = require('react-on-rails-pro-node-renderer/integrations/api');
 
 Bugsnag.start({ /* your options */ });
 
@@ -76,7 +76,7 @@ To track requests as [sessions](https://docs.bugsnag.com/platforms/javascript/ca
 the above example becomes
 ```js
 const Bugsnag = require('@bugsnag/js');
-const { addNotifier, setupTracing } = require('@shakacode-tools/react-on-rails-pro-node-renderer/integrations/api');
+const { addNotifier, setupTracing } = require('react-on-rails-pro-node-renderer/integrations/api');
 
 Bugsnag.start({ /* your options */ });
 
@@ -117,7 +117,7 @@ Bugsnag v7 is a bit more complicated:
 
 ```js
 const Bugsnag = require('@bugsnag/js');
-const { addNotifier, setupTracing } = require('@shakacode-tools/react-on-rails-pro-node-renderer/integrations/api');
+const { addNotifier, setupTracing } = require('react-on-rails-pro-node-renderer/integrations/api');
 
 Bugsnag.start({ /* your options */ });
 
@@ -142,7 +142,7 @@ If you want to report HTTP requests from Fastify, you can use `configureFastify`
 Extending the above example:
 
 ```js
-const { configureFastify } = require('@shakacode-tools/react-on-rails-pro-node-renderer/integrations/api');
+const { configureFastify } = require('react-on-rails-pro-node-renderer/integrations/api');
 
 configureFastify((app) => {
   app.addHook('onError', (_req, _reply, error, done) => {

data/react_on_rails_pro/docs/node-renderer/js-configuration.md

@@ -8,39 +8,41 @@ The values in this file must be kept in sync with with the `config/initializers/
 
 Here are the options available for the JavaScript renderer configuration object, as well as the available default ENV values if using the command line program node-renderer.
 
-[//]: # (If you change text here, you may want to update comments in packages/node-renderer/src/shared/configBuilder.ts as well.)
+[//]: # 'If you change text here, you may want to update comments in packages/node-renderer/src/shared/configBuilder.ts as well.'
 
 1. **port** (default: `process.env.RENDERER_PORT || 3800`) - The port the renderer should listen to.
-[On Heroku](https://devcenter.heroku.com/articles/dyno-startup-behavior#port-binding-of-web-dynos) or [ControlPlane](https://docs.controlplane.com/reference/workload/containers#port-variable) you may want to use `process.env.PORT`.
+   [On Heroku](https://devcenter.heroku.com/articles/dyno-startup-behavior#port-binding-of-web-dynos) or [ControlPlane](https://docs.controlplane.com/reference/workload/containers#port-variable) you may want to use `process.env.PORT`.
 1. **logLevel** (default: `process.env.RENDERER_LOG_LEVEL || 'info'`) - The renderer log level. Set it to `silent` to turn logging off.
-[Available levels](https://getpino.io/#/docs/api?id=levels): `{ fatal: 60, error: 50, warn: 40, info: 30, debug: 20, trace: 10 }`. `silent` can be used as well.
+   [Available levels](https://getpino.io/#/docs/api?id=levels): `{ fatal: 60, error: 50, warn: 40, info: 30, debug: 20, trace: 10 }`. `silent` can be used as well.
 1. **logHttpLevel** (default: `process.env.RENDERER_LOG_HTTP_LEVEL || 'error'`) - The HTTP server log level (same allowed values as `logLevel`).
 1. **fastifyServerOptions** (default: `{}`) - Additional options to pass to the Fastify server factory. See [Fastify documentation](https://fastify.dev/docs/latest/Reference/Server/#factory).
-1. **bundlePath** (default: `process.env.RENDERER_BUNDLE_PATH || '/tmp/react-on-rails-pro-node-renderer-bundles'` ) - path to a temp directory where uploaded bundle files will be stored. For example you can set it to `path.resolve(__dirname, './.node-renderer-bundles')` if you configured renderer from the `/` directory of your app.
+1. **serverBundleCachePath** (default: `process.env.RENDERER_SERVER_BUNDLE_CACHE_PATH || process.env.RENDERER_BUNDLE_PATH || '/tmp/react-on-rails-pro-node-renderer-bundles'` ) - Path to a cache directory where uploaded server bundle files will be stored. This is distinct from Shakapacker's public asset directory. For example you can set it to `path.resolve(__dirname, './.node-renderer-bundles')` if you configured renderer from the `/` directory of your app.
 1. **workersCount** (default: `process.env.RENDERER_WORKERS_COUNT || defaultWorkersCount()` where default is your CPUs count - 1) - Number of workers that will be forked to serve rendering requests. If you set this manually make sure that value is a **Number** and is `>= 0`. Setting this to `0` will run the renderer in a single process mode without forking any workers, which is useful for debugging purposes. For production use, the value should be `>= 1`.
 1. **password** (default: `env.RENDERER_PASSWORD`) - The password expected to receive from the **Rails client** to authenticate rendering requests.
-If no password is set, no authentication will be required.
+   If no password is set, no authentication will be required.
 1. **allWorkersRestartInterval** (default: `env.RENDERER_ALL_WORKERS_RESTART_INTERVAL`) - Interval in minutes between scheduled restarts of all workers. By default restarts are not enabled. If restarts are enabled, `delayBetweenIndividualWorkerRestarts` should also be set.
 1. **delayBetweenIndividualWorkerRestarts** (default: `env.RENDERER_DELAY_BETWEEN_INDIVIDUAL_WORKER_RESTARTS`) - Interval in minutes between individual worker restarts (when cluster restart is triggered). By default restarts are not enabled. If restarts are enabled, `allWorkersRestartInterval` should also be set.
+1. **gracefulWorkerRestartTimeout**: (default: `env.GRACEFUL_WORKER_RESTART_TIMEOUT`) - Time in seconds that the master waits for a worker to gracefully restart (after serving all active requests) before killing it. Use this when you want to avoid situations where a worker gets stuck in an infinite loop and never restarts. This config is only usable if worker restart is enabled. The timeout starts when the worker should restart; if it elapses without a restart, the worker is killed.
 1. **maxDebugSnippetLength** (default: 1000) - If the rendering request is longer than this, it will be truncated in exception and logging messages.
-1. **supportModules** - (default: `env.RENDERER_SUPPORT_MODULES || null`) - If set to true, `supportModules` enables the server-bundle code to call a default set of NodeJS global objects and functions that get added to the VM context: 
-`{ Buffer, TextDecoder, TextEncoder, URLSearchParams, ReadableStream, process, setTimeout, setInterval, setImmediate, clearTimeout, clearInterval, clearImmediate, queueMicrotask }`.
-This option is required to equal `true` if you want to use loadable components.
-Setting this value to false causes the NodeRenderer to behave like ExecJS.
-See also `stubTimers`.
-1. **additionalContext** - (default: `null`) - additionalContext enables you to specify additional NodeJS objects (usually from https://nodejs.org/api/globals.html) to add to the VM context in addition to our `supportModules` defaults. 
-Object shorthand notation may be used, but is not required.
-Example: `{ URL, Crypto }`
-1. **stubTimers** - (default: `env.RENDERER_STUB_TIMERS` if that environment variable is set, `true` otherwise) - With this option set, use of functions `setTimeout`, `setInterval`, `setImmediate`, `clearTimeout`, `clearInterval`, `clearImmediate`, and `queueMicrotask` will do nothing during server-rendering. 
-This is useful when using dependencies like [react-virtuoso](https://github.com/petyosi/react-virtuoso) that use these functions during hydration.
-In RORP, hydration typically is synchronous and single-task (unless you use streaming) and thus callbacks passed to  task-scheduling functions should never run during server-side rendering.
-Because these functions are valid client-side, they are ignored on server-side rendering without errors or warnings.
-See also `supportModules`.
+1. **supportModules** - (default: `env.RENDERER_SUPPORT_MODULES || null`) - If set to true, `supportModules` enables the server-bundle code to call a default set of NodeJS global objects and functions that get added to the VM context:
+   `{ Buffer, TextDecoder, TextEncoder, URLSearchParams, ReadableStream, process, setTimeout, setInterval, setImmediate, clearTimeout, clearInterval, clearImmediate, queueMicrotask }`.
+   This option is required to equal `true` if you want to use loadable components.
+   Setting this value to false causes the NodeRenderer to behave like ExecJS.
+   See also `stubTimers`.
+1. **additionalContext** - (default: `null`) - additionalContext enables you to specify additional NodeJS objects (usually from https://nodejs.org/api/globals.html) to add to the VM context in addition to our `supportModules` defaults.
+   Object shorthand notation may be used, but is not required.
+   Example: `{ URL, Crypto }`
+1. **stubTimers** - (default: `env.RENDERER_STUB_TIMERS` if that environment variable is set, `true` otherwise) - With this option set, use of functions `setTimeout`, `setInterval`, `setImmediate`, `clearTimeout`, `clearInterval`, `clearImmediate`, and `queueMicrotask` will do nothing during server-rendering.
+   This is useful when using dependencies like [react-virtuoso](https://github.com/petyosi/react-virtuoso) that use these functions during hydration.
+   In RORP, hydration typically is synchronous and single-task (unless you use streaming) and thus callbacks passed to task-scheduling functions should never run during server-side rendering.
+   Because these functions are valid client-side, they are ignored on server-side rendering without errors or warnings.
+   See also `supportModules`.
 
 Deprecated options:
 
-1. **honeybadgerApiKey**, **sentryDsn**, **sentryTracing**, **sentryTracesSampleRate** - Deprecated and have no effect. 
-If you have any of them set, see [Error Reporting and Tracing](./error-reporting-and-tracing.md) for the new way to set up error reporting and tracing.
+1. **bundlePath** - Renamed to `serverBundleCachePath`. The old name will continue to work but will log a deprecation warning.
+1. **honeybadgerApiKey**, **sentryDsn**, **sentryTracing**, **sentryTracesSampleRate** - Deprecated and have no effect.
+   If you have any of them set, see [Error Reporting and Tracing](./error-reporting-and-tracing.md) for the new way to set up error reporting and tracing.
 1. **includeTimerPolyfills** - Renamed to `stubTimers`.
 
 ## Example Launch Files
@@ -52,13 +54,14 @@ If you have any of them set, see [Error Reporting and Tracing](./error-reporting
 ### Simple example:
 
 Create a file './node-renderer.js'
+
 ```js
 import path from 'path';
-import { reactOnRailsProNodeRenderer } from '@shakacode-tools/react-on-rails-pro-node-renderer';
+import { reactOnRailsProNodeRenderer } from 'react-on-rails-pro-node-renderer';
 
 const config = {
   // Save bundles to relative "./.node-renderer-bundles" dir of our app
-  bundlePath: path.resolve(__dirname, './.node-renderer-bundles'),
+  serverBundleCachePath: path.resolve(__dirname, './.node-renderer-bundles'),
 
   // All other values are the defaults, as described above
 };
@@ -75,7 +78,6 @@ else if (process.env.CI) {
 }
 
 reactOnRailsProNodeRenderer(config);
-
 ```
 
 And add this line to your `scripts` section of `package.json`

data/react_on_rails_pro/docs/node-renderer/troubleshooting.md

@@ -1,3 +1,5 @@
 # Node Renderer Troubleshooting
 
 - If you enabled restarts (having `allWorkersRestartInterval` and `delayBetweenIndividualWorkerRestarts`), you should set it with a high number to avoid the app from crashing because all Node renderer workers are stopped/killed.
+
+- If your app contains streamed pages that take too much time to be streamed to the client, ensure to not set the `gracefulWorkerRestartTimeout` parameter or set to a high number, so the worker is not killed while it's still serving an active request.