jlog-rails 0.1.3 → 0.2.0

data/vendor/assets/javascripts/logger.js

@@ -0,0 +1,370 @@
+(function(JLog){
+  var anonymousLoggerName = "[anonymous]";
+  var defaultLoggerName = "[default]";
+  var rootLoggerName = "root";
+
+  var loggers = {};
+  var loggerNames = [];
+
+  var rootLogger = new Logger(rootLoggerName);
+  var rootLoggerDefaultLevel = JLog.Level.DEBUG;
+
+  rootLogger.setLevel(rootLoggerDefaultLevel);
+  JLog.getRootLogger = function() {
+    return rootLogger;
+  };
+
+  var defaultLogger = null;
+  JLog.getDefaultLogger = function() {
+    if (!defaultLogger) defaultLogger = JLog.getLogger(defaultLoggerName);
+    return defaultLogger;
+  };
+
+  /*
+    Class: Logger
+    Manager of logged events.
+  */
+  function Logger(name) {
+    this.parent = null;
+    this.children = [];
+
+    var _name = name;
+    var _appenders = [];
+    var _currentLevel = null;
+    var _isRoot = (_name === rootLoggerName);
+    var _enabled = true;
+
+    var _appenderCache = null;
+    var _appenderCacheInvalidated = false;
+
+    this.turnOn  = function() { _enabled = true;  };
+    this.turnOff = function() { _enabled = false; };
+    this.isOn    = function() { return _enabled;  };
+
+    this.getName = function() { return _name; }
+
+    var _additive = true;
+    /*
+      Method: getAdditivity
+
+      Get if log events are propagated higher in logger hierarchy.
+
+      Returns:
+        If events should be propagated higher.
+
+      See Also:
+        <setAdditivity>
+    */
+    this.getAdditivity = function() { return _additive; };
+
+    /*
+      Method: setAdditivity
+
+      Set if log events are propagated higher in logger hierarchy.
+
+      Parameters:
+        additivity - if events should be propagated higher.
+
+      See Also:
+        <getAdditivity>
+    */
+    this.setAdditivity = function(additivity) {
+      var valueChanged = (_additive != additivity);
+      _additive = additivity;
+      if(valueChanged) this._invalidateAppenderCache();
+    };
+
+    /*
+      Method: addChild
+
+      Makes given logger a child of current logger. If child is additive, all it's events will go through this logger
+      either.
+
+      Parameters:
+        childLogger - given logger.
+    */
+    this.addChild = function(childLogger) {
+      this.children.push(childLogger);
+      childLogger.parent = this;
+      childLogger._invalidateAppenderCache();
+    };
+
+    /*
+      Method: addAppender
+
+      Push an appender for this logger.
+
+      Parameters:
+        appender - appender to push.
+
+      See Also:
+        <removeAppender>
+        <removeAllAppenders>
+    */
+    this.addAppender = function(appender) {
+      if(_appenders.indexOf(appender) >= 0) return;
+      _appenders.push(appender);
+      this._invalidateAppenderCache();
+    };
+
+    /*
+      Method: removeAppender
+
+      Remove appender out of this logger.
+
+      Parameters:
+        appender - appender to remove.
+
+      See Also:
+        <addAppender>
+        <removeAllAppenders>
+    */
+    this.removeAppender = function(appender) {
+      _appenders.splice(_appenders.indexOf(appender), 1);
+      this._invalidateAppenderCache();
+    };
+
+    /*
+      Method: removeAllAppender
+
+      Remove all appenders from this logger.
+
+      See Also:
+        <addAppender>
+        <removeAppender>
+    */
+    this.removeAllAppenders = function() {
+      _appenders = [];
+      this._invalidateAppenderCache();
+    };
+
+    /*
+      Method: getEffectiveAppenders
+
+      Returns all appender which will log given message.
+    */
+    this.getEffectiveAppenders = function() {
+      if (_appenderCache === null || _appenderCacheInvalidated) {
+        // Build appender cache
+        var parentEffectiveAppenders = (_isRoot || !this.getAdditivity()) ? [] : this.parent.getEffectiveAppenders();
+        _appenderCache = _.union(parentEffectiveAppenders, _appenders);
+        _appenderCacheInvalidated = false;
+      }
+      return _appenderCache;
+    };
+
+    this._invalidateAppenderCache = function() {
+      _appenderCacheInvalidated = true;
+      _.each(this.children, function(c) { c._invalidateAppenderCache(); });
+    };
+
+    /*
+      Method: log
+
+      Publish logger message across all the appenders! Prefer using specialized function instead.
+
+      Parameters:
+        level - <Level> of message event
+        params - array of message parts. first parameter is usually a simple message.
+    */
+    this.log = function(level, params) {
+      try {
+        if(!(this.isOn() && level.isGreaterOrEqual(this._getEffectiveLevel()))) return;
+
+        params = Array.prototype.slice.call(params || []);
+
+        var exception;
+        var finalParamIndex = params.length - 1;
+        var lastParam = params[finalParamIndex];
+        if (params.length > 1 && (lastParam instanceof Error)) {
+          exception = lastParam;
+          --finalParamIndex;
+        }
+
+        var messages = finalParamIndex >= 0 ? params.slice(0, finalParamIndex + 1) : [];
+
+        var logEvent = new JLog.LoggingEvent(this, new Date(), level, messages, exception);
+
+        this._callAppenders(logEvent);
+      } catch(loggerError) {
+        JLog.handleError(loggerError);
+        // TODO deal with errors inside logger - user of the logger should not know about such a bugs, unless explicitly
+        // requested this!
+      }
+    };
+
+    this._callAppenders = function(logEvent) {
+      _.each(this.getEffectiveAppenders(), function(app) { app.doAppend(logEvent); });
+    };
+
+    /*
+      Method: setLevel
+
+      Set minimal level of log messages to populate.
+
+      Parameters:
+        level - minimal <Level>
+    */
+    this.setLevel = function(level) {
+      if(!(level instanceof JLog.Level)) throw new Error("Logger.setLevel: please use JLog.Level to set Level");
+      // Having a level of null on the root logger would be very bad.
+      if(_isRoot && level === null)
+        throw new Error("Logger.setLevel: you cannot set the level of the root logger to null");
+      _currentLevel = level;
+    };
+
+    /*
+      Method: getLevel
+
+      Get minimal level of log messages to populate.
+    */
+    this.getLevel = function() { return _currentLevel; };
+
+    this._getEffectiveLevel = function() {
+      for(var logger = this; logger !== null; logger = logger.parent) {
+        var level = logger.getLevel();
+        if(level !== null) return level;
+      }
+    };
+
+    this.toString = function() { return "Logger[" + this.getName() + "]"; };
+  };
+
+  Logger.prototype = {
+    /*
+      Method: debug
+
+      Attempt to publish <Level.DEBUG> message.
+    */
+    debug: function() {
+      this.log(JLog.Level.DEBUG, arguments);
+    },
+
+    /*
+      Method: info
+
+      Attempt to publish <Level.INFO> message.
+    */
+    info: function() {
+      this.log(JLog.Level.INFO, arguments);
+    },
+
+    /*
+      Method: warn
+
+      Attempt to publish <Level.WARN> message.
+    */
+    warn: function() {
+      this.log(JLog.Level.WARN, arguments);
+    },
+
+    /*
+      Method: error
+
+      Attempt to publish <Level.ERROR> message.
+    */
+    error: function() {
+      this.log(JLog.Level.ERROR, arguments);
+    },
+
+    /*
+      Method: fatal
+
+      Attempt to publish <Level.FATAL> message.
+    */
+    fatal: function() {
+      this.log(JLog.Level.FATAL, arguments);
+    },
+
+    /*
+      Method: isEnabledFor
+
+      Checks if logger will publish message of given <Level>.
+    */
+    isEnabledFor: function(level) {
+      return level >= this._getEffectiveLevel();
+    },
+
+    /*
+      Method: isDebugEnabled
+
+      Checks if logger will publish message of <Level.DEBUG>.
+    */
+    isDebugEnabled: function() {
+      return this.isEnabledFor(JLog.Level.DEBUG);
+    },
+
+    /*
+      Method: isInfoEnabled
+
+      Checks if logger will publish message of <Level.INFO>.
+    */
+    isInfoEnabled: function() {
+      return this.isEnabledFor(JLog.Level.INFO);
+    },
+
+    /*
+      Method: isWarnEnabled
+
+      Checks if logger will publish message of <Level.WARN>.
+    */
+    isWarnEnabled: function() {
+      return this.isEnabledFor(JLog.Level.WARN);
+    },
+
+    /*
+      Method: isErrorEnabled
+
+      Checks if logger will publish message of <Level.ERROR>.
+    */
+    isErrorEnabled: function() {
+      return this.isEnabledFor(JLog.Level.ERROR);
+    },
+
+    /*
+      Method: isFatalEnabled
+
+      Checks if logger will publish message of <Level.FATAL>.
+    */
+    isFatalEnabled: function() {
+      return this.isEnabledFor(JLog.Level.FATAL);
+    }
+  };
+
+  /*
+    Method: getLogger
+
+    Returns instance of logger for given hierarchy.
+
+    Parameters:
+      loggerName - dot separated logger name.
+
+    Returns:
+      <Logger> for given name.
+  */
+  JLog.getLogger = function(loggerName) {
+    // Use anonymous logger if loggerName is not specified or invalid
+    if (!(typeof loggerName == "string")) loggerName = anonymousLoggerName;
+
+    // Do not allow retrieval of the root logger by name
+    if (loggerName == rootLoggerName)
+      throw new Error("JLog.getLogger: root logger may not be obtained by name");
+
+    // Create the logger for this name if it doesn't already exist
+    if (!loggers[loggerName]) {
+      var logger = new Logger(loggerName);
+      loggers[loggerName] = logger;
+      loggerNames.push(loggerName);
+
+      // Set up parent logger, if it doesn't exist
+      var lastDotIndex = loggerName.lastIndexOf(".");
+      var parentLogger;
+      if(lastDotIndex > -1) {
+        var parentLoggerName = loggerName.substring(0, lastDotIndex);
+        parentLogger = JLog.getLogger(parentLoggerName); // Recursively sets up parents etc.
+      } else parentLogger = rootLogger;
+      parentLogger.addChild(logger);
+    }
+    return loggers[loggerName];
+  };
+})(JLog);

