To ensure the persistence of this information even during server process crashes, it is necessary to save it in a way that survives such incidents. The typical method of achieving this is by storing the data in a persistent store, often on a disk drive.

From an architectural standpoint, there are two primary approaches you can take:

1. Maintain your current architecture but incorporate a "save to disk" mechanism whenever the proxies' state is altered (added, removed, or modified). This involves saving the entire current state of routes to disk each time a change occurs. To implement this, introduce a new RAM-based data structure to hold the current state of all created routes. While you could attempt to read this from Express, it may be more beneficial to manage your own data structure, granting you control over which attributes are saved. By saving the state with every alteration, the most you risk losing is the operation that was being processed for saving at the moment. Ensure adequate concurrency protection in the save operation to prevent conflicts between simultaneous saves - this is a relatively straightforward task.

2. Transition to a database-centric design where each modification triggers the writing of that particular change to a database equipped with a persistent store. Upon server restarts, retrieving the state from the database allows you to recreate the pre-restart status.

While a database solution typically offers better scalability, simply writing the whole state to disk after each change is usually simpler (avoiding the need for a database) - employing JSON file format might be the easiest option. Both methods can function effectively within a certain scale limit, beyond which the database approach becomes preferable (in terms of changes per second or total proxy count).

Storing these in a database and then retrieving them individually doesn't seem efficient for potentially handling thousands of uniquely generated proxies.

Consider reframing this perspective: a database setup is likely the more scalable choice for managing a large number of proxies, although dealing with thousands shouldn't pose a significant challenge using either of the mentioned techniques.

The newly created routes are stored in the app variable (app._router). Is it possible to pull routes from another source like Redis or MongoDB?

If I were handling this scenario, I would personally persist the data to a permanent storage repository each time a new proxy is added, removed, or updated, without overly relying on Express for tracking purposes.

Is there a way to ensure the continuity of routing information?

Express lacks built-in features for automatic route persistence. It's assumed in the express framework that the startup code or subsequent operations will cater to creating the required route handlers, leaving room for manual intervention in preserving this info.

Do any node management tools (PM2, forever, supervisor, etc.) safeguard against or recover from such issues?

To my knowledge, such tools mainly focus on process management rather than maintaining internal states within processes.

Is there an optimal alternative solution? Any advice would be highly appreciated.

Saving the data independently and restoring the state from the persisted storage upon server initialization, as outlined in the aforementioned strategies, appears to be a prudent course of action.

Here's a practical example of the first approach described above, illustrating the practice of saving data post every modification and reloading the stored state during server boot-up:

const app = require('express')();
const proxy = require('express-http-proxy');
const vhost = require('vhost');
const Promise = require('bluebird');
const fs = Promise.promisify(require('fs'));

let proxyData = [];
readProxyData();

app.get('/create', function(req, res){
    app.use(vhost('subdomain.mysite.com', proxy('http://example.com')));

    // save proxy data
    proxyData.push({subDomain: 'subdomain.mysite.com', userDomain: 'http://example.com'})
    saveProxyData();

    res.send('Created');
});

app.listen(8080);

// invoked whenever a new proxy is added 
// (after updating proxyData with proxy details)
function saveProxyData() {
     // leverage promises to sequence successive saves
     proxyData.promise = proxyData.promise.then(function() {
         return fs.writeFileAsync("proxyState.json", JSON.stringify(proxyData));
     }).catch(function(err) {
         console.err(err);
         return;
     });
}

// called only during server start
function readProxyData() {
    try {
        proxyData = require("proxyState.json");
    } catch(err) {
         console.err("Error reading proxyState.json - proceeding with no saved state: ", err);
    }
    proxyData.promise = Promise.resolve();

    // reinstate previous proxies stored in proxyData
    proxyData.forEach(function(item) {
        app.use(vhost(item.subDomain, proxy(item.userDomain)));
    });
}

One solution is to handle unhandled errors or exceptions in your code. By using the process and uncaughtException methods, you can ensure that your application does not exit unexpectedly when an error occurs.

process.on('uncaughtException', function (err) {
  console.log('Caught exception: ' + err);
});

When a process comes to an end, any information stored in its temporary memory is erased. To prevent data loss, it's recommended to save that data into a more durable system like a database or file storage as soon as it's captured by your server.

Recently, I developed a convenient npm package called cashola to simplify this task.

Here's how you can implement the same functionality using cashola:

var cashola = require('cashola');
var app = require('express')();
var proxy = require('express-http-proxy');
var vhost = require('vhost');

var state = cashola.rememberArraySync('state');

for (const item of state) {
    app.use(vhost(item.domain, proxy(item.proxy)));
}

app.get('/create', function(req, res){
    const vhostDomain = 'subdomain.mysite.com';
    const proxyDomain = 'http://example.com';
    state.push({ domain: vhostDomain, proxy: proxyDomain });
    app.use(vhost(vhostDomain, proxy(proxyDomain)));
    res.send('Created');
});

app.listen(8080);