Add a License

[rbdr/cologne] / lib / loggers / console.js

diff --git a/lib/loggers/console.js b/lib/loggers/console.js
index dc077c8858b1d6afa5b9d154896da6a2c0cb311e..5e5ded1241d494ac0bcfcb70cf23cdff34ead9f0 100644 (file)
--- a/lib/loggers/console.js
+++ b/lib/loggers/console.js
@@ -1,91 +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, messageArray = [], message, severity;
-
-        for (i = 0; i < arguments.length; i++) {
-          messageArray.push(this.format(arguments[i]));
-          if (!severity) {
-            severity = arguments[i]._level
-          }
-        }
-
-        message = messageArray.join(' ');
-
-        switch (severity){
-          case 0:
-          case 1:
-          case 2:
-          case 3:
-            this.console.error(message);
-            break;
-          case 4:
-            this.console.warn(message);
-            break;
-          case 5:
-          case 6:
-            this.console.info(message);
-            break;
-          case 7:
-          default:
-            this.console.log(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;
-      }
+
+  /**
+   * 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)));
+};