Global Error Handling in Node.js

Synopsis:

  We will explore how to configure a global error handling middleware in Express.js, how to catch different types of errors (synchronous, asynchronous), and how to handle uncaught exceptions and unhandled promise rejections to keep your server running stably.

• 1. The Importance of Global Error Handling:

  Without proper error handling, an uncaught error in yourNode.js application can cause the process to abruptly stop, leaving your server inactive and your users without service. A global handler:

  • Prevents server crashes: Catches errors that would otherwise block the application.
  • Provides consistent responses: Sends standardized error messages to the client.
  • Improves debugging: Centralizes error logging for easier tracking.
  • Separates business logic from error handling: Keeps your code cleaner.
• 2. Error Handling Middleware in Express.js:

  Express.js has a special type of middleware function dedicated to error handling. It is distinguished by havingfour arguments: (err, req, res, next). This middleware must be the last in your application's middleware chain so that it can catch any error that occurs in previous middleware or routes.

  How errors reach the global middleware:

  • Synchronous errors: If an error occurs in a synchronous function of a route or middleware, Express automatically catches it and passes it to the error handler.
    app.get('/sync-error', (req, res) => { throw new Error('Synchronous error'); });
  • Asynchronous errors (promises): For errors inasynchronous functions (such as those using async/await or returning promises), you mustexplicitly pass them to next() or use a library like express-async-errors for Express to catch them automatically.
    app.get('/async-error', async (req, res, next) => { try { await someAsyncOperation(); } catch (error) { next(error); } });

• 3. Error Handling Outside Express (Node.js Core):

  Not all errors occur within the Express request-response cycle.Node.js has mechanisms to catch errors at the process level.

  • process.on('unhandledRejection')

    This event is fired when a promise is rejected(rejects a Promise.reject() or a throw new Error() inside a promise) but there is no .catch() handler attached to catch it. It is crucial to prevent the process from crashing.

  • process.on('uncaughtException'):

    This event is fired when a synchronous exception is uncaught anywhere in your code. This is an indication of a serious programming error and usually requires the process to be closed and restarted.

• 4. Error Types and Strategies:

  It is useful to distinguish between:

  • Operational Errors: Expected errors that occur during normal operation (e.g., failed input validation, resource not found, network issues). These should be handled in a controlled manner and usually result in a specific error message to the client (e.g., 400 Bad Request, 404 Not Found). You can create custom error classes for them.
  • Programming Errors: Unexpected errors that indicate a defect in the code (e.g., undefined variable, accessing a null property). These often lead to application crashes and should be corrected immediately by the developer. The events uncaughtException and unhandledRejection are useful here.

  Example of a Custom Error Class for operational errors:

• 5. Async Route Wrapper (Async Wrapper):

  To avoid having to write try...catch(next) in every asynchronous route, you can create a wrapper function.