@plust/datasleuth/dist/utils/logging.js

Build LLM-powered research pipelines and output structured data.

/**
 * Logging utility for the @plust/datasleuth package
 */
/**
 * Logger class that handles log message formatting and output
 */
export class Logger {
    /**
     * Creates a new logger instance
     */
    constructor(options = {}) {
        this.level = options.level ?? 'info';
        this.options = {
            includeTimestamp: options.includeTimestamp ?? true,
            includeStepName: options.includeStepName ?? true,
            logToConsole: options.logToConsole ?? true,
            customLoggers: options.customLoggers
        };
    }
    /**
     * Set the current step name for step-specific logging
     */
    setCurrentStep(stepName) {
        this.currentStep = stepName;
    }
    /**
     * Get the current step name
     */
    getCurrentStep() {
        return this.currentStep;
    }
    /**
     * Set the minimum log level
     */
    setLogLevel(level) {
        this.level = level;
    }
    /**
     * Log a debug message
     */
    debug(message, ...args) {
        this.log('debug', message, ...args);
    }
    /**
     * Log an info message
     */
    info(message, ...args) {
        this.log('info', message, ...args);
    }
    /**
     * Log a warning message
     */
    warn(message, ...args) {
        this.log('warn', message, ...args);
    }
    /**
     * Log an error message
     */
    error(message, ...args) {
        this.log('error', message, ...args);
    }
    /**
     * Log a message with the specified level
     */
    log(level, message, ...args) {
        if (!this.shouldLog(level))
            return;
        const formattedMessage = this.formatMessage(level, message);
        if (this.options.logToConsole) {
            const consoleMethod = this.getConsoleMethod(level);
            consoleMethod(formattedMessage, ...args);
        }
        if (this.options.customLoggers) {
            for (const logger of this.options.customLoggers) {
                logger(level, formattedMessage, ...args);
            }
        }
    }
    /**
     * Check if the given log level should be logged based on the current minimum level
     */
    shouldLog(level) {
        const levels = {
            debug: 0,
            info: 1,
            warn: 2,
            error: 3
        };
        return levels[level] >= levels[this.level];
    }
    /**
     * Format the log message with optional timestamp and step name
     */
    formatMessage(level, message) {
        let formattedMessage = message;
        if (this.options.includeTimestamp) {
            formattedMessage = `[${new Date().toISOString()}] ${formattedMessage}`;
        }
        if (this.options.includeStepName && this.currentStep) {
            formattedMessage = `[${this.currentStep}] ${formattedMessage}`;
        }
        return `[${level.toUpperCase()}] ${formattedMessage}`;
    }
    /**
     * Get the appropriate console method for the log level
     */
    getConsoleMethod(level) {
        switch (level) {
            case 'debug': return console.debug;
            case 'info': return console.info;
            case 'warn': return console.warn;
            case 'error': return console.error;
            default: return console.log;
        }
    }
}
/**
 * Global logger instance
 */
export const logger = new Logger();
/**
 * Creates a step-specific logger that automatically includes the step name
 */
export function createStepLogger(stepName) {
    return {
        debug: (message, ...args) => {
            const prevStep = logger.getCurrentStep();
            logger.setCurrentStep(stepName);
            logger.debug(message, ...args);
            logger.setCurrentStep(prevStep);
        },
        info: (message, ...args) => {
            const prevStep = logger.getCurrentStep();
            logger.setCurrentStep(stepName);
            logger.info(message, ...args);
            logger.setCurrentStep(prevStep);
        },
        warn: (message, ...args) => {
            const prevStep = logger.getCurrentStep();
            logger.setCurrentStep(stepName);
            logger.warn(message, ...args);
            logger.setCurrentStep(prevStep);
        },
        error: (message, ...args) => {
            const prevStep = logger.getCurrentStep();
            logger.setCurrentStep(stepName);
            logger.error(message, ...args);
            logger.setCurrentStep(prevStep);
        }
    };
}
//# sourceMappingURL=logging.js.map