Handling Uncaught Exceptions and Rejections

In this lesson, you will learn how to prevent your Node.js application from crashing unexpectedly when an error slips through your logic.

In Node.js, your code runs on the event loop. If an error occurs that you haven't explicitly handled (using try/catch or .catch()), the error propagates up to the runtime level. An Uncaught Exception (for synchronous code) or an Unhandled Promise Rejection (for asynchronous code) will typically trigger a process crash. This is a safety measure: Node.js stops the process because it can no longer guarantee the integrity of your application’s state.

The "Safety Net" Strategy

While the goal is to always handle your errors where they happen, you should implement global listeners to log the error before the process exits. This prevents the application from "dying silently."

// Catch synchronous errors that escape your logic
process.on('uncaughtException', (err) => {
  console.error('CRITICAL: Uncaught Exception detected:', err);
  // Log to a monitoring service here
  process.exit(1); // Exit with failure code
});

// Catch asynchronous Promise rejections
process.on('unhandledRejection', (reason, promise) => {
  console.error('CRITICAL: Unhandled Rejection at:', promise, 'reason:', reason);
  // Do not rely on the app to continue after this
  process.exit(1);
});

Why We Exit the Process

You might wonder, "Why can’t I just ignore the error and keep running?"

When an uncaughtException occurs, your application’s memory state might be corrupted or inconsistent. If you try to continue, your code might behave unpredictably, leading to even harder-to-debug logic errors later. By logging the error and calling process.exit(1), you allow a process manager (like PM2 or Kubernetes) to restart your application in a clean, fresh state.

Always treat these global listeners as a final "last resort" mechanism. They are meant to help you debug and maintain uptime through restarts, not to replace robust try/catch blocks around your asynchronous operations and I/O tasks.

Key Takeaway: Global error listeners are your final safety net to log critical failures and safely restart your process, ensuring that your application doesn't remain in an unstable or broken state.