@omniconvert/server-side-testing-sdk/dist/cjs/logger/BrowserLogger.js

TypeScript SDK for server-side A/B testing and experimentation

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.BrowserLogger = void 0;
/**
 * Browser logger implementation
 * Provides structured logging for browser environments
 */
class BrowserLogger {
    constructor(logLevel = 'info', maxLogs = 1000, outputToConsole = false) {
        this.logs = [];
        this.maxLogs = 1000;
        this.logLevel = 'info';
        this.outputToConsole = false;
        this.logLevel = logLevel;
        this.maxLogs = maxLogs;
        this.outputToConsole = outputToConsole;
    }
    /**
     * Log debug message
     */
    debug(message, context) {
        this.log('debug', message, context);
    }
    /**
     * Log info message
     */
    info(message, context) {
        this.log('info', message, context);
    }
    /**
     * Log notice message
     */
    notice(message, context) {
        this.log('notice', message, context);
    }
    /**
     * Log warning message
     */
    warning(message, context) {
        this.log('warning', message, context);
    }
    /**
     * Log error message
     */
    error(message, context) {
        this.log('error', message, context);
    }
    /**
     * Core logging method
     */
    log(level, message, context) {
        const entry = {
            level,
            message,
            context,
            timestamp: new Date(),
            id: this.generateLogId(),
        };
        // Add to internal log storage
        this.logs.push(entry);
        // Trim logs if over limit
        if (this.logs.length > this.maxLogs) {
            this.logs.shift();
        }
        // Output to browser console if level is appropriate and console output is enabled
        if (this.outputToConsole && this.shouldLog(level)) {
            this.outputToBrowserConsole(entry);
        }
    }
    /**
     * Check if log level should be output
     */
    shouldLog(level) {
        const levels = ['debug', 'info', 'notice', 'warning', 'error'];
        const currentLevelIndex = levels.indexOf(this.logLevel);
        const messageLevelIndex = levels.indexOf(level);
        return messageLevelIndex >= currentLevelIndex;
    }
    /**
     * Output log entry to browser console
     */
    outputToBrowserConsole(entry) {
        const prefix = `[${entry.timestamp.toISOString()}] [${entry.level.toUpperCase()}]`;
        const message = `${prefix} ${entry.message}`;
        switch (entry.level) {
            case 'debug':
                if (entry.context) {
                    console.debug(message, entry.context);
                }
                else {
                    console.debug(message);
                }
                break;
            case 'info':
            case 'notice':
                if (entry.context) {
                    console.info(message, entry.context);
                }
                else {
                    console.info(message);
                }
                break;
            case 'warning':
                if (entry.context) {
                    console.warn(message, entry.context);
                }
                else {
                    console.warn(message);
                }
                break;
            case 'error':
                if (entry.context) {
                    console.error(message, entry.context);
                }
                else {
                    console.error(message);
                }
                break;
        }
    }
    /**
     * Get all logs
     */
    getLogs(filterLevel) {
        if (!filterLevel) {
            return [...this.logs];
        }
        return this.logs.filter(log => log.level === filterLevel);
    }
    /**
     * Get logs by level priority
     */
    getLogsByPriority(minLevel) {
        const levels = ['debug', 'info', 'notice', 'warning', 'error'];
        const minLevelIndex = levels.indexOf(minLevel);
        return this.logs.filter(log => {
            const logLevelIndex = levels.indexOf(log.level);
            return logLevelIndex >= minLevelIndex;
        });
    }
    /**
     * Clear all logs
     */
    clearLogs() {
        this.logs = [];
    }
    /**
     * Set log level
     */
    setLogLevel(level) {
        this.logLevel = level;
    }
    /**
     * Get current log level
     */
    getLogLevel() {
        return this.logLevel;
    }
    /**
     * Set maximum number of logs to keep
     */
    setMaxLogs(maxLogs) {
        this.maxLogs = maxLogs;
        // Trim existing logs if necessary
        if (this.logs.length > maxLogs) {
            this.logs = this.logs.slice(-maxLogs);
        }
    }
    /**
     * Get maximum number of logs
     */
    getMaxLogs() {
        return this.maxLogs;
    }
    /**
     * Export logs as JSON
     */
    exportLogs() {
        return JSON.stringify(this.logs, null, 2);
    }
    /**
     * Get log statistics
     */
    getLogStats() {
        const stats = {
            total: this.logs.length,
            debug: 0,
            info: 0,
            notice: 0,
            warning: 0,
            error: 0,
        };
        this.logs.forEach(log => {
            stats[log.level]++;
        });
        return stats;
    }
    /**
     * Enable/disable console output
     */
    setConsoleOutput(enabled) {
        this.outputToConsole = enabled;
    }
    /**
     * Check if console output is enabled
     */
    isConsoleOutputEnabled() {
        return this.outputToConsole;
    }
    /**
     * Generate unique log ID
     */
    generateLogId() {
        return Date.now().toString(36) + Math.random().toString(36).substring(2);
    }
}
exports.BrowserLogger = BrowserLogger;
//# sourceMappingURL=BrowserLogger.js.map