slf/lib/LoggerFactory.js

Simple Logging Facade

"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
function _export(target, all) {
    for(var name in all)Object.defineProperty(target, name, {
        enumerable: true,
        get: all[name]
    });
}
_export(exports, {
    Level: function() {
        return Level;
    },
    LoggerFactory: function() {
        return LoggerFactory;
    }
});
var _logger = require("./Logger");
var _utils = require("./utils");
function _arrayLikeToArray(arr, len) {
    if (len == null || len > arr.length) len = arr.length;
    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
    return arr2;
}
function _arrayWithoutHoles(arr) {
    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
}
function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
    }
}
function _iterableToArray(iter) {
    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
}
function _nonIterableSpread() {
    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _toConsumableArray(arr) {
    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
}
function _unsupportedIterableToArray(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
    var n = Object.prototype.toString.call(o).slice(8, -1);
    if (n === "Object" && o.constructor) n = o.constructor.name;
    if (n === "Map" || n === "Set") return Array.from(n);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
}
var Level;
(function(Level) {
    Level[Level["Debug"] = 1] = "Debug";
    Level[Level["Info"] = 2] = "Info";
    Level[Level["Warn"] = 3] = "Warn";
    Level[Level["Error"] = 4] = "Error";
    Level[Level["Critical"] = 5] = "Critical";
})(Level || (Level = {}));
var checkIfLevelKey = function(key) {
    return Object.keys(Level).includes(key);
};
var checkIfLevelBelow = function(event) {
    var level = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : Level.Debug;
    var levelKey = (0, _utils.capitalize)(event.level);
    return level > Level[levelKey];
};
var provideToFactory = function(events) {
    var level = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : Level.Debug;
    var filteredEvents = events.filter(function(e) {
        return !checkIfLevelBelow(e, level);
    });
    // events is empty if all are below set level
    if (filteredEvents.length > 0) {
        var _ref;
        var ref;
        (ref = __slf._factory) === null || ref === void 0 ? void 0 : (_ref = ref).call.apply(_ref, [
            __slf
        ].concat(_toConsumableArray(filteredEvents)));
    }
};
var __slf = global.__slf ? global.__slf : global.__slf = {
    _chain: [],
    _queued: [],
    _factory: null,
    _logLevel: null,
    hasWarned: false
};
var LoggerFactory = /*#__PURE__*/ function() {
    "use strict";
    function LoggerFactory() {
        _classCallCheck(this, LoggerFactory);
    }
    LoggerFactory.getLogger = function getLogger(name) {
        var sink;
        if (__slf._factory) {
            sink = __slf._factory;
        } else if (!__slf.hasWarned) {
            __slf.hasWarned = true;
            console.log("Warning SLF: No LoggerFactory installed");
        }
        if (!sink) {
            sink = function() {
                for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
                    args[_key] = arguments[_key];
                }
                if (__slf._factory) {
                    provideToFactory(args, LoggerFactory.getLogLevel());
                } else {
                    __slf._queued[__slf._queued.length % 100] = args;
                }
            };
        }
        return new _logger.Logger(name, sink, __slf._chain, LoggerFactory.getLogLevel());
    };
    LoggerFactory.setFactory = function setFactory(factory, level) {
        if (__slf._factory && factory) {
            console.log("Warning SLF: Replacing installed LoggerFactory", __slf._factory, factory);
        }
        if (!factory) {
            __slf._queued.length = 0;
        }
        __slf._factory = factory;
        if (__slf._factory && __slf._queued.length > 0) {
            console.log("***** dumping Q");
            __slf._queued.forEach(function(evt) {
                return provideToFactory(evt, level);
            });
            __slf._queued.length = 0;
        }
        if (!__slf._logLevel) {
            __slf._logLevel = LoggerFactory.getLogLevel(level);
        }
    };
    /**
   * middleware has function(event, next)
   * next should be called next(err, event);
   */ LoggerFactory.use = function use(middleware) {
        __slf._chain.push(middleware);
    };
    LoggerFactory.getLogLevel = function getLogLevel(level) {
        var envString = process.env.SLF_LOG_LEVEL;
        var envLevel;
        if (envString) {
            var capitalized = (0, _utils.capitalize)(envString);
            if (checkIfLevelKey(capitalized)) {
                envLevel = capitalized;
            }
        }
        return __slf._logLevel || level || envLevel && Level[envLevel] || Level.Debug;
    };
    return LoggerFactory;
}();