Graceful shutdown on errors in Node.js - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to listen for uncaught exceptions and log the error.

Node.js

process.on('uncaughtException', (err) => {
  console.error('Uncaught Exception:', [1]);
});

Drag options to blanks, or click blank then click option'

Aerr.message

Berr

Cerror

Dexception

Attempts:

3 left

💡 Hint

Common Mistakes

Using a variable name not defined in the callback.

Logging only err.message which hides stack trace.

The err object contains the error details. Logging err shows the full error.

2fill in blank

medium

Complete the code to listen for unhandled promise rejections and log the reason.

Node.js

process.on('unhandledRejection', (reason, promise) => {
  console.error('Unhandled Rejection at:', [1]);
});

Drag options to blanks, or click blank then click option'

Apromise

Bexception

Cerror

Dreason

Attempts:

3 left

💡 Hint

Common Mistakes

Logging the promise object instead of the reason.

Using undefined variable names.

The reason parameter contains why the promise was rejected. Logging it helps diagnose the issue.

3fill in blank

hard

Fix the error in the code to properly close the server on SIGINT signal.

Node.js

process.on('SIGINT', () => {
  console.log('SIGINT received, shutting down...');
  server.[1](() => {
    console.log('Server closed');
    process.exit(0);
  });
});

Drag options to blanks, or click blank then click option'

Aclose

Bshutdown

Cstop

Dend

Attempts:

3 left

💡 Hint

Common Mistakes

Using non-existent methods like shutdown or stop.

Not calling process.exit() after closing.

The server.close() method stops the server from accepting new connections and calls the callback when done.

4fill in blank

hard

Fill both blanks to log the error and exit the process with failure code.

Node.js

process.on('uncaughtException', (err) => {
  console.error('Error:', [1]);
  process.[2](1);
});

Drag options to blanks, or click blank then click option'

Aerr

Bexit

Cabort

Dthrow

Attempts:

3 left

💡 Hint

Common Mistakes

Using process.abort() which causes a core dump.

Not exiting the process after an uncaught exception.

Logging the error object err shows details. Using process.exit(1) exits with failure status.

5fill in blank

hard

Fill all three blanks to handle SIGTERM by closing the server and exiting cleanly.

Node.js

process.on('[1]', () => {
  console.log('Signal received, closing server...');
  server.[2](() => {
    console.log('Server closed, exiting.');
    process.[3](0);
  });
});

Drag options to blanks, or click blank then click option'

ASIGTERM

Bclose

Cexit

DSIGINT

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing SIGINT with SIGTERM.

Not calling process.exit() after closing the server.

SIGTERM is the termination signal. server.close() stops the server. process.exit(0) exits successfully.

Practice

1. What is the main purpose of implementing a graceful shutdown in a Node.js application?

easy

A. To restart the server automatically after an error

B. To log all incoming requests for debugging

C. To increase the server's performance under load

D. To stop accepting new requests and clean up resources before exiting

Solution

1. Step 1: Understand graceful shutdown concept

   Graceful shutdown means stopping new work and cleaning up before the app exits.

2. Step 2: Identify the main goal

   The goal is to avoid abrupt termination by closing servers and resources properly.

3. Final Answer:

   To stop accepting new requests and clean up resources before exiting -> Option D

4. Quick Check:

   Graceful shutdown = stop new work + cleanup [OK]

Hint: Remember: graceful shutdown means clean exit, not restart [OK]

Common Mistakes:

• Confusing graceful shutdown with automatic restart
• Thinking it improves performance directly
• Assuming it only logs requests

2. Which of the following is the correct way to listen for an uncaught exception to trigger graceful shutdown in Node.js?

easy

A. process.on('uncaughtException', handler)

B. process.addListener('error', handler)

C. process.listen('uncaughtException', handler)

D. process.catch('uncaughtException', handler)

Solution

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

   Node.js uses process.on(event, handler) to listen for events.

2. Step 2: Identify the correct event for uncaught exceptions

   The event name is 'uncaughtException', so process.on('uncaughtException', handler) is correct.

3. Final Answer:

   process.on('uncaughtException', handler) -> Option A

