@tomisakae/tomibot/dist/utils/logger.util.js

TomiBot - AI Chatbot CLI với Google Genkit. Một chatbot AI thông minh chạy trên command line với giao diện đẹp.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.logger = exports.Logger = void 0;
const config_1 = require("../core/config");
class Logger {
    constructor(context = 'App') {
        this.context = context;
    }
    static setLogLevel(level) {
        Logger.logLevel = level;
    }
    static getLogLevel() {
        return Logger.logLevel;
    }
    debug(message, ...args) {
        if (this.shouldLog('debug')) {
            this.log('debug', message, ...args);
        }
    }
    info(message, ...args) {
        if (this.shouldLog('info')) {
            this.log('info', message, ...args);
        }
    }
    warn(message, ...args) {
        if (this.shouldLog('warn')) {
            this.log('warn', message, ...args);
        }
    }
    error(message, ...args) {
        if (this.shouldLog('error')) {
            this.log('error', message, ...args);
        }
    }
    shouldLog(level) {
        const levels = ['debug', 'info', 'warn', 'error'];
        const currentLevelIndex = levels.indexOf(Logger.logLevel);
        const messageLevelIndex = levels.indexOf(level);
        return messageLevelIndex >= currentLevelIndex;
    }
    log(level, message, ...args) {
        const timestamp = new Date().toISOString();
        const formattedMessage = this.formatMessage(level, timestamp, message);
        if (config_1.config.isDevelopment() || process.env['ENABLE_LOGGING'] === 'true') {
            switch (level) {
                case 'debug':
                    console.debug(formattedMessage, ...args);
                    break;
                case 'info':
                    console.info(formattedMessage, ...args);
                    break;
                case 'warn':
                    console.warn(formattedMessage, ...args);
                    break;
                case 'error':
                    console.error(formattedMessage, ...args);
                    break;
            }
        }
        if (config_1.config.isProduction()) {
            this.sendToExternalLogger(level, timestamp, message, args);
        }
    }
    formatMessage(level, timestamp, message) {
        const levelUpper = level.toUpperCase().padEnd(5);
        const contextFormatted = `[${this.context}]`.padEnd(12);
        if (config_1.config.uiConfig.colors) {
            return this.colorizeMessage(level, `${timestamp} ${levelUpper} ${contextFormatted} ${message}`);
        }
        return `${timestamp} ${levelUpper} ${contextFormatted} ${message}`;
    }
    colorizeMessage(level, message) {
        const colors = {
            debug: '\x1b[36m',
            info: '\x1b[32m',
            warn: '\x1b[33m',
            error: '\x1b[31m',
        };
        const reset = '\x1b[0m';
        const color = colors[level] || '';
        return `${color}${message}${reset}`;
    }
    sendToExternalLogger(level, timestamp, message, args) {
        if (level === 'error') {
            this.logToFile('error', timestamp, message, args);
        }
    }
    logToFile(_level, _timestamp, _message, _args) {
    }
    createChildLogger(childContext) {
        return new Logger(`${this.context}:${childContext}`);
    }
    logMethodEntry(methodName, args) {
        if (config_1.config.isDevelopment()) {
            this.debug(`→ ${methodName}`, args ? { args } : '');
        }
    }
    logMethodExit(methodName, result) {
        if (config_1.config.isDevelopment()) {
            this.debug(`← ${methodName}`, result !== undefined ? { result } : '');
        }
    }
    logPerformance(operation, startTime) {
        const duration = Date.now() - startTime;
        this.debug(`⏱️ ${operation} took ${duration}ms`);
    }
    static createLogger(context) {
        return new Logger(context);
    }
    static async withPerformanceLogging(logger, operation, fn) {
        const startTime = Date.now();
        logger.debug(`Starting ${operation}`);
        try {
            const result = await fn();
            logger.logPerformance(operation, startTime);
            return result;
        }
        catch (error) {
            logger.error(`${operation} failed:`, error);
            logger.logPerformance(`${operation} (failed)`, startTime);
            throw error;
        }
    }
}
exports.Logger = Logger;
Logger.logLevel = 'info';
if (config_1.config.isDevelopment()) {
    Logger.setLogLevel('debug');
}
else {
    Logger.setLogLevel('info');
}
exports.logger = new Logger('TomiBot');
//# sourceMappingURL=logger.util.js.map