jlog-rails 0.1.3 → 0.2.0

data/vendor/assets/javascripts/layout.js

@@ -0,0 +1,216 @@
+JLog.Layout = function() {};
+/*
+  Class: Layout
+
+  Abstract class for message formatting.
+*/
+JLog.Layout.prototype = {
+  defaults: {
+    loggerKey: "logger",
+    timeStampKey: "timestamp",
+    millisecondsKey: "milliseconds",
+    levelKey: "level",
+    messageKey: "message",
+    exceptionKey: "exception",
+    urlKey: "url"
+  },
+  loggerKey: "logger",
+  timeStampKey: "timestamp",
+  millisecondsKey: "milliseconds",
+  levelKey: "level",
+  messageKey: "message",
+  exceptionKey: "exception",
+  urlKey: "url",
+  /*
+    Property: batchHeader
+
+    Header of batch output.
+
+    See Also:
+      <allowBatching>, <batchFooter>, <batchSeparator>
+  */
+  batchHeader: "",
+  /*
+    Property: batchFooter
+
+    Footer of batch output.
+
+    See Also:
+      <allowBatching>, <batchHeader>, <batchSeparator>
+  */
+  batchFooter: "",
+  /*
+    Property: batchSeparator
+
+    Separator of batch output.
+
+    See Also:
+      <allowBatching>, <batchHeader>, <batchFooter>
+  */
+  batchSeparator: "",
+  /*
+    Property: useTimeStampsInMilliseconds
+
+    If timestamp should be outputted in milliseconds.
+  */
+  useTimeStampsInMilliseconds: null,
+
+  /*
+    Method: format
+
+    Formats log message into a string. Has to be overloaded by derivative classes.
+
+    Parameters:
+      logMessage - Log Message to format.
+
+    Returns:
+      Message formatted as string.
+  */
+  format: function(logMessage) {
+    JLog.handleError("Layout.format: layout supplied has no format() method");
+  },
+
+  /*
+    Method: getContentType
+
+    Used to set content type for network sending.
+
+    Returns:
+      Content-Type header value.
+  */
+  getContentType: function() {
+    return "text/plain";
+  },
+
+  /*
+    Method: allowBatching
+
+    If formatted messages can be send in a batch. If true, messages will be send in format:
+    batchHeader+MESSAGES.join(batchSeparator)+batchFooter
+
+    Returns:
+      Boolean
+
+    See Also:
+      <batchHeader>, <batchFooter>, <batchSeparator>
+  */
+  allowBatching: function() {
+    return true;
+  },
+
+  /*
+    Method: getTimeStampValue
+
+    Returns string representation of time of event occurrence in seconds or milliseconds, depending on configuration.
+
+    Parameters:
+      loggingEvent - <LoggingEvent> to fetch timestamp.
+  */
+  getTimeStampValue: function(loggingEvent) {
+    return this.useTimeStampsInMilliseconds() ?
+      loggingEvent.timeStampInMilliseconds : loggingEvent.timeStampInSeconds;
+  },
+
+  /*
+    Method: getDataValues
+
+    Builds the map of log event environment.
+
+    Parameters:
+      loggingEvent - <LoggingEvent> to fetch data from.
+      combineMessages - Boolean, if messages should be combined into single String, or Array is required.
+  */
+  getDataValues: function(loggingEvent, combineMessages) {
+    var dataValues = [
+      [this.loggerKey, loggingEvent.logger.name],
+      [this.timeStampKey, this.getTimeStampValue(loggingEvent)],
+      [this.levelKey, loggingEvent.level.name],
+      [this.urlKey, window.location.href],
+      [this.messageKey, combineMessages ? loggingEvent.getCombinedMessages() : loggingEvent.messages]
+    ];
+    if(!this.useTimeStampsInMilliseconds()) {
+      dataValues.push([this.millisecondsKey, loggingEvent.milliseconds]);
+    }
+    if(loggingEvent.exception) {
+      dataValues.push([this.exceptionKey, getExceptionStringRep(loggingEvent.exception)]);
+    }
+    if(this.hasCustomFields()) {
+      for(var i = 0, len = this.customFields.length; i < len; i++) {
+        var val = this.customFields[i].value;
+
+        // Check if the value is a function. If so, execute it, passing it the
+        // current layout and the logging event
+        try {
+          if(typeof val === "function")
+            val = val(this, loggingEvent);
+        } catch(e) {
+          JLog.handleError(e);
+          val = "[Exception during evaluating]"
+        }
+
+        dataValues.push([this.customFields[i].name, val]);
+      }
+    }
+    return dataValues;
+  },
+
+  /*
+    Method: setKeys
+
+    Sets key names for standard environment variables.
+
+    Parameters:
+      loggerKey - key for <Logger> name value
+      timeStampKey - key for timestamp value
+      levelKey - key for event <Level> value
+      messageKey - key for message value(s)
+      exceptionKey - key for exception value
+      urlKey - key for URL value
+      millisecondsKey - key for timestamp value in milliseconds
+  */
+  setKeys: function(loggerKey, timeStampKey, levelKey, messageKey,
+                    exceptionKey, urlKey, millisecondsKey) {
+    this.loggerKey = extractStringFromParam(loggerKey, this.defaults.loggerKey);
+    this.timeStampKey = extractStringFromParam(timeStampKey, this.defaults.timeStampKey);
+    this.levelKey = extractStringFromParam(levelKey, this.defaults.levelKey);
+    this.messageKey = extractStringFromParam(messageKey, this.defaults.messageKey);
+    this.exceptionKey = extractStringFromParam(exceptionKey, this.defaults.exceptionKey);
+    this.urlKey = extractStringFromParam(urlKey, this.defaults.urlKey);
+    this.millisecondsKey = extractStringFromParam(millisecondsKey, this.defaults.millisecondsKey);
+  },
+
+  /*
+    Method: setCustomField
+
+    Sets custom variable of the layout.
+
+    Parameters:
+      name - Key for custom field
+      value - Value for custom field
+  */
+  setCustomField: function(name, value) {
+    var fieldUpdated = false;
+    for (var i = 0, len = this.customFields.length; i < len; i++) {
+      if (this.customFields[i].name === name) {
+        this.customFields[i].value = value;
+        fieldUpdated = true;
+      }
+    }
+    if (!fieldUpdated) {
+      this.customFields.push({"name": name, "value": value});
+    }
+  },
+
+  /*
+    Method: hasCustomFields
+
+    Checks, if there are any custom fields.
+  */
+  hasCustomFields: function() {
+    return (this.customFields.length > 0);
+  },
+
+  toString: function() {
+    JLog.handleError("Layout.toString: all layouts must override this method");
+  }
+};

