portfree/dist/utils/logger.js

A cross-platform CLI tool for managing processes running on specific ports

"use strict";
/**
 * Simple logging utility for debugging purposes
 * Provides different log levels and can be controlled via environment variables
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.logger = exports.Logger = exports.LOG_LEVELS = void 0;
exports.createLogger = createLogger;
/**
 * Log levels in order of severity
 */
exports.LOG_LEVELS = {
    ERROR: 0,
    WARN: 1,
    INFO: 2,
    DEBUG: 3,
    TRACE: 4
};
/**
 * Logger class for debugging and information output
 */
class Logger {
    /**
     * Create a new Logger instance
     * @param name - Logger name (usually module or class name)
     */
    constructor(name = 'PortFree') {
        this.name = name;
        this.level = this._getLogLevel();
    }
    /**
     * Get the current log level from environment variables
     * @returns Log level number
     * @private
     */
    _getLogLevel() {
        const envLevel = process.env.PORTFREE_LOG_LEVEL ?? process.env.LOG_LEVEL ?? 'INFO';
        const level = exports.LOG_LEVELS[envLevel.toUpperCase()];
        return level !== undefined ? level : exports.LOG_LEVELS.INFO;
    }
    /**
     * Check if a log level should be output
     * @param level - Log level to check
     * @returns True if should log
     * @private
     */
    _shouldLog(level) {
        return level <= this.level;
    }
    /**
     * Format log message with timestamp and level
     * @param level - Log level name
     * @param message - Log message
     * @param args - Additional arguments
     * @returns Formatted message
     * @private
     */
    _formatMessage(level, message, ...args) {
        const timestamp = new Date().toISOString();
        const formattedArgs = args.length > 0 ? ' ' + args.map(arg => typeof arg === 'object' ? JSON.stringify(arg, null, 2) : String(arg)).join(' ') : '';
        return `[${timestamp}] ${level} [${this.name}] ${message}${formattedArgs}`;
    }
    /**
     * Log error message
     * @param message - Error message
     * @param args - Additional arguments
     */
    error(message, ...args) {
        if (this._shouldLog(exports.LOG_LEVELS.ERROR)) {
            console.error(this._formatMessage('ERROR', message, ...args));
        }
    }
    /**
     * Log warning message
     * @param message - Warning message
     * @param args - Additional arguments
     */
    warn(message, ...args) {
        if (this._shouldLog(exports.LOG_LEVELS.WARN)) {
            console.warn(this._formatMessage('WARN', message, ...args));
        }
    }
    /**
     * Log info message
     * @param message - Info message
     * @param args - Additional arguments
     */
    info(message, ...args) {
        if (this._shouldLog(exports.LOG_LEVELS.INFO)) {
            console.log(this._formatMessage('INFO', message, ...args));
        }
    }
    /**
     * Log debug message
     * @param message - Debug message
     * @param args - Additional arguments
     */
    debug(message, ...args) {
        if (this._shouldLog(exports.LOG_LEVELS.DEBUG)) {
            console.log(this._formatMessage('DEBUG', message, ...args));
        }
    }
    /**
     * Log trace message
     * @param message - Trace message
     * @param args - Additional arguments
     */
    trace(message, ...args) {
        if (this._shouldLog(exports.LOG_LEVELS.TRACE)) {
            console.log(this._formatMessage('TRACE', message, ...args));
        }
    }
    /**
     * Create a child logger with a specific name
     * @param name - Child logger name
     * @returns New logger instance
     */
    child(name) {
        return new Logger(`${this.name}:${name}`);
    }
}
exports.Logger = Logger;
/**
 * Default logger instance
 */
exports.logger = new Logger();
/**
 * Create a logger with a specific name
 * @param name - Logger name
 * @returns Logger instance
 */
function createLogger(name) {
    return new Logger(name);
}
//# sourceMappingURL=logger.js.map