Como evito que o node.js falhe? try-catch não funciona

Pela minha experiência, um servidor php lançaria uma exceção no log ou no final do servidor, mas o node.js simplesmente trava. Cercar meu código com um try-catch também não funciona, pois tudo é feito de forma assíncrona. Gostaria de saber o que todos os outros fazem em seus servidores de produção.

Outras respostas são realmente insanas, como você pode ler nos próprios documentos do Node em http://nodejs.org/docs/latest/api/process.html#process_event_uncaughtexception

Se alguém estiver usando outras respostas indicadas, leia Node Docs:

Observe que esse uncaughtExceptioné um mecanismo muito bruto para manipulação de exceções e pode ser removido no futuro

PM2

Primeiro de tudo, eu recomendo a instalação PM2para Node.js. O PM2 é realmente ótimo no tratamento de falhas e no monitoramento de aplicativos do Nó, bem como no balanceamento de carga. O PM2 inicia imediatamente o aplicativo Node sempre que ele falha, para por qualquer motivo ou mesmo quando o servidor é reiniciado. Portanto, se algum dia, mesmo depois de gerenciar nosso código, o aplicativo travar, o PM2 poderá reiniciá-lo imediatamente. Para obter mais informações, Instalando e executando o PM2

Agora voltando à nossa solução para impedir que o próprio aplicativo falhe.

Então, depois de prosseguir, finalmente cheguei ao que o próprio documento do Node sugere:

Não use uncaughtException, use domainscom em clustervez disso. Se você usar uncaughtException, reinicie o aplicativo após cada exceção não tratada!

DOMAIN com Cluster

Na verdade, o que fazemos é enviar uma resposta de erro à solicitação que acionou o erro, enquanto os outros terminam no horário normal e parar de ouvir novas solicitações nesse trabalhador.

Dessa maneira, o uso do domínio anda de mãos dadas com o módulo de cluster, pois o processo mestre pode bifurcar um novo trabalhador quando um trabalhador encontra um erro. Veja o código abaixo para entender o que quero dizer

Ao usar Domaine a resiliência de separar nosso programa em vários processos de trabalho Cluster, podemos reagir de maneira mais apropriada e lidar com erros com muito mais segurança.

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

Embora Domainesteja pendente de descontinuação e será removido quando a nova substituição ocorrer, conforme declarado na Documentação do Node

Este módulo está com suspensão pendente. Depois que uma API de substituição for finalizada, este módulo será totalmente descontinuado. Os usuários que absolutamente precisam ter a funcionalidade que os domínios fornecem podem depender dela por enquanto, mas devem esperar migrar para uma solução diferente no futuro.

Mas até que a nova substituição não seja introduzida, o Domínio com Cluster é a única boa solução sugerida pela Documentação do Nó.

Para uma compreensão aprofundada Domaine Clusterleitura

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

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

Agradecemos a Stanley Luo por nos compartilhar esta maravilhosa explicação detalhada sobre cluster e domínios

Cluster e domínios

Coloquei esse código diretamente nas minhas declarações de solicitação e declarações globais:

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

funciona para mim. a única coisa que eu não gosto é que não recebo tanta informação quanto gostaria se deixasse a coisa falhar.

Conforme mencionado aqui, você encontrará error.stackuma mensagem de erro mais completa, como o número da linha que causou o erro:

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

Experimentar supervisor

npm install supervisor
supervisor app.js

Ou você pode instalar em seu foreverlugar.

Tudo o que isso fará é recuperar o servidor quando ele travar, reiniciando-o.

forever pode ser usado dentro do código para recuperar normalmente qualquer processo que trava.

Os foreverdocumentos têm informações sólidas sobre tratamento de saída / erro programaticamente.

O uso do try-catch pode resolver os erros não detectados, mas em algumas situações complexas, ele não funciona corretamente, como capturar a função assíncrona. Lembre-se de que no Node, qualquer chamada de função assíncrona pode conter uma operação potencial de falha de aplicativo.

O uso uncaughtExceptioné uma solução alternativa, mas é reconhecido como ineficiente e provavelmente será removido nas versões futuras do Node, portanto, não conte com isso.

A solução ideal é usar o domínio: http://nodejs.org/api/domain.html

Para garantir que seu aplicativo esteja em funcionamento, mesmo que o servidor tenha travado, use as seguintes etapas:

1. use o cluster de nós para dividir vários processos por núcleo. Portanto, se um processo morreu, outro processo será inicializado automaticamente. Confira: http://nodejs.org/api/cluster.html

2. use domain para capturar operação assíncrona em vez de usar try-catch ou uncaught. Não estou dizendo que tentar pegar ou não ser um mau pensamento!

3. use forever / supervisor para monitorar seus serviços

4. adicione daemon para executar seu aplicativo de nó: http://upstart.ubuntu.com

espero que isto ajude!

Dê uma chance ao módulo do nó pm2, ele é muito consistente e possui ótima documentação. Gerente de processo de produção para aplicativos Node.js. com um balanceador de carga interno. evite uncaughtException para esse problema. https://github.com/Unitech/pm2

UncaughtException é "um mecanismo muito bruto" (tão verdadeiro) e os domínios estão obsoletos agora. No entanto, ainda precisamos de algum mecanismo para detectar erros em domínios (lógicos). A biblioteca:

https://github.com/vacuumlabs/yacol

pode ajudá-lo a fazer isso. Com um pouco de escrita extra, você pode ter boas semânticas de domínio em todo o seu código!

Funciona muito bem em 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();
});