Handling uncaught exceptions in Node.js - Step-by-Step Execution

Concept Flow - Handling uncaught exceptions

Start Node.js Process

↓

Run Code

↓

Exception Occurs?

No→Continue Running

Yes↓

Is Exception Caught?

Yes→Handle Exception

No↓

Trigger 'uncaughtException' Event

↓

Run uncaughtException Handler

↓

Decide to Exit or Continue

↓

Process Ends or Continues

Node.js runs code and if an error happens without a catch, it triggers the 'uncaughtException' event where you can handle it before deciding to exit or continue.

Execution Sample

Node.js

process.on('uncaughtException', (err) => {
  console.log('Caught:', err.message);
});

throw new Error('Oops!');

This code sets a handler for uncaught exceptions and then throws an error that triggers it.

Execution Table

Step	Action	Evaluation	Result
1	Set 'uncaughtException' handler	Handler registered	Ready to catch errors
2	Throw new Error('Oops!')	Error thrown, no try-catch	Uncaught exception triggered
3	'uncaughtException' event fires	Handler runs with error object	Logs 'Caught: Oops!'
4	No process exit called	Process continues running	Program does not crash here

💡 Execution stops if process.exit() is called inside handler; otherwise, process continues.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
err.message	undefined	Error object with message 'Oops!'	'Oops!'	'Oops!'

Key Moments - 3 Insights

Why doesn't the program crash immediately after the error is thrown?

Because the 'uncaughtException' handler catches the error at step 3, preventing the default crash behavior.

Can the program continue running safely after an uncaught exception?

It can continue if you don't call process.exit() in the handler, but it's risky because the program state may be unstable (see step 4).

What happens if there is no 'uncaughtException' handler?

Node.js will print the error and exit the process immediately after the uncaught exception occurs (step 2 triggers crash).

Visual Quiz - 3 Questions

Look at the execution table, what is logged when the 'uncaughtException' event fires?

A 'Unhandled Exception'

B 'Caught: Oops!'

C 'Error: Oops!'

D Nothing is logged

💡 Hint

Check row 3 in the execution_table where the handler logs the error message.

At which step does the error become an uncaught exception triggering the event?

A Step 2

B Step 1

C Step 3

D Step 4

💡 Hint

Look at the execution_table row where the error is thrown without a try-catch.

If process.exit() is called inside the handler, what changes in the execution flow?

A Program continues running normally

B Program logs error but does not exit

C Program exits immediately after handling error

D Handler is never called

💡 Hint

Refer to the exit_note explaining process exit behavior after handler runs.

Concept Snapshot

Handling uncaught exceptions in Node.js:
- Use process.on('uncaughtException', handler) to catch errors not caught by try-catch.
- The handler receives the error object.
- You can log or clean up inside the handler.
- Calling process.exit() stops the program; otherwise, it continues but may be unstable.
- Without a handler, Node.js crashes on uncaught exceptions.

Full Transcript

In Node.js, when your code throws an error that is not caught by any try-catch block, it triggers an 'uncaughtException' event. You can listen for this event using process.on('uncaughtException', handler). The handler receives the error object and can log it or perform cleanup. If you do not call process.exit() inside the handler, the program continues running, but this can be risky because the program state might be corrupted. If no handler is set, Node.js will print the error and exit immediately. This flow helps you catch unexpected errors globally and decide how to handle them safely.

Practice

1. What is the primary purpose of using process.on('uncaughtException') in a Node.js application?

easy

A. To handle HTTP requests automatically

B. To log user activity in the application

C. To restart the server after every request

D. To catch errors that were not handled anywhere else in the code

Solution

1. Step 1: Understand the role of uncaught exceptions

   Uncaught exceptions are errors that happen but are not caught by any try-catch block or error handler in the code.

2. Step 2: Purpose of process.on('uncaughtException')

   This event listener catches those uncaught errors to prevent the app from crashing unexpectedly.

3. Final Answer:

   To catch errors that were not handled anywhere else in the code -> Option D

4. Quick Check:

   Uncaught exceptions = catch unhandled errors [OK]

Hint: Remember: uncaughtException catches errors missed by try-catch [OK]

Common Mistakes:

• Thinking it handles normal HTTP requests
• Assuming it restarts the server automatically
• Confusing it with logging user actions

2. Which of the following is the correct syntax to listen for uncaught exceptions in Node.js?

easy

A. process.listen('uncaughtException', (err) => { console.error(err); });

B. process.catch('uncaughtException', (err) => { console.error(err); });

C. process.on('uncaughtException', (err) => { console.error(err); });

D. process.handle('uncaughtException', (err) => { console.error(err); });

Solution

1. Step 1: Identify the correct event listener method

   Node.js uses process.on to listen for events like 'uncaughtException'.

2. Step 2: Verify the event name and callback

   The event name is exactly 'uncaughtException' and the callback receives the error object.

3. Final Answer:

   process.on('uncaughtException', (err) => { console.error(err); }); -> Option C

4. Quick Check:

   Use process.on for events [OK]

Hint: Use process.on for event listening, not catch or listen [OK]

Common Mistakes:

• Using process.catch instead of process.on
• Using process.listen or process.handle which don't exist
• Misspelling the event name

3. Consider the following Node.js code snippet:

process.on('uncaughtException', (err) => {
  console.log('Caught:', err.message);
});

throw new Error('Oops!');

What will be the output when this code runs?

medium

A. The program crashes without any output

B. Caught: Oops!

C. Error: Oops!

D. No output, the error is ignored

Solution

1. Step 1: Understand the uncaughtException handler

   The handler logs the error message prefixed with 'Caught:'.

2. Step 2: The thrown error triggers the handler

   The thrown error 'Oops!' is caught by the listener and logged as 'Caught: Oops!'.

3. Final Answer:

   Caught: Oops! -> Option B

4. Quick Check:

   Uncaught error triggers handler output [OK]

Hint: Thrown error triggers uncaughtException handler output [OK]

Common Mistakes:

• Expecting the program to crash immediately
• Thinking the error message prints with 'Error:' prefix
• Assuming no output because error is ignored

4. You wrote this code to catch uncaught exceptions:

process.on('uncaughtException', (error) => {
  console.log('Error:', error.message);
});

setTimeout(() => {
  throw new Error('Fail');
}, 1000);

But the program crashes after the error is logged. What is the best fix?

medium

A. Add process.exit(1); inside the handler after logging

B. Remove the throw statement inside setTimeout

C. Wrap the throw inside a try-catch block

D. Use process.on('error') instead of uncaughtException

Solution

1. Step 1: Understand uncaughtException behavior

   After catching, the app is in an unstable state and should exit safely.

2. Step 2: Add process.exit(1) to stop the app

   Calling process.exit(1) after logging ensures the app stops cleanly.

3. Final Answer:

   Add process.exit(1); inside the handler after logging -> Option A

4. Quick Check:

   Exit after uncaughtException to avoid unstable state [OK]

Hint: Exit process after uncaughtException to avoid crashes [OK]

Common Mistakes:

• Ignoring the need to exit after catching
• Trying to catch error inside setTimeout instead
• Using wrong event name 'error' instead of 'uncaughtException'

5. You want to log uncaught exceptions and then restart your Node.js server automatically. Which approach correctly combines handling uncaught exceptions and restarting the app?

hard

A. Use process.on('uncaughtException') to log error, then call process.exit(1), and use a separate script or tool to restart the server

B. Inside uncaughtException handler, just call server.listen() again to restart

C. Wrap the entire app code in a try-catch block to restart on error

D. Use process.on('exit') to catch errors and restart the server

Solution

1. Step 1: Handle uncaught exceptions by logging and exiting

   Inside the handler, log the error and call process.exit(1) to stop the app safely.

2. Step 2: Use an external tool or script to restart the server

   Node.js itself does not restart automatically; tools like PM2 or systemd can restart on exit.

3. Final Answer:

   Use process.on('uncaughtException') to log error, then call process.exit(1), and use a separate script or tool to restart the server -> Option A

4. Quick Check:

   Log + exit + external restart tool = correct approach [OK]

Hint: Exit on error, restart externally (PM2/systemd) for stability [OK]

Common Mistakes:

• Trying to restart server inside uncaughtException handler
• Using process.on('exit') to catch errors (wrong event)
• Wrapping entire app in try-catch which misses async errors