data/vendor/assets/javascripts/layouts/pattern.js

@@ -0,0 +1,184 @@
+(function() {
+  var newLine = "\n";
+
+  /*
+    Class: PatternLayout
+
+    Pattern based layout.
+  */
+
+  /*
+    Constructor: PatternLayout
+
+    Initializes Pattern Layout. Recognizes patterns like %[padding][trunctaion](type)[specifier], where type can be:
+    - *a* - array of messages.
+    - *m* - prints all the messages. Objects are dumped to the _specifier_ depth.
+    - *c* - prints logger name
+    - *d* - prints log event date
+    - *f* - prints custom field defined by _specifier_
+    - *n* - prints new line
+    - *p* - prints log event level name
+    - *r* - prints time in seconds since JLog startup
+    - *%* - prints % sign
+
+    Parameters:
+      pattern - (optional) String format
+  */
+  function PatternLayout(pattern) {
+    if(pattern) this.pattern = pattern;
+    else this.pattern = PatternLayout.DEFAULT_CONVERSION_PATTERN;
+    this.customFields = [];
+  }
+
+  /*
+    Constant: TTCC_CONVERSION_PATTERN
+
+    Usual verbose pattern.
+  */
+  PatternLayout.TTCC_CONVERSION_PATTERN = "%r %p %c - %m%n";
+
+  /*
+    Constant: DEFAULT_CONVERSION_PATTERN
+
+    Default concise pattern.
+  */
+  PatternLayout.DEFAULT_CONVERSION_PATTERN = "%m%n";
+
+  PatternLayout.prototype = new JLog.Layout();
+
+  /*
+    Method: format
+
+    Formats event into string.
+
+    Parameters:
+      loggingEvent - <LoggingEvent> to format
+  */
+  PatternLayout.prototype.format = function(loggingEvent) {
+    var regex = /%(-?[0-9]+)?(\.?[0-9]+)?([acdfmMnpr%])(\{([^\}]+)\})?|([^%]+)/;
+    var formattedString = "";
+    var result;
+    var searchString = this.pattern;
+
+    // Cannot use regex global flag since it doesn't work with exec in IE5
+    while ((result = regex.exec(searchString))) {
+      var matchedString = result[0];
+      var padding = result[1];
+      var truncation = result[2];
+      var conversionCharacter = result[3];
+      var specifier = result[5];
+      var text = result[6];
+
+      // Check if the pattern matched was just normal text
+      if (text) {
+        formattedString += "" + text;
+      } else {
+        // Create a raw replacement string based on the conversion
+        // character and specifier
+        var replacement = "";
+        switch(conversionCharacter) {
+        case "a": // Array of messages
+        case "m": // Message
+          var depth = 0;
+          if (specifier) {
+            depth = parseInt(specifier, 10);
+            if (isNaN(depth)) {
+              handleError("PatternLayout.format: invalid specifier '" +
+                          specifier + "' for conversion character '" + conversionCharacter +
+                          "' - should be a number");
+              depth = 0;
+            }
+          }
+          var messages = (conversionCharacter === "a") ? loggingEvent.messages[0] : loggingEvent.messages;
+          for (var i = 0, len = messages.length; i < len; i++) {
+            if (i > 0 && (replacement.charAt(replacement.length - 1) !== " ")) {
+              replacement += " ";
+            }
+            if (depth === 0) {
+              replacement += messages[i];
+            } else {
+              replacement += formatObjectExpansion(messages[i], depth);
+            }
+          }
+          break;
+        case "c": // Logger name
+          var loggerName = loggingEvent.logger.getName();
+          if (specifier) {
+            var precision = parseInt(specifier, 10);
+            var loggerNameBits = loggingEvent.logger.getName().split(".");
+            if (precision >= loggerNameBits.length) {
+              replacement = loggerName;
+            } else {
+              replacement = loggerNameBits.slice(loggerNameBits.length - precision).join(".");
+            }
+          } else {
+            replacement = loggerName;
+          }
+          break;
+        case "d": // Date
+          replacement = "[date-not-implemented]";
+          break;
+        case "f": // Custom field
+          if (this.hasCustomFields()) {
+            var ff = _.findWhere(this.customFields, {name: specifier});
+            if(!ff) replacement = "[Custom Field not fount: " + specifier + "]";
+            else replacement = ff.value;
+          }
+          break;
+        case "n": // New line
+          replacement = newLine;
+          break;
+        case "p": // Level
+          replacement = loggingEvent.level.name;
+          break;
+        case "r": // Milliseconds since log4javascript startup
+          replacement = "" + (loggingEvent.timeStamp.getTime() - JLog.startup.getTime());
+          break;
+        case "%": // Literal % sign
+          replacement = "%";
+          break;
+        default:
+          replacement = matchedString;
+          break;
+        }
+        // Format the replacement according to any padding or
+        // truncation specified
+        var l;
+
+        // First, truncation
+        if (truncation) {
+          l = parseInt(truncation.substr(1), 10);
+          var strLen = replacement.length;
+          if (l < strLen) {
+            replacement = replacement.substring(strLen - l, strLen);
+          }
+        }
+        // Next, padding
+        if (padding) {
+          if (padding.charAt(0) == "-") {
+            l = parseInt(padding.substr(1), 10);
+            // Right pad with spaces
+            while (replacement.length < l) {
+              replacement += " ";
+            }
+          } else {
+            l = parseInt(padding, 10);
+            // Left pad with spaces
+            while (replacement.length < l) {
+              replacement = " " + replacement;
+            }
+          }
+        }
+        formattedString += replacement;
+      }
+      searchString = searchString.substr(result.index + result[0].length);
+    }
+    return formattedString;
+  };
+
+  PatternLayout.prototype.toString = function() {
+    return "PatternLayout";
+  };
+
+  JLog.PatternLayout = PatternLayout;
+})(JLog);

