Wie verhindere ich, dass node.js abstürzt? try-catch funktioniert nicht

Nach meiner Erfahrung würde ein PHP-Server eine Ausnahme zum Protokoll oder zum Serverende auslösen, aber node.js stürzt einfach ab. Das Umgeben meines Codes mit einem Try-Catch funktioniert auch nicht, da alles asynchron ausgeführt wird. Ich würde gerne wissen, was alle anderen auf ihren Produktionsservern tun.

Andere Antworten sind wirklich verrückt, wie Sie in den eigenen Dokumenten von Node unter http://nodejs.org/docs/latest/api/process.html#process_event_uncaughtexception lesen können

Wenn jemand andere angegebene Antworten verwendet, lesen Sie die Knotendokumente:

Beachten Sie, dass dies uncaughtExceptionein sehr grober Mechanismus für die Ausnahmebehandlung ist und möglicherweise in Zukunft entfernt wird

PM2

Zuallererst würde ich die Installation PM2für sehr empfehlen Node.js. PM2 eignet sich hervorragend für den Umgang mit Abstürzen und die Überwachung von Node-Apps sowie für den Lastausgleich. PM2 startet die Node-App sofort, wenn sie abstürzt, aus irgendeinem Grund stoppt oder sogar wenn der Server neu gestartet wird. Wenn also eines Tages auch nach der Verwaltung unseres Codes die App abstürzt, kann PM2 sie sofort neu starten. Weitere Informationen finden Sie unter Installieren und Ausführen von PM2

Kommen wir nun zu unserer Lösung zurück, um zu verhindern, dass die App selbst abstürzt.

Nachdem ich es durchgearbeitet hatte, kam ich endlich auf das, was das Node-Dokument selbst vorschlägt:

Nicht verwenden uncaughtException, sondern domainsmit clusterverwenden. Wenn Sie verwenden uncaughtException, starten Sie Ihre Anwendung nach jeder nicht behandelten Ausnahme neu!

DOMAIN mit Cluster

Was wir tatsächlich tun, ist, eine Fehlerantwort auf die Anforderung zu senden, die den Fehler ausgelöst hat, während die anderen in ihrer normalen Zeit fertig werden und nicht mehr auf neue Anforderungen in diesem Worker warten.

Auf diese Weise geht die Domänennutzung Hand in Hand mit dem Cluster-Modul, da der Master-Prozess einen neuen Worker verzweigen kann, wenn ein Worker auf einen Fehler stößt. Sehen Sie sich den folgenden Code an, um zu verstehen, was ich meine

Durch die Verwendung Domainund die Widerstandsfähigkeit der Aufteilung unseres Programms in mehrere Arbeitsprozesse können Clusterwir angemessener reagieren und Fehler mit viel größerer Sicherheit behandeln.

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);
} 

Die DomainAbschreibung steht jedoch noch aus und wird entfernt, sobald der neue Ersatz wie in der Dokumentation des Knotens angegeben geliefert wird

Dieses Modul steht noch aus. Sobald eine Ersatz-API fertiggestellt wurde, ist dieses Modul vollständig veraltet. Benutzer, die unbedingt über die von Domains bereitgestellten Funktionen verfügen müssen, können sich vorerst darauf verlassen, sollten jedoch damit rechnen, in Zukunft auf eine andere Lösung migrieren zu müssen.

Bis der neue Ersatz nicht eingeführt wird, ist Domain with Cluster die einzig gute Lösung, die die Knotendokumentation vorschlägt.

Zum gründlichen Verständnis Domainund ClusterLesen

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

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

Vielen Dank an @Stanley Luo für die Weitergabe dieser wunderbaren ausführlichen Erklärung zu Cluster und Domains

Cluster & Domains

Ich habe diesen Code direkt unter meine erforderlichen Anweisungen und globalen Deklarationen eingefügt:

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

funktioniert bei mir. Das einzige, was ich nicht mag, ist, dass ich nicht so viele Informationen bekomme, wie ich es tun würde, wenn ich das Ding einfach abstürzen lassen würde.

Wie hier erwähnt, finden Sie error.stackeine vollständigere Fehlermeldung, z. B. die Zeilennummer, die den Fehler verursacht hat:

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

Versuchen supervisor

npm install supervisor
supervisor app.js

Oder Sie können foreverstattdessen installieren .

Dies reicht lediglich aus, um Ihren Server wiederherzustellen, wenn er abstürzt, indem Sie ihn neu starten.

forever kann innerhalb des Codes verwendet werden, um alle Prozesse, die abstürzen, ordnungsgemäß wiederherzustellen.

Die foreverDokumente enthalten solide Informationen zur programmgesteuerten Behebung / Fehlerbehandlung.

Die Verwendung von try-catch kann die nicht erfassten Fehler beheben, aber in einigen komplexen Situationen wird die Aufgabe nicht richtig ausgeführt, z. B. beim Abfangen der asynchronen Funktion. Denken Sie daran, dass in Node alle asynchronen Funktionsaufrufe einen potenziellen App-Absturz enthalten können.

Die Verwendung uncaughtExceptionist eine Problemumgehung, wird jedoch als ineffizient erkannt und wird wahrscheinlich in zukünftigen Versionen von Node entfernt. Verlassen Sie sich also nicht darauf.

Die ideale Lösung ist die Verwendung der Domain: http://nodejs.org/api/domain.html

Führen Sie die folgenden Schritte aus, um sicherzustellen, dass Ihre App funktioniert und auch Ihr Server abgestürzt ist:

1. Verwenden Sie den Knotencluster, um mehrere Prozesse pro Kern zu verzweigen. Wenn also ein Prozess gestorben ist, wird ein anderer Prozess automatisch gestartet. Überprüfen Sie heraus: http://nodejs.org/api/cluster.html

2. Verwenden Sie domain, um asynchrone Vorgänge abzufangen, anstatt try-catch oder uncaught zu verwenden. Ich sage nicht, dass Try-Catch oder Ungefangen ein schlechter Gedanke ist!

3. Verwenden Sie für immer / Supervisor, um Ihre Dienste zu überwachen

4. Fügen Sie einen Daemon hinzu, um Ihre Knoten-App auszuführen: http://upstart.ubuntu.com

hoffe das hilft!

Probieren Sie das pm2-Knotenmodul aus, es ist weit konsistent und verfügt über eine hervorragende Dokumentation. Produktionsprozessmanager für Node.js Apps mit integriertem Load Balancer. Bitte vermeiden Sie uncaughtException für dieses Problem. https://github.com/Unitech/pm2

UncaughtException ist "ein sehr grober Mechanismus" (so wahr) und Domains sind jetzt veraltet. Wir benötigen jedoch noch einen Mechanismus, um Fehler in (logischen) Domänen abzufangen. Die Bibliothek:

https://github.com/vacuumlabs/yacol

kann Ihnen dabei helfen. Mit ein wenig mehr Schreiben können Sie eine schöne Domain-Semantik rund um Ihren Code haben!

Funktioniert hervorragend beim Restifizieren:

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();
});