💡𝗛𝗮𝗻𝗱𝗹𝗶𝗻𝗴 𝗚𝗹𝗼𝗯𝗮𝗹 𝗘𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻𝘀 & 𝗚𝗿𝗮𝗰𝗲𝗳𝘂𝗹 𝗦𝗵𝘂𝘁𝗱𝗼𝘄𝗻𝘀 𝗶𝗻 𝗧𝘆𝗽𝗲𝗦𝗰𝗿𝗶𝗽𝘁 𝘄𝗶𝘁𝗵 𝗡𝗲𝘀𝘁𝗝𝗦 🚀

As developers, we’ve all faced the frustrating issue of an app unexpectedly crashing and leaving us to dig through logs to figure out what went wrong. Recently, I encountered this exact problem — my app would suddenly stop, causing downtime and impacting users. After implementing global exception handling in my TypeScript-based NestJS application, I was able to handle crashes gracefully and automatically restart the app after logging the error. 🙌

Let me walk you through how I tackled this issue by using process.on to catch exceptions and signals, and restart the app if necessary.

🛠️ The Code

import { NestFactory } from "@nestjs/core";
import { AppModule } from "./app.module";
import { Logger } from "@nestjs/common";

async function bootstrap() {
  const logger = new Logger("Global Exception Handling Service");

  // Handle uncaught exceptions (sync errors not handled in your app)
  process.on("uncaughtException", (error: any, origin: any) => {
    logger.error({
      module: "main process",
      method: "uncaughtException",
      correlationId: "To be implemented",
      timestamp: new Date().toISOString(),
      error: error?.message,
      stack: error?.stack,
      origin: origin,
    });
    // You may restart the app here
  });

  // Handle unhandled promise rejections (async errors not caught)
  process.on("unhandledRejection", (err: any) => {
    logger.error({
      module: "main process",
      method: "unhandledRejection",
      correlationId: "To be implemented",
      timestamp: new Date().toISOString(),
      error: err?.message,
    });
  });

  // Catch exit events (when the app is about to shut down)
  process.on("exit", (code) => {
    logger.error({
      module: "main process",
      method: "exit",
      correlationId: "To be implemented",
      timestamp: new Date().toISOString(),
      error: code,
    });
  });

  // Handle graceful shutdown on SIGTERM (used by cloud providers)
  process.on("SIGTERM", async () => {
    logger.log("Received SIGTERM. Shutting down gracefully...");
    await app.close();
    process.exit(0);
  });

  // Handle graceful shutdown on SIGINT (when user interrupts the process)
  process.on("SIGINT", async () => {
    logger.log("Received SIGINT. Shutting down gracefully...");
    await app.close();
    process.exit(0);
  });

  const app = await NestFactory.create(AppModule);
  const appPort = parseInt(process?.env?.APP_PORT) || 3000;
  await app.listen(appPort);
}

bootstrap();

🔍 Breaking It Down

1. process.on(“uncaughtException”):

Catches synchronous errors that weren’t caught elsewhere. These are typically errors that escape the try-catch blocks or unhandled errors in your app. Logging such exceptions allows you to identify the root cause and ensure the app can recover.

2. process.on(“unhandledRejection”):

Deals with asynchronous errors — promise rejections that weren’t handled. It’s crucial to log these to prevent hidden issues from slipping through the cracks.

3. process.on(“exit”):

This event gets triggered when the Node.js process is about to exit. Useful for logging any final state or doing cleanup tasks before the app closes completely.

4. process.on(“SIGTERM”):

Used by many cloud providers (like AWS, Heroku) to gracefully terminate an app. When receiving this signal, we can close the app gracefully, ensuring all operations complete properly.

5. process.on(“SIGINT”):

This is fired when a user presses Ctrl+C in the terminal to stop the application. Similar to SIGTERM, we handle this gracefully, ensuring the app shuts down without data loss.

💡 Why This Matters?

Before implementing this, my app would just stop without notice. Now, every exception or signal is logged, and I can automatically restart the app after a crash, reducing downtime and improving user experience.

The next time you encounter a random app shutdown, you’ll have all the details logged — no more digging through endless logs trying to figure out what went wrong!

💪 Takeaway:

Handling exceptions gracefully and ensuring a smooth shutdown process is critical for any production app. By implementing process.on, you:

• Catch and log all errors (both sync and async).

• Handle shutdown signals gracefully.

• Restart the app or perform necessary cleanups when unexpected issues occur.

🚀 Using 𝗜𝗻𝗹𝗶𝗻𝗲 𝗔𝗿𝗿𝗮𝘆𝘀 and 𝗖𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻 𝗘𝘅𝗽𝗿𝗲𝘀𝘀𝗶𝗼𝗻𝘀 in C# 12 simplifies your code and boosts performance. Start leveraging these features in your projects to write cleaner, faster, and more readable code!

Follow Apurv Upadhyay ☁️ for more insightful content..

#TypeScript #NestJS #NodeJS #ErrorHandling #GracefulShutdown #Programming