data/vendor/assets/javascripts/levels.js

@@ -0,0 +1,35 @@
+/*
+  Enum: Level
+
+  Levels of messages.
+
+  ALL - Used to mark <Logger> of <Appender> as ones allowing all messages.
+  DEBUG - Minimal priority for message. This one is used for least valuable, and massive messages.
+  INFO - Used to trace the system status. These messages are less aggressive then <Level.DEBUG>.
+  WARN - Something could be better at this time.
+  ERROR - Same as <Level.WARN>, but brakes some part of the system. Has to be fixed.
+  FATAL - Same as <Level.WARN>, but brakes all the system. If not fixed - nothing will work at all.
+  NONE - Used to mark <Logger> of <Appender> as ones blocking all the messages.
+*/
+JLog.Level = (function() {
+  function Level(priority, name) {
+    this.priority = priority;
+    this.name = name;
+  };
+
+  Level.prototype = {
+    isGreaterOrEqual: function(otherLevel) {
+      return this.priority >= otherLevel.priority;
+    }
+  };
+
+  Level.ALL   = new Level(0, "ALL");
+  Level.DEBUG = new Level(1, "DEBUG");
+  Level.INFO  = new Level(2, "INFO");
+  Level.WARN  = new Level(3, "WARN");
+  Level.ERROR = new Level(4, "ERROR");
+  Level.FATAL = new Level(5, "FATAL");
+  Level.NONE  = new Level(6, "NONE");
+
+  return Level;
+})();