Unhandled rejection handling in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What happens when a Promise rejection is not handled?

Consider a Node.js program where a Promise is rejected but no catch or rejection handler is attached. What is the typical behavior?

A Node.js emits an <code>unhandledRejection</code> event but does not terminate the process by default.

B Node.js immediately crashes with a fatal error.

C The program silently ignores the rejection and continues running.

D The rejection is automatically retried until it succeeds.

💡 Hint

Think about how Node.js informs you about unhandled promise rejections before deciding what to do.

Node.js emits an unhandledRejection event when a Promise is rejected without a handler. By default, it logs a warning but does not crash the process immediately.

❓ component_behavior

intermediate

What is the output of this unhandled rejection handler code?

Given the following Node.js code, what will be printed to the console?

Node.js

process.on('unhandledRejection', (reason, promise) => {
  console.log('Unhandled Rejection at:', promise, 'reason:', reason.message);
});

Promise.reject(new Error('Fail!'));

A SyntaxError due to incorrect event handler syntax.

B Unhandled Rejection at: undefined reason: Fail!

C No output, the rejection is handled silently.

D Unhandled Rejection at: [object Promise] reason: Fail!

💡 Hint

Look at the parameters passed to the unhandledRejection event handler.

The event handler receives the rejected Promise and the reason (Error object). Logging them shows the Promise object and the error message.

🔧 Debug

advanced

Why does this unhandled rejection handler not catch the error?

Examine this code snippet. Why does the unhandledRejection event not trigger?

Node.js

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

const p = Promise.reject(new Error('Oops!'));
p.catch(() => {});

A The event handler is missing the second parameter, so it fails silently.

B Because the Promise has a catch handler, the rejection is considered handled and no event is emitted.

C The event name is misspelled, so it never triggers.

D Promises rejected inside event handlers do not emit unhandledRejection.

💡 Hint

Think about when Node.js emits the unhandledRejection event.

If a Promise rejection is handled by a catch or then handler, Node.js does not emit the unhandledRejection event.

📝 Syntax

advanced

Which option correctly attaches a global unhandled rejection handler?

Choose the code snippet that correctly listens for unhandled Promise rejections in Node.js.

A process.addListener('unhandledRejection', reason => console.log(reason));

B process.onUnhandledRejection((reason) => console.log(reason));

C process.on('unhandledRejection', (reason, promise) => { console.log(reason); });

D process.handle('unhandledRejection', (reason) => console.log(reason));

💡 Hint

Recall the correct Node.js API for event listening on process.

The correct method is process.on(eventName, callback). Options C and D use invalid method names.

❓ lifecycle

expert

What is the effect of calling process.exit() inside an unhandled rejection handler?

Consider this code snippet:

process.on('unhandledRejection', (reason) => {
  console.error('Error:', reason.message);
  process.exit(1);
});

Promise.reject(new Error('Critical failure'));

What happens when this code runs?

A The error message is logged, and the Node.js process exits immediately with code 1.

B The error message is logged, but the process continues running normally.

C The unhandledRejection event is ignored because <code>process.exit()</code> is called.

D The process crashes with an unhandled exception error before logging.

💡 Hint

Think about what process.exit() does inside event handlers.

Calling process.exit(1) stops the Node.js process immediately after logging the error.

Practice

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

easy

A. To catch errors from promises that were not handled anywhere else

B. To handle synchronous errors in try-catch blocks

C. To restart the Node.js server automatically

D. To log all successful promise resolutions

Solution

1. Step 1: Understand what unhandled rejections are

   Unhandled rejections happen when a promise fails but no .catch() or try-catch handles the error.

2. Step 2: Role of process.on('unhandledRejection')

   This event listener catches those unhandled promise errors so you can log or clean up before the app crashes.

3. Final Answer:

   To catch errors from promises that were not handled anywhere else -> Option A

4. Quick Check:

   Unhandled promise errors = process.on('unhandledRejection') [OK]

Hint: Unhandled promise errors are caught by process.on('unhandledRejection') [OK]

Common Mistakes:

• Confusing unhandledRejection with synchronous try-catch
• Thinking it restarts the server automatically
• Assuming it logs successful promises

2. Which of the following is the correct syntax to listen for unhandled promise rejections in Node.js?

easy

A. process.on('unhandledRejection', handlerFunction)

