Come evitare l'arresto anomalo di node.js? try-catch non funziona

Dalla mia esperienza, un server php genererebbe un'eccezione al registro o alla fine del server, ma node.js semplicemente si blocca. Circondare il mio codice con un try-catch non funziona neanche dal momento che tutto viene fatto in modo asincrono. Vorrei sapere cosa fanno gli altri nei loro server di produzione.

Altre risposte sono davvero pazze, come puoi leggere nei documenti di Node su http://nodejs.org/docs/latest/api/process.html#process_event_uncaughtexception

Se qualcuno utilizza altre risposte dichiarate leggi Node Docs:

Si noti che uncaughtExceptionè un meccanismo molto grezzo per la gestione delle eccezioni e potrebbe essere rimosso in futuro

PM2

Prima di tutto, consiglio vivamente l'installazione PM2per Node.js. PM2 è davvero eccezionale nella gestione degli arresti anomali e nel monitoraggio delle app Node nonché nel bilanciamento del carico. PM2 avvia immediatamente l'app Node ogni volta che si arresta in modo anomalo, si arresta per qualsiasi motivo o anche al riavvio del server. Quindi, se un giorno anche dopo aver gestito il nostro codice, l'app si blocca, PM2 può riavviarlo immediatamente. Per ulteriori informazioni, Installazione ed esecuzione di PM2

Ora torniamo alla nostra soluzione per evitare che l'app stessa si blocchi.

Quindi, dopo averlo esaminato, ho finalmente trovato quello che il documento Node stesso suggerisce:

Non utilizzare uncaughtException, utilizzare domainscon clusterinvece. Se lo usi uncaughtException, riavvia l'applicazione dopo ogni eccezione non gestita!

DOMINIO con Cluster

Ciò che effettivamente facciamo è inviare una risposta di errore alla richiesta che ha provocato l'errore, lasciando che gli altri finissero il loro tempo normale e smettessero di ascoltare nuove richieste in quel lavoratore.

In questo modo, l'utilizzo del dominio va di pari passo con il modulo cluster, poiché il processo principale può eseguire il fork di un nuovo lavoratore quando un lavoratore rileva un errore. Vedi il codice qui sotto per capire cosa intendo

Utilizzando Domaine la resilienza di separare il nostro programma in più processi di lavoro utilizzando Cluster, possiamo reagire in modo più appropriato e gestire gli errori con una sicurezza molto maggiore.

var cluster = require('cluster');
var PORT = +process.env.PORT || 1337;

if(cluster.isMaster) 
{
   cluster.fork();
   cluster.fork();

   cluster.on('disconnect', function(worker) 
   {
       console.error('disconnect!');
       cluster.fork();
   });
} 
else 
{
    var domain = require('domain');
    var server = require('http').createServer(function(req, res) 
    {
        var d = domain.create();
        d.on('error', function(er) 
        {
            //something unexpected occurred
            console.error('error', er.stack);
            try 
            {
               //make sure we close down within 30 seconds
               var killtimer = setTimeout(function() 
               {
                   process.exit(1);
               }, 30000);
               // But don't keep the process open just for that!
               killtimer.unref();
               //stop taking new requests.
               server.close();
               //Let the master know we're dead.  This will trigger a
               //'disconnect' in the cluster master, and then it will fork
               //a new worker.
               cluster.worker.disconnect();

               //send an error to the request that triggered the problem
               res.statusCode = 500;
               res.setHeader('content-type', 'text/plain');
               res.end('Oops, there was a problem!\n');
           } 
           catch (er2) 
           {
              //oh well, not much we can do at this point.
              console.error('Error sending 500!', er2.stack);
           }
       });
    //Because req and res were created before this domain existed,
    //we need to explicitly add them.
    d.add(req);
    d.add(res);
    //Now run the handler function in the domain.
    d.run(function() 
    {
        //You'd put your fancy application logic here.
        handleRequest(req, res);
    });
  });
  server.listen(PORT);
} 

Sebbene Domainsia in attesa di svalutazione e verrà rimosso quando la nuova sostituzione verrà fornita come indicato nella Documentazione di Node

