LoggerFactory

Factory for creating context-bound logger instances.

Import

import { LoggerFactory } from '@shinijs/logger';

Usage

import { Injectable } from '@nestjs/common';
import { LoggerFactory } from '@shinijs/logger';

@Injectable()
export class MyService {
  private readonly logger = LoggerFactory.createLogger('MyService');

  doWork() {
    this.logger.info('Working...'); // Context is automatically 'MyService'
  }
}

Methods

createLogger(context: string): ContextBoundLogger

Creates a context-bound logger instance that automatically applies the specified context to all log messages.

Parameters:

• context - The context name (e.g., service name)

Returns: A ContextBoundLogger instance

Example:

const logger = LoggerFactory.createLogger('OrderService');

logger.info('Processing order'); // Context: 'OrderService'
logger.error('Order failed', error); // Context: 'OrderService'

getBaseLogger(): CustomLogger

Gets the base logger instance (singleton).

Returns: The base CustomLogger instance

Example:

const baseLogger = LoggerFactory.getBaseLogger();
baseLogger.setContext('Global');

ContextBoundLogger

The logger returned by createLogger() is a context-bound logger with an immutable context. It implements NestJS LoggerService for full compatibility with NestJS's standard logger interface.

Methods

All logging methods are available with the same signatures as CustomLogger, plus support for NestJS LoggerService signatures:

• log(message: string, context?: string): void
• info(message: string, meta?: Record<string, unknown>, context?: LogContext): void
• error(message: string, error?: Error | unknown, context?: LogContext): void
• warn(message: string, meta?: Record<string, unknown>, context?: LogContext): void
• debug(message: string, meta?: Record<string, unknown>, context?: LogContext): void
• verbose(message: string, meta?: Record<string, unknown>, context?: LogContext): void
• getContext(): string - Returns the bound context
• setContext(context: string): void - No-op (context is immutable)

NestJS LoggerService Compatibility

ContextBoundLogger implements LoggerService, making it compatible with any NestJS module that accepts a logger:

import { LoggerService } from '@nestjs/common';
import { LoggerFactory } from '@shinijs/logger';

const logger = LoggerFactory.createLogger('MyService');
// logger implements LoggerService
const nestLogger: LoggerService = logger; // ✅ Type-safe

Immutable Context

The context is set when the logger is created and cannot be changed:

const logger = LoggerFactory.createLogger('MyService');

logger.setContext('OtherService'); // Does nothing - context remains 'MyService'
logger.getContext(); // Returns 'MyService'

Use Cases

Service-Level Logging

@Injectable()
export class UserService {
  private readonly logger = LoggerFactory.createLogger('UserService');

  async createUser(data: CreateUserDto) {
    this.logger.info('Creating user', { email: data.email });
    // All logs automatically include 'UserService' context
  }
}

Multiple Loggers

@Injectable()
export class ComplexService {
  private readonly logger = LoggerFactory.createLogger('ComplexService');
  private readonly auditLogger = LoggerFactory.createLogger('Audit');

  performAction() {
    this.logger.info('Action performed'); // Context: 'ComplexService'
    this.auditLogger.info('Action audited'); // Context: 'Audit'
  }
}

Class Property Initialization

export class MyClass {
  private readonly logger = LoggerFactory.createLogger('MyClass');

  constructor() {
    // Logger is ready to use
    this.logger.debug('Class instantiated');
  }
}

Benefits

• Immutability - Context cannot be accidentally changed
• Type Safety - Full TypeScript support
• Convenience - No need to call setContext() repeatedly
• Consistency - All logs from a service have the same context

See Also

• CustomLogger - Base logger service
• Context Logging - Advanced context patterns
• Examples - Usage examples