B. process.catch('unhandledRejection', handlerFunction)

C. process.listen('unhandledRejection', handlerFunction)

D. process.handle('unhandledRejection', handlerFunction)

Solution

1. Step 1: Recall Node.js event listening syntax

   Node.js uses process.on(eventName, callback) to listen to events.

2. Step 2: Match the event name and method

   The event for unhandled promise rejections is 'unhandledRejection', so the correct syntax is process.on('unhandledRejection', handlerFunction).

3. Final Answer:

   process.on('unhandledRejection', handlerFunction) -> Option A

4. Quick Check:

   Event listening in Node.js = process.on() [OK]

Hint: Use process.on('unhandledRejection', handler) to catch promise errors [OK]

Common Mistakes:

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

3. Consider this Node.js code snippet:

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

Promise.reject(new Error('Failed promise'));

What will be printed to the console?

medium

A. No output, program crashes silently

B. Error: Failed promise

C. Error: undefined

D. Unhandled promise rejection

Solution

1. Step 1: Understand the unhandledRejection event handler

   The handler logs the error message from the rejection reason.

2. Step 2: Analyze the rejected promise

   The promise rejects with new Error('Failed promise'), so reason.message is 'Failed promise'.

3. Final Answer:

   Error: Failed promise -> Option B

4. Quick Check:

   Rejected error message logged = 'Error: Failed promise' [OK]

Hint: Unhandled rejection logs error.message from rejected Error object [OK]

Common Mistakes:

• Expecting no output or silent crash
• Confusing reason.message with undefined
• Thinking the event logs generic text

4. You wrote this code to catch unhandled promise rejections:

process.on('unhandledRejection', (error) => {
  console.log('Caught:', error);
});

Promise.reject('Oops!');

But the console shows Caught: Oops! instead of an error message. What is the issue?

medium

A. The handler function must be async to catch rejections

B. The event name should be 'unhandledRejections' (plural)

C. You must use try-catch instead of process.on for promises

D. The rejection reason is a string, not an Error object, so error.message is undefined

Solution

1. Step 1: Check the rejection reason type

   The promise rejects with a string 'Oops!', not an Error object.

2. Step 2: Understand how the handler logs the error

   The handler logs the whole error variable, which is the string 'Oops!', so it prints exactly that.

3. Final Answer:

   The rejection reason is a string, not an Error object, so error.message is undefined -> Option D

4. Quick Check:

   Rejection reason type affects error.message presence [OK]

Hint: Rejection reason can be any type; strings have no .message [OK]

Common Mistakes:

• Using wrong event name 'unhandledRejections'
• Thinking async handler is required
• Believing try-catch catches unhandled rejections

5. You want to log unhandled promise rejections and then gracefully shut down your Node.js server. Which code snippet correctly implements this behavior?

hard

A. process.on('unhandledRejection', (reason) => {
console.error('Unhandled rejection:', reason);
process.exit(1);
});

B. process.on('unhandledRejection', (reason) => {
console.log('Handled rejection:', reason.message);
});

C. process.on('unhandledRejection', (reason) => {
console.error('Unhandled rejection:', reason);
server.close(() => process.exit(1));
});

D. process.on('unhandledRejection', async (reason) => {
await server.close();
console.log('Server closed');
});

Solution

1. Step 1: Understand graceful shutdown

   Graceful shutdown means closing server connections before exiting the process.

2. Step 2: Analyze each option's shutdown approach

   process.on('unhandledRejection', (reason) => { console.error('Unhandled rejection:', reason); server.close(() => process.exit(1)); }); logs the error, then calls server.close() with a callback to exit after closing. This is correct.

3. Step 3: Identify why others are incorrect

   process.on('unhandledRejection', (reason) => { console.error('Unhandled rejection:', reason); process.exit(1); }); exits immediately without closing server; C only logs without shutdown; D awaits server.close but does not exit process.

4. Final Answer:

   process.on('unhandledRejection', (reason) => { console.error('Unhandled rejection:', reason); server.close(() => process.exit(1)); }); -> Option C

5. Quick Check:

   Graceful shutdown = server.close() then exit [OK]

Hint: Close server before exit to shutdown gracefully [OK]

Common Mistakes:

• Exiting process immediately without closing server
• Not calling process.exit after closing server
• Logging without shutting down server