shardy/dist/Logger.js

Framework for online games and applications on Node.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Logger = exports.LoggerScope = exports.LoggerType = exports.LoggerFilterMode = void 0;
const path_1 = __importDefault(require("path"));
const winston_1 = require("winston");
var LoggerFilterMode;
(function (LoggerFilterMode) {
    LoggerFilterMode[LoggerFilterMode["And"] = 0] = "And";
    LoggerFilterMode[LoggerFilterMode["Or"] = 1] = "Or";
    LoggerFilterMode[LoggerFilterMode["Ignore"] = 2] = "Ignore";
})(LoggerFilterMode || (exports.LoggerFilterMode = LoggerFilterMode = {}));
var LoggerType;
(function (LoggerType) {
    LoggerType["All"] = "all";
    LoggerType["Info"] = "info";
    LoggerType["Warning"] = "warn";
    LoggerType["Error"] = "error";
})(LoggerType || (exports.LoggerType = LoggerType = {}));
var LoggerScope;
(function (LoggerScope) {
    LoggerScope[LoggerScope["None"] = 0] = "None";
    LoggerScope[LoggerScope["User"] = 1] = "User";
    LoggerScope[LoggerScope["System"] = 2] = "System";
    LoggerScope[LoggerScope["Debug"] = 3] = "Debug";
    LoggerScope[LoggerScope["All"] = 4] = "All";
})(LoggerScope || (exports.LoggerScope = LoggerScope = {}));
class Logger {
    constructor(tags, label) {
        this.tags = tags;
        this.filter = {};
        this.checkFilter = (0, winston_1.format)((info) => {
            if (this.isFilterEmpty(this.filter)) {
                return false;
            }
            const mode = this.filter.mode ? this.filter.mode : LoggerFilterMode.And;
            const conditions = [];
            if (this.filter.scope) {
                if (this.filter.scope.includes(LoggerScope.None)) {
                    return false;
                }
                if (this.filter.scope.includes(LoggerScope.All)) {
                    conditions.push(true);
                }
                else {
                    conditions.push(this.filter.scope.includes(info.scope));
                }
            }
            if (this.filter.type) {
                if (this.filter.type.includes(LoggerType.All)) {
                    conditions.push(true);
                }
                else {
                    conditions.push(this.filter.type.includes(info.type));
                }
            }
            if (this.filter.tags && this.tags) {
                for (let i = 0; i < this.filter.tags.length; i++) {
                    conditions.push(this.filter.tags[i] === this.tags[i]);
                }
            }
            if (this.filter.contains) {
                conditions.push(info.message.indexOf(this.filter.contains) >= 0);
            }
            let isPassed = false;
            switch (mode) {
                case LoggerFilterMode.And:
                    isPassed = conditions.every((item) => item === true);
                    break;
                case LoggerFilterMode.Or:
                    isPassed = conditions.some((item) => item === true);
                    break;
                case LoggerFilterMode.Ignore:
                    isPassed = conditions.every((item) => item === false);
                    break;
                default:
                    break;
            }
            return isPassed ? info : false;
        });
        this.logger = (0, winston_1.createLogger)({ format: this.logFormat(), exitOnError: false });
        if (label) {
            this.setLabel(this.tags, label);
        }
        if (process.env.ENV === 'development') {
            this.filter.type = [LoggerType.All];
            this.logger.add(new winston_1.transports.Console());
            this.logger.add(new winston_1.transports.File({ filename: path_1.default.join(__dirname, process.env.LOGS_DIR, 'all.log') }));
        }
        else {
            this.logger.add(new winston_1.transports.File({
                filename: path_1.default.join(__dirname, process.env.LOGS_DIR, 'info.log'),
                level: LoggerType.Info,
            }));
            this.logger.add(new winston_1.transports.File({
                filename: path_1.default.join(__dirname, process.env.LOGS_DIR, 'warnings.log'),
                level: LoggerType.Warning,
            }));
            this.logger.add(new winston_1.transports.File({
                filename: path_1.default.join(__dirname, process.env.LOGS_DIR, 'errors.log'),
                level: LoggerType.Error,
                handleExceptions: true,
            }));
        }
    }
    isFilterEmpty(filter) {
        for (const i in filter) {
            return false;
        }
        return true;
    }
    formatLabelTag() {
        let label = '-';
        if (this.tags.length > 0) {
            label = this.tags[0];
            for (let i = 1; i < this.tags.length; i++) {
                label = label.concat(`|${this.tags[i]}`);
            }
        }
        return label;
    }
    logFormat(label) {
        return winston_1.format.combine(winston_1.format.label({ label: label ? label : this.formatLabelTag() }), winston_1.format.colorize(), winston_1.format.timestamp(), winston_1.format.prettyPrint(), winston_1.format.splat(), this.checkFilter(), winston_1.format.printf((info) => {
            return `${info.timestamp} [${info.label}] ${info.level} ${info.message}`;
        }));
    }
    setLabel(data = [], label) {
        this.tags = data;
        this.logger.format = this.logFormat(label);
    }
    setFilter(data) {
        this.filter = data;
    }
    clearFilter() {
        this.filter = {};
    }
    disable() {
        this.filter = { scope: [LoggerScope.None] };
    }
    getFilter() {
        return this.filter;
    }
    getTags() {
        return this.tags;
    }
    info(message, scope = LoggerScope.User) {
        this.logger.info(message, { type: LoggerType.Info, scope });
    }
    warn(message, scope = LoggerScope.User) {
        this.logger.warn(message, { type: LoggerType.Warning, scope });
    }
    error(message, scope = LoggerScope.User) {
        this.logger.error(message, { type: LoggerType.Error, scope });
    }
    destroy() {
        this.logger.destroy();
    }
}
exports.Logger = Logger;
//# sourceMappingURL=Logger.js.map