smyld-lib-common/dist/logging/LogManager.js

SMYLD Javascript Core Library, contains several core APIs that benefit the developers working on SPA applications

import { LogLevel } from "./LogSettings";
import { LogConfiguration } from "./LogConfiguration";
import { RuleCondition } from "./config/LogRule";
/**
 * @class
 * Singleton manager for all logger instances in the application.
 * Provides methods to register, retrieve, and configure loggers.
 */
export class LogManager {
    /** The singleton instance of LogManager */
    static _instance;
    /** Map of logger names to logger instances */
    _loggers;
    _allLoggers = [];
    _logLevel = undefined;
    _logSettings = { cacheLogs: false, logLevel: LogLevel.DEFAULT, pooledLoggers: true };
    _logConfiguration = new LogConfiguration();
    /**
     * Private constructor to prevent direct instantiation.
     * Use getInstance() instead.
     */
    constructor() {
        this._loggers = new Map();
    }
    get logSettings() {
        return this._logSettings;
    }
    get logLevel() {
        return this._logLevel;
    }
    set logSettings(value) {
        this._logSettings = value;
    }
    /**
     * Gets the singleton instance of LogManager.
     * Creates the instance if it doesn't exist yet.
     *
     * @returns {LogManager} The singleton LogManager instance
     *
     * @example
     * const logManager = LogManager.getInstance();
     */
    static getInstance() {
        if (!LogManager._instance) {
            LogManager._instance = new LogManager();
        }
        return LogManager._instance;
    }
    /**
     * Registers a logger with the manager.
     *
     * @param {string} name - The name to identify the logger
     * @param {Logger} logger - The logger instance to register
     *
     * @example
     * const userLogger = new Logger({ source: 'UserService' });
     * LogManager.getInstance().registerLogger('UserService', userLogger);
     */
    registerLogger(name, logger) {
        const configLogLevel = this._logConfiguration.detectLogLevel(logger);
        logger.logLevel = configLogLevel;
        this._allLoggers.push(logger);
        this._loggers.set(name, logger);
    }
    /**
     * Retrieves a logger by name.
     *
     * @param {string} name - The name of the logger to retrieve
     * @returns {Logger | undefined} The logger instance if found, undefined otherwise
     *
     * @example
     * const userLogger = LogManager.getInstance().getLogger('UserService');
     * if (userLogger) {
     *     userLogger.info('User service initialized');
     * }
     */
    getLogger(name) {
        return this._loggers.get(name);
    }
    /**
     * Checks if a logger with the given name exists.
     *
     * @param {string} name - The name of the logger to check
     * @returns {boolean} True if the logger exists, false otherwise
     *
     * @example
     * if (LogManager.getInstance().hasLogger('UserService')) {
     *     // Use existing logger
     * } else {
     *     // Create new logger
     * }
     */
    hasLogger(name) {
        return this._loggers.has(name);
    }
    /**
     * Sets the log level for all registered loggers.
     *
     * @param {LogLevel} logLevel - The log level to set
     *
     * @example
     * // Set all loggers to only show errors in production
     * if (process.env.NODE_ENV === 'production') {
     *     LogManager.getInstance().setGeneralLogLevel(LogLevel.ERROR);
     * }
     */
    setGeneralLogLevel(logLevel) {
        this._logLevel = logLevel;
        this._allLoggers.forEach(logger => {
            logger.logLevel = logLevel;
        });
    }
    /**
     * Sets the log level for any logger that holds a source that starts with the given name
     *
     * @param {string} name - The name of the logger
     * @param {LogLevel} logLevel - The log level to set
     *
     * @example
     * // Enable debug logs for a specific component
     * LogManager.getInstance().setLogLevel('AuthService', LogLevel.DEBUG);
     */
    setLogLevel(name, logLevel) {
        this._logConfiguration.addRule(RuleCondition.startsWith, name, logLevel);
        this._allLoggers.forEach(curLogger => {
            if (curLogger.source.startsWith(name)) {
                curLogger.logLevel = logLevel;
            }
        });
    }
    /**
     * Setting the log level for any logger that its name contains the given name parameter
     * @param name
     * @param logLevel
     */
    setLogLevelContaining(name, logLevel) {
        this._logConfiguration.addRule(RuleCondition.contains, name, logLevel);
        this._allLoggers.forEach(curLogger => {
            if (curLogger.source.indexOf(name) !== -1) {
                curLogger.logLevel = logLevel;
            }
        });
    }
    setLogLevelByRegex(regex, logLevel) {
        this._logConfiguration.addRule(RuleCondition.regex, regex, logLevel);
        const targetLoggers = this.getLoggersByRegex(regex);
        targetLoggers.forEach(curLogger => curLogger.logLevel = logLevel);
    }
    getLoggersByRegex(regex) {
        let result = [];
        this._allLoggers.forEach(curLogger => {
            if (regex.test(curLogger.source)) {
                result.push(curLogger);
            }
        });
        return result;
    }
    /**
     * Returns all registered loggers.
     *
     * @returns {Logger[]} Array of all registered logger instances
     *
     * @example
     * const allLoggers = LogManager.getInstance().getAllLoggers();
     * console.log(`Total loggers: ${allLoggers.length}`);
     */
    getAllLoggers() {
        return this._allLoggers;
    }
    clearLoggers() {
        this._allLoggers = [];
        this._loggers.clear();
    }
    clearConfiguration() {
        this._logConfiguration.clearConfigurations();
    }
    clearAll() {
        this.clearLoggers();
        this.clearConfiguration();
    }
}
//# sourceMappingURL=LogManager.js.map