Added some logging stubs and MDC

index.js

@@ -2,7 +2,9 @@
 
 var _ = require('lodash');
 
-var Logger = require("./lib/Logger.class.js");
+var Logger = require('./lib/Logger.class');
+var Level = require('./lib/Level.class');
+var MDC = require('./lib/MDC.class');
 
 var fileRegex = /[\w\.]+:/;
 
@@ -20,6 +22,7 @@ class Main {
             name = param2;
         }
         if (!name || _.trim(name) == '') {
+            // TODO this shoud include a relative path to the root of the project (try to compare process.args to this path)
             var match = fileRegex.exec(new Error().stack.substr(__filename.length + 37));
             name = _.trimRight(match[0], ':');
         }
@@ -47,4 +50,6 @@ class Main {
     }
 }
 
-module.exports = new Main();
+module.exports = new Main();
+module.exports.Level = Level;
+module.exports.MDC = MDC;

lib/Logger.class.js

@@ -1,21 +1,27 @@
 "use strict";
 
-var Level = require("./Level.class");
+var _ = require('lodash');
+
+var Level = require('./Level.class');
+var Message = require('./Message.class');
 
 var defaultConfig = {
-    level: Level.INFO
+    level: Level.INFO,
+    capture: false
 };
 
 module.exports = class Logger {
     constructor(name) {
         this._config = {};
         this._name = name;
+        this._buffer = [];
         this.config = defaultConfig;
     }
 
     set config(config) {
         Object.assign(this._config, config);
         this.level = config.level;
+        this.capture = config.capture;
     }
 
     set level(level) {
@@ -26,11 +32,106 @@ module.exports = class Logger {
         return this._level;
     }
 
+    set capture(capture) {
+        this._capture = capture;
+    }
+
+    get capture() {
+        return this._capture;
+    }
+
+    /**
+     * If captured has been enabled then this will clear all captured messages and return them.
+     *
+     * @returns {Array.<Message>}
+     */
+    get captured() {
+        var messages = this._buffer.splice(0, this._buffer.length);
+        return messages;
+    }
+
     enabled(level) {
         return Level.parse(level) >= this._level;
     }
 
     get name() {
         return this._name;
     }
+
+    ERROR() {
+        this.log(Level.error, arguments);
+    }
+
+    ERR() {
+        this.log(Level.error, arguments);
+    }
+
+    error() {
+        this.log(Level.error, arguments);
+    }
+
+    err() {
+        this.log(Level.error, arguments);
+    }
+
+    WARN() {
+        this.log(Level.warn, arguments);
+    }
+
+    WARNING() {
+        this.log(Level.warn, arguments);
+    }
+
+    warn() {
+        this.log(Level.warn, arguments);
+    }
+
+    warning() {
+        this.log(Level.warn, arguments);
+    }
+
+    INFO() {
+        this.log(Level.info, arguments);
+    }
+
+    info() {
+        this.log(Level.info, arguments);
+    }
+
+    DEBUG() {
+        this.log(Level.debug, arguments);
+    }
+
+    debug() {
+        this.log(Level.debug, arguments);
+    }
+
+    TRACE() {
+        this.log(Level.trace, arguments);
+    }
+
+    trace() {
+        this.log(Level.trace, arguments);
+    }
+
+    log() {
+        var level, pattern, error, mdc, params = [];
+        for (let arg of arguments) {
+            if (arg instanceof Level) {
+                level = arg;
+            }
+            else if (arg instanceof Error) {
+                error = arg;
+            }
+            else if (arg instanceof MDC) {
+                mdc = arg;
+            }
+            else if (_.isString(arg) && !pattern) {
+                pattern = arg;
+            }
+            else {
+                params.push(arg);
+            }
+        }
+    }
 };

lib/MDC.class.js

@@ -0,0 +1,96 @@
+"use strict";
+
+var _ = require('lodash');
+
+function mergeValue(target, source) {
+    if (!_.isObject(target) && !_.isArray(target)) {
+        target = [target];
+    }
+    if (!_.isObject(source)) {
+        target.push(source);
+        return target;
+    }
+    if (_.isArray(source)) {
+        return target.concat(source);
+    }
+    for (var prop in source) {
+        if (!target[prop]) {
+            target[prop] = source[prop];
+        }
+        else {
+            if (_.isObject(target[prop]) || _.isObject(source[prop])) {
+                target[prop] = mergeValue(target[prop], source[prop]);
+                return target;
+            }
+            if (!_.isArray(target[prop])) {
+                target[prop] = [target[prop]];
+            }
+            if (!_.isArray(source[prop])) {
+                target[prop].push(source[prop]);
+            }
+            else {
+                target[prop] = [...target[prop], ...source[prop]];
+            }
+        }
+    }
+    return target;
+}
+
+module.exports = class MDC {
+    constructor() {
+        this._data = {};
+    }
+
+    get size() {
+        return this.length;
+    }
+
+    get length() {
+        return Object.keys(this._data).length;
+    }
+
+    get empty() {
+        return this.length === 0;
+    }
+
+    get(name) {
+        if (name) {
+            return this._data[name];
+        }
+        return this._data;
+    }
+
+    set(name, value) {
+        if (!value && _.isObject(name)) {
+            this._data = name;
+            return this;
+        }
+        this._data[name] = value;
+        return this;
+    }
+
+    delete(name) {
+        delete this._data[name];
+    }
+
+    clear() {
+        let data = this._data;
+        this._data = {};
+        return data;
+    }
+
+    merge(name, value) {
+        if (!value) {
+            if (_.isObject(name)) {
+                this._data = mergeValue(this._data, name);
+            }
+        }
+        if (name && value) {
+            if (!this._data[name]) {
+                this._data[name] = value;
+            } else {
+                this._data[name] = mergeValue(this._data[name], value);
+            }
+        }
+    }
+};

lib/Message.class.js

@@ -0,0 +1,69 @@
+"use strict";
+
+module.exports = class Message {
+    constructor(level, message, mdc, error) {
+        this._time = Date.now();
+        this._level = level;
+        this._message = message;
+        this._mdc = mdc;
+        this._error = error;
+        this._entry = process.mainModule;
+        this._process = process.pid;
+    }
+
+    /**
+     * The level of this message.
+     * @returns {Level}
+     */
+    get level() {
+        return this._level;
+    }
+
+    /**
+     * The rendered message.
+     * @returns {string}
+     */
+    get message() {
+        return this._message;
+    }
+
+    /**
+     * The mete data container with contextual information (if any).
+     * @returns {object|unknown}
+     */
+    get mdc() {
+        return this._mdc;
+    }
+
+    /**
+     * Returns the error passed in with the message (if any)
+     * @returns {Error|unknown}
+     */
+    get error() {
+        return this._error;
+    }
+
+    /**
+     * Returns the time this message was generated.
+     * @returns {number|*}
+     */
+    get time() {
+        return this._time;
+    }
+
+    /**
+     * Returns the entry point of this script / process.
+     * @returns {string|*}
+     */
+    get entry() {
+        return this._entry;
+    }
+
+    /**
+     * Returns the process id in which this messages has been generated.
+     * @returns {boolean|Number|*}
+     */
+    get process() {
+        return this._process;
+    }
+};

test/Level.class.test.js

@@ -2,7 +2,7 @@
 
 var expect = require('chai').expect;
 
-var Level = require('../lib/Level.class');
+var Level = require('..').Level;
 
 describe("Level.class", () => {
     it("should have the same level for different names", () => {