nestjs-pino

What is nestjs-pino?

The `nestjs-pino` package is a logging module for NestJS applications that integrates the Pino logger. Pino is a fast, low-overhead logging library for Node.js. This package allows you to leverage Pino's performance and features within a NestJS application.

What are nestjs-pino's main functionalities?

Basic Logging

This feature allows you to set up basic logging in a NestJS application using Pino. The `LoggerModule.forRoot` method configures the logger with the specified options.

const { LoggerModule } = require('nestjs-pino');

@Module({
  imports: [
    LoggerModule.forRoot({
      pinoHttp: { level: 'info' }
    })
  ]
})
export class AppModule {}

Request Logging

This feature enables logging of HTTP requests. The `pinoHttp` option allows you to configure the logging level and other settings for HTTP request logging.

const { LoggerModule } = require('nestjs-pino');

@Module({
  imports: [
    LoggerModule.forRoot({
      pinoHttp: { level: 'info', prettyPrint: true }
    })
  ]
})
export class AppModule {}

Custom Logger Configuration

This feature allows you to provide a custom configuration for the logger using a factory function. This is useful for dynamic configuration based on environment variables or other runtime conditions.

const { LoggerModule } = require('nestjs-pino');

@Module({
  imports: [
    LoggerModule.forRootAsync({
      useFactory: () => ({
        pinoHttp: { level: 'debug', prettyPrint: true }
      })
    })
  ]
})
export class AppModule {}

Other packages similar to nestjs-pino

winston

Winston is another popular logging library for Node.js. It is highly configurable and supports multiple transports (e.g., console, file, HTTP). Compared to Pino, Winston is more feature-rich but generally slower in performance.

bunyan

Bunyan is a simple and fast JSON logging library for Node.js. Like Pino, it focuses on performance and structured logging. However, Pino is generally considered faster and more modern.

log4js

Log4js is a logging library inspired by the Java library log4j. It supports various appenders (e.g., console, file, SMTP) and is highly configurable. While it offers more features, it is not as performant as Pino.

README

NestJS-Pino

✨✨✨ Platform agnostic logger for NestJS based on Pino with REQUEST CONTEXT IN EVERY LOG ✨✨✨

Example

In controller:

import { Logger } from 'nestjs-pino';

@Controller()
export class AppController {
  constructor(
    private readonly myService: MyService,
    private readonly logger: Logger
  ) {}

  @Get()
  getHello(): string {
    this.logger.log("calling AppController.getHello");
    return `Hello ${this.myService.getWorld()}`;
  }
}

In service:

import { Logger } from 'nestjs-pino';

@Injectable()
export class MyService {
  constructor(private readonly logger: Logger) {}

  getWorld() {
    this.logger.debug("calling MyService.getWorld");
    return "World!";
  }
}

Output (every log has request context):

{"level":30,"time":1568720266616,"pid":25566,"hostname":"my-host","req":{"id":1,"method":"GET","url":"/","headers":{...},"remoteAddress":"::1","remotePort":53753},"msg":"calling AppController.getHello","v":1}
{"level":20,"time":1568720266616,"pid":25566,"hostname":"my-host","req":{"id":1,"method":"GET","url":"/","headers":{...},"remoteAddress":"::1","remotePort":53753},"msg":"calling MyService.getWorld","v":1}
{"level":30,"time":1568720266623,"pid":25566,"hostname":"my-host","req":{"id":1,"method":"GET","url":"/","headers":{...},"remoteAddress":"::1","remotePort":53753},"res":{"statusCode":200,"headers":{...}},"responseTime":9,"msg":"request completed","v":1}

Install

npm i nestjs-pino

Register module

Default params

Just import LoggerModule to your module:

import { LoggerModule } from 'nestjs-pino';

@Module({
  imports: [LoggerModule.forRoot()],
  ...
})
class MyModule {}

Configure

Also, you can configure it. forRoot function has the same API as express-pino-logger has (it's the same as pino itself and can take existing logger via { logger: pino(...) }):

import { LoggerModule } from 'nestjs-pino';

@Module({
  imports: [
    LoggerModule.forRoot(
      {
        name: 'add some name to every JSON line',
        level: process.env.NODE_ENV !== 'production' ? 'debug' : 'info',
        prettyPrint: process.env.NODE_ENV !== 'production',
        useLevelLabels: true,
        // and all the others...
      },
      someWritableStream
    )
  ],
  ...
})
class MyModule {}

Extreme mode

If you want to enable extreme mode you should read pino extreme mode docs first.

If you are ok with that, so you can configure module like this:

import * as pino from 'pino';
import { LoggerModule } from 'nestjs-pino';

const dest = pino.extreme();
const logger = pino(dest);

@Module({
  imports: [LoggerModule.forRoot({ logger })],
  ...
})
class MyModule {}

Also you can read more about Log loss prevention.

Usage as Logger service

Logger implements standard NestJS LoggerService interface. So if you are familiar with built in NestJS logger you are good to go.

// my.service.ts
import { Logger } from 'nestjs-pino';

@Injectable()
export class MyService {
  constructor(private readonly logger: Logger) {}

  getWorld() {
    this.logger.debug("calling MyService.getWorld");
    return "World!";
  }
}

Usage as NestJS app logger

import { Logger } from 'nestjs-pino';

const app = await NestFactory.create(MyModule, { logger: new Logger() });

FAQ

Q: How does it work?

A: It use express-pino-logger under hood, so every request has it's own child-logger, and with help of async_hooks Logger can get it while calling own methods. So your logs can be groupped by req.id.

Q: Why use async_hooks instead of REQUEST scope?

A: REQUEST scope can have perfomance issues depending on your app. TL;DR: using it will cause to instantiating every class, that injects Logger, as a result it will slow down your app.

Q: I'm using old nodejs version, will it work for me?

A: Please read this.

Q: What about pino built in methods/levels?

A: Pino built in methods are not compatible to NestJS built in LoggerService methods, so decision is to map pino methods to LoggerService methods to save Logger API:

• trace=verbose
• debug=debug
• info=log
• warn=warn
• error=error