En el desarrollo de software, es fundamental comprender cómo funcionan los procesos internos de nuestras aplicaciones, especialmente cuando se trata de aplicaciones de Node.js. Aprender a escuchar y manejar eventos puede marcar la diferencia entre una aplicación robusta o una que falla ante la menor falta de control. Aquí podrás conocer la manera de detectar y manejar eventos importantes en tus procesos, garantizando un flujo continuo y sin interrupciones inesperadas.
¿Cómo escuchar eventos en un proceso?
La gestión de eventos en Node.js es un aspecto vital para controlar el comportamiento de nuestras aplicaciones. A continuación se describe cómo aprovechar los módulos globales y escuchar eventos sin importar requerir nada externamente.
// Detecta cuando el programa está a punto de finalizarprocess.on('exit',()=>{console.log('El proceso se ha acabado, listo.');});
Además, es posible manejar las tareas justo antes de que se cierre el programa.
process.on('beforeExit',()=>{console.log('El proceso va a terminar.');// Aquí podemos ejecutar nuestras acciones finales});
¿Qué hacer ante excepciones no gestionadas?
A menudo, al desarrollar rápidamente, puedes pasar por alto excepciones que destruyen el flujo de tu aplicación. Node.js proporciona maneras de capturarlas y manejarlas adecuadamente.
process.on('uncaughtException',(err)=>{console.error('Vaya, se nos ha olvidado capturar un error:', err);// Aquí puedes gestionar el error, por ejemplo, escribiéndolo en un archivo});
Para casos donde las promesas se rechazan sin un manejo adecuado, también existe un evento específico.
process.on('unhandledRejection',(reason, promise)=>{console.error('Rechazo no manejado en:', promise,'razón:', reason);});
¿Qué sucede con los eventos y el Event Loop?
Es importante entender cómo funcionan los eventos en relación con el Event Loop, especialmente al desconectarse de este durante el proceso de salida.
setTimeout(()=>{console.log('Esto no se verá si se desconecta antes.');},0);process.on('exit',()=>{// Una vez se ejecuta 'exit', se desconecta del Event Loop});
En cambio, si se establecen temporizadores fuera del momento de desconexión, sí se ejecutarán.
setTimeout(()=>{console.log('Esto se verá si no ha existido ninguna desconexión del Event Loop.');},0);
¿Por qué es importante gestionar correctamente los procesos?
Gestionar de manera adecuada los eventos y excepciones permite que nuestras aplicaciones se mantengan estables y seguras. Además, un manejo adecuado te permitirá:
Monitorizar en producción: Detectar errores antes de que afecten al usuario final.
Garantizar la estabilidad: Reducir las interrupciones inesperadas en los servicios.
Tomar acciones preventivas: Como escribir registros de errores o enviar alertas.
Es fundamental aprovechar el módulo process de Node.js, que ya viene integrado de manera global, sin necesidad de importar nada adicional. Este conocimiento fortalecerá tus aplicaciones y las preparará para situaciones imprevistas.
¡Continúa aprendiendo y profundizando en las capacidades avanzadas de manejo de procesos! 🌟
En el desarrollo de software, es fundamental comprender cómo funcionan los procesos internos de nuestras aplicaciones, especialmente cuando se trata de aplicaciones de Node.js. Aprender a escuchar y manejar eventos puede marcar la diferencia entre una aplicación robusta o una que falla ante la menor falta de control. Aquí podrás conocer la manera de detectar y manejar eventos importantes en tus procesos, garantizando un flujo continuo y sin interrupciones inesperadas.
¿Cómo escuchar eventos en un proceso?
La gestión de eventos en Node.js es un aspecto vital para controlar el comportamiento de nuestras aplicaciones. A continuación se describe cómo aprovechar los módulos globales y escuchar eventos sin importar requerir nada externamente.
// Detecta cuando el programa está a punto de finalizar
process.on('exit', () => {
console.log('El proceso se ha acabado, listo.');
});
Además, es posible manejar las tareas justo antes de que se cierre el programa.
process.on('beforeExit', () => {
console.log('El proceso va a terminar.');
// Aquí podemos ejecutar nuestras acciones finales
});
¿Qué hacer ante excepciones no gestionadas?
A menudo, al desarrollar rápidamente, puedes pasar por alto excepciones que destruyen el flujo de tu aplicación. Node.js proporciona maneras de capturarlas y manejarlas adecuadamente.
process.on('uncaughtException', (err) => {
console.error('Vaya, se nos ha olvidado capturar un error:', err);
// Aquí puedes gestionar el error, por ejemplo, escribiéndolo en un archivo
});
Para casos donde las promesas se rechazan sin un manejo adecuado, también existe un evento específico.
Es importante entender cómo funcionan los eventos en relación con el Event Loop, especialmente al desconectarse de este durante el proceso de salida.
setTimeout(() => {
console.log('Esto no se verá si se desconecta antes.');
}, 0);
process.on('exit', () => {
// Una vez se ejecuta 'exit', se desconecta del Event Loop
});
En cambio, si se establecen temporizadores fuera del momento de desconexión, sí se ejecutarán.
setTimeout(() => {
console.log('Esto se verá si no ha existido ninguna desconexión del Event Loop.');
}, 0);
¿Por qué es importante gestionar correctamente los procesos?
Gestionar de manera adecuada los eventos y excepciones permite que nuestras aplicaciones se mantengan estables y seguras. Además, un manejo adecuado te permitirá:
Monitorizar en producción: Detectar errores antes de que afecten al usuario final.
Garantizar la estabilidad: Reducir las interrupciones inesperadas en los servicios.
Tomar acciones preventivas: Como escribir registros de errores o enviar alertas.
Es fundamental aprovechar el módulo process de Node.js, que ya viene integrado de manera global, sin necesidad de importar nada adicional. Este conocimiento fortalecerá tus aplicaciones y las preparará para situaciones imprevistas.
¡Continúa aprendiendo y profundizando en las capacidades avanzadas de manejo de procesos! 🌟
El objecto process es una instancia de EventEmitter; podemos suscribirnos a el para escuchar eventos de node.
UncaughtException: Permite capturar cualquier error que no fue caputurado previamente. Esto evita que Node cierre todos los hijos al encontrar un error no manejado.
Algo muy interesante que también se puede hacer con process es tomar argumentos que le pases al ejecutar el programa. Por ejemplo si ejecutás:
node process.js "Patricio Manuel" Ugarte 27
Al invocar en mi código a process.argv, este almacenará un array cuyo dos primeros valores siempre serán:
La ruta absoluta donde está instalado Node en tu sistema.
La ruta absoluta del archivo que estamos ejecutando con Node.
Y el resto de los índices se irán ocupando con los valores que le pasamos en orden. En el ejemplo que di serían:
"Patricio Manuel"
"Ugarte"
"27"
Nótese que usé comillas (dobles o simples es lo mismo) para indicar que el espacio entre mi primer nombre y mi segundo nombre forma parte de un único argumento, si no me los hubiera tomado como dos distintos. Y que el número también lo considerará como un String (Algo que podemos solucionar facilmente con un .parseInt()).
Para luego acceder a en nuestro código a los valores que les pasamos podemos hacer:
Donde estoy aprovechando el Array Matching de ES6 para guardar los datos que me interesan del Array process.argv en variables, para usar esos valores en mi código.
Para leer más sobre el módulo global process recomiendo la Documentación Oficial de NodeJS.
Experimentando en el código para entender la diferencia entre los eventos exit y beforeExit, descubrí algo que me pareció interesante.
Como bien dice el profe Carlos, exit cierra el Hilo Principal, y las funciones asíncronas que integremos, no se ejecutaran:
process.on('exit', () => {
console.log("El Proceso acabó")
setTimeout(() => {
console.log("Esto no debe de verse, ya que ocurriría después de que el programa se cerró")
}, 2000)
})
Este console.log no va a ejecutarse
Pero con beforeExit es una historia muy diferente:
let x = -1
process.on(‘beforeExit’, () => {
setTimeout(() => {
if(x) {
console.log(“El Proceso va a terminar”)
console.log(“Esta funcion asíncrona se va a repetir…”)
x++
} else {
console.log(“Y repetir…”)
}
}, 2000)
})
beforeExit ++no cierra++ el Hilo Principal, por lo que al detectar el evento y ejecutar la función asíncrona, el final del Hilo Principal se va a “posponer” para darle tiempo de concluir la función en el Thread Pool. Esto provocará que el evento beforeEnd se dispare nuevamente, haciendo que la función asíncrona se ejecute otra vez…y ciclando la aplicación.
El Proceso va a terminar
Esta funcion asíncrona se va a repetir...
Y repetir...
Y repetir...
Y repetir...
Y repetir...
//no se hace, ya que process pertenece los modulos globales, que ya vienen con node
//const process = require('process');
//el proceso esta por terminar
process.on('beforeExit', () => {
console.log('El proceso ya casito termina');
})
//el proceso ha terminado
//console.log(process.on('uncaughtException'));
process.on('uncaughtRejection', (err, origen) => {
console.error('se nos olvido captura el error');
console.error(err);
});
//funcionQueNoExiste();
console.log('esto no sale')
process.on('exit', () => {
console.log('El proceso termino');
setTimeout(() => {
console.log('este mensaje es invisible');
}, 500);
})
setTimeout(() => {
console.log('este mensaje es totalmente visible');
}, 500);
El evento exit se activa cuando el proceso está a punto de salir.
process.on ('exit', function () {
console.log('Ultimo llamado antes de terminar el proceso')
});
Exit puede ser util para guardar algún tipo de informe final antes de salir. Tendrán que ejecutarse procesos sincronos pues cualquier proceso asincrono no sera ejecutado.
El otro evento incorporado se llama uncaughException - se dispara cada vez que se produce una excepción que no se ha considerado. No es la forma ideal de manejar errores, pero puede ser muy útil como última línea de defensa si un programa necesita mantenerse en funcionamiento indefinidamente.
process.on ('uncaughtException', function (err) {
console.error ('¡Se produjo un error no considerado!');
console.error (err.stack);
});
Finalmente, el evento beforeExit se emite cuando Node.js vacía su ciclo y no tiene trabajo adicional que programar. Este evento si puede hacer llamadas asincronas puesto que genera que el proceso de Node.Js continue hasta terminar el nuevo evento.
//const process = require('process')
process.on('beforeExit', () =>{
console.log('Ey !! El proceso esta a punto de acabar')
})
process.on('exit', () =>{
console.log('El proceso acabo')
})
process.on('uncaughtException', (err) =>{
console.log(`Ocurio un error: ${err.message}`)
})
//functionQueDaError()
Les dejo mi versión de la clase en donde además de manejar el uncaughtException, agrego ejemplo para unhandledRejection, además de manejar intencionalmente distintos tipos de declaración en las funciones, declarativas, anónimas y de flecha.
// const proc = require('process');
// Previous line commented because process is a global included into node core
// As arrow function
process.on('beforeExit', () => {
console.log('Exiting...');
});
// As anonymous function
process.on('exit', function () {
console.log('Program terminated');
});
// ------------------------- EXCEPTION STUFF ----------------------------------
// Function declaration, as anonymous function
const exceptionCatcher = function (error, origin) {
console.error('Personalized error: ', error);
console.error('Origin: ', origin);
};
// Event handler pointing to exception catcher
process.on('uncaughtException', exceptionCatcher);
// * COMMENT NEXT LINE TO SEE UNHANDLED PROMISE BEHAVIOR
ghostFunction(); // To provoque the uncaught exception, which ends the process
// * COMMENT PREVIOUS LINE TO SEE UNHANDLED PROMISE BEHAVIOR
console.log('This info is unaccesible if the exception was caught :D');
// --------------------------- PROMISE STUFF ----------------------------------
// Function declaration, as arrow function
const rejectionCatcher = (error, origin) => {
console.error('Personalized error: ', error);
console.error('Origin: ', origin);
};
// Event handler pointing to rejection catcher
process.on('unhandledRejection', rejectionCatcher);
function somePromiseFunction() {
return new Promise((resolve, reject) => {
if (false) resolve('Everything was OK');
else reject('Nothing was OK');
});
};
somePromiseFunction();
console.log('This info is accesible even if the rejection was caught :D');