data/vendor/assets/javascripts/logging_event.js

@@ -0,0 +1,81 @@
+/*
+  Class: LoggingEvent
+
+  Contains all the data about single log event.
+*/
+
+/*
+  Constructor: LoggingEvent
+
+  Initializes event.
+
+  Parameters:
+    logger - <Logger> which was the event source
+    timeStamp - Date of event occurrence
+    level - <Level> of the log event
+    messages - Array of messages in event
+    exception - Exception of the message
+*/
+JLog.LoggingEvent = function(logger, timeStamp, level, messages, exception) {
+  this.logger = logger;
+  this.timeStamp = timeStamp;
+  this.timeStampInMilliseconds = timeStamp.getTime();
+  this.timeStampInSeconds = Math.floor(this.timeStampInMilliseconds / 1000);
+  this.milliseconds = this.timeStamp.getMilliseconds();
+  this.level = level;
+  this.messages = messages;
+  this.exception = exception;
+};
+
+/*
+  Property: logger
+
+  <Logger> which was the event source
+*/
+
+/*
+  Property: timeStamp
+
+  Date of event occurrence
+*/
+
+/*
+  Property: level
+
+  <Level> of the log event
+*/
+
+/*
+  Property: messages
+
+  Array of messages in event
+*/
+
+/*
+  Property: exception
+
+  Exception of the message
+*/
+
+JLog.LoggingEvent.prototype = {
+  /*
+    Method: getThrowableStrRep
+
+    Returns exception of the message as a String.
+  */
+  getThrowableStrRep: function() {
+    return this.exception ? getExceptionStringRep(this.exception) : "";
+  },
+
+  /*
+    Method: getCombinedMessages
+
+    Returns messages of the event joined with new line symbol.
+  */
+  getCombinedMessages: function() {
+    return (this.messages.length == 1) ? this.messages[0] : this.messages.join(newLine);
+  },
+  toString: function() {
+    return "LoggingEvent[" + this.level + "]";
+  }
+};

