@neoma/logging/dist/logging.module.d.ts

Great logging for NestJs

import { DynamicModule, MiddlewareConsumer, NestModule } from "@nestjs/common";
import { LoggingConfiguration } from "@lib/interfaces";
/**
 * 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)
 *   }
 * }
 * ```
 */
export declare class LoggingModule implements NestModule {
    /**
     * 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?: LoggingConfiguration): DynamicModule;
    configure(consumer: MiddlewareConsumer): void;
}