Multi-driver logging system with structured logging support. AdonisJS Core re-exports the complete @adonisjs/logger package for comprehensive application logging across different environments and destinations.
Central logging manager supporting multiple drivers and log destinations.
/**
* Logger manager for multi-driver logging system
*/
class LoggerManager {
/**
* Use specific logger driver
* @param name - Logger name (optional, uses default if not provided)
* @returns Logger instance
*/
use(name?: string): Logger;
/**
* Log info message using default logger
* @param message - Log message
* @param meta - Additional metadata
*/
info(message: string, meta?: LogMetadata): void;
/**
* Log error message using default logger
* @param message - Log message
* @param meta - Additional metadata
*/
error(message: string, meta?: LogMetadata): void;
/**
* Log warning message using default logger
* @param message - Log message
* @param meta - Additional metadata
*/
warn(message: string, meta?: LogMetadata): void;
/**
* Log debug message using default logger
* @param message - Log message
* @param meta - Additional metadata
*/
debug(message: string, meta?: LogMetadata): void;
/**
* Log trace message using default logger
* @param message - Log message
* @param meta - Additional metadata
*/
trace(message: string, meta?: LogMetadata): void;
/**
* Log fatal message using default logger
* @param message - Log message
* @param meta - Additional metadata
*/
fatal(message: string, meta?: LogMetadata): void;
/**
* Create child logger with additional context
* @param bindings - Context to bind to child logger
* @returns Child logger instance
*/
child(bindings: LogBindings): Logger;
}Usage Examples:
import { LoggerManager } from "@adonisjs/core/logger";
const logger = new LoggerManager();
// Basic logging
logger.info('Application started successfully');
logger.warn('Database connection slow', { responseTime: 1500 });
logger.error('Failed to process payment', {
orderId: 'order_123',
error: 'Card declined'
});
// Use specific logger driver
const fileLogger = logger.use('file');
fileLogger.info('This goes to file');
const consoleLogger = logger.use('console');
consoleLogger.debug('This goes to console');
// Child logger with context
const requestLogger = logger.child({
requestId: 'req_abc123',
userId: 456
});
requestLogger.info('Processing user request');Individual logger instance with level-based logging methods.
/**
* Logger instance for performing logging operations
*/
interface Logger {
/**
* Log info level message
* @param message - Log message
* @param meta - Additional metadata
*/
info(message: string, meta?: LogMetadata): void;
/**
* Log error level message
* @param message - Log message
* @param meta - Additional metadata
*/
error(message: string, meta?: LogMetadata): void;
/**
* Log warning level message
* @param message - Log message
* @param meta - Additional metadata
*/
warn(message: string, meta?: LogMetadata): void;
/**
* Log debug level message
* @param message - Log message
* @param meta - Additional metadata
*/
debug(message: string, meta?: LogMetadata): void;
/**
* Log trace level message
* @param message - Log message
* @param meta - Additional metadata
*/
trace(message: string, meta?: LogMetadata): void;
/**
* Log fatal level message
* @param message - Log message
* @param meta - Additional metadata
*/
fatal(message: string, meta?: LogMetadata): void;
/**
* Create child logger with additional bindings
* @param bindings - Context to bind to child logger
* @returns Child logger instance
*/
child(bindings: LogBindings): Logger;
/**
* Check if level is enabled
* @param level - Log level to check
* @returns True if level is enabled
*/
isLevelEnabled(level: LogLevel): boolean;
/**
* Get current log level
* @returns Current log level
*/
level: LogLevel;
}Configuration system for setting up logging drivers and formatters.
/**
* Define logger configuration
* @param config - Logger configuration object
* @returns Validated logger configuration
*/
function defineConfig(config: LoggerConfig): LoggerConfig;
/**
* Logger configuration interface
*/
interface LoggerConfig {
/** Default logger to use */
default: string;
/** Available logger configurations */
loggers: Record<string, LoggerDriverConfig>;
}
/**
* Available logger drivers
*/
const targets: {
/** Pretty console output for development */
pretty: PrettyTargetFactory;
/** JSON console output for production */
console: ConsoleTargetFactory;
/** File-based logging */
file: FileTargetFactory;
/** Rotating file logs */
fileRotating: FileRotatingTargetFactory;
};Usage Examples:
import { defineConfig, targets } from "@adonisjs/core/logger";
export default defineConfig({
default: 'app',
loggers: {
app: {
enabled: true,
name: 'adonisjs-app',
level: 'info',
transport: {
targets: [
targets.pretty({
messageKey: 'msg'
}),
targets.file({
destination: 'logs/app.log',
sync: false
})
]
}
},
database: {
enabled: true,
name: 'database',
level: 'debug',
transport: {
targets: [
targets.file({
destination: 'logs/database.log',
sync: false
})
]
}
}
}
});Different output destinations for log messages.
/**
* Pretty console target for development
*/
interface PrettyTargetFactory {
(config: PrettyTargetConfig): LogTarget;
}
/**
* Console target for structured JSON output
*/
interface ConsoleTargetFactory {
(config: ConsoleTargetConfig): LogTarget;
}
/**
* File target for file-based logging
*/
interface FileTargetFactory {
(config: FileTargetConfig): LogTarget;
}
/**
* Rotating file target for log rotation
*/
interface FileRotatingTargetFactory {
(config: FileRotatingTargetConfig): LogTarget;
}
/**
* Log target interface
*/
interface LogTarget {
target: string;
level?: LogLevel;
options: Record<string, any>;
}Support for structured logging with metadata and context.
/**
* Structured log entry
*/
interface LogEntry {
/** Log level */
level: LogLevel;
/** Log message */
message: string;
/** Timestamp */
time: Date;
/** Logger name */
name: string;
/** Process ID */
pid: number;
/** Hostname */
hostname: string;
/** Additional metadata */
[key: string]: any;
}
/**
* Log bindings for child loggers
*/
interface LogBindings {
/** Request ID for tracing */
requestId?: string;
/** User ID for user-specific logs */
userId?: number | string;
/** Session ID */
sessionId?: string;
/** Custom context fields */
[key: string]: any;
}
/**
* Log metadata for additional context
*/
interface LogMetadata {
/** Error object */
error?: Error;
/** HTTP status code */
statusCode?: number;
/** Response time in milliseconds */
responseTime?: number;
/** Database query */
query?: string;
/** Custom metadata fields */
[key: string]: any;
}Usage Examples:
// Structured logging with metadata
logger.info('User authenticated successfully', {
userId: 123,
email: 'user@example.com',
loginMethod: 'password',
responseTime: 145
});
logger.error('Database connection failed', {
error: new Error('Connection timeout'),
database: 'primary',
host: 'db.example.com',
port: 5432
});
// Child logger with request context
const requestLogger = logger.child({
requestId: 'req_123abc',
method: 'POST',
url: '/api/users',
userAgent: 'Mozilla/5.0...'
});
requestLogger.info('Processing request');
requestLogger.warn('Slow database query', { queryTime: 2000 });
requestLogger.info('Request completed', { statusCode: 201 });Custom formatters for different log output formats.
/**
* Log formatter interface
*/
interface LogFormatter {
/**
* Format log entry
* @param entry - Log entry to format
* @returns Formatted log string
*/
format(entry: LogEntry): string;
}
/**
* Built-in formatters
*/
namespace Formatters {
/**
* JSON formatter for structured output
*/
class JsonFormatter implements LogFormatter {
format(entry: LogEntry): string;
}
/**
* Pretty formatter for human-readable output
*/
class PrettyFormatter implements LogFormatter {
constructor(options?: PrettyFormatterOptions);
format(entry: LogEntry): string;
}
/**
* Simple text formatter
*/
class SimpleFormatter implements LogFormatter {
constructor(options?: SimpleFormatterOptions);
format(entry: LogEntry): string;
}
}Hierarchical log levels for filtering messages.
/**
* Available log levels (in order of severity)
*/
type LogLevel =
| 'trace' // Most verbose
| 'debug' // Debug information
| 'info' // General information
| 'warn' // Warning messages
| 'error' // Error messages
| 'fatal'; // Fatal errors
/**
* Log level utilities
*/
namespace LogLevels {
/**
* Check if level A includes level B
* @param levelA - Base level
* @param levelB - Level to check
* @returns True if levelA includes levelB
*/
function includes(levelA: LogLevel, levelB: LogLevel): boolean;
/**
* Get numeric value for log level
* @param level - Log level
* @returns Numeric level value
*/
function getValue(level: LogLevel): number;
/**
* Get all levels at or above specified level
* @param level - Minimum level
* @returns Array of included levels
*/
function getIncludedLevels(level: LogLevel): LogLevel[];
}interface LoggerDriverConfig {
enabled: boolean;
name: string;
level: LogLevel;
transport: {
targets: LogTarget[];
};
}
interface PrettyTargetConfig {
messageKey?: string;
levelKey?: string;
timeKey?: string;
colorize?: boolean;
ignore?: string[];
}
interface ConsoleTargetConfig {
messageKey?: string;
levelKey?: string;
timeKey?: string;
}
interface FileTargetConfig {
destination: string;
sync?: boolean;
mkdir?: boolean;
append?: boolean;
}
interface FileRotatingTargetConfig extends FileTargetConfig {
frequency?: 'daily' | 'hourly' | 'test';
size?: string;
maxFiles?: number;
dateFormat?: string;
}
interface PrettyFormatterOptions {
colorize?: boolean;
includeTimestamp?: boolean;
timestampFormat?: string;
}
interface SimpleFormatterOptions {
includeTimestamp?: boolean;
timestampFormat?: string;
includeLevel?: boolean;
includeName?: boolean;
}
interface LoggerManagerConfig {
default: string;
loggers: Record<string, LoggerDriverConfig>;
}