feat: Add global exception filter for consistent error handling and logging, add request ID tracking for log correlation across requests, add uncaught exception and unhandled rejection handler

Author: caneppelevitor

server/filters/http-exception.filter.ts

@@ -0,0 +1,79 @@
+import {
+    ExceptionFilter,
+    Catch,
+    ArgumentsHost,
+    HttpException,
+    HttpStatus,
+    Logger,
+} from "@nestjs/common";
+import { Request, Response } from "express";
+
+@Catch()
+export class AllExceptionsFilter implements ExceptionFilter {
+    private readonly logger = new Logger(AllExceptionsFilter.name);
+
+    catch(exception: unknown, host: ArgumentsHost) {
+        const ctx = host.switchToHttp();
+        const response = ctx.getResponse<Response>();
+        const request = ctx.getRequest<Request>();
+
+        const status =
+            exception instanceof HttpException
+                ? exception.getStatus()
+                : HttpStatus.INTERNAL_SERVER_ERROR;
+
+        const message =
+            exception instanceof HttpException
+                ? exception.getResponse()
+                : exception instanceof Error
+                ? exception.message
+                : "Internal server error";
+
+        const requestId =
+            (request as any).requestId ||
+            request.headers["x-request-id"] ||
+            `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+
+        const errorContext = {
+            requestId,
+            method: request.method,
+            url: request.url,
+            ip: request.ip || request.socket?.remoteAddress,
+            statusCode: status,
+        };
+
+        // Handle "headers already sent" error
+        if (
+            exception instanceof Error &&
+            exception.message.includes("Cannot set headers after they are sent")
+        ) {
+            this.logger.error(
+                `Headers already sent - ${request.method} ${request.url} | RequestId: ${requestId}`,
+                exception.stack
+            );
+            return;
+        }
+
+        // Log the error with context
+        const errorMessage =
+            typeof message === "string" ? message : JSON.stringify(message);
+        this.logger.error(
+            `${request.method} ${request.url} | Status: ${status} | RequestId: ${requestId} | Error: ${errorMessage}`,
+            exception instanceof Error ? exception.stack : ""
+        );
+
+        // Send error response only if headers haven't been sent
+        if (!response.headersSent) {
+            response.status(status).json({
+                requestId,
+                statusCode: status,
+                timestamp: new Date().toISOString(),
+                path: request.url,
+                message:
+                    status === HttpStatus.INTERNAL_SERVER_ERROR
+                        ? "Internal server error"
+                        : message,
+            });
+        }
+    }
+}

server/main.ts

@@ -7,6 +7,7 @@ import { SwaggerModule, DocumentBuilder } from "@nestjs/swagger";
 import loadConfig from "./configLoader";
 import * as dotenv from "dotenv";
 import { WinstonLogger } from "./winstonLogger";
+import { AllExceptionsFilter } from "./filters/http-exception.filter";
 const cookieParser = require("cookie-parser");
 const mongoose = require("mongoose");
 dotenv.config();
@@ -23,11 +24,40 @@ async function initApp() {
         origin: options?.cors || "*",
         credentials: true,
         methods: "GET,HEAD,PUT,PATCH,POST,DELETE, OPTIONS",
-        allowedHeaders: ["accept", "x-requested-with", "content-type"],
+        allowedHeaders: [
+            "accept",
+            "x-requested-with",
+            "content-type",
+            "x-request-id",
+        ],
+        exposedHeaders: ["x-request-id"],
     };
 
     const logger = new WinstonLogger();
 
+    // Handle uncaught exceptions
+    process.on("uncaughtException", (error: Error) => {
+        logger.error(
+            `Uncaught Exception: ${error.message}`,
+            error.stack,
+            "UncaughtException"
+        );
+        setTimeout(() => process.exit(1), 1000);
+    });
+
+    // Handle unhandled promise rejections
+    process.on("unhandledRejection", (reason: any) => {
+        const errorMessage =
+            reason instanceof Error
+                ? `${reason.message}\n${reason.stack}`
+                : String(reason);
+        logger.error(
+            `Unhandled Rejection: ${errorMessage}`,
+            "",
+            "UnhandledRejection"
+        );
+    });
+
     const app = await NestFactory.create<NestExpressApplication>(
         AppModule.register(options),
         {
@@ -58,6 +88,9 @@ async function initApp() {
         })
     );
 
+    // Global exception filter for consistent error handling and logging
+    app.useGlobalFilters(new AllExceptionsFilter());
+
     // FIXME: not working but we need to enable in the future
     // app.use(helmet());
     app.use(cookieParser());

server/middleware/logger.middleware.ts

@@ -1,24 +1,45 @@
-import { Injectable, Logger, NestMiddleware } from '@nestjs/common';
-import { Request, Response, NextFunction } from 'express';
+import { Injectable, Logger, NestMiddleware } from "@nestjs/common";
+import { Request, Response, NextFunction } from "express";
+
+declare global {
+    namespace Express {
+        interface Request {
+            requestId?: string;
+            startTime?: number;
+        }
+    }
+}
 
 @Injectable()
 export class LoggerMiddleware implements NestMiddleware {
-  private logger = new Logger('HTTP');
+    private logger = new Logger("HTTP");
+
+    use(request: Request, response: Response, next: NextFunction): void {
+        const startTime = Date.now();
+        const { ip, method, originalUrl } = request;
+        const userAgent = request.get("user-agent") || "";
 
-  use(request: Request, response: Response, next: NextFunction): void {
-    const { ip, method, originalUrl } = request;
-    const userAgent = request.get('user-agent') || '';
+        // Generate or use existing request ID
+        const requestId =
+            (request.headers["x-request-id"] as string) ||
+            `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
 
-    response.on('finish', () => {
-      const { statusCode } = response;
-      const contentLength = response.get('content-length');
+        // Attach to request for use in exception filters and services
+        request.requestId = requestId;
+        request.startTime = startTime;
+        request.headers["x-request-id"] = requestId;
+        response.setHeader("x-request-id", requestId);
 
-      this.logger.log(
-        `${method} ${originalUrl} ${statusCode} ${contentLength} - ${userAgent} ${ip}`,
-      );
-    });
+        response.on("finish", () => {
+            const { statusCode } = response;
+            const contentLength = response.get("content-length") || 0;
+            const responseTime = Date.now() - startTime;
 
-    next();
-  }
-} 
+            this.logger.log(
+                `${method} ${originalUrl} ${statusCode} ${contentLength} ${responseTime}ms - ${userAgent} ${ip}`
+            );
+        });
 
+        next();
+    }
+}