Questo modulo è in attesa di deprecazione. Una volta finalizzata un'API sostitutiva, questo modulo sarà completamente deprecato. Gli utenti che devono assolutamente disporre delle funzionalità fornite dai domini possono fare affidamento su di esso per il momento, ma dovrebbero aspettarsi di dover migrare verso una soluzione diversa in futuro.

Ma fino a quando non verrà introdotta la nuova sostituzione, Domain with Cluster è l'unica buona soluzione suggerita dalla documentazione del nodo.

Per una comprensione Domaine una Clusterlettura approfondite

https://nodejs.org/api/domain.html#domain_domain (Stability: 0 - Deprecated)

https://nodejs.org/api/cluster.html

Grazie a @Stanley Luo per averci condiviso questa meravigliosa spiegazione approfondita su Cluster e Domini

Cluster e domini

Ho inserito questo codice nelle mie dichiarazioni obbligatorie e dichiarazioni globali:

process.on('uncaughtException', function (err) {
  console.error(err);
  console.log("Node NOT Exiting...");
});

per me va bene. l'unica cosa che non mi piace è che non ottengo tutte le informazioni che vorrei se lasciassi andare in crash.

Come accennato qui troverai error.stackun messaggio di errore più completo come il numero di riga che ha causato l'errore:

process.on('uncaughtException', function (error) {
   console.log(error.stack);
});

Provare supervisor

npm install supervisor
supervisor app.js

Oppure puoi installare foreverinvece.

Tutto ciò che farà è ripristinare il server quando si arresta in modo anomalo riavviandolo.

forever può essere utilizzato all'interno del codice per ripristinare con grazia tutti i processi che si arrestano in modo anomalo.

I foreverdocumenti hanno solide informazioni sulla gestione dell'uscita / errore a livello di codice.

L'uso di try-catch può risolvere gli errori non rilevati, ma in alcune situazioni complesse, non farà il lavoro giusto come la cattura della funzione asincrona. Ricorda che in Nodo, qualsiasi chiamata di funzione asincrona può contenere una potenziale operazione di arresto anomalo dell'app.

L'uso uncaughtExceptionè una soluzione alternativa ma è riconosciuto come inefficiente e probabilmente verrà rimosso nelle future versioni di Node, quindi non contare su di esso.

La soluzione ideale è utilizzare il dominio: http://nodejs.org/api/domain.html

Per assicurarti che l'app sia attiva e funzionante anche il tuo server si è bloccato, procedi nel seguente modo:

1. utilizzare il cluster di nodi per fork più processi per core. Quindi, se un processo è morto, un altro processo verrà avviato automaticamente. Scopri: http://nodejs.org/api/cluster.html

2. usa il dominio per catturare l'operazione asincrona invece di usare try-catch o non rilevati. Non sto dicendo che provare a catturare o non catturato sia una cattiva idea!

3. usa per sempre / supervisore per monitorare i tuoi servizi

4. aggiungi demone per eseguire l'app nodo: http://upstart.ubuntu.com

spero che questo ti aiuti!

Provare il modulo nodo pm2 è molto coerente e ha un'ottima documentazione. Gestione dei processi di produzione per le app Node.js con un bilanciamento del carico integrato. si prega di evitare uncaughtException per questo problema. https://github.com/Unitech/pm2

UncaughtException è "un meccanismo molto grezzo" (così vero) e i domini ora sono deprecati. Tuttavia, abbiamo ancora bisogno di un meccanismo per rilevare errori nei domini (logici). La Biblioteca:

https://github.com/vacuumlabs/yacol

può aiutarti a farlo. Con un po 'di scrittura extra puoi avere una buona semantica del dominio su tutto il tuo codice!

Funziona alla grande su restify:

server.on('uncaughtException', function (req, res, route, err) {
  log.info('******* Begin Error *******\n%s\n*******\n%s\n******* End Error *******', route, err.stack);
  if (!res.headersSent) {
    return res.send(500, {ok: false});
  }
  res.write('\n');
  res.end();
});