Click here to see the GitHub issue and comment

The solution involves utilizing middleware.

import { Injectable, NestMiddleware, Logger } from '@nestjs/common';

import { Request, Response, NextFunction } from 'express';

@Injectable()
export class AppLoggerMiddleware implements NestMiddleware {
  private logger = new Logger('HTTP');

  use(request: Request, response: Response, next: NextFunction): void {
    const { ip, method, path: url } = request;
    const userAgent = request.get('user-agent') || '';

    response.on('close', () => {
      const { statusCode } = response;
      const contentLength = response.get('content-length');

      this.logger.log(
        `${method} ${url} ${statusCode} ${contentLength} - ${userAgent} ${ip}`
      );
    });

    next();
  }
}

Add the middleware to your AppModule as shown below:

export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer): void {
    consumer.apply(AppLoggerMiddleware).forRoutes('*');
  }
}

Why not try using the finish event instead of the close event?

import { Request, Response, NextFunction } from "express";
import { Injectable, NestMiddleware, Logger } from "@nestjs/common";

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  private logger = new Logger("HTTP");

  use(request: Request, response: Response, next: NextFunction): void {
    const { ip, method, originalUrl } = request;
    const userAgent = request.get("user-agent") || "";

    response.on("finish", () => {
      const { statusCode } = response;
      const contentLength = response.get("content-length");

      this.logger.log(
        `${method} ${originalUrl} ${statusCode} ${contentLength} - ${userAgent} ${ip}`,
      );
    });

    next();
  }
}

It is because, to my knowledge, the express connection is maintained even after sending a response.
Therefore, the close event cannot be triggered.

Reference

01. Node document about response event.
02. Github issue

Opting for Morgan as middleware to intercept requests appealed to me due to its formatting options. Meanwhile, I stuck with the standard Nest Logger for handling output to maintain consistency across my application.

// middleware/request-logging.ts
import { Logger } from '@nestjs/common';
import morgan, { format } from 'morgan';

export function implementRequestLogging(app) {
    const logger = new Logger('Request');
    app.use(
        morgan('tiny', {
            stream: {
                write: (message) => logger.log(message.replace('\n', '')),
            },
        }),
    );
}

// main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { implementRequestLogging } from './middleware/request-logging';

async function bootstrap() {
    const app = await NestFactory.create(AppModule);
    implementRequestLogging(app);
    await app.listen(configService.get<number>('SERVER_PORT'));
    logger.log(`Application is running on: ${await app.getUrl()}`);
}

NestJS Request Logging Interceptor

// Required modules imported for request logging interceptor
import { Injectable, NestInterceptor, ExecutionContext, CallHandler, Logger } from '@nestjs/common';
import { Observable } from 'rxjs';
import { catchError, tap } from 'rxjs/operators';

@Injectable()
export class ReqLoggingInterceptor implements NestInterceptor {
  private readonly logger = new Logger('HTTP_REQUEST');

  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    // Extracting request and response objects
    const req = context.switchToHttp().getRequest();
    const res = context.switchToHttp().getResponse();

    // Recording current timestamp
    const now = Date.now();

    // Checking environment for production
    const isProduction = process.env.DB_HOST?.toLowerCase()?.includes('stage') || process.env.NODE_ENV === 'local';

    // Constructing log message
    const logMessage =
      `METHOD - ${req.method} | URL - ${req.url} | ` +
      (!isProduction
        ? ''
        : `QUERY - ${JSON.stringify(req.query)} | PARAMS - ${JSON.stringify(req.params)} | BODY - ${JSON.stringify(req.body)} `) +
      `${this.getColorizedStatusCode(res.statusCode)} ${Date.now() - now} ms`;

    // Handling the observable
    return next.handle().pipe(
      tap(() => {
        // Logging request details on success
       req.url && this.logger.log(logMessage);
      }),
      catchError((error) => {
        // Logging request details on error and rethrowing the error
      req.url && this.logger.log(logMessage);
        throw error;
      }),
    );
  }

  private getColorizedStatusCode(statusCode: number): string {
    // ANSI escape codes for colorizing status code
    const yellow = '\x1b[33m';
    const reset = '\x1b[0m';

    return `${yellow}${statusCode}${reset}`;
  }
}

Instead of using external libraries like morgan, I have implemented a custom logging interceptor in NestJS...

Additional Note:

1. I include request body, query, and params in logs for easier debugging of errors.

Give this code a try =>

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
    use(req: Request, res: Response, next: Function) {
        const { ip, method, originalUrl: url  } = req;
        const hostname = require('os').hostname();
        const userAgent = req.get('user-agent') || '';
        const referer = req.get('referer') || '';

        res.on('close', () => {
            const { statusCode, statusMessage } = res;
            const contentLength = res.get('content-length');
            logger.log(`[${hostname}] "${method} ${url}" ${statusCode} ${statusMessage} ${contentLength} "${referer}" "${userAgent}" "${ip}"`);
        });

        next();
    }
}

merge(fromEvent())

import { NestMiddleware, Injectable } from '@nestjs/common';
import { FastifyRequest, FastifyReply } from 'fastify';
import { InjectPinoLogger, PinoLogger } from 'nestjs-pino';
import serializers from 'pino-std-serializers';
import { merge, fromEvent, first } from 'rxjs';


@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  constructor(
    @InjectPinoLogger(LoggerMiddleware.name)
    private readonly logger: PinoLogger,
  ) {}

  use(req: FastifyRequest, res: FastifyReply['raw'], next: (error?: Error) => void) {
    
    // Logging request information
    const method = req.method;
    const url = req.url;
    const now = Date.now();
    const traceId = this.cls.get<IAsyncStorage>(TRACE_ID);

    this.logger.assign({ traceIdContext: traceId.value });

    this.logger.debug({
      info: {
        url,
        now,
        method,
        country,
        request: serializers.req(req),
        requestType: 'external-request',
      },
    });
    
    // Constructing data for logging the response
    const loggerData = {
      info: {
        url,
        method,
        country,
        response: serializers.res(res),
        requestType: 'response-from',
        data: '<omitted>', // JSON.stringify(this.responseJson),
      },
    };

    // Handling events for response completion and error
    const event$ = merge(fromEvent(res, 'finish'), fromEvent(res, 'close'));
    const eventError$ = merge(fromEvent(res, 'error'));

    // Subscribing to handle response completion event
    event$.pipe(first()).subscribe({
      next: () => {
        this.logger.debug(loggerData);
      },
    });

    // Subscribing to handle response error event
    eventError$.pipe(first()).subscribe({
      next: () => {
        this.logger.error(loggerData);
      },
    });

    return next(); // Proceed to the next middleware in the chain
  }
}

Dealing with the issue of logging the correct status code can be tricky, especially when filters run after interceptors. I found that implementing the logging directly in the interceptor was the most reliable solution for me, similar to what you have done in your code. By leveraging the observable in the interceptor, you can ensure that functions are executed after successful or error completions.

One challenge I faced was that the status code on the response may not always be properly set, even within the tap or catchError operators. To work around this, I checked the method of the request - if it's a POST method, then a successful response is a 201; otherwise, it is always a 200. In case of an error, I extracted the status code from the error object instead of relying on the response object. This ensured that the status code would be available on my error object before the observable completes, thanks to my Exception filter running beforehand.