Comment éviter que node.js ne plante? try-catch ne fonctionne pas

D'après mon expérience, un serveur php lèverait une exception au journal ou à la fin du serveur, mais node.js se bloque simplement. Entourer mon code d'un try-catch ne fonctionne pas non plus puisque tout est fait de manière asynchrone. J'aimerais savoir ce que font les autres sur leurs serveurs de production.

D'autres réponses sont vraiment insensées, comme vous pouvez les lire dans les propres documents de Node à http://nodejs.org/docs/latest/api/process.html#process_event_uncaughtexception

Si quelqu'un utilise d'autres réponses énoncées, lisez Node Docs:

Notez qu'il uncaughtExceptions'agit d'un mécanisme très grossier pour la gestion des exceptions et peut être supprimé à l'avenir

PM2

Tout d'abord, je recommande fortement l'installation PM2pour Node.js. PM2 est vraiment excellent pour gérer les plantages et surveiller les applications Node ainsi que pour l'équilibrage de charge. PM2 démarre immédiatement l'application Node chaque fois qu'elle se bloque, s'arrête pour une raison quelconque ou même lorsque le serveur redémarre. Ainsi, si un jour, même après avoir géré notre code, l'application tombe en panne, PM2 peut la redémarrer immédiatement. Pour plus d'informations, Installer et exécuter PM2

Revenons maintenant à notre solution pour empêcher l'application elle-même de planter.

Donc, après avoir parcouru, j'ai finalement trouvé ce que le document Node lui-même suggère:

Ne pas utiliser uncaughtException, utiliser domainsavec à la clusterplace. Si vous utilisez uncaughtException, redémarrez votre application après chaque exception non gérée!

DOMAIN avec cluster

En fait, nous envoyons une réponse d'erreur à la demande qui a déclenché l'erreur, tout en laissant les autres terminer dans leur temps normal et en arrêtant d'écouter les nouvelles demandes de ce worker.

De cette manière, l'utilisation du domaine va de pair avec le module de cluster, puisque le processus maître peut créer un fork d'un nouveau worker lorsqu'un worker rencontre une erreur. Voir le code ci-dessous pour comprendre ce que je veux dire

Grâce à l'utilisation Domainet à la résilience de la séparation de notre programme en plusieurs processus de travail Cluster, nous pouvons réagir de manière plus appropriée et gérer les erreurs avec une sécurité beaucoup plus grande.

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

Bien qu'il Domainsoit en attente de dépréciation et sera supprimé car le nouveau remplacement arrive comme indiqué dans la documentation de Node

Ce module est en attente de dépréciation. Une fois qu'une API de remplacement a été finalisée, ce module sera complètement obsolète. Les utilisateurs qui doivent absolument disposer des fonctionnalités fournies par les domaines peuvent s'y fier pour le moment, mais devraient s'attendre à devoir migrer vers une solution différente à l'avenir.

Mais jusqu'à ce que le nouveau remplacement ne soit pas introduit, Domain with Cluster est la seule bonne solution ce que suggère Node Documentation.

Pour une compréhension Domainet une Clusterlecture approfondies

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

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

Merci à @Stanley Luo pour nous avoir partagé cette merveilleuse explication approfondie sur les clusters et les domaines

Cluster et domaines

J'ai mis ce code juste sous mes instructions require et déclarations globales:

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

travaille pour moi. la seule chose que je n'aime pas à ce sujet, c'est que je ne reçois pas autant d'informations que si je laissais simplement la chose planter.

Comme mentionné ici, vous trouverez error.stackun message d'erreur plus complet tel que le numéro de ligne à l'origine de l'erreur:

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

Essayer supervisor

npm install supervisor
supervisor app.js

Ou vous pouvez installer à la foreverplace.

Tout cela va faire est de récupérer votre serveur lorsqu'il plante en le redémarrant.

forever peut être utilisé dans le code pour récupérer gracieusement tout processus qui plante.

Les foreverdocuments contiennent des informations solides sur la gestion des sorties / erreurs par programme.

L'utilisation de try-catch peut résoudre les erreurs non interceptées, mais dans certaines situations complexes, cela ne fonctionnera pas correctement, comme la fonction de capture asynchrone. N'oubliez pas que dans Node, tout appel de fonction asynchrone peut contenir une opération de plantage d'application potentielle.

L'utilisation uncaughtExceptionest une solution de contournement, mais elle est reconnue comme inefficace et sera probablement supprimée dans les futures versions de Node, alors ne comptez pas dessus.

La solution idéale est d'utiliser le domaine: http://nodejs.org/api/domain.html

Pour vous assurer que votre application est opérationnelle même si votre serveur est en panne, procédez comme suit:

1. utilisez le cluster de nœuds pour créer plusieurs processus par cœur. Donc, si un processus meurt, un autre processus démarre automatiquement. Consultez: http://nodejs.org/api/cluster.html

2. utilisez domain pour intercepter l'opération asynchrone au lieu d'utiliser try-catch ou uncaught. Je ne dis pas qu'essayer ou non est une mauvaise pensée!

3. utilisez forever / supervisor pour surveiller vos services

4. ajoutez un démon pour exécuter votre application de nœud: http://upstart.ubuntu.com

J'espère que cela t'aides!

Essayez le module de nœud pm2, il est de loin cohérent et a une excellente documentation. Gestionnaire de processus de production pour les applications Node.js avec un équilibreur de charge intégré. veuillez éviter uncaughtException pour ce problème. https://github.com/Unitech/pm2

UncaughtException est "un mécanisme très grossier" (donc vrai) et les domaines sont désormais obsolètes. Cependant, nous avons encore besoin d'un mécanisme pour détecter les erreurs autour des domaines (logiques). La bibliothèque:

https://github.com/vacuumlabs/yacol

peut vous aider à le faire. Avec un peu d'écriture supplémentaire, vous pouvez avoir une belle sémantique de domaine tout autour de votre code!

Fonctionne très bien sur 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();
});