Control de errores globales y manejo de señales en Node.js

Creating robust applications in Node.js involves properly handling global errors and system signals. Many developers overlook global events that allow to control unexpected situations, so it is important to integrate and understand them in order to maintain the stability of the application.

Why use global events such as uncaughtException?

The event called uncaughtException allows to capture errors that are not explicitly controlled within the code. When an unexpected error is generated and it is not inside a block that can handle it, this event is fired automatically informing about the error and avoiding the uncontrolled crash of the application.

To implement it, it is only necessary to add it to the process module as follows:

process.on('uncaughtException', (error)  =>  {    console.error('An uncontrolled error was caught:', error);});

This makes it easy to identify exactly where the problem occurred and correct it quickly.

What is the benefit of using unhandledRejection?

The unhandledRejection event detects and controls rejections of promises that do not have catch events defined. This type of rejections are frequent in applications that use promises and can cause unexpected failures.

Adding this event is simple:

process.on('unhandledRejection', (reason, promise)  =>  {    console.error('Promise rejected and not handled:', reason);});

By having this control, it is possible to clearly diagnose rejections without explicit handling and maintain continuous operation of the server.

How to handle system signals for controlled shutdowns?

System signals tell the application to perform a controlled exit, an orderly shutdown that maintains the integrity of active processes. Some common signals are:

• SIGINT: Issued when control C is pressed.
• SIGTERM: Signal to terminate programs sent by external sources.

Implementing them is possible by listening to each signal and managing the shutdown:

['SIGINT', 'SIGTERM', 'SIGUSR1', 'SIGUSR2'].forEach((signal)  =>  {    process.on(signal,  ()  =>  {        console.log(`Received signal ${signal}`);        process.exit(1); // Controlled exit indicating error.     });});

This approach allows the application to terminate its processes cleanly and in a safe state when it detects shutdowns from the operating system.

I invite you to share your experience controlling global events and signals in your Node.js projects; tell me how you have solved unexpected errors or abrupt exits so far.