4. Quick Check:

   Use process.on for events like uncaughtException [OK]

Hint: Use process.on(event, handler) for error events [OK]

Common Mistakes:

• Using process.catch instead of process.on
• Using wrong event names like 'error' for uncaughtException
• Confusing listen with on

3. Consider this Node.js code snippet handling graceful shutdown:

const server = require('http').createServer();
process.on('SIGINT', () => {
  console.log('Shutdown signal received');
  server.close(() => {
    console.log('Server closed');
    process.exit(0);
  });
});
server.listen(3000, () => console.log('Server running'));

What will be the output if you press Ctrl+C in the terminal?

medium

A. Shutdown signal received\nServer running\nServer closed

B. Server running\nShutdown signal received\nServer closed

C. Server running\nServer closed\nShutdown signal received

D. Server closed\nShutdown signal received\nServer running

Solution

1. Step 1: Understand server start and signal handling order

   The server logs 'Server running' when it starts listening. On Ctrl+C, SIGINT triggers the handler.

2. Step 2: Trace the shutdown logs

   On SIGINT, it logs 'Shutdown signal received', then closes the server, then logs 'Server closed'.

3. Final Answer:

   Server running\nShutdown signal received\nServer closed -> Option B

4. Quick Check:

   Startup log first, then SIGINT logs in order [OK]

Hint: Remember: server.listen logs first, then signal handler logs [OK]

Common Mistakes:

• Mixing order of logs on startup and shutdown
• Assuming server closes before signal logs
• Ignoring asynchronous server.close callback

4. Given this code snippet for graceful shutdown, what is the main problem?

const server = require('http').createServer();
process.on('uncaughtException', (err) => {
  console.error('Error:', err);
  process.exit(1);
});
server.listen(3000);

medium

A. It listens on the wrong port

B. It does not log the error properly

C. It exits immediately without closing the server

D. It uses the wrong event name for errors

Solution

1. Step 1: Analyze error handling behavior

   The handler logs the error but calls process.exit(1) immediately.

2. Step 2: Check for graceful shutdown steps

   It does not close the server before exiting, which can cause abrupt termination.

3. Final Answer:

   It exits immediately without closing the server -> Option C

4. Quick Check:

   Graceful shutdown requires closing server before exit [OK]

Hint: Always close servers before calling process.exit [OK]

Common Mistakes:

• Exiting without cleanup
• Ignoring server.close in error handlers
• Assuming logging is enough

5. You want to implement a graceful shutdown that handles both SIGTERM and uncaughtException events, ensuring the server closes before exit. Which code snippet correctly achieves this?

hard

A. process.on('SIGTERM', () => { server.close(() => process.exit(0)); }); process.on('uncaughtException', (err) => { console.error(err); server.close(() => process.exit(1)); });

B. process.on('SIGTERM', () => { server.close(); }); process.on('uncaughtException', () => { process.exit(1); });

C. process.on('SIGTERM', () => { process.exit(0); }); process.on('uncaughtException', () => { process.exit(1); });

D. process.on('SIGTERM', () => { console.log('Terminated'); }); process.on('uncaughtException', (err) => { console.error(err); });

Solution

1. Step 1: Check handling of SIGTERM

   process.on('SIGTERM', () => { server.close(() => process.exit(0)); }); process.on('uncaughtException', (err) => { console.error(err); server.close(() => process.exit(1)); }); closes the server and then exits, which is correct for graceful shutdown.

2. Step 2: Check handling of uncaughtException

   process.on('SIGTERM', () => { server.close(() => process.exit(0)); }); process.on('uncaughtException', (err) => { console.error(err); server.close(() => process.exit(1)); }); logs the error, closes the server, then exits with error code, ensuring cleanup.

3. Final Answer:

   process.on('SIGTERM', () => { server.close(() => process.exit(0)); }); process.on('uncaughtException', (err) => { console.error(err); server.close(() => process.exit(1)); }); -> Option A

4. Quick Check:

   Close server before exit on signals and errors [OK]

Hint: Always close server before exit on signals and errors [OK]

Common Mistakes:

• Exiting immediately without closing server
• Not logging errors on uncaughtException
• Ignoring asynchronous server.close callback