unhandledRejection or uncaughtException in node.js

[razb-viola]

In Node.js docs they say that if we have such an errors, we should cleanup and let the server exit gracefully.

The correct use of 'uncaughtException' is to perform synchronous cleanup of allocated resources (e.g. file descriptors, handles, etc) before shutting down the process.

What does it mean, and, why?
Let me be more specific:

If we have an Express node.js app listening for requests, and request 1 got unchaughtException or unhandledRejection error, should we shut down the whole server gracefully (closing Express server and receive no more requests, disconnect from databases, etc)?

If yes, I don't understand how it will help with the problem that request 1 got into an issue.. And why should we stop other requests from coming in?

If for example we install a dependency that has this code (in purpose or not):

setTimeout(() => throw new Error('oops'))

It will make a denial of service to our app.. since it will always has to shut down due to it..

And also, this won't stop from the request that initiated this bad code to keep on running, unless we force an exit - but this will drop all of the other requests in the middle.

Could someone please provide more specific example or instruction of what "is to perform synchronous cleanup of allocated resources" as Node.js docs states?

[fifixc]

Handling Uncaught Exceptions:

When an uncaught exception occurs in your Node.js application, it typically indicates a critical error that was not properly handled by your code. Examples of such errors include programming mistakes, unexpected runtime issues, or resource exhaustion.

In an Express.js application, if an uncaught exception occurs during the handling of a request, it could potentially leave the application in an inconsistent state. This could lead to data corruption, resource leaks, or other undesirable outcomes.

The purpose of handling uncaught exceptions is not necessarily to prevent the current request from failing (since it has already failed), but rather to ensure that the application gracefully handles the error and cleans up any allocated resources before shutting down.

By performing synchronous cleanup of allocated resources, you can mitigate the impact of the error on other parts of the application and prevent further damage.

Shutting Down Gracefully:

When an uncaught exception occurs in an Express.js application, it's often a sign of a severe problem that may affect the stability and reliability of the entire application.

In many cases, it's preferable to shut down the entire server gracefully when an uncaught exception occurs, rather than continuing to accept new requests. This helps prevent further errors from occurring and ensures that the application does not enter an inconsistent state.

By shutting down the server gracefully, you can initiate the cleanup process, close any open connections, release any acquired resources (such as database connections or file handles), and ensure that the application exits cleanly.

While this may temporarily disrupt service for other users, it helps maintain the overall stability and integrity of the application.

Example of Synchronous Cleanup:

Let's say your Express.js application manages database connections. In the event of an uncaught exception, you could use the 'uncaughtException' event to catch the error, perform any necessary cleanup operations (such as closing database connections), and then exit the process.

Here's a simplified example:

process.on('uncaughtException', (err) => {
  console.error('Uncaught Exception:', err);
  
  // Perform synchronous cleanup of allocated resources
  closeDatabaseConnections();

  // Exit the process
  process.exit(1);
});

// Express.js setup
const express = require('express');
const app = express();

// Route handler
app.get('/', (req, res) => {
  // Simulate an uncaught exception
  throw new Error('Oops! Something went wrong.');
});

// Start the server
const server = app.listen(process.env.PORT, () => {
  console.log(`Server is running on port: ${process.env.PORT}`);
});

// Function to close database connections
function closeDatabaseConnections() {
  // Perform cleanup operations, such as closing database connections
  console.log('Closing database connections...');
}