Handling worker crashes and restart in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a worker crashes in this Node.js cluster code?

Consider this Node.js cluster code snippet. What will be the output behavior when a worker process crashes?

Node.js

import cluster from 'cluster';
import os from 'os';

if (cluster.isPrimary) {
  const numCPUs = os.cpus().length;
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on('exit', (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died.`);
  });
} else {
  process.exit(1); // Worker crashes immediately
}

A The primary ignores worker crashes and no logs are shown.

B The primary automatically restarts each worker after it crashes.

C The primary logs each worker's death but does not restart any workers.

D The primary crashes as well when any worker crashes.

💡 Hint

Look at the cluster event listeners and what happens on 'exit'.

The code listens for 'exit' events and logs when a worker dies. However, it does not call cluster.fork() again to restart the worker. So workers are not restarted automatically.

📝 Syntax

intermediate

Which option correctly restarts a worker after it crashes?

Given this cluster setup, which code snippet correctly restarts a worker when it crashes?

Node.js

import cluster from 'cluster';
import os from 'os';

if (cluster.isPrimary) {
  const numCPUs = os.cpus().length;
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on('exit', (worker, code, signal) => {
    // Restart worker here
  });
} else {
  // Worker code
}

A cluster.on('exit', (worker) => { cluster.fork(); });

B cluster.on('exit', (worker) => { worker.fork(); });

C cluster.on('exit', () => { cluster.restart(); });

D cluster.on('exit', (worker) => { cluster.fork(worker.id); });

💡 Hint

Remember how to create new workers in Node.js cluster.

To restart a worker, the primary process must call cluster.fork() to create a new worker. The worker object does not have a fork method, and cluster.restart() is not a valid method.

🔧 Debug

advanced

Why does this cluster code fail to restart workers properly?

Examine this code snippet. Why does it fail to restart workers after they crash?

Node.js

import cluster from 'cluster';
import os from 'os';

if (cluster.isPrimary) {
  const numCPUs = os.cpus().length;
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on('exit', (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died.`);
    cluster.fork(worker.id);
  });
} else {
  process.exit(1);
}

A cluster.fork() does not accept any arguments, so passing worker.id causes an error and no restart.

B The 'exit' event is not emitted on worker crashes, so the handler never runs.

C The worker process exits with code 1, which prevents cluster from restarting it.

D The code forks too many workers causing resource exhaustion.

💡 Hint

Check the cluster.fork() method signature.

The cluster.fork() method does not take any arguments. Passing worker.id causes an error or unexpected behavior, so the worker is not restarted properly.

❓ state_output

advanced

What is the number of active workers after a crash and restart?

Given this cluster code, how many worker processes will be active after one worker crashes and the restart code runs?

Node.js

import cluster from 'cluster';
import os from 'os';

if (cluster.isPrimary) {
  const numCPUs = os.cpus().length;
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on('exit', (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died.`);
    cluster.fork();
  });
} else {
  if (process.env.CRASH) process.exit(1);
  else setTimeout(() => {}, 10000);
}

A No workers remain active after the crash.

B The number of active workers decreases by one and never recovers.

C The number of active workers doubles after the restart.

D The number of active workers remains equal to the number of CPUs.

💡 Hint

Think about how cluster.fork() replaces crashed workers.

The code starts one worker per CPU. When a worker crashes, the 'exit' event triggers and cluster.fork() creates a new worker. So the total number of active workers stays the same.

🧠 Conceptual

expert

Why is it important to handle worker crashes and restart in Node.js clusters?

Choose the best explanation for why managing worker crashes and restarts is critical in Node.js cluster applications.

A To reduce CPU usage by stopping workers that crash frequently.

B To ensure the application remains available and responsive by replacing failed workers automatically.

C To prevent the primary process from using too much memory by restarting workers manually.

D To allow workers to share memory directly without restarting.

💡 Hint

Think about what happens if workers crash and are not restarted.

Automatically restarting crashed workers keeps the app running smoothly and prevents downtime. It helps maintain performance and availability.