lavva.exalushome/build/js/Services/Logging/LoggerService.js

Library implementing communication and abstraction layers for ExalusHome system

import { LogLevel } from "./ILoggerService";
///window.stacktrace = true;
export class LoggerService {
    constructor() {
        this._blockedServices = [];
        this._logLevel = LogLevel.Debug;
        if (window.loglevel !== undefined && window.loglevel !== null)
            this._logLevel = window.loglevel;
        window["logger"] = this;
    }
    EnableStackTrace() {
        LoggerService.DoesThrowStackTrace = true;
    }
    DisableStackTrace() {
        LoggerService.DoesThrowStackTrace = false;
    }
    IsBlocked(service) {
        if (service === undefined)
            return false;
        return this._blockedServices.any(a => a == service);
    }
    DisableLogsFrom(name) {
        if (this._blockedServices.all(a => a != name))
            this._blockedServices.push(name);
        this.Debug(LoggerService.ServiceName, `Disabling logs from ${name}`);
    }
    EnableLogsFrom(name) {
        if (this._blockedServices.any(a => a == name))
            this._blockedServices = this._blockedServices.where(a => a != name).toArray();
        this.Debug(LoggerService.ServiceName, `Enaabling logs from ${name}`);
    }
    get LogLevel() {
        return this._logLevel;
    }
    set LogLevel(level) {
        this._logLevel = level;
    }
    GetServiceName() {
        return LoggerService.ServiceName;
    }
    GetTimeStamp() {
        const date = new Date();
        return `${date.getHours()}:${date.getMinutes()}:${date.getSeconds()}.${date.getMilliseconds()} | `;
    }
    Warning(contextClassType, message) {
        switch (this._logLevel) {
            case LogLevel.Warning:
            case LogLevel.Info:
            case LogLevel.Debug:
                break;
            case LogLevel.None:
            default:
                return;
        }
        if (contextClassType === undefined || this.IsBlocked(contextClassType))
            return;
        if (contextClassType != null)
            if (message === null || message === undefined)
                console.warn(`${this.GetTimeStamp()}[WARN] ${contextClassType}`);
            else
                console.warn(`${this.GetTimeStamp()}[WARN] [${contextClassType}] ${message}`);
    }
    Error(contextClassType, message) {
        switch (this._logLevel) {
            case LogLevel.Warning:
            case LogLevel.Info:
            case LogLevel.Debug:
            case LogLevel.Error:
                break;
            case LogLevel.None:
            default:
                return;
        }
        if (contextClassType != null)
            if (message === null || message === undefined)
                console.error(`${this.GetTimeStamp()}[ERROR] ${contextClassType}`);
            else
                console.error(`${this.GetTimeStamp()}[ERROR] [${contextClassType}] ${message}`);
    }
    Info(contextClassType, message) {
        switch (this._logLevel) {
            case LogLevel.Info:
            case LogLevel.Debug:
                break;
            case LogLevel.None:
            default:
                return;
        }
        if (contextClassType === undefined || this.IsBlocked(contextClassType))
            return;
        if (contextClassType != null)
            if (message === null || message === undefined)
                console.info(`${this.GetTimeStamp()}[INFO] ${contextClassType}`);
            else
                console.info(`${this.GetTimeStamp()}[INFO] [${contextClassType}] ${message}`);
    }
    Debug(contextClassType, message) {
        switch (this._logLevel) {
            case LogLevel.Debug:
                break;
            case LogLevel.None:
            default:
                return;
        }
        if (contextClassType === undefined || this.IsBlocked(contextClassType))
            return;
        if (contextClassType != null)
            if (message === null || message === undefined)
                console.debug(`${this.GetTimeStamp()}[DEBUG] ${contextClassType}`);
            else if (LoggerService.DoesThrowStackTrace || window["stacktrace"] === true)
                console.debug(`${this.GetTimeStamp()}[DEBUG] [${contextClassType}] ${message} \nstack:\n${new Error().stack}}`);
            else
                console.debug(`${this.GetTimeStamp()}[DEBUG] [${contextClassType}] ${message}`);
    }
    Log(contextClassType, message) {
        switch (this._logLevel) {
            case LogLevel.None:
                return;
            default:
                break;
        }
        if (contextClassType === undefined || this.IsBlocked(contextClassType))
            return;
        if (contextClassType != null)
            if (message === null || message === undefined)
                console.log(`${this.GetTimeStamp()}[LOG] ${contextClassType}`);
            else
                console.log(`${this.GetTimeStamp()}[LOG] [${contextClassType}] ${message}`);
    }
}
LoggerService.ServiceName = "LoggerService";
LoggerService.DoesThrowStackTrace = false;
//# sourceMappingURL=LoggerService.js.map