X-Git-Url: https://git.r.bdr.sh/rbdr/cologne/blobdiff_plain/73ca23120543f14672a960bb343db2bee676620b..1cb3bca6c3333fbdf185fdeaf7efe130a40219f8:/lib/loggers/console.js?ds=inline diff --git a/lib/loggers/console.js b/lib/loggers/console.js index e8f4d86..5e5ded1 100644 --- a/lib/loggers/console.js +++ b/lib/loggers/console.js @@ -1,95 +1,95 @@ -(function (global) { - var Module, Class; - - // Load up dependencies - if (typeof require === 'function') { - var Ne = require('neon'); - Module = Ne.Module; - Class = Ne.Class; - } else { - Module = global.Module; - Class = global.Class; +'use strict'; + +const Utilities = require('../utilities'); + +/** + * Logger for the javascript console. + * + * @implements ILogger + * @memberof Loggers + * @class Console + */ +module.exports = class ConsoleLogger { + constructor(config) { + + /** + * The console it will write to, can be any object that looks + * and acts like a console, including other cologne objects. + * + * @name console + * @instance + * @memberof Loggers.Console + * @type Object + * @default global.console + */ + this.console = console; + + /** + * The formatter it will use to output the log. If not present it + * will output raw JSON + * + * @name formatter + * @instance + * @memberof Loggers.Console + * @type IFormatter + * @default null + */ + this.formatter = null; + + Object.assign(this, config); } - var Cobalt = {}; - Module(Cobalt, 'Logger')({}); - - Cobalt.Logger.JsConsole = Class(Cobalt.Logger, 'JsConsole')({ - prototype : { - console : null, - formatterOpts : {}, - - init : function (config) { - var logger = this, - property; - - if (config) { - for (property in config) { - logger[property] = config[property]; - } - } - - if (!logger.console) { - logger.console = console; - } - }, - - log : function () { - var i, message = [], severity; - - for (i = 0; i < arguments.length; i++) { - // We're not formatting objects for now. - - if (typeof arguments[i].message === 'object') { - message.push(arguments[i].message); - } else { - message.push(this.format(arguments[i])); - } - if (!severity) { - severity = arguments[i]._level - } - } - - switch (severity){ - case 0: - case 1: - case 2: - case 3: - this.console.error.apply(this.console, message); - break; - case 4: - this.console.warn.apply(this.console, message); - break; - case 5: - case 6: - this.console.info.apply(this.console, message); - break; - case 7: - default: - this.console.log.apply(this.console, message); - break; - } - }, - - format : function (logObject) { - // Usually what you want to do here is format. Preferably using - // someone inside Cobalt.Formatter - if (this.formatter) { - return this.formatter.format(logObject, this.formatterOpts); - } - - return logObject.message; - } + + /** + * Main entry point, for each incoming argument it will attempt to + * format and send to the console. + * + * @function log + * @instance + * @memberof Loggers.Console + * @return {undefined} + */ + log(...logs) { + + const formattedLogs = logs.map((log) => ({ log: this._format(log), level: log._level })); + + for (const { log, level } of formattedLogs) { + this._log(log, level ); } - }); - if (Cobalt.Logger.JsConsole.__objectSpy) { - Cobalt.Logger.JsConsole.__objectSpy.destroy(); } - if (typeof require === 'function') { - global.JsConsole = Cobalt.Logger.JsConsole; - } else { - global.Cobalt.Logger.JsConsole = Cobalt.Logger.JsConsole; + // Routes an individual log to the appropriatet console + + _log(log, level) { + + switch (level) { + case 0: + case 1: + case 2: + case 3: + this.console.error(log); + break; + case 4: + this.console.warn(log); + break; + case 5: + case 6: + this.console.info(log); + break; + case 7: + default: + this.console.log(log); + break; + } + } + + _format(logObject) { + + if (this.formatter) { + return this.formatter.format(logObject); + } + + return Utilities.stringify(logObject); } -}(typeof window !== 'undefined' ? window : (typeof exports !== 'undefined' ? exports : self))); +};