¿Cómo evito que se bloquee node.js? try-catch no funciona

Desde mi experiencia, un servidor php lanzaría una excepción al registro o al final del servidor, pero node.js simplemente se bloquea. Rodear mi código con un try-catch tampoco funciona ya que todo se hace de forma asincrónica. Me gustaría saber qué hacen los demás en sus servidores de producción.

Otras respuestas son realmente una locura, ya que puede leer los documentos de Node en http://nodejs.org/docs/latest/api/process.html#process_event_uncaughtexception

Si alguien está usando otras respuestas declaradas, lea Node Docs:

Tenga en cuenta que uncaughtExceptiones un mecanismo muy burdo para el manejo de excepciones y puede eliminarse en el futuro

PM2

En primer lugar, recomendaría encarecidamente la instalación PM2de Node.js. PM2 es realmente excelente para manejar fallas y monitorear aplicaciones de Nodo, así como el equilibrio de carga. PM2 inicia inmediatamente la aplicación Node cada vez que se bloquea, se detiene por cualquier motivo o incluso cuando el servidor se reinicia. Entonces, si algún día, incluso después de administrar nuestro código, la aplicación se bloquea, PM2 puede reiniciarlo de inmediato. Para más información, Instalación y ejecución de PM2

Ahora volviendo a nuestra solución para evitar que la aplicación se bloquee.

Entonces, después de pasar, finalmente se me ocurrió lo que sugiere el documento Node:

No use uncaughtException, use domainscon en su clusterlugar. Si lo usa uncaughtException, reinicie su aplicación después de cada excepción no controlada.

DOMINIO con Cluster

Lo que realmente hacemos es enviar una respuesta de error a la solicitud que activó el error, al tiempo que permite que los demás finalicen en su tiempo normal y dejen de escuchar nuevas solicitudes en ese trabajador.

De esta manera, el uso del dominio va de la mano con el módulo de clúster, ya que el proceso maestro puede bifurcar a un nuevo trabajador cuando un trabajador encuentra un error. Vea el código a continuación para entender a qué me refiero

Al usar Domain, y la resistencia de separar nuestro programa en múltiples procesos de trabajo Cluster, podemos reaccionar de manera más apropiada y manejar los errores con mucha mayor seguridad.

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

Aunque Domainestá pendiente de desaprobación y se eliminará a medida que el nuevo reemplazo llegue como se indica en la documentación del nodo

Este módulo está pendiente de desuso. Una vez que se haya finalizado una API de reemplazo, este módulo quedará totalmente en desuso. Los usuarios que deben tener absolutamente la funcionalidad que proporcionan los dominios pueden confiar en ella por el momento, pero deben esperar migrar a una solución diferente en el futuro.

Pero hasta que no se introduzca el nuevo reemplazo, Domain with Cluster es la única buena solución que sugiere Node Documentation.

Para una comprensión profunda Domainy Clusterlectura

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

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

Gracias a @Stanley Luo por compartir esta maravillosa explicación detallada sobre Cluster y Dominios.

Cluster y Dominios

Puse este código justo debajo de mis declaraciones obligatorias y declaraciones globales:

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

funciona para mi. Lo único que no me gusta es que no obtengo tanta información como si solo dejara que la cosa se estrellara.

Como se menciona aquí , encontrará error.stackun mensaje de error más completo, como el número de línea que causó el error:

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

Tratar supervisor

npm install supervisor
supervisor app.js

O puede instalar en su foreverlugar.

Todo esto hará que recuperes tu servidor cuando se bloquea reiniciando.

forever se puede usar dentro del código para recuperar con gracia cualquier proceso que se bloquee.

Los foreverdocumentos tienen información sólida sobre el manejo de salida / error mediante programación.

El uso de try-catch puede resolver los errores no detectados, pero en algunas situaciones complejas, no funcionará correctamente, como atrapar la función asincrónica. Recuerde que en Node, cualquier llamada a la función asíncrona puede contener una posible operación de bloqueo de la aplicación.

El uso uncaughtExceptiones una solución alternativa, pero se reconoce que es ineficiente y es probable que se elimine en futuras versiones de Node, así que no cuente con ello.

La solución ideal es usar el dominio: http://nodejs.org/api/domain.html

Para asegurarse de que su aplicación esté en funcionamiento incluso si su servidor se ha bloqueado, siga estos pasos:

1. use el clúster de nodo para bifurcar múltiples procesos por núcleo. Entonces, si un proceso murió, otro proceso se iniciará automáticamente. Echa un vistazo: http://nodejs.org/api/cluster.html

2. use el dominio para capturar la operación asincrónica en lugar de usar try-catch o no capturado. ¡No digo que try-catch o no atrapado sea un mal pensamiento!

3. use forever / supervisor para monitorear sus servicios

4. agregue daemon para ejecutar su aplicación de nodo: http://upstart.ubuntu.com

¡espero que esto ayude!

Intente con el módulo de nodo pm2, es muy consistente y tiene una excelente documentación. Administrador de procesos de producción para aplicaciones Node.js con un equilibrador de carga incorporado. evite la excepción no capturada para este problema. https://github.com/Unitech/pm2

UncaughtException es "un mecanismo muy burdo" (tan cierto) y los dominios están en desuso ahora. Sin embargo, todavía necesitamos algún mecanismo para detectar errores en los dominios (lógicos). La biblioteca:

https://github.com/vacuumlabs/yacol

puede ayudarte a hacer esto. ¡Con un poco de escritura adicional puede tener una buena semántica de dominio alrededor de su código!

Funciona muy bien en 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();
});