data/vendor/assets/javascripts/mount.js

@@ -0,0 +1,4 @@
+var JLog = {
+  handleError: function(error) {},
+  startup: new Date()
+};

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jlog-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Helios Technologies
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-21 00:00:00.000000000 Z
+date: 2013-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jquery-rails
@@ -24,6 +24,20 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: just_underscore
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A lightweight JavaScript logger (for Rails)
 email: contact@heliostech.fr
 executables: []
@@ -46,7 +60,22 @@ files:
 - lib/jlog/formatters.rb
 - lib/jlog/version.rb
 - script/rails
+- test/ajax-appender-test.js
+- test/buster.js
+- test/lib/jquery-1.9.1.min.js
+- test/lib/underscore.js
+- test/logger-test.js
+- test/pattern-layout-test.js
+- vendor/assets/javascripts/appender.js
+- vendor/assets/javascripts/appenders/ajax.js
+- vendor/assets/javascripts/appenders/console.js
 - vendor/assets/javascripts/jlog.js
+- vendor/assets/javascripts/layout.js
+- vendor/assets/javascripts/layouts/pattern.js
+- vendor/assets/javascripts/levels.js
+- vendor/assets/javascripts/logger.js
+- vendor/assets/javascripts/logging_event.js
+- vendor/assets/javascripts/mount.js
 homepage: http://rubygems.org/gems/jlog-rails
 licenses: []
 metadata: {}
@@ -70,4 +99,10 @@ rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: Jlog for Rails
-test_files: []
+test_files:
+- test/ajax-appender-test.js
+- test/buster.js
+- test/lib/jquery-1.9.1.min.js
+- test/lib/underscore.js
+- test/logger-test.js
+- test/pattern-layout-test.js