x-forwarded-for

added node 0.12 to travis config
0.6.25
2015-06-01 15:30:46 +02:00 · 2015-05-13 08:06:16 +10:00 · 2015-05-13 08:03:35 +10:00 · 2015-05-13 07:54:33 +10:00 · 2015-04-27 11:01:20 -06:00 · 2015-04-24 11:14:17 -06:00
33 changed files with 976 additions and 210 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,5 +1,6 @@
 language: node_js
 node_js:
+  - "0.12"
  - "0.10"
  - "0.8"

--- a/README.md
+++ b/README.md
@@ -13,6 +13,7 @@ Out of the box it supports the following features:
 * GELF appender
 * hook.io appender
 * Loggly appender
+* Logstash UDP appender
 * multiprocess appender (useful when you've got worker processes)
 * a logger for connect/express servers
 * configurable log message layout/patterns
@@ -107,8 +108,9 @@ For FileAppender you can also pass the path to the log directory as an option wh
 log4js.configure('my_log4js_configuration.json', { cwd: '/absolute/path/to/log/dir' });
 ```
 If you have already defined an absolute path for one of the FileAppenders in the configuration file, you could add a "absolute": true to the particular FileAppender to override the cwd option passed. Here is an example configuration file:
-```json
+
 #### my_log4js_configuration.json ####
+```json
 {
  "appenders": [
    {
--- a/examples/example.js
+++ b/examples/example.js
@@ -35,11 +35,13 @@ logger.setLevel('ERROR');
 //console logging methods have been replaced with log4js ones.
 //so this will get coloured output on console, and appear in cheese.log
 console.error("AAArgh! Something went wrong", { some: "otherObject", useful_for: "debug purposes" });
+console.log("This should appear as info output");

 //these will not appear (logging level beneath error)
 logger.trace('Entering cheese testing');
 logger.debug('Got cheese.');
 logger.info('Cheese is Gouda.');
+logger.log('Something funny about cheese.');
 logger.warn('Cheese is quite smelly.');
 //these end up on the console and in cheese.log
 logger.error('Cheese %s is too ripe!', "gouda");
--- a/examples/logstashUDP.js
+++ b/examples/logstashUDP.js
@@ -0,0 +1,39 @@
+var log4js = require('../lib/log4js');
+
+/*
+ Sample logstash config:
+   udp {
+    codec => json
+    port => 10001
+    queue_size => 2
+    workers => 2
+    type => myAppType
+  }
+*/
+
+log4js.configure({
+  "appenders": [
+    {
+      type: "console",
+      category: "myLogger"
+    },
+    {
+      "host": "127.0.0.1",
+      "port": 10001,
+      "type": "logstashUDP",
+      "logType": "myAppType", // Optional, defaults to 'category'
+      "fields": {             // Optional, will be added to the 'fields' object in logstash
+        "field1": "value1",
+        "field2": "value2"
+      },
+      "layout": {
+        "type": "pattern",
+        "pattern": "%m"
+      },
+      "category": "myLogger"
+    }
+  ]
+});
+
+var logger = log4js.getLogger("myLogger");
+logger.info("Test log message %s", "arg1", "arg2");
--- a/lib/appenders/clustered.js
+++ b/lib/appenders/clustered.js
@@ -87,6 +87,15 @@ function createAppender(config) {
 					// console.log("master : " + cluster.isMaster + " received message: " + JSON.stringify(message.event));
 					
 					var loggingEvent = deserializeLoggingEvent(message.event);
+					
+					// Adding PID metadata
+					loggingEvent.pid = worker.process.pid;
+					loggingEvent.cluster = {
+						master: process.pid,
+						worker: worker.process.pid,
+						workerId: worker.id
+					};
+					
 					masterAppender(loggingEvent);
 				}
 			});
--- a/lib/appenders/console.js
+++ b/lib/appenders/console.js
@@ -2,10 +2,10 @@
 var layouts = require('../layouts')
 , consoleLog = console.log.bind(console);

-function consoleAppender (layout) {
+function consoleAppender (layout, timezoneOffset) {
  layout = layout || layouts.colouredLayout;
  return function(loggingEvent) {
-    consoleLog(layout(loggingEvent));
+    consoleLog(layout(loggingEvent, timezoneOffset));
  };
 }

@@ -14,7 +14,7 @@ function configure(config) {
  if (config.layout) {
    layout = layouts.layout(config.layout.type, config.layout);
  }
-  return consoleAppender(layout);
+  return consoleAppender(layout, config.timezoneOffset);
 }

 exports.appender = consoleAppender;
--- a/lib/appenders/dateFile.js
+++ b/lib/appenders/dateFile.js
@@ -20,8 +20,9 @@ process.on('exit', function() {
 * @pattern the format that will be added to the end of filename when rolling,
 *          also used to check when to roll files - defaults to '.yyyy-MM-dd'
 * @layout layout function for log messages - defaults to basicLayout
+ * @timezoneOffset optional timezone offset in minutes - defaults to system local
 */
-function appender(filename, pattern, alwaysIncludePattern, layout) {
+function appender(filename, pattern, alwaysIncludePattern, layout, timezoneOffset) {
  layout = layout || layouts.basicLayout;

  var logFile = new streams.DateRollingFileStream(
@@ -32,7 +33,7 @@ function appender(filename, pattern, alwaysIncludePattern, layout) {
  openFiles.push(logFile);

  return function(logEvent) {
-    logFile.write(layout(logEvent) + eol, "utf8");
+    logFile.write(layout(logEvent, timezoneOffset) + eol, "utf8");
  };

 }
@@ -52,11 +53,11 @@ function configure(config, options) {
    config.filename = path.join(options.cwd, config.filename);
  }

-  return appender(config.filename, config.pattern, config.alwaysIncludePattern, layout);
+  return appender(config.filename, config.pattern, config.alwaysIncludePattern, layout, config.timezoneOffset);
 }

 function shutdown(cb) {
-  async.forEach(openFiles, function(file, done) {
+  async.each(openFiles, function(file, done) {
    if (!file.write(eol, "utf-8")) {
      file.once('drain', function() {
        file.end(done);
--- a/lib/appenders/file.js
+++ b/lib/appenders/file.js
@@ -6,7 +6,8 @@ var layouts = require('../layouts')
 , streams = require('../streams')
 , os = require('os')
 , eol = os.EOL || '\n'
-, openFiles = [];
+, openFiles = []
+, levels = require('../levels');

 //close open files on process exit.
 process.on('exit', function() {
@@ -25,8 +26,10 @@ process.on('exit', function() {
 *   if not provided then logs won't be rotated.
 * @param numBackups - the number of log files to keep after logSize 
 *   has been reached (default 5)
+ * @param compress - flag that controls log file compression
+ * @param timezoneOffset - optional timezone offset in minutes (default system local)
 */
-function fileAppender (file, layout, logSize, numBackups) {
+function fileAppender (file, layout, logSize, numBackups, compress, timezoneOffset) {
  var bytesWritten = 0;
  file = path.normalize(file);
  layout = layout || layouts.basicLayout;
@@ -40,7 +43,8 @@ function fileAppender (file, layout, logSize, numBackups) {
      stream = new streams.RollingFileStream(
        file,
        fileSize,
-        numFiles
+        numFiles,
+        { "compress": compress }
      );
    } else {
      stream = fs.createWriteStream(
@@ -60,10 +64,11 @@ function fileAppender (file, layout, logSize, numBackups) {
  
  // push file to the stack of open handlers
  openFiles.push(logFile);
-  
+
  return function(loggingEvent) {
-    logFile.write(layout(loggingEvent) + eol, "utf8");
+    logFile.write(layout(loggingEvent, timezoneOffset) + eol, "utf8");
  };
+
 }

 function configure(config, options) {
@@ -76,11 +81,11 @@ function configure(config, options) {
    config.filename = path.join(options.cwd, config.filename);
  }

-  return fileAppender(config.filename, layout, config.maxLogSize, config.backups);
+  return fileAppender(config.filename, layout, config.maxLogSize, config.backups, config.compress, config.timezoneOffset);
 }

 function shutdown(cb) {
-  async.forEach(openFiles, function(file, done) {
+  async.each(openFiles, function(file, done) {
    if (!file.write(eol, "utf-8")) {
      file.once('drain', function() {
        file.end(done);
--- a/lib/appenders/fileSync.js
+++ b/lib/appenders/fileSync.js
@@ -127,8 +127,10 @@ RollingFileSync.prototype.write = function(chunk, encoding) {
 *   if not provided then logs won't be rotated.
 * @param numBackups - the number of log files to keep after logSize 
 *   has been reached (default 5)
+ * @param timezoneOffset - optional timezone offset in minutes
+ *   (default system local)
 */
-function fileAppender (file, layout, logSize, numBackups) {
+function fileAppender (file, layout, logSize, numBackups, timezoneOffset) {
  debug("fileSync appender created");
  var bytesWritten = 0;
  file = path.normalize(file);
@@ -166,7 +168,7 @@ function fileAppender (file, layout, logSize, numBackups) {
  var logFile = openTheStream(file, logSize, numBackups);
  
  return function(loggingEvent) {
-    logFile.write(layout(loggingEvent) + eol);
+    logFile.write(layout(loggingEvent, timezoneOffset) + eol);
  };
 }

@@ -180,7 +182,7 @@ function configure(config, options) {
    config.filename = path.join(options.cwd, config.filename);
  }

-  return fileAppender(config.filename, layout, config.maxLogSize, config.backups);
+  return fileAppender(config.filename, layout, config.maxLogSize, config.backups, config.timezoneOffset);
 }

 exports.appender = fileAppender;
--- a/lib/appenders/gelf.js
+++ b/lib/appenders/gelf.js
@@ -85,6 +85,8 @@ function gelfAppender (layout, host, port, hostname, facility) {
    var firstData = data[0];
    
    if (!firstData.GELF) return; // identify with GELF field defined
+    // Remove the GELF key, some gelf supported logging systems drop the message with it
+    delete firstData.GELF;
    Object.keys(firstData).forEach(function(key) {
      // skip _id field for graylog2, skip keys not starts with UNDERSCORE
      if (key.match(/^_/) || key !== "_id") { 
--- a/lib/appenders/logLevelFilter.js
+++ b/lib/appenders/logLevelFilter.js
@@ -13,9 +13,9 @@ function logLevelFilter (minLevelString, maxLevelString, appender) {
  };
 }

-function configure(config) {
+function configure(config, options) {
  log4js.loadAppender(config.appender.type);
-  var appender = log4js.appenderMakers[config.appender.type](config.appender);
+  var appender = log4js.appenderMakers[config.appender.type](config.appender, options);
  return logLevelFilter(config.level, config.maxLevel, appender);
 }

--- a/lib/appenders/logstashUDP.js
+++ b/lib/appenders/logstashUDP.js
@@ -0,0 +1,50 @@
+"use strict";
+var layouts = require('../layouts')
+, dgram = require('dgram')
+, util = require('util');
+
+function logstashUDP (config, layout) {
+  var udp = dgram.createSocket('udp4');
+  var type = config.logType ? config.logType : config.category;
+  layout = layout || layouts.colouredLayout;
+  if(!config.fields) {
+    config.fields = {};
+  }
+  return function(loggingEvent) {
+    var logMessage = layout(loggingEvent);
+    var fields = {};
+    for(var i in config.fields) {
+      fields[i] = config.fields[i];
+    }
+    fields['level'] = loggingEvent.level.levelStr;
+    var logObject = {
+      '@timestamp': (new Date(loggingEvent.startTime)).toISOString(),
+      type: type,
+      message: logMessage,
+      fields: fields
+    };
+    sendLog(udp, config.host, config.port, logObject);
+  };
+}
+
+function sendLog(udp, host, port, logObject) {
+  var buffer = new Buffer(JSON.stringify(logObject));
+  udp.send(buffer, 0, buffer.length, port, host, function(err, bytes) {
+    if(err) {
+      console.error(
+        "log4js.logstashUDP - %s:%p Error: %s", host, port, util.inspect(err)
+      );
+    }
+  });
+}
+
+function configure(config) {
+  var layout;
+  if (config.layout) {
+    layout = layouts.layout(config.layout.type, config.layout);
+  }
+  return logstashUDP(config, layout);
+}
+
+exports.appender = logstashUDP;
+exports.configure = configure;
--- a/lib/appenders/smtp.js
+++ b/lib/appenders/smtp.js
@@ -1,7 +1,10 @@
 "use strict";
 var layouts = require("../layouts")
 , mailer = require("nodemailer")
-, os = require('os');
+, os = require('os')
+, async = require('async')
+, unsentCount = 0
+, shutdownTimeout;

 /**
 * SMTP Appender. Sends logging events using SMTP protocol. 
@@ -11,6 +14,7 @@ var layouts = require("../layouts")
 * @param config appender configuration data
 *    config.sendInterval time between log emails (in seconds), if 0
 *    then every event sends an email
+*    config.shutdownTimeout time to give up remaining emails (in seconds; defaults to 5).
 * @param layout a function that takes a logevent and returns a string (defaults to basicLayout).
 */
 function smtpAppender(config, layout) {
@@ -21,22 +25,31 @@ function smtpAppender(config, layout) {
 	var logEventBuffer = [];
 	var sendTimer;
 	
+	shutdownTimeout = ('shutdownTimeout' in config ? config.shutdownTimeout : 5) * 1000;
+	
 	function sendBuffer() {
    if (logEventBuffer.length > 0) {
 		
-      var transport = mailer.createTransport(config.transport, config[config.transport]);
+      var transport = mailer.createTransport(config.SMTP);
      var firstEvent = logEventBuffer[0];
      var body = "";
+      var count = logEventBuffer.length;
      while (logEventBuffer.length > 0) {
-        body += layout(logEventBuffer.shift()) + "\n";
+        body += layout(logEventBuffer.shift(), config.timezoneOffset) + "\n";
      }

      var msg = {
        to: config.recipients,
        subject: config.subject || subjectLayout(firstEvent),
-        text: body,
        headers: { "Hostname": os.hostname() }
      };
+	  
+      if (!config.html) {
+	msg.text = body;
+      } else {
+    	msg.html = body;
+      }
+      
      if (config.sender) {
        msg.from = config.sender;
      }
@@ -45,6 +58,7 @@ function smtpAppender(config, layout) {
          console.error("log4js.smtpAppender - Error happened", error);
        }
        transport.close();
+        unsentCount -= count;
      });
    }
 	}
@@ -59,6 +73,7 @@ function smtpAppender(config, layout) {
 	}
 	
 	return function(loggingEvent) {
+		unsentCount++;
 		logEventBuffer.push(loggingEvent);
 		if (sendInterval > 0) {
 			scheduleSend();
@@ -76,7 +91,19 @@ function configure(config) {
 	return smtpAppender(config, layout);
 }

+function shutdown(cb) {
+	if (shutdownTimeout > 0) {
+		setTimeout(function() { unsentCount = 0; }, shutdownTimeout);
+	}
+	async.whilst(function() {
+		return unsentCount > 0;
+	}, function(done) {
+		setTimeout(done, 100);
+	}, cb);
+}
+
 exports.name = "smtp";
 exports.appender = smtpAppender;
 exports.configure = configure;
+exports.shutdown = shutdown;

--- a/lib/connect-logger.js
+++ b/lib/connect-logger.js
@@ -1,8 +1,9 @@
 "use strict";
 var levels = require("./levels");
-var DEFAULT_FORMAT = ':remote-addr - -' + 
-  ' ":method :url HTTP/:http-version"' + 
-  ' :status :content-length ":referrer"' + 
+var _ = require('underscore');
+var DEFAULT_FORMAT = ':remote-addr - -' +
+  ' ":method :url HTTP/:http-version"' +
+  ' :status :content-length ":referrer"' +
  ' ":user-agent"';
 /**
 * Log requests with the given `options` or a `format` string.
@@ -52,16 +53,15 @@ function getLogger(logger4js, options) {
 		// nologs
 		if (nolog && nolog.test(req.originalUrl)) return next();
 		if (thislogger.isLevelEnabled(level) || options.level === 'auto') {
-      
+
 			var start = new Date()
 			, statusCode
 			, writeHead = res.writeHead
-			, end = res.end
 			, url = req.originalUrl;

 			// flag as logging
 			req._logging = true;
-      
+
 			// proxy for statusCode.
 			res.writeHead = function(code, headers){
 				res.writeHead = writeHead;
@@ -78,11 +78,9 @@ function getLogger(logger4js, options) {
 					level = levels.toLevel(options.level, levels.INFO);
 				}
 			};
-      
-			// proxy end to output a line to the provided logger.
-			res.end = function(chunk, encoding) {
-				res.end = end;
-				res.end(chunk, encoding);
+
+			//hook on end request to emit the log entry of the HTTP request.
+			res.on('finish', function() {
 				res.responseTime = new Date() - start;
 				//status code response level handling
 				if(res.statusCode && options.level === 'auto'){
@@ -91,21 +89,68 @@ function getLogger(logger4js, options) {
 					if(res.statusCode >= 400) level = levels.ERROR;
 				}
 				if (thislogger.isLevelEnabled(level)) {
+          var combined_tokens = assemble_tokens(req, res, options.tokens || []);
 					if (typeof fmt === 'function') {
-						var line = fmt(req, res, function(str){ return format(str, req, res); });
+						var line = fmt(req, res, function(str){ return format(str, combined_tokens); });
 						if (line) thislogger.log(level, line);
 					} else {
-						thislogger.log(level, format(fmt, req, res));
+						thislogger.log(level, format(fmt, combined_tokens));
 					}
 				}
-			};
+			});
 		}
-    
+
    //ensure next gets always called
    next();
  };
 }

+/**
+ * Adds custom {token, replacement} objects to defaults, overwriting the defaults if any tokens clash
+ *
+ * @param  {IncomingMessage} req
+ * @param  {ServerResponse} res
+ * @param  {Array} custom_tokens [{ token: string-or-regexp, replacement: string-or-replace-function }]
+ * @return {Array}
+ */
+function assemble_tokens(req, res, custom_tokens) {
+  var array_unique_tokens = function(array) {
+    var a = array.concat();
+    for(var i=0; i<a.length; ++i) {
+      for(var j=i+1; j<a.length; ++j) {
+        if(a[i].token == a[j].token) { // not === because token can be regexp object
+          a.splice(j--, 1);
+        }
+      }
+    }
+    return a;
+  };
+
+  var default_tokens = [];
+  default_tokens.push({ token: ':url', replacement: req.originalUrl });
+  default_tokens.push({ token: ':method', replacement: req.method });
+  default_tokens.push({ token: ':status', replacement: res.__statusCode || res.statusCode });
+  default_tokens.push({ token: ':response-time', replacement: res.responseTime });
+  default_tokens.push({ token: ':date', replacement: new Date().toUTCString() });
+  default_tokens.push({ token: ':referrer', replacement: req.headers.referer || req.headers.referrer || '' });
+  default_tokens.push({ token: ':http-version', replacement: req.httpVersionMajor + '.' + req.httpVersionMinor });
+  default_tokens.push({ token: ':remote-addr', replacement: req.headers['x-forwarded-for'] || req.ip || req._remoteAddress ||
+    (req.socket && (req.socket.remoteAddress || (req.socket.socket && req.socket.socket.remoteAddress))) });
+  default_tokens.push({ token: ':user-agent', replacement: req.headers['user-agent'] });
+  default_tokens.push({ token: ':content-length', replacement: (res._headers && res._headers['content-length']) ||
+      (res.__headers && res.__headers['Content-Length']) || '-' });
+  default_tokens.push({ token: /:req\[([^\]]+)\]/g, replacement: function(_, field) {
+    return req.headers[field.toLowerCase()];
+  } });
+  default_tokens.push({ token: /:res\[([^\]]+)\]/g, replacement: function(_, field) {
+    return res._headers ?
+      (res._headers[field.toLowerCase()] || res.__headers[field])
+      : (res.__headers && res.__headers[field]);
+  } });
+
+  return array_unique_tokens(custom_tokens.concat(default_tokens));
+};
+
 /**
 * Return formatted log line.
 *
@@ -116,33 +161,10 @@ function getLogger(logger4js, options) {
 * @api private
 */

-function format(str, req, res) {
-	return str
-    .replace(':url', req.originalUrl)
-    .replace(':method', req.method)
-    .replace(':status', res.__statusCode || res.statusCode)
-    .replace(':response-time', res.responseTime)
-    .replace(':date', new Date().toUTCString())
-    .replace(':referrer', req.headers.referer || req.headers.referrer || '')
-    .replace(':http-version', req.httpVersionMajor + '.' + req.httpVersionMinor)
-    .replace(
-      ':remote-addr', req.ip || req._remoteAddress || ( 
-      req.socket && 
-        (req.socket.remoteAddress || (req.socket.socket && req.socket.socket.remoteAddress))
-    ))
-    .replace(':user-agent', req.headers['user-agent'] || '')
-    .replace(
-      ':content-length', 
-      (res._headers && res._headers['content-length']) || 
-        (res.__headers && res.__headers['Content-Length']) || 
-        '-'
-    )
-    .replace(/:req\[([^\]]+)\]/g, function(_, field){ return req.headers[field.toLowerCase()]; })
-    .replace(/:res\[([^\]]+)\]/g, function(_, field){
-      return res._headers ? 
-        (res._headers[field.toLowerCase()] || res.__headers[field])
-        : (res.__headers && res.__headers[field]);
-    });
+function format(str, tokens) {
+  return _.reduce(tokens, function(current_string, token) {
+    return current_string.replace(token.token, token.replacement);
+  }, str);
 }

 /**
@@ -158,9 +180,9 @@ function format(str, req, res) {
 *         NOT LOGGING http://example.com/hoge.gif and http://example.com/hoge.gif?fuga
 *         LOGGING http://example.com/hoge.agif
 *   1.2 in "\\.gif|\\.jpg$"
- *         NOT LOGGING http://example.com/hoge.gif and 
+ *         NOT LOGGING http://example.com/hoge.gif and
 *           http://example.com/hoge.gif?fuga and http://example.com/hoge.jpg?fuga
- *         LOGGING http://example.com/hoge.agif, 
+ *         LOGGING http://example.com/hoge.agif,
 *           http://example.com/hoge.ajpg and http://example.com/hoge.jpg?hoge
 *   1.3 in "\\.(gif|jpe?g|png)$"
 *         NOT LOGGING http://example.com/hoge.gif and http://example.com/hoge.jpeg
@@ -178,15 +200,15 @@ function createNoLogCondition(nolog) {
 	if (nolog) {
    if (nolog instanceof RegExp) {
      regexp = nolog;
-    } 
-    
+    }
+
    if (typeof nolog === 'string') {
      regexp = new RegExp(nolog);
    }
-    
+
    if (Array.isArray(nolog)) {
      var regexpsAsStrings = nolog.map(
-        function convertToStrings(o) { 
+        function convertToStrings(o) {
          return o.source ? o.source : o;
        }
      );
--- a/lib/date_format.js
+++ b/lib/date_format.js
@@ -21,9 +21,9 @@ function addZero(vNumber) {
 * Thanks to http://www.svendtofte.com/code/date_format/
 * @private
 */
-function offset(date) {
+function offset(timezoneOffset) {
  // Difference to Greenwich time (GMT) in hours
-  var os = Math.abs(date.getTimezoneOffset());
+  var os = Math.abs(timezoneOffset);
  var h = String(Math.floor(os/60));
  var m = String(os%60);
  if (h.length == 1) {
@@ -32,26 +32,32 @@ function offset(date) {
  if (m.length == 1) {
    m = "0" + m;
  }
-  return date.getTimezoneOffset() < 0 ? "+"+h+m : "-"+h+m;
+  return timezoneOffset < 0 ? "+"+h+m : "-"+h+m;
 }

-exports.asString = function(/*format,*/ date) {
+exports.asString = function(/*format,*/ date, timezoneOffset) {
  var format = exports.ISO8601_FORMAT;
  if (typeof(date) === "string") {
    format = arguments[0];
    date = arguments[1];
+    timezoneOffset = arguments[2];
  }
-
-  var vDay = addZero(date.getDate());
-  var vMonth = addZero(date.getMonth()+1);
-  var vYearLong = addZero(date.getFullYear());
-  var vYearShort = addZero(date.getFullYear().toString().substring(2,4));
+  // make the date independent of the system timezone by working with UTC
+  if (timezoneOffset === undefined) {
+    timezoneOffset = date.getTimezoneOffset();
+  }
+  date.setUTCMinutes(date.getUTCMinutes() - timezoneOffset);
+  var vDay = addZero(date.getUTCDate());
+  var vMonth = addZero(date.getUTCMonth()+1);
+  var vYearLong = addZero(date.getUTCFullYear());
+  var vYearShort = addZero(date.getUTCFullYear().toString().substring(2,4));
  var vYear = (format.indexOf("yyyy") > -1 ? vYearLong : vYearShort);
-  var vHour  = addZero(date.getHours());
-  var vMinute = addZero(date.getMinutes());
-  var vSecond = addZero(date.getSeconds());
-  var vMillisecond = padWithZeros(date.getMilliseconds(), 3);
-  var vTimeZone = offset(date);
+  var vHour  = addZero(date.getUTCHours());
+  var vMinute = addZero(date.getUTCMinutes());
+  var vSecond = addZero(date.getUTCSeconds());
+  var vMillisecond = padWithZeros(date.getUTCMilliseconds(), 3);
+  var vTimeZone = offset(timezoneOffset);
+  date.setUTCMinutes(date.getUTCMinutes() + timezoneOffset);
  var formatted = format
    .replace(/dd/g, vDay)
    .replace(/MM/g, vMonth)
--- a/lib/layouts.js
+++ b/lib/layouts.js
@@ -71,11 +71,11 @@ function colorize (str, style) {
  return colorizeStart(style) + str + colorizeEnd(style);
 }

-function timestampLevelAndCategory(loggingEvent, colour) {
+function timestampLevelAndCategory(loggingEvent, colour, timezoneOffest) {
  var output = colorize(
    formatLogData(
      '[%s] [%s] %s - '
-      , dateFormat.asString(loggingEvent.startTime)
+      , dateFormat.asString(loggingEvent.startTime, timezoneOffest)
      , loggingEvent.level
      , loggingEvent.categoryName
    )
@@ -93,18 +93,19 @@ function timestampLevelAndCategory(loggingEvent, colour) {
 *
 * @author Stephan Strittmatter
 */
-function basicLayout (loggingEvent) {
-  return timestampLevelAndCategory(loggingEvent) + formatLogData(loggingEvent.data);
+function basicLayout (loggingEvent, timezoneOffset) {
+  return timestampLevelAndCategory(loggingEvent, undefined, timezoneOffset) + formatLogData(loggingEvent.data);
 }

 /**
 * colouredLayout - taken from masylum's fork.
 * same as basicLayout, but with colours.
 */
-function colouredLayout (loggingEvent) {
+function colouredLayout (loggingEvent, timezoneOffset) {
  return timestampLevelAndCategory(
    loggingEvent,
-    colours[loggingEvent.level.toString()]
+    colours[loggingEvent.level.toString()],
+    timezoneOffset
  ) + formatLogData(loggingEvent.data);
 }

@@ -139,13 +140,14 @@ function messagePassThroughLayout (loggingEvent) {
 * Takes a pattern string, array of tokens and returns a layout function.
 * @param {String} Log format pattern String
 * @param {object} map object of different tokens
+ * @param {number} timezone offset in minutes
 * @return {Function}
 * @author Stephan Strittmatter
 * @author Jan Schmidle
 */
-function patternLayout (pattern, tokens) {
+function patternLayout (pattern, tokens, timezoneOffset) {
  var TTCC_CONVERSION_PATTERN  = "%r %p %c - %m%n";
-  var regex = /%(-?[0-9]+)?(\.?[0-9]+)?([\[\]cdhmnprzx%])(\{([^\}]+)\})?|([^%]+)/;
+  var regex = /%(-?[0-9]+)?(\.?[0-9]+)?([\[\]cdhmnprzxy%])(\{([^\}]+)\})?|([^%]+)/;
  
  pattern = pattern || TTCC_CONVERSION_PATTERN;

@@ -177,7 +179,7 @@ function patternLayout (pattern, tokens) {
      }
    }
    // Format the date
-    return dateFormat.asString(format, loggingEvent.startTime);
+    return dateFormat.asString(format, loggingEvent.startTime, timezoneOffset);
  }
  
  function hostname() {
@@ -197,7 +199,7 @@ function patternLayout (pattern, tokens) {
  }

  function startTime(loggingEvent) {
-    return "" + loggingEvent.startTime.toLocaleTimeString();
+    return dateFormat.asString('hh:mm:ss', loggingEvent.startTime, timezoneOffset);
  }

  function startColour(loggingEvent) {
@@ -212,8 +214,25 @@ function patternLayout (pattern, tokens) {
    return '%';
  }

-  function pid() {
-    return process.pid;
+  function pid(loggingEvent) {
+    if (loggingEvent && loggingEvent.pid) {
+      return loggingEvent.pid;
+    } else {
+      return process.pid;
+    }
+  }
+  
+  function clusterInfo(loggingEvent, specifier) {
+    if (loggingEvent.cluster && specifier) {
+      return specifier
+        .replace('%m', loggingEvent.cluster.master)
+        .replace('%w', loggingEvent.cluster.worker)
+        .replace('%i', loggingEvent.cluster.workerId);
+    } else if (loggingEvent.cluster) {
+      return loggingEvent.cluster.worker+'@'+loggingEvent.cluster.master;
+    } else {
+      return pid();
+    }
  }

  function userDefined(loggingEvent, specifier) {
@@ -237,6 +256,7 @@ function patternLayout (pattern, tokens) {
    'r': startTime,
    '[': startColour,
    ']': endColour,
+    'y': clusterInfo,
    'z': pid,
    '%': percent,
    'x': userDefined
@@ -295,9 +315,7 @@ function patternLayout (pattern, tokens) {
      } else {
        // Create a raw replacement string based on the conversion
        // character and specifier
-        var replacement = 
-          replaceToken(conversionCharacter, loggingEvent, specifier) || 
-          matchedString;
+        var replacement = replaceToken(conversionCharacter, loggingEvent, specifier);

        // Format the replacement according to any padding or
        // truncation specified
--- a/lib/levels.js
+++ b/lib/levels.js
@@ -63,6 +63,7 @@ module.exports = {
  WARN: new Level(30000, "WARN"), 
  ERROR: new Level(40000, "ERROR"), 
  FATAL: new Level(50000, "FATAL"), 
+  MARK: new Level(9007199254740992, "MARK"), // 2^53
  OFF: new Level(Number.MAX_VALUE, "OFF"), 
  toLevel: toLevel
 };
--- a/lib/log4js.js
+++ b/lib/log4js.js
@@ -65,6 +65,8 @@ var events = require('events')
  replaceConsole: false
 };

+require('./appenders/console');
+
 function hasLogger(logger) {
  return loggers.hasOwnProperty(logger);
 }
@@ -92,6 +94,22 @@ function getBufferedLogger(categoryName) {
    return logger;
 }

+function normalizeCategory (category) {
+  return  category + '.';
+}
+
+function doesLevelEntryContainsLogger (levelCategory, loggerCategory) {  
+  var normalizedLevelCategory = normalizeCategory(levelCategory);
+  var normalizedLoggerCategory = normalizeCategory(loggerCategory);
+  return normalizedLoggerCategory.substring(0, normalizedLevelCategory.length) == normalizedLevelCategory;
+}
+
+function doesAppenderContainsLogger (appenderCategory, loggerCategory) {
+  var normalizedAppenderCategory = normalizeCategory(appenderCategory);
+  var normalizedLoggerCategory = normalizeCategory(loggerCategory);
+  return normalizedLoggerCategory.substring(0, normalizedAppenderCategory.length) == normalizedAppenderCategory;
+}
+

 /**
 * Get a logger instance. Instance is cached on categoryName level.
@@ -99,32 +117,51 @@ function getBufferedLogger(categoryName) {
 * @return {Logger} instance of logger for the category
 * @static
 */
-function getLogger (categoryName) {
+function getLogger (loggerCategoryName) {

  // Use default logger if categoryName is not specified or invalid
-  if (typeof categoryName !== "string") {
-    categoryName = Logger.DEFAULT_CATEGORY;
+  if (typeof loggerCategoryName !== "string") {
+    loggerCategoryName = Logger.DEFAULT_CATEGORY;
  }

-  var appenderList;
-  if (!hasLogger(categoryName)) {
+  if (!hasLogger(loggerCategoryName)) {
+
+    var level = undefined;
+
+    // If there's a "levels" entry in the configuration
+    if (levels.config) {
+      // Goes through the categories in the levels configuration entry, starting by the "higher" ones.
+      var keys = Object.keys(levels.config).sort();
+      for (var idx = 0; idx < keys.length; idx++) {
+        var levelCategory = keys[idx];
+        if (doesLevelEntryContainsLogger(levelCategory, loggerCategoryName)) {
+          // level for the logger
+          level = levels.config[levelCategory];
+        }
+      }
+    }
+  
    // Create the logger for this name if it doesn't already exist
-    loggers[categoryName] = new Logger(categoryName);
-    if (appenders[categoryName]) {
-      appenderList = appenders[categoryName];
-      appenderList.forEach(function(appender) {
-        loggers[categoryName].addListener("log", appender);
-      });
+    loggers[loggerCategoryName] = new Logger(loggerCategoryName, level);
+
+    var appenderList;
+    for(var appenderCategory in appenders) {
+      if (doesAppenderContainsLogger(appenderCategory, loggerCategoryName)) {
+        appenderList = appenders[appenderCategory];
+        appenderList.forEach(function(appender) {
+          loggers[loggerCategoryName].addListener("log", appender);
+        });
+      }
    }
    if (appenders[ALL_CATEGORIES]) {
      appenderList = appenders[ALL_CATEGORIES];
      appenderList.forEach(function(appender) {
-        loggers[categoryName].addListener("log", appender);
+        loggers[loggerCategoryName].addListener("log", appender);
      });
    }
  }
  
-  return loggers[categoryName];
+  return loggers[loggerCategoryName];
 }

 /**
@@ -141,13 +178,19 @@ function addAppender () {
    args = args[0];
  }
  
-  args.forEach(function(category) {
-    addAppenderToCategory(appender, category);
+  args.forEach(function(appenderCategory) {
+    addAppenderToCategory(appender, appenderCategory);
    
-    if (category === ALL_CATEGORIES) {
+    if (appenderCategory === ALL_CATEGORIES) {
      addAppenderToAllLoggers(appender);
-    } else if (hasLogger(category)) {
-      loggers[category].addListener("log", appender);
+    } else {
+
+      for(var loggerCategory in loggers) {
+        if (doesAppenderContainsLogger(appenderCategory,loggerCategory)) {
+          loggers[loggerCategory].addListener("log", appender);
+        }
+      }
+      
    }
  });
 }
@@ -193,14 +236,19 @@ function configureAppenders(appenderList, options) {
  }
 }

-function configureLevels(levels) {
-  if (levels) {
-    for (var category in levels) {
-      if (levels.hasOwnProperty(category)) {
-        if(category === ALL_CATEGORIES) {
-          setGlobalLogLevel(levels[category]);
+function configureLevels(_levels) {
+  levels.config = _levels; // Keep it so we can create loggers later using this cfg
+  if (_levels) {
+    var keys = Object.keys(levels.config).sort();
+    for (var idx in keys) {
+      var category = keys[idx];
+      if(category === ALL_CATEGORIES) {
+        setGlobalLogLevel(_levels[category]);
+      }        
+      for(var loggerCategory in loggers) {
+        if (doesLevelEntryContainsLogger(category, loggerCategory)) {
+          loggers[loggerCategory].setLevel(_levels[category]);
        }
-        getLogger(category).setLevel(levels[category]);
      }
    }
  }
@@ -231,8 +279,8 @@ function loadConfigurationFile(filename) {
 function configureOnceOff(config, options) {
  if (config) {
    try {
-      configureAppenders(config.appenders, options);
      configureLevels(config.levels);
+      configureAppenders(config.appenders, options);
      
      if (config.replaceConsole) {
        replaceConsole();
@@ -248,12 +296,12 @@ function configureOnceOff(config, options) {
  }
 }

-function reloadConfiguration() {
+function reloadConfiguration(options) {
  var mtime = getMTime(configState.filename);
  if (!mtime) return;
-
+  
  if (configState.lastMTime && (mtime.getTime() > configState.lastMTime.getTime())) {
-    configureOnceOff(loadConfigurationFile(configState.filename));
+    configureOnceOff(loadConfigurationFile(configState.filename), options);
  }
  configState.lastMTime = mtime;
 }
@@ -275,7 +323,7 @@ function initReloadConfiguration(filename, options) {
  }
  configState.filename = filename;
  configState.lastMTime = getMTime(filename);
-  configState.timerId = setInterval(reloadConfiguration, options.reloadSecs*1000);
+  configState.timerId = setInterval(reloadConfiguration, options.reloadSecs*1000, options);
 }

 function configure(configurationFileOrObject, options) {
@@ -388,7 +436,7 @@ function shutdown(cb) {
    }, []);

  // Call each of the shutdown functions.
-  async.forEach(
+  async.each(
    shutdownFunctions,
    function(shutdownFn, done) {
      shutdownFn(done);
--- a/lib/logger.js
+++ b/lib/logger.js
@@ -51,7 +51,7 @@ Logger.prototype.removeLevel = function() {

 Logger.prototype.log = function() {
  var args = Array.prototype.slice.call(arguments)
-  , logLevel = levels.toLevel(args.shift())
+  , logLevel = levels.toLevel(args.shift(), levels.INFO)
  , loggingEvent;
  if (this.isLevelEnabled(logLevel)) {
    loggingEvent = new LoggingEvent(this.category, logLevel, args, this);
@@ -63,7 +63,7 @@ Logger.prototype.isLevelEnabled = function(otherLevel) {
  return this.level.isLessThanOrEqualTo(otherLevel);
 };

-['Trace','Debug','Info','Warn','Error','Fatal'].forEach(
+['Trace','Debug','Info','Warn','Error','Fatal', 'Mark'].forEach(
  function(levelString) {
    var level = levels.toLevel(levelString);
    Logger.prototype['is'+levelString+'Enabled'] = function() {
--- a/lib/streams/BaseRollingFileStream.js
+++ b/lib/streams/BaseRollingFileStream.js
@@ -16,7 +16,11 @@ module.exports = BaseRollingFileStream;
 function BaseRollingFileStream(filename, options) {
  debug("In BaseRollingFileStream");
  this.filename = filename;
-  this.options = options || { encoding: 'utf8', mode: parseInt('0644', 8), flags: 'a' };
+  this.options = options || {};
+  this.options.encoding = this.options.encoding || 'utf8';
+  this.options.mode = this.options.mode || parseInt('0644', 8);
+  this.options.flags = this.options.flags || 'a';
+
  this.currentSize = 0;
  
  function currentFileSize(file) {
--- a/lib/streams/RollingFileStream.js
+++ b/lib/streams/RollingFileStream.js
@@ -3,6 +3,8 @@ var BaseRollingFileStream = require('./BaseRollingFileStream')
 , debug = require('../debug')('RollingFileStream')
 , util = require('util')
 , path = require('path')
+, child_process = require('child_process')
+, zlib = require("zlib")
 , fs = require('fs')
 , async = require('async');

@@ -25,7 +27,7 @@ function RollingFileStream (filename, size, backups, options) {
 util.inherits(RollingFileStream, BaseRollingFileStream);

 RollingFileStream.prototype.shouldRoll = function() {
-  debug("should roll with current size %d, and max size %d", this.currentSize, this.size);
+  debug("should roll with current size " + this.currentSize + " and max size " + this.size);
  return this.currentSize >= this.size;
 };

@@ -38,6 +40,7 @@ RollingFileStream.prototype.roll = function(filename, callback) {
  }
  
  function index(filename_) {
+    debug('Calculating index of '+filename_);
    return parseInt(filename_.substring((path.basename(filename) + '.').length), 10) || 0;
  }
  
@@ -51,16 +54,42 @@ RollingFileStream.prototype.roll = function(filename, callback) {
    }
  }

+  function compress (filename, cb) {
+
+    var gzip = zlib.createGzip();
+    var inp = fs.createReadStream(filename);
+    var out = fs.createWriteStream(filename+".gz");
+    inp.pipe(gzip).pipe(out);
+    fs.unlink(filename, cb);
+
+  }
+
  function increaseFileIndex (fileToRename, cb) {
    var idx = index(fileToRename);
    debug('Index of ' + fileToRename + ' is ' + idx);
    if (idx < that.backups) {
+
+      var ext = path.extname(fileToRename);
+      var destination = filename + '.' + (idx+1);
+      if (that.options.compress && /^gz$/.test(ext.substring(1))) {
+        destination+=ext;
+      }
      //on windows, you can get a EEXIST error if you rename a file to an existing file
      //so, we'll try to delete the file we're renaming to first
-      fs.unlink(filename + '.' + (idx+1), function (err) {
+      fs.unlink(destination, function (err) {
        //ignore err: if we could not delete, it's most likely that it doesn't exist
-        debug('Renaming ' + fileToRename + ' -> ' + filename + '.' + (idx+1));
-        fs.rename(path.join(path.dirname(filename), fileToRename), filename + '.' + (idx + 1), cb);
+        debug('Renaming ' + fileToRename + ' -> ' + destination);
+        fs.rename(path.join(path.dirname(filename), fileToRename), destination, function(err) {
+          if (err) {
+            cb(err);
+          } else {
+            if (that.options.compress && ext!=".gz") {
+              compress(destination, cb);
+            } else {
+              cb();
+            }
+          }
+        });
      });
    } else {
      cb();
@@ -71,7 +100,7 @@ RollingFileStream.prototype.roll = function(filename, callback) {
    //roll the backups (rename file.n to file.n+1, where n <= numBackups)
    debug("Renaming the old files");
    fs.readdir(path.dirname(filename), function (err, files) {
-      async.forEachSeries(
+      async.eachSeries(
        files.filter(justTheseFiles).sort(byIndex).reverse(),
        increaseFileIndex,
        cb
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "log4js",
-  "version": "0.6.20",
+  "version": "0.6.25",
  "description": "Port of Log4js to work with node.",
  "keywords": [
    "logging",
@@ -8,6 +8,7 @@
    "log4j",
    "node"
  ],
+  "license": "Apache-2.0",
  "main": "./lib/log4js",
  "author": "Gareth Jones <gareth.nomiddlename@gmail.com>",
  "repository": {
@@ -28,9 +29,10 @@
    "lib": "lib"
  },
  "dependencies": {
-    "async": "0.1.15",
-    "semver": "~1.1.4",
-    "readable-stream": "~1.0.2"
+    "async": "~0.2.0",
+    "readable-stream": "~1.0.2",
+    "semver": "~4.3.3",
+    "underscore": "1.8.2"
  },
  "devDependencies": {
    "vows": "0.7.0",
--- a/test/connect-logger-test.js
+++ b/test/connect-logger-test.js
@@ -2,13 +2,15 @@
 "use strict";
 var vows = require('vows')
 , assert = require('assert')
+, util   = require('util')
+, EE     = require('events').EventEmitter
 , levels = require('../lib/levels');

 function MockLogger() {

  var that = this;
  this.messages = [];
-  
+
  this.log = function(level, message, exception) {
    that.messages.push({ level: level, message: message });
  };
@@ -16,7 +18,7 @@ function MockLogger() {
  this.isLevelEnabled = function(level) {
    return level.isGreaterThanOrEqualTo(that.level);
  };
-  
+
  this.level = levels.TRACE;

 }
@@ -37,15 +39,19 @@ function MockRequest(remoteAddr, method, originalUrl, headers) {
 }

 function MockResponse() {
-  
-  this.end = function(chunk, encoding) {    
+  var r = this;
+  this.end = function(chunk, encoding) {
+      r.emit('finish');
  };

  this.writeHead = function(code, headers) {
+      this.statusCode = code;
+      this._headers = headers;
  };
-
 }

+util.inherits(MockResponse, EE);
+
 function request(cl, method, url, code, reqHeaders, resHeaders) {
  var req = new MockRequest('my.remote.addr', method, url, reqHeaders);
  var res = new MockResponse();
@@ -60,7 +66,7 @@ vows.describe('log4js connect logger').addBatch({
      var clm = require('../lib/connect-logger');
      return clm;
    },
-    
+
    'should return a "connect logger" factory' : function(clm) {
      assert.isObject(clm);
    },
@@ -71,18 +77,21 @@ vows.describe('log4js connect logger').addBatch({
        var cl = clm.connectLogger(ml);
        return cl;
      },
-      
+
      'should return a "connect logger"': function(cl) {
        assert.isFunction(cl);
      }
    },
-    
+
    'log events' : {
      topic: function(clm) {
        var ml = new MockLogger();
        var cl = clm.connectLogger(ml);
+        var cb = this.callback;
        request(cl, 'GET', 'http://url', 200);
-        return ml.messages;
+        setTimeout(function() {
+          cb(null, ml.messages);
+        },10);
      },

      'check message': function(messages) {
@@ -104,7 +113,7 @@ vows.describe('log4js connect logger').addBatch({
        request(cl, 'GET', 'http://url', 200);
        return ml.messages;
      },
-      
+
      'check message': function(messages) {
        assert.isArray(messages);
        assert.isEmpty(messages);
@@ -114,12 +123,14 @@ vows.describe('log4js connect logger').addBatch({
    'log events with non-default level and custom format' : {
      topic: function(clm) {
        var ml = new MockLogger();
+        var cb = this.callback;
        ml.level = levels.INFO;
        var cl = clm.connectLogger(ml, { level: levels.INFO, format: ':method :url' } );
        request(cl, 'GET', 'http://url', 200);
-        return ml.messages;
-      },
-      
+        setTimeout(function() {
+          cb(null, ml.messages);
+        },10);      },
+
      'check message': function(messages) {
        assert.isArray(messages);
        assert.equal(messages.length, 1);
@@ -131,10 +142,13 @@ vows.describe('log4js connect logger').addBatch({
    'logger with options as string': {
      topic: function(clm) {
        var ml = new MockLogger();
+        var cb = this.callback;
        ml.level = levels.INFO;
        var cl = clm.connectLogger(ml, ':method :url');
        request(cl, 'POST', 'http://meh', 200);
-        return ml.messages;
+        setTimeout(function() {
+          cb(null, ml.messages);
+        },10);
      },
      'should use the passed in format': function(messages) {
        assert.equal(messages[0].message, 'POST http://meh');
@@ -144,6 +158,7 @@ vows.describe('log4js connect logger').addBatch({
    'auto log levels': {
      topic: function(clm) {
        var ml = new MockLogger();
+        var cb = this.callback;
        ml.level = levels.INFO;
        var cl = clm.connectLogger(ml, { level: 'auto', format: ':method :url' });
        request(cl, 'GET', 'http://meh', 200);
@@ -151,7 +166,9 @@ vows.describe('log4js connect logger').addBatch({
        request(cl, 'GET', 'http://meh', 302);
        request(cl, 'GET', 'http://meh', 404);
        request(cl, 'GET', 'http://meh', 500);
-        return ml.messages;
+        setTimeout(function() {
+          cb(null, ml.messages);
+        },10);
      },

      'should use INFO for 2xx': function(messages) {
@@ -175,10 +192,13 @@ vows.describe('log4js connect logger').addBatch({
    'format using a function': {
      topic: function(clm) {
        var ml = new MockLogger();
+        var cb = this.callback;
        ml.level = levels.INFO;
        var cl = clm.connectLogger(ml, function(req, res, formatFn) { return "I was called"; });
        request(cl, 'GET', 'http://blah', 200);
-        return ml.messages;
+        setTimeout(function() {
+          cb(null, ml.messages);
+        },10);
      },

      'should call the format function': function(messages) {
@@ -189,14 +209,17 @@ vows.describe('log4js connect logger').addBatch({
    'format that includes request headers': {
      topic: function(clm) {
        var ml = new MockLogger();
+        var cb = this.callback;
        ml.level = levels.INFO;
        var cl = clm.connectLogger(ml, ':req[Content-Type]');
        request(
-          cl, 
-          'GET', 'http://blah', 200, 
+          cl,
+          'GET', 'http://blah', 200,
          { 'Content-Type': 'application/json' }
        );
-        return ml.messages;
+        setTimeout(function() {
+          cb(null, ml.messages);
+        },10);
      },
      'should output the request header': function(messages) {
        assert.equal(messages[0].message, 'application/json');
@@ -206,6 +229,7 @@ vows.describe('log4js connect logger').addBatch({
    'format that includes response headers': {
      topic: function(clm) {
        var ml = new MockLogger();
+        var cb = this.callback;
        ml.level = levels.INFO;
        var cl = clm.connectLogger(ml, ':res[Content-Type]');
        request(
@@ -214,13 +238,58 @@ vows.describe('log4js connect logger').addBatch({
          null,
          { 'Content-Type': 'application/cheese' }
        );
-        return ml.messages;
+        setTimeout(function() {
+          cb(null, ml.messages);
+        },10);
      },

      'should output the response header': function(messages) {
        assert.equal(messages[0].message, 'application/cheese');
      }
-    }                                          
-    
+    },
+
+    'log events with custom token' : {
+      topic: function(clm) {
+        var ml = new MockLogger();
+        var cb = this.callback;
+        ml.level = levels.INFO;
+        var cl = clm.connectLogger(ml, { level: levels.INFO, format: ':method :url :custom_string', tokens: [{
+          token: ':custom_string', replacement: 'fooBAR'
+        }] } );
+        request(cl, 'GET', 'http://url', 200);
+        setTimeout(function() {
+          cb(null, ml.messages);
+        },10);
+      },
+
+      'check message': function(messages) {
+        assert.isArray(messages);
+        assert.equal(messages.length, 1);
+        assert.ok(levels.INFO.isEqualTo(messages[0].level));
+        assert.equal(messages[0].message, 'GET http://url fooBAR');
+      }
+    },
+
+    'log events with custom override token' : {
+      topic: function(clm) {
+        var ml = new MockLogger();
+        var cb = this.callback;
+        ml.level = levels.INFO;
+        var cl = clm.connectLogger(ml, { level: levels.INFO, format: ':method :url :date', tokens: [{
+          token: ':date', replacement: "20150310"
+        }] } );
+        request(cl, 'GET', 'http://url', 200);
+        setTimeout(function() {
+          cb(null, ml.messages);
+        },10);
+      },
+
+      'check message': function(messages) {
+        assert.isArray(messages);
+        assert.equal(messages.length, 1);
+        assert.ok(levels.INFO.isEqualTo(messages[0].level));
+        assert.equal(messages[0].message, 'GET http://url 20150310');
+      }
+    }
  }
 }).export(module);
--- a/test/date_format-test.js
+++ b/test/date_format-test.js
@@ -3,11 +3,13 @@ var vows = require('vows')
 , assert = require('assert')
 , dateFormat = require('../lib/date_format');

+function createFixedDate() {
+  return new Date(2010, 0, 11, 14, 31, 30, 5);
+}
+
 vows.describe('date_format').addBatch({
  'Date extensions': {
-    topic: function() {
-      return new Date(2010, 0, 11, 14, 31, 30, 5);
-    },
+    topic: createFixedDate,
    'should format a date as string using a pattern': function(date) {
      assert.equal(
        dateFormat.asString(dateFormat.DATETIME_FORMAT, date),
@@ -20,13 +22,16 @@ vows.describe('date_format').addBatch({
        '2010-01-11 14:31:30.005'
      );
    },
-    'should provide a ISO8601 with timezone offset format': function(date) {
+    'should provide a ISO8601 with timezone offset format': function() {
+      var date = createFixedDate();
+      date.setMinutes(date.getMinutes() - date.getTimezoneOffset() - 660);
      date.getTimezoneOffset = function() { return -660; };
      assert.equal(
        dateFormat.asString(dateFormat.ISO8601_WITH_TZ_OFFSET_FORMAT, date),
        "2010-01-11T14:31:30+1100"
      );
-
+      date = createFixedDate();
+      date.setMinutes(date.getMinutes() - date.getTimezoneOffset() + 120);
      date.getTimezoneOffset = function() { return 120; };
      assert.equal(
        dateFormat.asString(dateFormat.ISO8601_WITH_TZ_OFFSET_FORMAT, date),
@@ -40,7 +45,9 @@ vows.describe('date_format').addBatch({
        '14:31:30.005'
      );
    },
-    'should provide a custom format': function(date) {
+    'should provide a custom format': function() {
+      var date = createFixedDate();
+      date.setMinutes(date.getMinutes() - date.getTimezoneOffset() + 120);
      date.getTimezoneOffset = function() { return 120; };
      assert.equal(
        dateFormat.asString("O.SSS.ss.mm.hh.dd.MM.yy", date),
--- a/test/fileAppender-test.js
+++ b/test/fileAppender-test.js
@@ -5,6 +5,7 @@ var vows = require('vows')
 , sandbox = require('sandboxed-module')
 , log4js = require('../lib/log4js')
 , assert = require('assert')
+, zlib = require('zlib')
 , EOL = require('os').EOL || '\n';

 log4js.clearAppenders();
@@ -104,6 +105,70 @@ vows.describe('log4js fileAppender').addBatch({
      );
    }
  },
+  'fileAppender subcategories': {
+    topic: function() {
+      var that = this;
+
+      log4js.clearAppenders();
+
+      function addAppender(cat) {
+        var testFile = path.join(__dirname, '/fa-subcategories-test-'+cat.join('-').replace(/\./g, "_")+'.log');
+        remove(testFile);
+        log4js.addAppender(require('../lib/appenders/file').appender(testFile), cat);
+        return testFile;
+      }
+
+      var file_sub1 = addAppender([ 'sub1']);
+      
+      var file_sub1_sub12$sub1_sub13 = addAppender([ 'sub1.sub12', 'sub1.sub13' ]);
+      
+      var file_sub1_sub12 = addAppender([ 'sub1.sub12' ]);
+
+      
+      var logger_sub1_sub12_sub123 = log4js.getLogger('sub1.sub12.sub123');
+      
+      var logger_sub1_sub13_sub133 = log4js.getLogger('sub1.sub13.sub133');
+
+      var logger_sub1_sub14 = log4js.getLogger('sub1.sub14');
+
+      var logger_sub2 = log4js.getLogger('sub2');
+      
+
+      logger_sub1_sub12_sub123.info('sub1_sub12_sub123');
+      
+      logger_sub1_sub13_sub133.info('sub1_sub13_sub133');
+
+      logger_sub1_sub14.info('sub1_sub14');
+
+      logger_sub2.info('sub2');
+           
+      
+      setTimeout(function() {
+        that.callback(null, {
+          file_sub1: fs.readFileSync(file_sub1).toString(),
+          file_sub1_sub12$sub1_sub13: fs.readFileSync(file_sub1_sub12$sub1_sub13).toString(),
+          file_sub1_sub12: fs.readFileSync(file_sub1_sub12).toString()
+        });        
+      }, 3000);
+    },
+    'check file contents': function (err, fileContents) {
+
+      // everything but category 'sub2'
+      assert.match(fileContents.file_sub1, /^(\[\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}\.\d{3}\] \[INFO\] (sub1.sub12.sub123 - sub1_sub12_sub123|sub1.sub13.sub133 - sub1_sub13_sub133|sub1.sub14 - sub1_sub14)[\s\S]){3}$/);
+      assert.ok(fileContents.file_sub1.match(/sub123/) && fileContents.file_sub1.match(/sub133/) && fileContents.file_sub1.match(/sub14/));
+      assert.ok(!fileContents.file_sub1.match(/sub2/));
+
+      // only catgories starting with 'sub1.sub12' and 'sub1.sub13'
+      assert.match(fileContents.file_sub1_sub12$sub1_sub13, /^(\[\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}\.\d{3}\] \[INFO\] (sub1.sub12.sub123 - sub1_sub12_sub123|sub1.sub13.sub133 - sub1_sub13_sub133)[\s\S]){2}$/);
+      assert.ok(fileContents.file_sub1_sub12$sub1_sub13.match(/sub123/) && fileContents.file_sub1_sub12$sub1_sub13.match(/sub133/));
+      assert.ok(!fileContents.file_sub1_sub12$sub1_sub13.match(/sub14|sub2/));
+
+      // only catgories starting with 'sub1.sub12'
+      assert.match(fileContents.file_sub1_sub12, /^(\[\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}\.\d{3}\] \[INFO\] (sub1.sub12.sub123 - sub1_sub12_sub123)[\s\S]){1}$/);
+      assert.ok(!fileContents.file_sub1_sub12.match(/sub14|sub2|sub13/));
+
+    }
+  },
  'with a max file size and no backups': {
    topic: function() {
      var testFile = path.join(__dirname, '/fa-maxFileSize-test.log')
@@ -214,6 +279,79 @@ vows.describe('log4js fileAppender').addBatch({
        }
      }
    }
+  },
+  'with a max file size and 2 compressed backups': {
+    topic: function() {
+      var testFile = path.join(__dirname, '/fa-maxFileSize-with-backups-compressed-test.log')
+      , logger = log4js.getLogger('max-file-size-backups');
+      remove(testFile);
+      remove(testFile+'.1.gz');
+      remove(testFile+'.2.gz');
+      
+      //log file of 50 bytes maximum, 2 backups
+      log4js.clearAppenders();
+      log4js.addAppender(
+        require('../lib/appenders/file').appender(testFile, log4js.layouts.basicLayout, 50, 2, true), 
+        'max-file-size-backups'
+      );
+      logger.info("This is the first log message.");
+      logger.info("This is the second log message.");
+      logger.info("This is the third log message.");
+      logger.info("This is the fourth log message.");
+      var that = this;
+      //give the system a chance to open the stream
+      setTimeout(function() {
+        fs.readdir(__dirname, function(err, files) { 
+          if (files) { 
+            that.callback(null, files.sort()); 
+          } else { 
+            that.callback(err, files); 
+          }
+        });
+      }, 1000);
+    },
+    'the log files': {
+      topic: function(files) {
+        var logFiles = files.filter(
+          function(file) { return file.indexOf('fa-maxFileSize-with-backups-compressed-test.log') > -1; }
+        );
+        return logFiles;
+      },
+      'should be 3': function (files) {
+        assert.equal(files.length, 3);
+      },
+      'should be named in sequence': function (files) {
+        assert.deepEqual(files, [
+          'fa-maxFileSize-with-backups-compressed-test.log', 
+          'fa-maxFileSize-with-backups-compressed-test.log.1.gz', 
+          'fa-maxFileSize-with-backups-compressed-test.log.2.gz'
+        ]);
+      },
+      'and the contents of the first file': {
+        topic: function(logFiles) {
+          fs.readFile(path.join(__dirname, logFiles[0]), "utf8", this.callback);
+        },
+        'should be the last log message': function(contents) {
+          assert.include(contents, 'This is the fourth log message.');
+        }
+      },
+      'and the contents of the second file': {
+        topic: function(logFiles) {
+          zlib.gunzip(fs.readFileSync(path.join(__dirname, logFiles[1])), this.callback);
+        },
+        'should be the third log message': function(contents) {
+          assert.include(contents.toString('utf8'), 'This is the third log message.');
+        }
+      },
+      'and the contents of the third file': {
+        topic: function(logFiles) {
+          zlib.gunzip(fs.readFileSync(path.join(__dirname, logFiles[2])), this.callback);
+        },
+        'should be the second log message': function(contents) {
+          assert.include(contents.toString('utf8'), 'This is the second log message.');
+        }
+      }
+    }
  }
 }).addBatch({
  'configure' : {
--- a/test/gelfAppender-test.js
+++ b/test/gelfAppender-test.js
@@ -244,6 +244,7 @@ vows.describe('log4js gelfAppender').addBatch({
      },
      'should pick up the options': function(message) {
        assert.equal(message.host, 'cheese');
+        assert.isUndefined(message.GELF); // make sure flag was removed
        assert.equal(message._facility, 'nonsense');
        assert.equal(message._every1, 'Hello every one'); // the default value
        assert.equal(message._every2, 'Overwritten!'); // the overwritten value
--- a/test/layouts-test.js
+++ b/test/layouts-test.js
@@ -179,7 +179,7 @@ vows.describe('log4js layouts').addBatch({
    topic: function() {
      var event = {
        data: ['this is a test'],
-        startTime: new Date(2010, 11, 5, 14, 18, 30, 45),
+        startTime: new Date('2010-12-05T14:18:30.045Z'), //new Date(2010, 11, 5, 14, 18, 30, 45),
        categoryName: "multiple.levels.of.tests",
        level: {
          toString: function() { return "DEBUG"; }
@@ -282,14 +282,14 @@ vows.describe('log4js layouts').addBatch({
      test(args, '%x{testFunction}', 'testFunctionToken');
    },
    '%x{doesNotExist} should output the string stored in tokens': function(args) {
-      test(args, '%x{doesNotExist}', '%x{doesNotExist}');
+      test(args, '%x{doesNotExist}', 'null');
    },
    '%x{fnThatUsesLogEvent} should be able to use the logEvent': function(args) {
      test(args, '%x{fnThatUsesLogEvent}', 'DEBUG');
    },
    '%x should output the string stored in tokens': function(args) {
-      test(args, '%x', '%x');
-    },
+      test(args, '%x', 'null');
+    }
  },
  'layout makers': {
    topic: require('../lib/layouts'),
--- a/test/levels-test.js
+++ b/test/levels-test.js
@@ -43,6 +43,7 @@ vows.describe('levels').addBatch({
      assert.isNotNull(levels.WARN);
      assert.isNotNull(levels.ERROR);
      assert.isNotNull(levels.FATAL);
+      assert.isNotNull(levels.MARK);
      assert.isNotNull(levels.OFF);
    },
    'ALL': {
@@ -56,7 +57,8 @@ vows.describe('levels').addBatch({
            levels.INFO, 
            levels.WARN, 
            levels.ERROR, 
-            levels.FATAL, 
+            levels.FATAL,
+            levels.MARK,
            levels.OFF
          ]
        );
@@ -70,6 +72,7 @@ vows.describe('levels').addBatch({
            levels.WARN, 
            levels.ERROR, 
            levels.FATAL, 
+            levels.MARK,
            levels.OFF
          ]
        );
@@ -84,6 +87,7 @@ vows.describe('levels').addBatch({
            levels.WARN, 
            levels.ERROR, 
            levels.FATAL, 
+            levels.MARK,
            levels.OFF
          ]
        );
@@ -99,6 +103,7 @@ vows.describe('levels').addBatch({
            levels.WARN, 
            levels.ERROR, 
            levels.FATAL, 
+            levels.MARK,
            levels.OFF
          ]
        );
@@ -113,6 +118,7 @@ vows.describe('levels').addBatch({
            levels.WARN, 
            levels.ERROR, 
            levels.FATAL, 
+            levels.MARK,
            levels.OFF
          ]
        );
@@ -127,6 +133,7 @@ vows.describe('levels').addBatch({
            levels.WARN, 
            levels.ERROR, 
            levels.FATAL, 
+            levels.MARK,
            levels.OFF
          ]
        );
@@ -141,6 +148,7 @@ vows.describe('levels').addBatch({
            levels.WARN, 
            levels.ERROR, 
            levels.FATAL, 
+            levels.MARK,
            levels.OFF
          ]
        );
@@ -154,6 +162,7 @@ vows.describe('levels').addBatch({
            levels.WARN, 
            levels.ERROR, 
            levels.FATAL, 
+            levels.MARK,
            levels.OFF
          ]
        );
@@ -168,6 +177,7 @@ vows.describe('levels').addBatch({
            levels.WARN, 
            levels.ERROR, 
            levels.FATAL, 
+            levels.MARK,
            levels.OFF
          ]
        );
@@ -180,6 +190,7 @@ vows.describe('levels').addBatch({
          levels.WARN, 
          levels.ERROR, 
          levels.FATAL, 
+          levels.MARK,
          levels.OFF
        ]);
        assertThat(info).isNotLessThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG]);
@@ -190,6 +201,7 @@ vows.describe('levels').addBatch({
          levels.WARN, 
          levels.ERROR, 
          levels.FATAL, 
+          levels.MARK,
          levels.OFF
        ]);
      },
@@ -202,6 +214,7 @@ vows.describe('levels').addBatch({
          levels.WARN, 
          levels.ERROR, 
          levels.FATAL, 
+          levels.MARK,
          levels.OFF
        ]);
      }
@@ -209,7 +222,7 @@ vows.describe('levels').addBatch({
    'WARN': {
      topic: levels.WARN,
      'should be less than ERROR': function(warn) {
-        assertThat(warn).isLessThanOrEqualTo([levels.ERROR, levels.FATAL, levels.OFF]);
+        assertThat(warn).isLessThanOrEqualTo([levels.ERROR, levels.FATAL, levels.MARK, levels.OFF]);
        assertThat(warn).isNotLessThanOrEqualTo([
          levels.ALL, 
          levels.TRACE, 
@@ -224,7 +237,7 @@ vows.describe('levels').addBatch({
          levels.DEBUG, 
          levels.INFO
        ]);
-        assertThat(warn).isNotGreaterThanOrEqualTo([levels.ERROR, levels.FATAL, levels.OFF]);
+        assertThat(warn).isNotGreaterThanOrEqualTo([levels.ERROR, levels.FATAL, levels.MARK, levels.OFF]);
      },
      'should only be equal to WARN': function(trace) {
        assertThat(trace).isEqualTo([levels.toLevel("WARN")]);
@@ -242,7 +255,7 @@ vows.describe('levels').addBatch({
    'ERROR': {
      topic: levels.ERROR,
      'should be less than FATAL': function(error) {
-        assertThat(error).isLessThanOrEqualTo([levels.FATAL, levels.OFF]);
+        assertThat(error).isLessThanOrEqualTo([levels.FATAL, levels.MARK, levels.OFF]);
        assertThat(error).isNotLessThanOrEqualTo([
          levels.ALL, 
          levels.TRACE, 
@@ -259,7 +272,7 @@ vows.describe('levels').addBatch({
          levels.INFO, 
          levels.WARN
        ]);
-        assertThat(error).isNotGreaterThanOrEqualTo([levels.FATAL, levels.OFF]);
+        assertThat(error).isNotGreaterThanOrEqualTo([levels.FATAL, levels.MARK, levels.OFF]);
      },
      'should only be equal to ERROR': function(trace) {
        assertThat(trace).isEqualTo([levels.toLevel("ERROR")]);
@@ -270,6 +283,7 @@ vows.describe('levels').addBatch({
          levels.INFO, 
          levels.WARN, 
          levels.FATAL, 
+          levels.MARK,
          levels.OFF
        ]);
      }
@@ -277,7 +291,7 @@ vows.describe('levels').addBatch({
    'FATAL': {
      topic: levels.FATAL,
      'should be less than OFF': function(fatal) {
-        assertThat(fatal).isLessThanOrEqualTo([levels.OFF]);
+        assertThat(fatal).isLessThanOrEqualTo([levels.MARK, levels.OFF]);
        assertThat(fatal).isNotLessThanOrEqualTo([
          levels.ALL, 
          levels.TRACE, 
@@ -295,8 +309,8 @@ vows.describe('levels').addBatch({
          levels.INFO, 
          levels.WARN, 
          levels.ERROR
-        ]);
-        assertThat(fatal).isNotGreaterThanOrEqualTo([levels.OFF]);
+       ]);
+        assertThat(fatal).isNotGreaterThanOrEqualTo([levels.MARK, levels.OFF]);
      },
      'should only be equal to FATAL': function(fatal) {
        assertThat(fatal).isEqualTo([levels.toLevel("FATAL")]);
@@ -306,7 +320,48 @@ vows.describe('levels').addBatch({
          levels.DEBUG, 
          levels.INFO, 
          levels.WARN, 
-          levels.ERROR, 
+          levels.ERROR,
+          levels.MARK, 
+          levels.OFF
+        ]);
+      }
+    },
+    'MARK': {
+      topic: levels.MARK,
+      'should be less than OFF': function(mark) {
+        assertThat(mark).isLessThanOrEqualTo([levels.OFF]);
+        assertThat(mark).isNotLessThanOrEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO, 
+          levels.WARN, 
+          levels.FATAL, 
+          levels.ERROR
+        ]);
+      },
+      'should be greater than FATAL': function(mark) {
+        assertThat(mark).isGreaterThanOrEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO, 
+          levels.WARN, 
+          levels.ERROR,
+          levels.FATAL
+       ]);
+        assertThat(mark).isNotGreaterThanOrEqualTo([levels.OFF]);
+      },
+      'should only be equal to MARK': function(mark) {
+        assertThat(mark).isEqualTo([levels.toLevel("MARK")]);
+        assertThat(mark).isNotEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO, 
+          levels.WARN, 
+          levels.ERROR,
+          levels.FATAL, 
          levels.OFF
        ]);
      }
@@ -321,7 +376,8 @@ vows.describe('levels').addBatch({
          levels.INFO, 
          levels.WARN, 
          levels.ERROR, 
-          levels.FATAL
+          levels.FATAL,
+          levels.MARK
        ]);
      },
      'should be greater than everything': function(off) {
@@ -332,7 +388,8 @@ vows.describe('levels').addBatch({
          levels.INFO, 
          levels.WARN, 
          levels.ERROR, 
-          levels.FATAL
+          levels.FATAL,
+          levels.MARK
        ]);
      },
      'should only be equal to OFF': function(off) {
@@ -344,7 +401,8 @@ vows.describe('levels').addBatch({
          levels.INFO, 
          levels.WARN, 
          levels.ERROR, 
-          levels.FATAL
+          levels.FATAL,
+          levels.MARK
        ]);
      }
    }
@@ -353,14 +411,14 @@ vows.describe('levels').addBatch({
    topic: levels.INFO,
    'should handle string arguments': function(info) {
      assertThat(info).isGreaterThanOrEqualTo(["all", "trace", "debug"]);
-      assertThat(info).isNotGreaterThanOrEqualTo(['warn', 'ERROR', 'Fatal', 'off']);
+      assertThat(info).isNotGreaterThanOrEqualTo(['warn', 'ERROR', 'Fatal', 'MARK', 'off']);
    }
  },
  'isLessThanOrEqualTo': {
    topic: levels.INFO,
    'should handle string arguments': function(info) {
      assertThat(info).isNotLessThanOrEqualTo(["all", "trace", "debug"]);
-      assertThat(info).isLessThanOrEqualTo(['warn', 'ERROR', 'Fatal', 'off']);
+      assertThat(info).isLessThanOrEqualTo(['warn', 'ERROR', 'Fatal', 'MARK', 'off']);
    }
  },
  'isEqualTo': {
--- a/test/logstashUDP-test.js
+++ b/test/logstashUDP-test.js
@@ -0,0 +1,106 @@
+"use strict";
+var sys = require("sys");
+var vows = require('vows')
+, assert = require('assert')
+, log4js = require('../lib/log4js')
+, sandbox = require('sandboxed-module')
+;
+
+function setupLogging(category, options) {
+  var udpSent = {};
+  
+  var fakeDgram = {
+    createSocket: function (type) {
+      return {
+        send: function(buffer, offset, length, port, host, callback) {
+          udpSent.date = new Date();
+          udpSent.host = host;
+          udpSent.port = port;
+          udpSent.length = length;
+          udpSent.offset = 0;
+          udpSent.buffer = buffer;
+          callback(undefined, length);
+        }
+      };
+    }
+  };
+
+  var logstashModule = sandbox.require('../lib/appenders/logstashUDP', {
+    requires: {
+      'dgram': fakeDgram
+    }
+  });
+  log4js.clearAppenders();
+  log4js.addAppender(logstashModule.configure(options), category);
+  
+  return {
+    logger: log4js.getLogger(category),
+    results: udpSent
+  };
+}
+
+vows.describe('logstashUDP appender').addBatch({
+  'when logging with logstash via UDP': {
+    topic: function() {
+      var setup = setupLogging('logstashUDP', {
+        "host": "127.0.0.1",
+        "port": 10001,
+        "type": "logstashUDP",
+        "logType": "myAppType",
+        "category": "myLogger",
+        "fields": {
+          "field1": "value1",
+          "field2": "value2"
+        },
+        "layout": {
+          "type": "pattern",
+          "pattern": "%m"
+        }
+      });
+      setup.logger.log('trace', 'Log event #1');
+      return setup;
+    },
+    'an UDP packet should be sent': function (topic) {
+      assert.equal(topic.results.host, "127.0.0.1");
+      assert.equal(topic.results.port, 10001);
+      assert.equal(topic.results.offset, 0);
+      var json = JSON.parse(topic.results.buffer.toString());
+      assert.equal(json.type, 'myAppType');
+      var fields = {
+        field1: 'value1',
+        field2: 'value2',
+        level: 'TRACE'
+      };
+      assert.equal(JSON.stringify(json.fields), JSON.stringify(fields));
+      assert.equal(json.message, 'Log event #1');
+      // Assert timestamp, up to hours resolution.
+      var date = new Date(json['@timestamp']);
+      assert.equal(
+        date.toISOString().substring(0, 14),
+        topic.results.date.toISOString().substring(0, 14)
+      );
+    }
+  },
+
+  'when missing some options': {
+    topic: function() {
+      var setup = setupLogging('myLogger', {
+        "host": "127.0.0.1",
+        "port": 10001,
+        "type": "logstashUDP",
+        "category": "myLogger",
+        "layout": {
+          "type": "pattern",
+          "pattern": "%m"
+        }
+      });
+      setup.logger.log('trace', 'Log event #1');
+      return setup;
+    },
+    'it sets some defaults': function (topic) {
+      var json = JSON.parse(topic.results.buffer.toString());
+      assert.equal(json.type, 'myLogger');
+      assert.equal(JSON.stringify(json.fields), JSON.stringify({'level': 'TRACE'}));
+    }
+  }
+}).export(module);
--- a/test/nolog-test.js
+++ b/test/nolog-test.js
@@ -1,6 +1,8 @@
 "use strict";
 var vows = require('vows')
 , assert = require('assert')
+, util   = require('util')
+, EE     = require('events').EventEmitter
 , levels = require('../lib/levels');

 function MockLogger() {
@@ -31,13 +33,14 @@ function MockRequest(remoteAddr, method, originalUrl) {
 }

 function MockResponse(statusCode) {
-
+  var r = this;
  this.statusCode = statusCode;

  this.end = function(chunk, encoding) {
-    
+      r.emit('finish');
  };
 }
+util.inherits(MockResponse, EE);

 vows.describe('log4js connect logger').addBatch({
  'getConnectLoggerModule': {
@@ -61,9 +64,12 @@ vows.describe('log4js connect logger').addBatch({
        topic: function(d){
          var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.png'); // not gif
          var res = new MockResponse(200);
+          var cb  = this.callback;
          d.cl(req, res, function() { });
          res.end('chunk', 'encoding');
-          return d.ml.messages;
+          setTimeout(function() {
+              cb(null, d.ml.messages);
+          },10);
        }, 
        'check message': function(messages){
          assert.isArray(messages);
@@ -81,9 +87,12 @@ vows.describe('log4js connect logger').addBatch({
        topic: function(d) {
          var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.gif'); // gif
          var res = new MockResponse(200);
+          var cb  = this.callback;
          d.cl(req, res, function() { });
          res.end('chunk', 'encoding');
-          return d.ml.messages;
+          setTimeout(function() {
+              cb(null, d.ml.messages);
+          },10);
        }, 
        'check message': function(messages) {
          assert.isArray(messages);
@@ -103,9 +112,12 @@ vows.describe('log4js connect logger').addBatch({
        topic: function(d){
          var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.png'); // not gif
          var res = new MockResponse(200);
+          var cb  = this.callback;
          d.cl(req, res, function() { });
          res.end('chunk', 'encoding');
-          return d.ml.messages;
+          setTimeout(function() { 
+            cb(null, d.ml.messages) 
+          }, 10);
        }, 
        'check message': function(messages){
          assert.isArray(messages);
@@ -123,9 +135,12 @@ vows.describe('log4js connect logger').addBatch({
        topic: function(d) {
          var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.gif'); // gif
          var res = new MockResponse(200);
+          var cb  = this.callback;
          d.cl(req, res, function() { });
          res.end('chunk', 'encoding');
-          return d.ml.messages;
+          setTimeout(function() { 
+            cb(null, d.ml.messages) 
+          }, 10);
        }, 
        'check message': function(messages) {
          assert.isArray(messages);
@@ -136,9 +151,12 @@ vows.describe('log4js connect logger').addBatch({
        topic: function(d) {
          var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.jpeg'); // gif
          var res = new MockResponse(200);
+          var cb  = this.callback;
          d.cl(req, res, function() { });
          res.end('chunk', 'encoding');
-          return d.ml.messages;
+          setTimeout(function() { 
+            cb(null, d.ml.messages) 
+          }, 10);
        }, 
        'check message': function(messages) {
          assert.isArray(messages);
@@ -157,9 +175,12 @@ vows.describe('log4js connect logger').addBatch({
        topic: function(d){
          var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.png'); // not gif
          var res = new MockResponse(200);
+          var cb  = this.callback;
          d.cl(req, res, function() { });
          res.end('chunk', 'encoding');
-          return d.ml.messages;
+          setTimeout(function() { 
+            cb(null, d.ml.messages) 
+          }, 10);
        }, 
        'check message': function(messages){
          assert.isArray(messages);
@@ -177,9 +198,12 @@ vows.describe('log4js connect logger').addBatch({
        topic: function(d) {
          var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.gif'); // gif
          var res = new MockResponse(200);
+          var cb  = this.callback;
          d.cl(req, res, function() { });
          res.end('chunk', 'encoding');
-          return d.ml.messages;
+          setTimeout(function() { 
+            cb(null, d.ml.messages) 
+          }, 10);
        }, 
        'check message': function(messages) {
          assert.isArray(messages);
@@ -191,9 +215,12 @@ vows.describe('log4js connect logger').addBatch({
        topic: function(d) {
          var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.jpeg'); // gif
          var res = new MockResponse(200);
+          var cb  = this.callback;
          d.cl(req, res, function() { });
          res.end('chunk', 'encoding');
-          return d.ml.messages;
+          setTimeout(function() { 
+            cb(null, d.ml.messages) 
+          }, 10);
        }, 
        'check message': function(messages) {
          assert.isArray(messages);
@@ -212,9 +239,12 @@ vows.describe('log4js connect logger').addBatch({
        topic: function(d){
          var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.png'); // not gif
          var res = new MockResponse(200);
+          var cb  = this.callback;
          d.cl(req, res, function() { });
          res.end('chunk', 'encoding');
-          return d.ml.messages;
+          setTimeout(function() { 
+            cb(null, d.ml.messages) 
+          }, 10);
        }, 
        'check message': function(messages){
          assert.isArray(messages);
@@ -232,9 +262,12 @@ vows.describe('log4js connect logger').addBatch({
        topic: function(d) {
          var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.gif'); // gif
          var res = new MockResponse(200);
+          var cb  = this.callback;
          d.cl(req, res, function() { });
          res.end('chunk', 'encoding');
-          return d.ml.messages;
+          setTimeout(function() { 
+            cb(null, d.ml.messages) 
+          }, 10);
        }, 
        'check message': function(messages) {
          assert.isArray(messages);
@@ -246,9 +279,12 @@ vows.describe('log4js connect logger').addBatch({
        topic: function(d) {
          var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.jpeg'); // gif
          var res = new MockResponse(200);
+          var cb  = this.callback;
          d.cl(req, res, function() { });
          res.end('chunk', 'encoding');
-          return d.ml.messages;
+          setTimeout(function() { 
+            cb(null, d.ml.messages) 
+          }, 10);
        }, 
        'check message': function(messages) {
          assert.isArray(messages);
--- a/test/smtpAppender-test.js
+++ b/test/smtpAppender-test.js
@@ -74,7 +74,6 @@ vows.describe('log4js smtpAppender').addBatch({
 		topic: function() {
      var setup = setupLogging('minimal config', {
        recipients: 'recipient@domain.com',
-        transport: "SMTP",
        SMTP: {
          port: 25,
          auth: {
@@ -98,7 +97,6 @@ vows.describe('log4js smtpAppender').addBatch({
        recipients: 'recipient@domain.com',
        sender: 'sender@domain.com',
        subject: 'This is subject',
-        transport: "SMTP",
        SMTP: {
          port: 25,
          auth: {
@@ -134,7 +132,6 @@ vows.describe('log4js smtpAppender').addBatch({
      var self = this;
      var setup = setupLogging('separate email for each event', {
        recipients: 'recipient@domain.com',
-        transport: "SMTP",
        SMTP: {
          port: 25,
          auth: {
@@ -168,7 +165,6 @@ vows.describe('log4js smtpAppender').addBatch({
      var setup = setupLogging('multiple events in one email', {
        recipients: 'recipient@domain.com',
        sendInterval: 1,
-        transport: "SMTP",
        SMTP: {
          port: 25,
          auth: {
@@ -206,7 +202,6 @@ vows.describe('log4js smtpAppender').addBatch({
      var setup = setupLogging('error when sending email', {
        recipients: 'recipient@domain.com',
        sendInterval: 0,
-        transport: 'SMTP',
        SMTP: { port: 25, auth: { user: 'user@domain.com' } }
      });

--- a/test/streams/rollingFileStream-test.js
+++ b/test/streams/rollingFileStream-test.js
@@ -122,7 +122,7 @@ vows.describe('RollingFileStream').addBatch({
        __dirname + "/test-rolling-file-stream-write-more", 
        45
      );
-      async.forEach(
+      async.each(
        [0, 1, 2, 3, 4, 5, 6], 
        function(i, cb) {
          stream.write(i +".cheese\n", "utf8", cb);
@@ -183,7 +183,7 @@ vows.describe('RollingFileStream').addBatch({
        45,
        5
      );
-      async.forEach(
+      async.each(
        [0, 1, 2, 3, 4, 5, 6], 
        function(i, cb) {
          stream.write(i +".cheese\n", "utf8", cb);
--- a/test/subcategories-test.js
+++ b/test/subcategories-test.js
@@ -0,0 +1,86 @@
+"use strict";
+var assert = require('assert')
+, vows = require('vows')
+, sandbox = require('sandboxed-module')
+, log4js = require('../lib/log4js')
+, levels = require('../lib/levels');
+
+vows.describe('subcategories').addBatch({
+    'loggers created after levels configuration is loaded': {
+      topic: function() {
+
+        log4js.configure({
+          "levels": {
+            "sub1": "WARN",
+            "sub1.sub11": "TRACE",
+            "sub1.sub11.sub111": "WARN",
+            "sub1.sub12": "INFO"            
+          }
+        }, { reloadSecs: 30 })
+
+        return {
+          "sub1":  log4js.getLogger('sub1'), // WARN
+          "sub11":  log4js.getLogger('sub1.sub11'), // TRACE
+          "sub111":  log4js.getLogger('sub1.sub11.sub111'), // WARN
+          "sub12":  log4js.getLogger('sub1.sub12'), // INFO
+
+          "sub13":  log4js.getLogger('sub1.sub13'), // Inherits sub1: WARN
+          "sub112":  log4js.getLogger('sub1.sub11.sub112'), // Inherits sub1.sub11: TRACE
+          "sub121":  log4js.getLogger('sub1.sub12.sub121'), // Inherits sub12: INFO
+          "sub0":  log4js.getLogger('sub0') // Not defined, not inherited: TRACE
+        };
+      },
+      'check logger levels': function(loggers) {
+        assert.equal(loggers.sub1.level, levels.WARN);
+        assert.equal(loggers.sub11.level, levels.TRACE);
+        assert.equal(loggers.sub111.level, levels.WARN);
+        assert.equal(loggers.sub12.level, levels.INFO);
+
+        assert.equal(loggers.sub13.level, levels.WARN);
+        assert.equal(loggers.sub112.level, levels.TRACE);
+        assert.equal(loggers.sub121.level, levels.INFO);
+        assert.equal(loggers.sub0.level, levels.TRACE);         
+      }
+    },
+    'loggers created before levels configuration is loaded': {
+      topic: function() {
+
+        var loggers = {
+          "sub1":  log4js.getLogger('sub1'), // WARN
+          "sub11":  log4js.getLogger('sub1.sub11'), // TRACE
+          "sub111":  log4js.getLogger('sub1.sub11.sub111'), // WARN
+          "sub12":  log4js.getLogger('sub1.sub12'), // INFO
+
+          "sub13":  log4js.getLogger('sub1.sub13'), // Inherits sub1: WARN
+          "sub112":  log4js.getLogger('sub1.sub11.sub112'), // Inherits sub1.sub11: TRACE
+          "sub121":  log4js.getLogger('sub1.sub12.sub121'), // Inherits sub12: INFO
+          "sub0":  log4js.getLogger('sub0') // Not defined, not inherited: TRACE
+        };
+
+
+        log4js.configure({
+          "levels": {
+            "sub1": "WARN",
+            "sub1.sub11": "TRACE",
+            "sub1.sub11.sub111": "WARN",
+            "sub1.sub12": "INFO"            
+          }
+        }, { reloadSecs: 30 })
+
+        return loggers;
+
+
+      },
+      'check logger levels': function(loggers) {
+        assert.equal(loggers.sub1.level, levels.WARN);
+        assert.equal(loggers.sub11.level, levels.TRACE);
+        assert.equal(loggers.sub111.level, levels.WARN);
+        assert.equal(loggers.sub12.level, levels.INFO);
+
+        assert.equal(loggers.sub13.level, levels.WARN);
+        assert.equal(loggers.sub112.level, levels.TRACE);
+        assert.equal(loggers.sub121.level, levels.INFO);
+        assert.equal(loggers.sub0.level, levels.TRACE);         
+      }
+    }
+}).exportTo(module);
Author	SHA1	Message	Date
Francisco Dans	3bf2bade32	x-forwarded-for	2015-06-01 15:30:46 +02:00
Gareth Jones	0c74fbbf7d	added node 0.12 to travis config	2015-05-13 08:06:16 +10:00
Gareth Jones	8dff114b49	0.6.25	2015-05-13 08:03:35 +10:00
Gareth Jones	c76fe098ae	Merge pull request #294 from Skiggz/gelf-fix Remove GELF flag when capturing custom fields	2015-05-13 07:54:33 +10:00
Skylar Lowery	1454ae5350	Use isUndefined test method vs equals undefined *doh	2015-04-27 11:01:20 -06:00
Skylar Lowery	3cf1d697e8	Remove GELF flag when capturing custom fields * Logstash (which supports GELF) drops messages with this key * There's no particular need to keep this key	2015-04-24 11:14:17 -06:00
Gareth Jones	9fe32d06e3	0.6.24	2015-04-17 11:36:22 +10:00
Gareth Jones	b8e1d03928	Merge pull request #292 from hasegawa-jun/fix-reference-error make sure to call require()	2015-04-17 11:35:28 +10:00
hasegawa-jun	ebfcf94db3	make sure to call require()	2015-04-17 10:08:00 +09:00
Gareth Jones	adeb714243	made calling logger.log safe if level is not provided as first argument (github issue #279 )	2015-04-17 08:31:12 +10:00
Gareth Jones	1cdd37c488	0.6.23	2015-04-17 08:21:00 +10:00
Gareth Jones	eb87ccb78d	Merge pull request #277 from hasegawa-jun/shutdown-smtp-appender Implemented shutdown function for SMTP appender	2015-04-17 08:12:17 +10:00
Gareth Jones	8360bb732c	Merge pull request #282 from qbrandon/master Add appender-level timezone offset config	2015-04-17 08:10:15 +10:00
Gareth Jones	085a88d6fc	upgraded semver package version (github issue #291 )	2015-04-17 08:05:47 +10:00
Gareth Jones	957d5d369d	Merge pull request #288 from alawatthe/nodemailermigration The smtp appender now works with the current version of nodemailer - fixes #287	2015-04-17 07:54:57 +10:00
alawatthe	57fc9e7aa0	The smtp appender now works with the current version of nodemailer	2015-04-11 12:03:14 +02:00
Quentin Brandon	435f4f320f	Bugfixes: get the unit tests passing again	2015-03-20 18:35:53 +09:00
Quentin Brandon	af69eddd1c	Add optional timezoneOffset config for appenders Example: log4js.configure({ appenders: [{type: 'console', timezoneOffset: -540}], replaceConsole: true }); The expected value is the equivalent of (new Date).getTimezoneOffset() In this example, -540 is the value for JST. This allows machines members of world-wide-spread cluster to all report log time-stamps using the same timezone (or adapt the timezone to a local different from the system)	2015-03-20 11:51:23 +09:00
hasegawa-jun	4dfe14a0c2	added shutdownTimeout option	2015-03-17 09:25:22 +09:00
Gareth Jones	4a217afc37	Merge pull request #278 from cfogelberg/custom-connect-tokens Custom connect tokens	2015-03-12 10:02:24 +11:00
Christo Fogelberg	41504a755d	test/connect-logger-test.js - tests for custom tokens	2015-03-10 06:37:53 +00:00
Christo Fogelberg	f22621199f	test/connect-logger-test.js - trailing whitespace Sublime removed	2015-03-10 06:24:57 +00:00
Christo Fogelberg	25c543f8ae	lib/connect-logger.js - allow options.tokens	2015-03-10 06:18:02 +00:00
Christo Fogelberg	24268422cf	lib/connect-logger.js - format takes tokens array instead of req, res	2015-03-10 06:13:49 +00:00
Christo Fogelberg	ba80dc1588	Trailing whitespace Sublime removed	2015-03-08 19:36:17 +00:00
hasegawa-jun	adfad9ad20	Implemented shutdown function for SMTP appender	2015-03-04 09:13:30 +09:00
Gareth Jones	35067af550	0.6.22	2015-01-10 15:40:03 +11:00
Gareth Jones	d31521bac0	Merge pull request #240 from vivocha/vivocha-0.6.20 Vivocha 0.6.20	2015-01-10 15:34:31 +11:00
Gareth Jones	6d7cab343d	Merge pull request #260 from DerKnerd/patch-1 Update README.md	2015-01-10 15:29:53 +11:00
Gareth Jones	c624aef282	Merge pull request #261 from boljen/clusterpid added cluster identifier support	2015-01-10 15:29:01 +11:00
Gareth Jones	0ae72ee424	Merge pull request #264 from FleetingClouds/master Force bundling of appenders/console	2015-01-10 15:26:39 +11:00
Gareth Jones	a4be20f8e1	Merge pull request #266 from sc2bigjoe/patch-1 Update smtp.js	2015-01-10 15:23:28 +11:00
Gareth Jones	d10d40b572	Merge pull request #268 from askhogan/master Allow for blank tokens due to dynamic data	2015-01-10 15:22:24 +11:00
Gareth Jones	51ab2963d0	Merge pull request #269 from Nekle/master add options to reload function	2015-01-10 15:21:46 +11:00
Fuxian Ding	1f1442cb7c	add options to reload function if `cwd` is included in option, reload will not work	2014-12-27 12:48:24 +08:00
Patrick Hogan	f987990339	added null tests	2014-12-23 19:42:32 -08:00
Patrick Hogan	6b029e98fc	Allow for blank tokens due to dynamic data Metadata for users such as name, email, etc are not always present for users. For example, I am running express and I want to log the %x{company}%x{username} so that when I look at my logs I can immediately understand which user this affects. Or for example, I could log %x{payingOrTial} the type of user. This works well when the user is logged in. However, my logger encompasses everything. I log when the server boots up. I log during the login screen where a user is not yet logged in. In these circumstances there is no way to retrieve this metadata. So for example ``` "username": function () { var session = require('continuation-local-storage').getNamespace('api.callinize'); if(!session) session = require('continuation-local-storage').getNamespace('dashboard.callinize'); var username = session && session.get('user') && session.get('user').username; if(!username) return ""; return " " + username + " "; } ``` I try to get the metadata. If I get no metdata I return a blank string. Unfortunately, in the current implementation, due to the OR operator, even if I have a replacement of "" \|\| matchedString, ``` replaceToken(conversionCharacter, loggingEvent, specifier) \|\| matchedString; ``` the blank string equals false and puts the token in the log instead of the blank string. This makes the log lines get long with information that is not relevant. The better thing to do is simply allow for blank strings. This lets the user have control over their logs and also allows for more metadata to go in the logs, without having to pick only metadata that is always present.	2014-12-21 14:49:25 -08:00
sc2bigjoe	1629e01df9	Update smtp.js added the ability for smtp appender to send message as html instead of plaintext. in your log4js.config file simply include "html": "true", to write out as html, otherwise it will send plaintext	2014-12-17 11:28:50 -05:00
Martin Bramwell	ec72c03f81	Force bundling of appenders/console Changes to be committed: modified: lib/log4js.js	2014-12-09 02:59:58 -05:00
Christophe Bol	3300dfae60	fixed error when logging from the clustered master	2014-12-01 15:34:09 +01:00
Christophe Bol	b694fd1d8d	added cluster identifier support	2014-12-01 12:29:45 +01:00
Imanuel Ulbricht	e07adf2ca4	Update README.md	2014-11-28 17:49:46 +01:00
Gareth Jones	ec5f4485f8	Merge pull request #258 from osher/patch-4 fix bug: headers are changed after log entry emits	2014-11-16 09:19:47 +11:00
osher	2f44dbf53e	0.8 compatibility	2014-11-05 11:58:09 +02:00
osher	9da158f945	fix tests - they have to be async!	2014-11-05 11:49:21 +02:00
osher	cd3971cc03	fix bug: headers are changed after log entry emits In the original version, the following operation looks synchronic, however it is not: ``` res.end = end; res.end(data,enc); //emit the log entry ``` In fact, it starts a series of async operations, in which the request may yet be changed after the request log has already been emitted (in our case - a change on request headers was observed, probably by some low level hook or hacky wrap of some http.ServerResponse method that's involved on the process - but called asynchronously) what leads to situation that the request log does not capture valid data. (observed by us: - request headers - calculated end time, when concerning big content ) The fix just used `setTimeout(function() { /emit the log entry/ }, 1)`, but I'm afraid it may not hold true for big contents. Well. maybe the headers part will, but the response time calculation will lie. The fix relays on: http://nodejs.org/api/http.html#http_event_finish	2014-11-04 17:28:52 +02:00
Gareth Jones	176d44833e	0.6.21	2014-09-11 09:26:02 +10:00
Gareth Jones	988e9a41f6	added license info	2014-09-11 09:23:55 +10:00
Gareth Jones	39ce97d140	Merge pull request #242 from marcelog/marcelog_logstash_udp_appender adding logstash UDP appender	2014-09-11 09:20:42 +10:00
Gareth Jones	c753fe37bb	Merge pull request #243 from laenger/master pass options to wrapped appender in logLevelFilter	2014-09-11 09:16:46 +10:00
Marcelo Gornstein	a7a0964803	adding logstash UDP appender	2014-09-10 13:03:21 -03:00
Christian Langer	82950eb965	pass options to wrapped appender in logLevelFilter	2014-09-09 03:28:02 +02:00
Luis Malheiro	1e999f36d7	Fix and test for MARK level.	2014-09-08 12:17:50 +02:00
Luis Malheiro	17c9b29ca5	Removed property 'level' from the file appender, because that functionality is provided by appender logLevelFilter.	2014-09-08 11:33:22 +02:00
Luis Malheiro	492c45d055	Test for appender using subcategories.	2014-09-08 11:14:00 +02:00
Luis Malheiro	ebbbea198d	Added test to check loggers using sub-categories.	2014-09-02 14:33:51 +02:00
Gareth Jones	cacade0a37	Merge pull request #239 from lazutkin/gh-238 Closes #238 Updated async library	2014-09-02 19:33:58 +10:00
Luis Malheiro	02ea4831ea	Test for the 'compress' option at the file appender.	2014-09-01 18:05:36 +02:00
Luis Malheiro	39a73586ed	Fixed bug that failed test 'set level on all categories'	2014-09-01 14:37:25 +02:00
Luis Malheiro	036293db41	Log compression.	2014-08-29 16:33:41 +02:00
Luis Malheiro	6fa998408a	Adds subcategories to the appenders and loggers. Adds property "level" at the file appender to limit the levels that a file appender accepts. Creates a MARK category that always write to the log. That's useful to write things like '---- STARTED ----'.	2014-08-29 16:33:32 +02:00
Dmitry M. Lazutkin	7558a3c367	Closes #238 Updated async library in order to use lib in —use-strict mode	2014-08-28 12:04:02 +04:00