Simplest Morgan NestJS Middleware

morgan.nestjs.middleware.ts

import { Injectable, MiddlewareFunction, NestMiddleware } from '@nestjs/common';
import * as morgan from 'morgan';
import { LoggerService } from './mylogger';

@Injectable()
export class MorganMiddleware implements NestMiddleware {
  constructor(private readonly logger: LoggerService) {}
  resolve(): MiddlewareFunction {
    return morgan('combined', {
      stream: { write: str => this.logger.info(str) },
    });
  }
}

Hi,
Thanks for sharing!

In the new version of NestJS, it should look like

import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';
import { AppLogger } from '../../modules/monitor/logger/app-logger';
import * as morgan from 'morgan';
@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  constructor(private readonly logger: AppLogger) {}
  use(req: Request, res: Response, next: NextFunction) {
    morgan('combined', {
      stream: { write: (str) => this.logger.log(str) },
    });
    next();
  }
}

And it needs to be consumed in the app module, like so

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

This is how I solved it:

This does not make use of a NestMiddleware, but connects morgan directly to winston.

main.ts

async function bootstrap() {
    const app = await NestFactory.create(AppModule);

    // Add Winston logger middleware
    const logger = app.get(WINSTON_MODULE_NEST_PROVIDER);
    app.useLogger(logger);

    // Log request/responses
    app.use(
        morgan("common", {
            stream: {
                write: (message) => {
                    logger.log(message);
                },
            },
        })
    );

    await app.listen(PORT);
}

bootstrap();

app.module.ts

@Module({
    imports: [
        WinstonModule.forRootAsync({
            useClass: WinstonConfigService,
        }),
    ],
})
export class AppModule {}

HI 👋,

I do this:

import { Injectable, Logger, NestMiddleware } from '@nestjs/common'
import * as morgan from 'morgan'

@Injectable()
export class HttpLoggerMiddleware implements NestMiddleware {
  private readonly logger = new Logger(HttpLoggerMiddleware.name)

  use(req: any, res: any, next: () => void) {
    morgan(process.env.NODE_ENV === 'production' ? 'common' : 'dev', {
      stream: {
        write: (message) => this.logger.log(message)
      }
    })(req, res, next)
  }
}