Feature/logger refactor

package.js

@@ -8,7 +8,6 @@ Package.describe({
 
 Npm.depends({
   "getenv": "0.5.0",
-  "winston": "2.1.0",
   "babel-plugin-transform-decorators-legacy": "1.3.4"
 });
 
@@ -49,7 +48,9 @@ Package.onUse(function(api) {
     'source/injector.coffee',
     'source/injector_annotations.coffee',
     'source/module.coffee',
-    'source/application.coffee'
+    'source/application.coffee',
+    'source/loggers/adapter.js',
+    'source/loggers/console-adapter.js',
   ]);
 
   // Test helpers

source/configuration.js

@@ -1,40 +1,3 @@
-
 if (Meteor.isServer) {
-
-  let getenv = Npm.require('getenv');
-  // Wrapper
-  Space.getenv = getenv;
-
-  Space.configuration = Space.getenv.multi({
-    log: {
-      enabled: ['SPACE_LOG_ENABLED', false, 'bool'],
-      minLevel: ['SPACE_LOG_MIN_LEVEL', 'info', 'string']
-    }
-  });
-
-  // Pass down to the client
-  _.deepExtend(Meteor.settings, {
-    public: {
-      log: {
-        enabled: Space.configuration.log.enabled,
-        minLevel: Space.configuration.log.minLevel
-      }
-    }
-  });
-
-  __meteor_runtime_config__.PUBLIC_SETTINGS = Meteor.settings.public;
-
-}
-
-if (Meteor.isClient) {
-
-  let log = Meteor.settings.public.log;
-
-  // Guard and defaults when not loaded on server
-  Space.configuration = {
-    log: {
-      enabled: log && log.enabled || false,
-      minLevel: log && log.minLevel || 'info'
-    }
-  };
+  Space.getenv = Npm.require('getenv');
 }

source/logger.js

@@ -1,104 +1,100 @@
-let config = Space.configuration;
+const Logger = Space.Object.extend('Space.Logger', {
 
-if (Meteor.isServer) {
-  winston = Npm.require('winston');
-}
-
-Space.Object.extend(Space, 'Logger', {
-
-  _logger: null,
-  _minLevel: 6,
-  _state: 'stopped',
-
-  _levels: {
-    'error': 3,
-    'warning': 4,
-    'warn': 4,
-    'info': 6,
-    'debug': 7
+  STATES: {
+    stopped: 'stopped',
+    running: 'running'
   },
 
   Constructor() {
-    if (Meteor.isServer) {
-      this._logger = new winston.Logger({
-        transports: [
-          new winston.transports.Console({
-            colorize: true,
-            prettyPrint: true
-          })
-        ]
-      });
-      this._logger.setLevels(winston.config.syslog.levels);
+    this._state = this.STATES.stopped;
+    this._adapters = {};
+  },
+
+  addAdapter(id, adapter, shouldOverride = false) {
+    if (!id || typeof id !== 'string') {
+      throw new Error(this.constructor.ERRORS.invalidId);
     }
-    if (Meteor.isClient) {
-      this._logger = console;
+    if (this.hasAdapter(id) && !shouldOverride) {
+      throw new Error(this.constructor.ERRORS.mappingExists(id));
     }
+    this._adapters[id] = adapter;
   },
 
-  setMinLevel(name) {
-    let newCode = this._levelCode(name);
-    if (this._minLevel !== newCode) {
-      this._minLevel = newCode;
-      if (Meteor.isServer) {
-        this._logger.transports.console.level = name;
-      }
-    }
+  overrideAdapter(id, adapter) {
+    return this.addAdapter(id, adapter, true);
+  },
+
+  getAdapter(id) {
+    return this._adapters[id] || null;
+  },
+
+  hasAdapter(id) {
+    return (this._adapters[id] !== null && this._adapters[id] !== undefined);
+  },
+
+  removeAdapter(id) {
+    if (this._adapters[id]) {delete this._adapters[id];}
+  },
+
+  getAdapters() {
+    return this._adapters;
   },
 
   start() {
-    if (this._is('stopped')) {
-      this._state = 'running';
+    if (this.isInState(this.STATES.stopped)) {
+      this._state = this.STATES.running;
     }
   },
 
   stop() {
-    if (this._is('running')) {
-      this._state = 'stopped';
+    if (this.isInState(this.STATES.running)) {
+      this._state = this.STATES.stopped;
     }
   },
 
-  debug(message) {
-    check(message, String);
-    this._log('debug', arguments);
+  debug(...args) {
+    this._log('debug', args);
   },
 
-  info(message) {
-    check(message, String);
-    this._log('info', arguments);
+  info(...args) {
+    this._log('info', args);
   },
 
-  warning(message) {
-    check(message, String);
-    if (Meteor.isClient)
-      this._log('warn', arguments);
-    if (Meteor.isServer)
-      this._log('warning', arguments);
+  warning(...args) {
+    this._log('warning', args);
   },
 
-  error(message) {
-    check(message, String);
-    this._log('error', arguments);
+  error(...args) {
+    this._log('error', args);
   },
 
-  _levelCode(name) {
-    return this._levels[name];
+  isInState(expectedState) {
+    return (this._state === expectedState);
   },
 
-  _is(expectedState) {
-    if (this._state === expectedState) return true;
+  isRunning() {
+    return this.isInState(this.STATES.running);
   },
 
-  _log(level, message) {
-    if(this._is('running') && this._levelCode(level) <= this._minLevel) {
-      this._logger[level].apply(this._logger, message);
+  isStopped() {
+    return this.isInState(this.STATES.stopped);
+  },
+
+  _log(level, args) {
+    if (!this.isInState(this.STATES.running)) {return;}
+
+    for (let adapter of Object.values(this.getAdapters())) {
+      adapter[level].apply(adapter, args);
     }
   }
-
 });
 
-Space.log = new Space.Logger();
+Logger.ERRORS =  {
+  mappingExists(id) {
+    return `Adapter with id '${id}' would be overwritten. Use method
+    'overrideAdapter' for that`;
+  },
+  invalidId: 'Cannot map <null> or <undefined> or non string values'
+};
 
-if (config.log.enabled) {
-  Space.log.setMinLevel(config.log.minLevel);
-  Space.log.start();
-}
+export default Logger;

source/loggers/adapter.js

@@ -0,0 +1,44 @@
+const LoggingAdapter = Space.Object.extend('Space.Logger.LoggingAdapter', {
+
+  _lib: null,
+  Constructor(lib) {
+    if (!lib) {
+      throw new Error(this.ERRORS.undefinedLibrary);
+    }
+    this.setLibrary(lib);
+  },
+
+  setLibrary(lib) {
+    this._lib = lib;
+  },
+
+  getLibrary() {
+    return this._lib || null;
+  },
+
+  debug(...args) {
+    this._log('debug', args);
+  },
+
+  info(...args) {
+    this._log('info', args);
+  },
+
+  warning(...args) {
+    this._log('warning', args);
+  },
+
+  error(...args) {
+    this._log('error', args);
+  },
+
+  _log(level, args) {
+    this._lib[level].apply(this._lib, args);
+  },
+
+  ERRORS: {
+    undefinedLibrary: 'Logging library is required'
+  }
+});
+
+export default LoggingAdapter;

source/loggers/console-adapter.js

@@ -0,0 +1,14 @@
+import LoggingAdapter from './adapter';
+
+const ConsoleLogger = LoggingAdapter.extend('Space.Logger.ConsoleAdapter', {
+
+  Constructor() {
+    LoggingAdapter.call(this, console);
+  },
+
+  warning(...args) {
+    return this._log('warn', args);
+  }
+});
+
+export default ConsoleLogger;