Recover from npm package

14 files changed, 820 insertions, 595 deletions

diff --git a/lib/cobalt.js b/lib/cobalt.js
deleted file mode 100644
index b5dd94c..0000000
--- a/lib/cobalt.js
+++ /dev/null
@@ -1,320 +0,0 @@
-// Load up dependencies
-if (typeof require === 'function') {
-  require('neon');
-  var colors = require('colors');
-  var Microtime = require('microtime');
-}
-
-Cobalt = Module("Cobalt");
-Module(Cobalt, 'Logger')({});
-Module(Cobalt, 'Formatter')({});
-
-// Load up loggers + formatters
-if (typeof require === 'function') {
-  // Formatters
-  require('./formatters/token.js');
-  require('./formatters/simple.js');
-
-  // Loggers
-  require('./loggers/console.js');
-  require('./loggers/socket.js');
-  require('./loggers/file.js');
-}
-
-Cobalt.now = function () {
-  if (typeof performance !== 'undefined' && performance.timing) {
-    return performance.timing.navigationStart + performance.now();
-  }
-
-  if (typeof Microtime !== 'undefined') {
-    return Microtime.nowDouble() * 1000;
-  }
-
-  return Date.now();
-}
-
-// Stringify with circular dereference.
-Cobalt.stringify = function (object) {
-  var cache = [], stringified;
-  stringified = JSON.stringify(object, function (key, value) {
-    if (typeof value === 'object' && value !== null) {
-      if (cache.indexOf(value) !== -1) {
-        return "[Circular]";
-      }
-      cache.push(value);
-    }
-    return value;
-  });
-  cache = null;
-
-  return stringified;
-}
-
-Class(Cobalt, 'Console')({
-  prototype : {
-    from : "Generic Cobalt Logger",
-    version : "0.1.0",
-    currentIndent : 0,
-    indentSize : 2,
-    loggers : [],
-    separatorLength : 120,
-    currentColor : "black",
-
-    // Initialize instance of cobalt console
-    // and extend configuration.
-    init : function (config) {
-      var co = this,
-          property;
-
-      if (config) {
-        for (property in config) {
-          co[property] = config[property];
-        }
-      }
-    },
-
-    addLogger : function (logger) {
-      this.loggers.push(logger);
-    },
-
-    removeLogger : function (logger) {
-      var index;
-
-      index = this.loggers.indexOf(logger);
-      this.loggers.splice(index, 1);
-    },
-
-    // Builds a Cobalt Log Object
-    buildLog : function (item, level) {
-      var co = this, oldItem, logObject = {};
-
-      if (typeof item === "undefined" || item === null || !item._cobaltLog) {
-        logObject.message = item;
-        logObject._cobaltLog = true;
-        logObject._from = co.from;
-        logObject._level = level || 6;
-        logObject._levelString = co._levelString(logObject._level);
-        logObject._version = co.version;
-        logObject._timestamp = co.now();
-        logObject._indentLevel = co.currentIndent;
-        logObject._color = co.currentColor;
-        logObject._separator = false;
-        return logObject;
-      }
-
-      if (item._cobaltLog) {
-        item._level = level || item._level || 6;
-        item._levelString = co._levelString(item._level);
-      }
-
-      return item;
-    },
-
-    extendLog : function (extendingObject) {
-      var co = this, logObject,
-          property;
-
-      logObject = co.buildLog(undefined, 6);
-      extendingObject = extendingObject || {};
-
-      for (property in extendingObject) {
-        if (extendingObject.hasOwnProperty(property)) {
-          logObject[property] = extendingObject[property];
-        }
-      }
-
-      return logObject;
-    },
-
-    buildSeparator : function (type) {
-      var co = this;
-      return {
-        _cobaltLog : true,
-        _separator : true,
-        _version : co.version,
-        _timestamp : co.now(),
-        _separatorType : type,
-        _indentLevel : co.currentIndent,
-        _color : co.currentColor
-      }
-    },
-
-    _log : function (severity) {
-      var co = this,
-          logString,
-          logObjectArray = [],
-          i, j;
-
-      for (i = 1; i < arguments.length; i++) {
-        if (typeof arguments[i] === 'undefined') {
-          logObjectArray.push(co.buildLog("undefined", severity));
-        } else if (arguments[i] === null) {
-          logObjectArray.push(co.buildLog("null", severity));
-        } else {
-          logObjectArray.push(co.buildLog(arguments[i], severity));
-        }
-      }
-
-      for (j = 0; j < co.loggers.length; j++) {
-        co.loggers[j].log.apply(co.loggers[j], logObjectArray);
-      }
-    },
-
-    log : function () {
-      this._log.apply(this, [6].concat(Array.prototype.slice.call(arguments)));
-    },
-
-    debug : function () {
-      this._log.apply(this, [7].concat(Array.prototype.slice.call(arguments)));
-    },
-
-    info : function () {
-      this._log.apply(this, [6].concat(Array.prototype.slice.call(arguments)));
-    },
-
-    notice : function () {
-      this._log.apply(this, [5].concat(Array.prototype.slice.call(arguments)));
-    },
-
-    warn : function () {
-      this._log.apply(this, [4].concat(Array.prototype.slice.call(arguments)));
-    },
-
-    error : function () {
-      this._log.apply(this, [3].concat(Array.prototype.slice.call(arguments)));
-    },
-
-    dir : function () {
-    },
-
-    time : function () {
-    },
-
-    timeEnd : function () {
-    },
-
-    groupCollapsed : function () {
-    },
-
-    groupEnd : function () {
-    },
-
-    separator : function (type) {
-      var co = this;
-
-      co._log(7, co.buildSeparator(type));
-    },
-
-    space : function (lines) {
-      var co = this,
-          i;
-
-      if (typeof lines === "undefined") {
-        lines = 1;
-      }
-
-      for (i = 0; i < lines; i++) {
-        co.log(' ');
-      }
-
-      return co;
-    },
-
-    indent : function (callback) {
-      var co = this;
-
-      if (typeof callback === "function") {
-        co.currentIndent = co.currentIndent + co.indentSize;
-        callback();
-        co.currentIndent = co.currentIndent - co.indentSize;
-      } else {
-        co.currentIndent = co.currentIndent + co.indentSize;
-      }
-
-      return co;
-    },
-
-    outdent : function (callback) {
-      var co = this;
-
-      if (typeof callback === "function") {
-        co.currentIndent = co.currentIndent - co.indentSize;
-        if (co.currentIndent < 0) {
-          co.currentIndent = 0;
-        }
-
-        callback();
-
-        co.currentIndent = co.currentIndent + co.indentSize;
-      } else {
-        co.currentIndent = co.currentIndent - co.indentSize;
-        if (co.currentIndent < 0) {
-          co.currentIndent = 0;
-        }
-      }
-
-      return co;
-    },
-
-    color : function (color, callback) {
-      var co = this,
-          oldColor = co.currentColor;
-
-      if (typeof callback === "function") {
-        co.currentColor = color;
-        callback();
-        co.currentColor = oldColor;
-      } else {
-        co.currentColor = color;
-      }
-
-      return co;
-    },
-
-    // Returns the current time in microseconds.
-    now : function () {
-      if (typeof performance !== 'undefined' && performance.timing) {
-        return performance.timing.navigationStart + performance.now();
-      }
-
-      if (typeof Microtime !== 'undefined') {
-        return Microtime.nowDouble() * 1000;
-      }
-
-      return Date.now();
-    },
-
-    _levelString : function (level) {
-      switch(level) {
-        case 0:
-          return "PANIC";
-          break;
-        case 1:
-          return "ALERT"
-          break;
-        case 2:
-          return "CRIT"
-          break;
-        case 3:
-          return "ERROR"
-          break;
-        case 4:
-          return "WARN"
-          break;
-        case 5:
-          return "NOTICE"
-          break;
-        case 6:
-          return "INFO"
-          break;
-        case 7:
-          return "DEBUG"
-          break;
-      }
-    }
-  }
-});
-
-if (Cobalt.Console.__objectSpy) {
-  Cobalt.Console.__objectSpy.destroy();
-}
diff --git a/lib/cologne.js b/lib/cologne.js
new file mode 100644
index 0000000..646fe79
--- /dev/null
+++ b/lib/cologne.js
@@ -0,0 +1,328 @@
+'use strict';
+
+let LogUtilities = require('./cologne/log_utilities');
+
+/** TYPE DEFINITIONS **/
+
+/**
+ * Main interface for Cologne Loggers
+ *
+ * @memberof Cologne
+ * @interface ILogger
+ */
+
+/**
+ * Receives any number of cologne log objects and logs them.
+ *
+ * @memberof Cologne.ILogger
+ * @function
+ * @name log
+ * @returns {undefined}
+ */
+
+/**
+ * Main interface for Cologne Formatters
+ *
+ * @memberof Cologne
+ * @interface IFormatter
+ */
+
+/**
+ * Receives a cologne log object and returns a formatted string.
+ *
+ * @memberof Cologne.IFormatter
+ * @function
+ * @name format
+ * @param {Cologne.tCologneLog} logObject the log to be formatted
+ * @returns {string} the formatted log
+ */
+
+/**
+ * The main cologne log format.
+ *
+ * @memberof Cologne
+ * @typedef {object} tCologneLog
+ * @property {Number} _timestamp the timestamp in miliseconds with decimal
+ * numbers representing fractions of miliseconds
+ * @property {String} _cologneLog main identifier, encodes the version of the
+ * cologne log format being used.
+ * @property {String} _from the origin of the log message.
+ * @property {String} _level the severity level of the log, uses syslog
+ * priorities.
+ * @property {String} _levelString the severity level keyword of the log,
+ * uses syslog priority keywords.
+ */
+
+/**
+ * Cologne is a logger multiplexer that works mainly with a JSON format. It
+ * can be instantiated with several loggers, or they can be changed after
+ * the fact.
+ *
+ * ## Usage
+ *
+ * ```
+ * require('cologne');
+ *
+ * let co = new Cologne({
+ *   from: "Special Worker Logger",
+ *   loggers: [
+ *     new Cologne.Logger.Console({
+ *       formatter: new Cologne.Formatter.Token({
+ *         formatString: '[{{_timestamp}}]{{_from}}: {{message}}'
+ *       })
+ *     })
+ *   ]
+ * });
+ * ```
+ *
+ * @class Cologne
+ */
+let Cologne = class Cologne {
+
+  constructor (config) {
+
+    /**
+     * The name of this logger, useful to distinguish between different
+     * loggers.
+     *
+     * @name from
+     * @instance
+     * @memberof Cologne
+     * @type String
+     * @default 'Generic Cologne Logger
+     */
+    this.from = 'Generic Cologne Logger';
+
+    /**
+     * The array containing all the loggers it will call to.
+     *
+     * @name loggers
+     * @instance
+     * @memberof Cologne
+     * @type Cologne.ILogger[]
+     * @default []
+     */
+    this.loggers = [];
+
+    Object.assign(this, config || {});
+  }
+
+  /**
+   * Adds a logger to the current instance.
+   *
+   * @function addLogger
+   * @instance
+   * @memberof Cologne
+   * @param {Cologne.ILogger} logger the logger to add
+   * @return {undefined}
+   */
+  addLogger (logger) {
+    this.loggers.push(logger);
+  }
+
+  /**
+   * Removes a logger from the current instance.
+   *
+   * @function removeLogger
+   * @instance
+   * @memberof Cologne
+   * @param {Cologne.ILogger} logger the logger to remove
+   * @return {Cologne.ILogger[]} the removed log, inside an array.
+   */
+  removeLogger (logger) {
+    let index;
+
+    index = this.loggers.indexOf(logger);
+    if (index >= 0) {
+      this.loggers.splice(index, 1);
+    }
+  }
+
+  /**
+   * Given an item, it builds a cologne log object. this is done
+   * automatically by the logger, though this is useful if you need
+   * to attach metadata before logging.
+   *
+   * @function buildLog
+   * @instance
+   * @memberof Cologne
+   * @param {*} item The item to log
+   * @return {Cologne.tCologneLog} a cologne log object
+   */
+  buildLog (item, level, meta) {
+    let logObject;
+
+    logObject = {};
+
+    if (typeof item === 'undefined' || item === null || !item._cologneLog) {
+      logObject.message = item;
+      logObject._cologneLog = this.constructor._version;
+      logObject._from = this.from;
+      logObject._level = level || 6;
+      logObject._levelString = this._levelString(logObject._level);
+      logObject._timestamp = LogUtilities.now();
+
+      if (meta && typeof meta === 'object') {
+        Object.assign(logObject, meta);
+      }
+
+      return logObject;
+    }
+
+    if (item._cologneLog) {
+      item._level = level || item._level || 6;
+      item._levelString = this._levelString(item._level);
+    }
+
+    return item;
+  }
+
+  /**
+   * Default log function. Sends arguments to loggers. If not specified in log
+   * object, it will set the severity to 6 - INFO.
+   *
+   * @function log
+   * @instance
+   * @memberof Cologne
+   * @return {undefined}
+   */
+  log () {
+    this._log.apply(this, [null].concat(Array.prototype.slice.call(arguments)));
+  }
+
+  /**
+   * Logs with debug level
+   *
+   * @function debug
+   * @instance
+   * @memberof Cologne
+   * @return {undefined}
+   */
+  debug () {
+    this._log.apply(this, [7].concat(Array.prototype.slice.call(arguments)));
+  }
+
+  /**
+   * Logs with info level
+   *
+   * @function info
+   * @instance
+   * @memberof Cologne
+   * @return {undefined}
+   */
+  info () {
+    this._log.apply(this, [6].concat(Array.prototype.slice.call(arguments)));
+  }
+
+  /**
+   * Logs with notice level
+   *
+   * @function notice
+   * @instance
+   * @memberof Cologne
+   * @return {undefined}
+   */
+  notice () {
+    this._log.apply(this, [5].concat(Array.prototype.slice.call(arguments)));
+  }
+
+  /**
+   * Logs with warn level
+   *
+   * @function warn
+   * @instance
+   * @memberof Cologne
+   * @return {undefined}
+   */
+  warn () {
+    this._log.apply(this, [4].concat(Array.prototype.slice.call(arguments)));
+  }
+
+  /**
+   * Logs with error level
+   *
+   * @function error
+   * @instance
+   * @memberof Cologne
+   * @return {undefined}
+   */
+  error () {
+    this._log.apply(this, [3].concat(Array.prototype.slice.call(arguments)));
+  }
+
+  // Private method that builds all the logs and sends them to the loggers.
+  _log (severity) {
+    let remainingArguments, logObjectArray, log, logger;
+
+    remainingArguments = Array.prototype.slice.call(arguments, 1);
+    logObjectArray = [];
+
+    for (log of remainingArguments) {
+      if (typeof log === 'undefined') {
+        logObjectArray.push(this.buildLog('undefined', severity));
+        continue;
+      }
+
+      if (log === null) {
+        logObjectArray.push(this.buildLog('null', severity));
+        continue;
+      }
+
+      logObjectArray.push(this.buildLog(log, severity));
+    }
+
+    for (logger of this.loggers) {
+      logger.log.apply(logger, logObjectArray);
+    }
+  }
+
+  // Private utility method that will return the string for any given
+  // numerical severity level
+  _levelString (level) {
+    switch(level) {
+    case 0:
+      return 'emerg';
+    case 1:
+      return 'alert';
+    case 2:
+      return 'crit';
+    case 3:
+      return 'error';
+    case 4:
+      return 'warning';
+    case 5:
+      return 'notice';
+    case 6:
+      return 'info';
+    case 7:
+      return 'debug';
+    }
+  }
+};
+
+// Version of the Cologne Log Format used.
+Cologne._version = '1.0.0';
+
+/**
+ * Namespace that includes the built-in formatters.
+ *
+ * @namespace Formatter
+ * @memberof Cologne
+ */
+Cologne.Formatter = {};
+Cologne.Formatter.Simple = require('./cologne/formatter/simple');
+Cologne.Formatter.Token = require('./cologne/formatter/token');
+
+/**
+ * Namespace that includes the built-in loggers.
+ *
+ * @namespace Logger
+ * @memberof Cologne
+ */
+Cologne.Logger = {};
+Cologne.Logger.Console = require('./cologne/logger/console');
+Cologne.Logger.File = require('./cologne/logger/file');
+
+Cologne.LogUtilities = require('./cologne/log_utilities');
+
+module.exports = Cologne;
diff --git a/lib/cologne/formatter/simple.js b/lib/cologne/formatter/simple.js
new file mode 100644
index 0000000..48821fc
--- /dev/null
+++ b/lib/cologne/formatter/simple.js
@@ -0,0 +1,67 @@
+'use strict';
+
+let LogUtilities = require('../log_utilities');
+
+/**
+ * Simple formatter. Outputs a predefined format:
+ * `[{{_timestamp}}][{{_levelString}}] {{_from}}: {{message}}`;
+ *
+ * @memberof Cologne.Formatter
+ * @implements Cologne.IFormatter
+ * @class Simple
+ */
+let SimpleFormatter = class SimpleFormatter {
+
+  constructor (config) {
+
+    /**
+     * Flag that tells us whether or not to use ANSI color. Defaults to
+     * false.
+     *
+     * @name colorize
+     * @instance
+     * @memberof Cologne.Formatter.Simple
+     * @type Boolean
+     * @default false
+     */
+    this.colorize = false;
+
+    Object.assign(this, config || {});
+  }
+
+  /**
+   * Main entry point, it will read the incoming log object and convert
+   * it to the output string.
+   *
+   * @function format
+   * @instance
+   * @memberof Cologne.Formatter.Simple
+   * @param {Cologne.tCologneLog} logObjet the log to format
+   * @return {String} the formatted object
+   */
+  format (logObject) {
+    let date, levelString;
+
+    date = new Date(logObject._timestamp);
+    date = date.toISOString();
+    levelString = this._colorize(logObject._levelString, logObject._level);
+
+    return `[${date}][${levelString}] ${logObject._from}: ${logObject.message}`;
+  }
+
+  _colorize (levelString, level) {
+    let escapeCode, color, reset;
+
+    if (!this.colorize) {
+      return levelString;
+    }
+
+    escapeCode = String.fromCharCode(27);
+    color = escapeCode + LogUtilities.getAnsiCode(LogUtilities.getLevelAnsi(level));
+    reset = escapeCode + LogUtilities.getAnsiCode('reset');
+
+    return color + levelString + reset;
+  }
+};
+
+module.exports = SimpleFormatter;
diff --git a/lib/cologne/formatter/token.js b/lib/cologne/formatter/token.js
new file mode 100644
index 0000000..bb905ca
--- /dev/null
+++ b/lib/cologne/formatter/token.js
@@ -0,0 +1,104 @@
+'use strict';
+
+let LogUtilities = require('../log_utilities');
+
+/**
+ * Token formatter. Given a format string it will attempt to output
+ * a message.
+ *
+ * @memberof Cologne.Formatter
+ * @implements Cologne.IFormatter
+ * @class Token
+ */
+let TokenFormatter = class TokenFormatter {
+  constructor (config) {
+
+    /**
+     * The string to use as a template string. By default, any property
+     * inside double curly braces `{{likeThis}}` will be extracted from
+     * the object and replaced. If the object does not contain the
+     * property, it will leave it.
+     *
+     * @name formatString
+     * @instance
+     * @memberof Cologne.Formatter.Token
+     * @type String
+     * @default '{{message}}'
+     */
+    this.formatString = '{{message}}';
+
+    /**
+     * The regex rule to use to match the tokens.
+     *
+     * @name replaceRule
+     * @instance
+     * @memberof Cologne.Formatter.Token
+     * @type RegExp
+     * @default /{{(.*)}}/g
+     */
+    this.replaceRule = /{{(.*?)}}/g;
+
+    /**
+     * Flag that specifies whether or not to use an isoDate when using
+     * `_timestamp`. If false it will output the raw timestamp.
+     *
+     * @name isoDate
+     * @instance
+     * @memberof Cologne.Formatter.Token
+     * @type Boolean
+     * @default true
+     */
+    this.isoDate = true;
+
+    this._ansiRe = /_ansi:.+/;
+
+    Object.assign(this, config || {});
+  }
+
+  /**
+   * Main entry point, it will read the incoming log object and convert
+   * all the tokens to their corresponding representation, finally
+   * returning the string.
+   *
+   * @function format
+   * @instance
+   * @memberof Cologne.Formatter.Token
+   * @param {Cologne.tCologneLog} logObjet the log to format
+   * @return {String} the formatted object
+   */
+  format (logObject) {
+    let resultString, escapeCode;
+
+    escapeCode = String.fromCharCode(27);
+
+    resultString = this.formatString.replace(this.replaceRule, function (match, token) {
+      let date, ansiType;
+
+      if (token === '_timestamp' && this.isoDate) {
+        date = new Date(logObject._timestamp);
+        return date.toISOString();
+      }
+
+      if (token.match(this._ansiRe)) {
+        ansiType = token.split(':')[1];
+
+        // Smartish coloring
+        if (ansiType === '_level') {
+          return escapeCode + LogUtilities.getAnsiCode(LogUtilities.getLevelAnsi(logObject._level));
+        }
+
+        return escapeCode + LogUtilities.getAnsiCode(ansiType);
+      }
+
+      if (!logObject.hasOwnProperty(token)) {
+        return match;
+      }
+
+      return logObject[token];
+    }.bind(this));
+
+    return resultString;
+  }
+};
+
+module.exports = TokenFormatter;
diff --git a/lib/cologne/log_utilities.js b/lib/cologne/log_utilities.js
new file mode 100644
index 0000000..fc15a8a
--- /dev/null
+++ b/lib/cologne/log_utilities.js
@@ -0,0 +1,155 @@
+'use strict';
+
+let microtime = require('microtime');
+
+/**
+ * Container object for utilities used by loggers.
+ *
+ * @memberof Cologne
+ * @class LogUtilities
+ */
+let LogUtilities = {
+
+  /**
+   * Returns the current timestamp in miliseconds as a floating point that
+   * includes fractions (ie. microseconds)
+   *
+   * @function now
+   * @memberof Cologne.LogUtilities
+   * @return {Number} current time in miliseconds, including fractions.
+   */
+  now: function now() {
+    return microtime.nowDouble() * 1000;
+  },
+
+  /**
+   * Stringifies objects, avoiding circular references.
+   *
+   * @function stringify
+   * @memberof Cologne.LogUtilities
+   * @param {Object} object the object to stringify
+   * @return {String} the stringified object
+   */
+  stringify: function stringify(object) {
+    let cache;
+
+    cache = [];
+
+    return JSON.stringify(object, function (key, value) {
+      if (typeof value === 'object' && value !== null) {
+        if (cache.indexOf(value) !== -1) {
+          return this._circularString;
+        }
+
+        cache.push(value);
+      }
+
+      return value;
+    }.bind(this));
+  },
+
+  /**
+   * Given an ansi keyword, it will return the appropriate code.
+   *
+   * @function getAnsiCode
+   * @memberof Cologne.LogUtilities
+   * @param {String} ansiString the name of the desired code
+   * @return {String} the ansi code
+   */
+  getAnsiCode: function getAnsiCode(ansiString) {
+    switch(ansiString) {
+    case 'bold':
+      return '[1m';
+    case 'italics':
+      return '[3m';
+    case 'underline':
+      return '[4m';
+    case 'inverse':
+      return '[7m';
+    case 'strikethrough':
+      return '[9m';
+    case 'bold_off':
+      return '[22m';
+    case 'italics_off':
+      return '[23m';
+    case 'underline_off':
+      return '[24m';
+    case 'inverse_off':
+      return '[27m';
+    case 'strikethrough_off':
+      return '[29m';
+    case 'black':
+      return '[30m';
+    case 'red':
+      return '[31m';
+    case 'green':
+      return '[32m';
+    case 'yellow':
+      return '[33m';
+    case 'blue':
+      return '[34m';
+    case 'magenta':
+      return '[35m';
+    case 'cyan':
+      return '[36m';
+    case 'white':
+      return '[37m';
+    case 'default':
+      return '[39m';
+    case 'black_bg':
+      return '[40m';
+    case 'red_bg':
+      return '[41m';
+    case 'green_bg':
+      return '[42m';
+    case 'yellow_bg':
+      return '[43m';
+    case 'blue_bg':
+      return '[44m';
+    case 'magenta_bg':
+      return '[45m';
+    case 'cyan_bg':
+      return '[46m';
+    case 'white_bg':
+      return '[47m';
+    case 'default_bg':
+      return '[49m';
+    case 'reset': // for informative purpouses
+    default:
+      return '[0m';
+    }
+  },
+
+  /**
+   * Given a level, it will return the appropriate ansi keyword related
+   * to it.
+   *
+   * @function getLevelAnsi
+   * @memberof Cologne.LogUtilities
+   * @param {number} level the level of the log
+   * @return {String} the ansi keyword
+   */
+  getLevelAnsi: function getLevelAnsi(level) {
+    switch(level) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+      return 'red';
+    case 4:
+      return 'yellow';
+    case 5:
+    case 6:
+      return 'blue';
+    case 7:
+      return 'green';
+    default:
+      return 'default';
+    }
+  }
+};
+
+// String used as default circular reference.
+LogUtilities._circularString = '[Circular]';
+
+module.exports = LogUtilities;
diff --git a/lib/cologne/logger/console.js b/lib/cologne/logger/console.js
new file mode 100644
index 0000000..3a73e42
--- /dev/null
+++ b/lib/cologne/logger/console.js
@@ -0,0 +1,95 @@
+'use strict';
+
+let LogUtilities = require('../log_utilities');
+
+/**
+ * Logger for the javascript console.
+ *
+ * @memberof Cologne.Logger
+ * @implements Cologne.ILogger
+ * @class Console
+ */
+let ConsoleLogger = 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 Cologne.Logger.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 Cologne.Logger.Console
+     * @type Cologne.IFormatter
+     * @default null
+     */
+    this.formatter = null;
+
+    Object.assign(this, config || {});
+  }
+
+
+  /**
+   * Main entry point, for each incoming argument it will attempt to
+   * format and send to the console.
+   *
+   * @function log
+   * @instance
+   * @memberof Cologne.Logger.Console
+   * @return {undefined}
+   */
+  log () {
+    let logObject, messages, severity;
+
+    messages = [];
+
+    for (logObject of arguments) {
+      messages.push(this._format(logObject));
+
+      if (!severity) {
+        severity = logObject._level;
+      }
+    }
+
+    switch(severity) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+      this.console.error.apply(this.console, messages);
+      break;
+    case 4:
+      this.console.warn.apply(this.console, messages);
+      break;
+    case 5:
+    case 6:
+      this.console.info.apply(this.console, messages);
+      break;
+    case 7:
+    default:
+      this.console.log.apply(this.console, messages);
+      break;
+    }
+  }
+
+  _format (logObject) {
+    if (this.formatter) {
+      return this.formatter.format(logObject);
+    }
+
+    return LogUtilities.stringify(logObject);
+  }
+};
+
+module.exports = ConsoleLogger;
diff --git a/lib/cologne/logger/file.js b/lib/cologne/logger/file.js
new file mode 100644
index 0000000..e9a56e7
--- /dev/null
+++ b/lib/cologne/logger/file.js
@@ -0,0 +1,71 @@
+'use strict';
+
+let fs = require('fs');
+
+let LogUtilities = require('../log_utilities');
+
+/**
+ * Logger for files.
+ *
+ * @memberof Cologne.Logger
+ * @implements Cologne.ILogger
+ * @class File
+ */
+let FileLogger = class FileLogger {
+  constructor (config) {
+
+    /**
+     * Path to the file it will write to, must be readable.
+     *
+     * @name file
+     * @instance
+     * @memberof Cologne.Logger.File
+     * @type string
+     * @default null
+     */
+    this.file = null;
+
+    /**
+     * The formatter it will use to output the log. If not present it
+     * will output raw JSON
+     *
+     * @name formatter
+     * @instance
+     * @memberof Cologne.Logger.File
+     * @type Cologne.IFormatter
+     * @default null
+     */
+    this.formatter = null;
+
+    Object.assign(this, config || {});
+
+    this._stream = fs.createWriteStream(this.file, {flags: 'a'});
+  }
+
+  /**
+   * Main entry point, for each incoming argument it will attempt to
+   * format and send to the stream to be written.
+   *
+   * @function log
+   * @instance
+   * @memberof Cologne.Logger.File
+   * @return {undefined}
+   */
+  log () {
+    let logObject;
+
+    for (logObject of arguments) {
+      this._stream.write(this.format(logObject) + '\n');
+    }
+  }
+
+  format (logObject) {
+    if (this.formatter) {
+      return this.formatter.format(logObject);
+    }
+
+    return LogUtilities.stringify(logObject);
+  }
+};
+
+module.exports = FileLogger;
diff --git a/lib/ext/socket_helper.js b/lib/ext/socket_helper.js
deleted file mode 100644
index 50fe5bc..0000000
--- a/lib/ext/socket_helper.js
+++ /dev/null
@@ -1,7 +0,0 @@
-var bindEvents = function (socket, logger) {
-    socket.on('log', function (logArgs) {
-      logger.log.apply(logger, logArgs);
-    });
-}
-
-exports.bindEvents = bindEvents;
diff --git a/lib/formatters/ansi.js b/lib/formatters/ansi.js
deleted file mode 100644
index 806869a..0000000
--- a/lib/formatters/ansi.js
+++ /dev/null
@@ -1,29 +0,0 @@
-if (typeof require === 'function') {
-    require('colors');
-}
-
-Module(Cobalt.Formatter, 'Ansi')({
-  format : function (logObject, opts){
-    var indent,
-        message;
-
-    indent = Array(logObject._indentLevel + 1).join(' ');
-
-    message = indent + logObject.message;
-
-    switch(logObject._level) {
-      case 0:
-      case 1:
-      case 2:
-      case 3:
-        return message.red;
-      case 4:
-        return message.yellow;
-      case 5:
-      case 6:
-        return message.blue;
-      default:
-        return message;
-    }
-  }
-});
diff --git a/lib/formatters/simple.js b/lib/formatters/simple.js
deleted file mode 100644
index 9eb6bbe..0000000
--- a/lib/formatters/simple.js
+++ /dev/null
@@ -1,11 +0,0 @@
-Module(Cobalt.Formatter, 'Simple')({
-    format : function (logObject, opts){
-        var indent, date;
-
-        indent = Array(logObject._indentLevel + 1).join(' ');
-
-        date = new Date(logObject._timestamp);
-
-        return indent + '[' + date.toISOString() + '][' + logObject._levelString + '] ' + logObject._from + ' : ' + logObject.message;
-    }
-});
diff --git a/lib/formatters/token.js b/lib/formatters/token.js
deleted file mode 100644
index f3afba2..0000000
--- a/lib/formatters/token.js
+++ /dev/null
@@ -1,73 +0,0 @@
-Module(Cobalt.Formatter, 'Token')({
-  formatString : "{{message}}",
-  replaceRule : /{{(.*?)}}/g,
-  separatorLength : 60,
-  isoDate : true,
-  separatorType : "-",
-  format : function (logObject, opts){
-    var indent, indentSize,
-        separatorLength, separatorType,
-        output, property;
-    indentSize = logObject._indentLevel || 0;
-
-    // Extend opts
-    if (opts) {
-      for (property in opts) {
-        if (opts.hasOwnProperty(property)) {
-          this[property] = opts[property];
-        }
-      }
-    }
-
-    indent = Array(indentSize + 1).join(' ');
-
-    if (logObject._separator) {
-      separatorLength = logObject._separatorLength || this.separatorLength;
-      separatorType = logObject._separatorType || this.separatorType;
-      output = indent + Array(separatorLength - indentSize + 1).join(separatorType);
-    } else {
-      output = indent + this.parseFormatString(logObject, this.formatString);
-    }
-
-    if (this.ansiColor) {
-      output = this.colorize(logObject._level, output);
-    }
-
-    return output;
-  },
-
-  parseFormatString : function (logObject, formatString) {
-    var resultString = '';
-    if (typeof formatString === 'undefined') {
-      formatString = this.formatString;
-    }
-
-    resultString = formatString.replace(this.replaceRule, function(match, paren){
-      var date;
-      if (paren === "_timestamp" && this.isoDate) {
-        date = new Date(logObject[paren]);
-        return date.toISOString();
-      }
-      return logObject[paren] || "-";
-    }.bind(this));
-
-    return resultString;
-  },
-
-  colorize : function (level, message) {
-    switch(level) {
-      case 0:
-      case 1:
-      case 2:
-      case 3:
-        return message.red;
-      case 4:
-        return message.yellow;
-      case 5:
-      case 6:
-        return message.blue;
-      default:
-        return message;
-    }
-  }
-});
diff --git a/lib/loggers/console.js b/lib/loggers/console.js
deleted file mode 100644
index c4031eb..0000000
--- a/lib/loggers/console.js
+++ /dev/null
@@ -1,70 +0,0 @@
-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 (!arguments[i].__skipConsole && !arguments[i].message.__skipConsole) {
-          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;
-    }
-  }
-});
diff --git a/lib/loggers/file.js b/lib/loggers/file.js
deleted file mode 100644
index 0d60acd..0000000
--- a/lib/loggers/file.js
+++ /dev/null
@@ -1,48 +0,0 @@
-var fs = require('fs');
-
-Class(Cobalt.Logger, 'File')({
-  prototype : {
-    file : null,
-    formatterOpts : {},
-
-    init : function (config) {
-      if (config) {
-        for (property in config) {
-          this[property] = config[property];
-        }
-      }
-
-      this._stream = fs.createWriteStream(this.file, {flags: 'a'});
-    },
-
-    log : function () {
-      var i, message = [], severity;
-
-      for (i = 0; i < arguments.length; i++) {
-        // We're not formatting objects for now.
-
-        if (!arguments[i].__skipConsole && !arguments[i].message.__skipConsole) {
-          message.push(this.format(arguments[i]));
-          if (!severity) {
-            severity = arguments[i]._level
-          }
-        }
-      }
-
-      for (i = 0; i < message.length; i++) {
-        this._stream.write(message[i] + '\n');
-      }
-    },
-
-    format : function (logObject) {
-      if (this.formatter) {
-        if (typeof logObject.message === 'object') {
-          return logObject.message;
-        }
-        return this.formatter.format(logObject, this.formatterOpts);
-      }
-
-      return Cobalt.stringify(logObject);
-    }
-  }
-});
diff --git a/lib/loggers/socket.js b/lib/loggers/socket.js
deleted file mode 100644
index 7066274..0000000
--- a/lib/loggers/socket.js
+++ /dev/null
@@ -1,37 +0,0 @@
-if (typeof require === 'function') {
-  var ioClient = require('socket.io-client');
-}
-
-Class(Cobalt.Logger, 'Socket')({
-  prototype : {
-    serverUrl : '/',
-
-    init : function (config) {
-      var logger = this;
-
-      if (config) {
-        for (property in config) {
-          logger[property] = config[property];
-        }
-      }
-
-      if (!logger.socketIo) {
-        logger.socketIo = ioClient;
-      }
-
-      logger._socket = logger.socketIo.connect(logger.serverUrl);
-    },
-
-    log : function () {
-      var i, messageArray = [];
-
-      for (i = 0; i < arguments.length; i++) {
-        messageArray.push(arguments[i]);
-      }
-
-      if (this._socket) {
-        this._socket.emit('log', messageArray);
-      }
-    }
-  }
-});