@neoma/logging
Version:
Great logging for NestJs
164 lines • 6.5 kB
JavaScript
;
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var LoggingModule_1;
Object.defineProperty(exports, "__esModule", { value: true });
exports.LoggingModule = void 0;
const common_1 = require("@nestjs/common");
const services_1 = require("@lib/services");
const symbols_1 = require("@lib/symbols");
const request_logger_middleware_1 = require("@lib/middlewares/request-logger.middleware");
const request_logger_interceptor_1 = require("@lib/interceptors/request-logger.interceptor");
const core_1 = require("@nestjs/core");
/**
* NestJS module providing structured logging capabilities with automatic request tracing.
*
* Features:
* - **Two logger services**: ApplicationLoggerService (app-scoped) and RequestLoggerService (request-scoped)
* - **Automatic request logging**: Logs incoming requests and responses when `logLevel: 'debug'`
* - **Middleware integration**: RequestLoggerService automatically available as `req.logger` on all routes
* - **Error interceptor**: Configurable automatic error logging with `logErrors` option
* - **Field redaction**: Configurable sensitive data masking
* - **Request tracing**: Automatic ULID generation or header extraction for request correlation
* - **Context injection**: Merge custom metadata into all log entries
* - **Performance optimized**: Uses Pino logger internally for high throughput
*
* @example
* **Basic usage:**
* ```typescript
* @Module({
* imports: [LoggingModule] // Uses defaults
* })
* export class AppModule {}
* ```
*
* @example
* **Advanced configuration:**
* ```typescript
* @Module({
* imports: [
* LoggingModule.forRoot({
* logLevel: 'debug', // Enable request logging
* logContext: { service: 'user-api' }, // Add to all logs
* logRedact: ['password', '*.secret'], // Redact sensitive fields
* logRequestTraceIdHeader: 'x-trace-id', // Extract trace IDs
* logErrors: true // Log intercepted errors
* })
* ]
* })
* export class AppModule {}
* ```
*
* @example
* **Using the loggers:**
* ```typescript
* @Injectable()
* export class UserService {
* constructor(
* private appLogger: ApplicationLoggerService, // App-scoped
* private reqLogger: RequestLoggerService // Request-scoped
* ) {}
*
* async createUser(data: CreateUserDto) {
* // App logger - no request context
* this.appLogger.log('Creating new user')
*
* // Request logger - includes request context + trace ID
* this.reqLogger.log('User creation started', { email: data.email })
* }
* }
* ```
*
* @example
* **Using req.logger (middleware approach):**
* ```typescript
* @Controller('users')
* export class UserController {
* @Get(':id')
* getUser(@Req() req: Request, @Param('id') id: string) {
* // RequestLoggerService automatically available on req.logger
* req.logger.log('Fetching user', { userId: id })
* return this.userService.findById(id)
* }
* }
* ```
*/
let LoggingModule = LoggingModule_1 = class LoggingModule {
/**
* Configure the LoggingModule with custom options.
*
* This method creates a configured dynamic module that sets up both logger services
* with shared configuration. All options are optional and have sensible defaults.
*
* @param options - Logging configuration options (see LoggingConfiguration interface)
* @returns Configured DynamicModule for use in module imports
*
* @example
* **Production setup:**
* ```typescript
* LoggingModule.forRoot({
* logLevel: 'log', // Standard production level
* logContext: {
* service: 'user-service',
* version: process.env.APP_VERSION,
* environment: process.env.NODE_ENV
* },
* logRedact: ['password', '*.secret', 'authorization'],
* logRequestTraceIdHeader: 'x-correlation-id'
* })
* ```
*
* @example
* **Development setup:**
* ```typescript
* LoggingModule.forRoot({
* logLevel: 'debug', // Enable request logging
* logContext: { service: 'api-dev' },
* logErrors: true // Log intercepted errors
* })
* ```
*
* **Behavior:**
* - ApplicationLoggerService: Application-scoped, includes `logContext`
* - RequestLoggerService: Request-scoped, includes `logContext` + request details + trace ID
* - RequestLoggerMiddleware: Attaches RequestLoggerService to `req.logger` for all routes
* - RequestLoggerInterceptor: Automatically logs requests/responses when `logLevel: 'debug'`
* - Error logging: Configurable via `logErrors` option for intercepted errors
*/
static forRoot(options = {}) {
return {
module: LoggingModule_1,
providers: [
{
provide: symbols_1.LOGGING_MODULE_OPTIONS,
useValue: options,
},
],
exports: [services_1.ApplicationLoggerService],
};
}
configure(consumer) {
consumer.apply(request_logger_middleware_1.RequestLoggerMiddleware).forRoutes("*");
}
};
exports.LoggingModule = LoggingModule;
exports.LoggingModule = LoggingModule = LoggingModule_1 = __decorate([
(0, common_1.Module)({
providers: [
services_1.ApplicationLoggerService,
services_1.RequestLoggerService,
{ provide: symbols_1.LOGGING_MODULE_OPTIONS, useValue: {} },
request_logger_middleware_1.RequestLoggerMiddleware,
{
provide: core_1.APP_INTERCEPTOR,
useClass: request_logger_interceptor_1.RequestLoggerInterceptor,
},
],
exports: [services_1.ApplicationLoggerService, services_1.RequestLoggerService],
})
], LoggingModule);
//# sourceMappingURL=logging.module.js.map