A Nest module wrapper for winston , provides multi type of loggers.
Inspired by nest-winston
Installation
npm install --save nest-winston-module winston
Quick Start
Import WinstonModule
into the root AppModule
and use the forRoot()
method to configure it. This method accepts the same options object as createLogger()
function from the winston package:
import { Module } from '@nestjs/common';
import { WinstonModule } from 'nest-winston-module';
import * as winston from 'winston';
@Module({
imports: [
WinstonModule.forRoot({
// options
}),
],
})
export class AppModule {}
Afterward, the winston instance will be available to inject across entire project using the winston
injection token,
nest-winston-module
provide a token enum for you, to make handling different type of logs easier. here is what the injection token enum looks like:
enum WinstonProviderEnum {
/**
* @description for replacing nest core logger
*/
coreProvider = 'winstonCoreProvider',
/**
* @description application level logger
*/
appProvider = 'winstonAppProvider',
/**
* @description controller logger
*/
controllerProvider = 'winstonControllerProvider',
/**
* @description graphQL resolver logger
*/
resolverProvider = 'winstonResolverProvider',
/**
* @description service logger
*/
serviceProvider = 'winstonServiceProvider',
/**
* @description console logger
*/
consoleProvider = 'winstonConsoleProvider',
/**
* @description all logger providers map
*/
loggersProvider = 'winstonLoggersProvider',
}
Here is an example using winston logger in Nest Controller
:
import { Controller, Inject } from '@nestjs/common';
import { WinstonProviderEnum, NestWinstonLogger } from 'nest-winston-module';
@Controller('cats')
export class CatsController {
constructor(@Inject(WinstonProviderEnum.controllerProvider) private readonly logger: NestWinstonLogger) { }
}
Note that WinstonModule
is a global module, it will be available in all your feature modules.
Async configuration
Caveats: because the way Nest works, you can't inject dependencies exported from the root module itself (using
exports
). If you useforRootAsync()
and need to inject a service, that service must be either imported using theimports
options or exported from a global module.
Maybe you need to asynchronously pass your module options, for example when you need a configuration service. In such case, use the forRootAsync()
method, returning an options object from the useFactory
method:
import { Module } from '@nestjs/common';
import { WinstonModule } from 'nest-winston-module';
import * as winston from 'winston';
@Module({
imports: [
WinstonModule.forRootAsync({
useFactory: () => ({
// options
}),
inject: [],
}),
],
})
export class AppModule {}
The factory might be async, can inject dependencies with inject
option and import other modules using the imports
option.
Alternatively, you can use the useClass
syntax:
WinstonModule.forRootAsync({
useClass: WinstonConfigService,
})
With the above code, Nest will create a new instance of WinstonConfigService
and its method createWinstonModuleOptions
will be called in order to provide the module options.
Use as the main Nest logger
Apart from application logging, this module also provides the WinstonLogger
custom implementation, for use with the Nest logging system. Example main.ts
file:
import { WinstonProviderEnum } from 'nest-winston-module';
async function bootstrap() {
const app = await NestFactory.create(AppModule);
app.useLogger(app.get(WinstonProviderEnum.coreProvider));
}
bootstrap();
Here the get()
method on the NestApplication instance is used to retrieve the singleton instance of WinstonLogger
class, which is still configured using either WinstonModule.forRoot
or WinstonModule.forRootAsync
methods.
When using this technique, you can only inject the logger using the WinstonProviderEnum.coreProvider
token. Because winston
logger interface is different from Nest
logger interface.
Use as the main Nest logger (also for bootstrapping)
Using the dependency injection has one minor drawback. Nest has to bootstrap the application first (instantiating modules and providers, injecting dependencies, etc) and during this process the instance of WinstonLogger
is not yet available, which means that Nest falls back to the internal logger.
One solution is to create the logger outside of the application lifecycle, using the createLogger
function, and pass it to NestFactory.create
:
import { WinstonModule } from 'nest-winston-module';
async function bootstrap() {
const app = await NestFactory.create(AppModule, {
logger: WinstonModule.createLogger({
// options (same as WinstonModule.forRoot() options)
})
});
}
bootstrap();
By doing this, you give up the dependency injection, meaning that WinstonModule.forRoot
and WinstonModule.forRootAsync
are not needed anymore.
To use the logger also in your application, change your main module to provide the Logger
service from @nestjs/common
:
import { Logger, Module } from '@nestjs/common';
@Module({
providers: [Logger],
})
export class AppModule {}
Then simply inject the Logger
:
import { Controller, Inject, Logger, LoggerService } from '@nestjs/common';
@Controller('cats')
export class CatsController {
constructor(@Inject(Logger) private readonly logger: LoggerService) { }
}
This works because Nest Logger
wraps our winston logger (the same instance returned by the createLogger
method) and will forward all calls to it.
Utilities
The module also provides a custom Nest-like special formatter for console transports:
import { Module } from '@nestjs/common';
import {
coreOptions,
appOptions,
controllerOptions,
resolverOptions,
serviceOptions,
consoleOptions,
} from 'nest-winston-module';
import * as winston from 'winston';
@Module({
imports: [
WinstonModule.forRoot({
core: coreOptions,
app: appOptions,
resolver: resolverOptions,
controller: controllerOptions,
service: serviceOptions,
console: consoleOptions,
directory: process.cwd() + '/logs',
}),
],
})
export class AppModule {}