0.6.19

Pull request for #233

.bob.json

@@ -0,0 +1,12 @@
+{
+  "build": "clean lint coverage test",
+  "lint": {
+    "type": "jshint"
+  },
+  "coverage": {
+    "type": "vows"
+  },
+  "test": {
+    "type": "vows"
+  }
+}

.gitignore

@@ -2,4 +2,7 @@
 *.log??
 build
 node_modules
-
+.bob/
+test/streams/test-rolling-file-stream*
+test/streams/test-rolling-stream-with-existing-files*
+.idea

.jshintrc

@@ -0,0 +1,15 @@
+{ 
+  "node": true,
+  "laxcomma": true,
+  "indent": 2,
+  "globalstrict": true,
+  "maxparams": 5,
+  "maxdepth": 3,
+  "maxstatements": 20,
+  "maxcomplexity": 5,
+  "maxlen": 100,
+  "globals": {
+    "describe": true,
+    "it": true
+  } 
+}

README.md

@@ -1,7 +1,7 @@
 # log4js-node [![Build Status](https://secure.travis-ci.org/nomiddlename/log4js-node.png?branch=master)](http://travis-ci.org/nomiddlename/log4js-node)
 
 
-This is a conversion of the [log4js](http://log4js.berlios.de/index.html)
+This is a conversion of the [log4js](https://github.com/stritti/log4js)
 framework to work with [node](http://nodejs.org). I've mainly stripped out the browser-specific code and tidied up some of the javascript. 
 
 Out of the box it supports the following features:
@@ -12,6 +12,7 @@ Out of the box it supports the following features:
 * SMTP appender
 * GELF appender
 * hook.io appender
+* Loggly appender
 * multiprocess appender (useful when you've got worker processes)
 * a logger for connect/express servers
 * configurable log message layout/patterns
@@ -133,6 +134,8 @@ Documentation for most of the core appenders can be found on the [wiki](https://
 ## Documentation
 See the [wiki](https://github.com/nomiddlename/log4js-node/wiki). Improve the [wiki](https://github.com/nomiddlename/log4js-node/wiki), please.
 
+There's also [an example application](https://github.com/nomiddlename/log4js-example).
+
 ## Contributing
 Contributions welcome, but take a look at the [rules](https://github.com/nomiddlename/log4js-node/wiki/Contributing) first.
 

examples/example-connect-logger.js

@@ -1,14 +1,46 @@
-var log4js = require('./lib/log4js');
+//The connect/express logger was added to log4js by danbell. This allows connect/express servers to log using log4js.
-log4js.addAppender(log4js.fileAppender('cheese.log'), 'cheese');
+//https://github.com/nomiddlename/log4js-node/wiki/Connect-Logger
 
-var logger = log4js.getLogger('cheese');
+// load modules
-logger.setLevel('INFO');
+var log4js = require('log4js');
+var express = require("express");
+var app = express();
 
-var app = require('express').createServer();
+//config
+log4js.configure({
+	appenders: [
+		{ type: 'console' },
+		{ type: 'file', filename: 'logs/log4jsconnect.log', category: 'log4jslog' }
+	]
+});
+
+//define logger
+var logger = log4js.getLogger('log4jslog');
+
+// set at which time msg is logged print like: only on error & above
+// logger.setLevel('ERROR');
+
+//express app
 app.configure(function() {
-    app.use(log4js.connectLogger(logger, { level: log4js.levels.INFO }));
+	app.use(express.favicon(''));
+	// app.use(log4js.connectLogger(logger, { level: log4js.levels.INFO }));
+	// app.use(log4js.connectLogger(logger, { level: 'auto', format: ':method :url :status' }));
+
+	//### AUTO LEVEL DETECTION
+	//http responses 3xx, level = WARN
+	//http responses 4xx & 5xx, level = ERROR
+	//else.level = INFO
+	app.use(log4js.connectLogger(logger, { level: 'auto' }));
 });
-app.get('*', function(req,res) {
+
-    res.send('hello world\n <a href="/cheese">cheese</a>\n');
+//route
+app.get('/', function(req,res) {
+	res.send('hello world');
 });
+
+//start app
 app.listen(5000);
+
+console.log('server runing at localhost:5000');
+console.log('Simulation of normal response: goto localhost:5000');
+console.log('Simulation of error response: goto localhost:5000/xxx');

examples/flush-on-exit.js

@@ -0,0 +1,27 @@
+/**
+ * run this, then "ab -c 10 -n 100 localhost:4444/" to test (in
+ * another shell)
+ */
+var log4js = require('../lib/log4js');
+log4js.configure({
+      appenders: [
+        { type: 'file', filename: 'cheese.log', category: 'cheese' },
+        { type: 'console'}
+  ]
+});
+
+var logger = log4js.getLogger('cheese');
+logger.setLevel('INFO');
+
+var http=require('http');
+
+var server = http.createServer(function(request, response){
+    response.writeHead(200, {'Content-Type': 'text/plain'});
+    var rd = Math.random() * 50;
+    logger.info("hello " + rd);
+    response.write('hello ');
+    if (Math.floor(rd) == 30){
+        log4js.shutdown(function() { process.exit(1); });
+    }
+    response.end();
+}).listen(4444);

examples/loggly-appender.js

@@ -0,0 +1,24 @@
+//Note that loggly appender needs node-loggly to work.
+//If you haven't got node-loggly installed, you'll get cryptic
+//"cannot find module" errors when using the loggly appender
+var log4js = require('../lib/log4js');
+
+log4js.configure({
+  "appenders": [
+    {
+      type: "console",
+      category: "test"
+    },
+    {
+      "type"     : "loggly",
+      "token"    : "12345678901234567890",
+      "subdomain": "your-subdomain",
+      "tags"     : ["test"],
+      "category" : "loggly"
+    }
+  ]
+});
+
+var logger = log4js.getLogger("loggly");
+logger.info("Test log message");
+//logger.debug("Test log message");

examples/smtp-appender.js

@@ -0,0 +1,43 @@
+//Note that smtp appender needs nodemailer to work.
+//If you haven't got nodemailer installed, you'll get cryptic
+//"cannot find module" errors when using the smtp appender
+var log4js = require('../lib/log4js')
+, log
+, logmailer
+, i = 0;
+log4js.configure({
+  "appenders": [
+    {
+      type: "console",
+      category: "test"
+    },
+    {
+      "type": "smtp",
+      "recipients": "logfilerecipient@logging.com",
+      "sendInterval": 5,
+      "transport": "SMTP",
+      "SMTP": {
+        "host": "smtp.gmail.com",
+        "secureConnection": true,
+        "port": 465,
+        "auth": {
+          "user": "someone@gmail",
+          "pass": "********************"
+        },
+        "debug": true
+      },
+      "category": "mailer"
+    }
+  ]
+});
+log = log4js.getLogger("test");
+logmailer = log4js.getLogger("mailer");
+
+function doTheLogging(x) {
+    log.info("Logging something %d", x);
+    logmailer.info("Logging something %d", x);
+}
+
+for ( ; i < 500; i++) {
+    doTheLogging(i);
+}

lib/appenders/categoryFilter.js

@@ -0,0 +1,20 @@
+"use strict";
+var log4js = require('../log4js');
+
+function categoryFilter (excludes, appender) {
+  if (typeof(excludes) === 'string') excludes = [excludes];
+  return function(logEvent) {
+    if (excludes.indexOf(logEvent.categoryName) === -1) {
+      appender(logEvent);
+    }
+  };
+}
+
+function configure(config) {
+  log4js.loadAppender(config.appender.type);
+  var appender = log4js.appenderMakers[config.appender.type](config.appender);
+  return categoryFilter(config.exclude, appender);
+}
+
+exports.appender = categoryFilter;
+exports.configure = configure;

lib/appenders/clustered.js

@@ -0,0 +1,129 @@
+"use strict";
+
+var cluster = require('cluster');
+var log4js = require('../log4js');
+
+/**
+ * Takes a loggingEvent object, returns string representation of it.
+ */
+function serializeLoggingEvent(loggingEvent) {
+	// JSON.stringify(new Error('test')) returns {}, which is not really useful for us.
+	// The following allows us to serialize errors correctly.
+	for (var i = 0; i < loggingEvent.data.length; i++) {
+		var item = loggingEvent.data[i];
+		if (item && item.stack && JSON.stringify(item) === '{}') { // Validate that we really are in this case
+			loggingEvent.data[i] = {stack : item.stack};
+		}
+	}
+	return JSON.stringify(loggingEvent);
+}
+
+/**
+ * Takes a string, returns an object with
+ * the correct log properties.
+ *
+ * This method has been "borrowed" from the `multiprocess` appender 
+ * by `nomiddlename` (https://github.com/nomiddlename/log4js-node/blob/master/lib/appenders/multiprocess.js)
+ *
+ * Apparently, node.js serializes everything to strings when using `process.send()`, 
+ * so we need smart deserialization that will recreate log date and level for further processing by log4js internals.
+ */
+function deserializeLoggingEvent(loggingEventString) {
+
+	var loggingEvent;
+	
+	try {
+	
+		loggingEvent = JSON.parse(loggingEventString);
+		loggingEvent.startTime = new Date(loggingEvent.startTime);
+		loggingEvent.level = log4js.levels.toLevel(loggingEvent.level.levelStr);
+		
+	} catch (e) {
+		
+		// JSON.parse failed, just log the contents probably a naughty.
+		loggingEvent = {
+			startTime: new Date(),
+			categoryName: 'log4js',
+			level: log4js.levels.ERROR,
+			data: [ 'Unable to parse log:', loggingEventString ]
+		};
+	}
+	return loggingEvent;
+} 
+
+/**
+ * Creates an appender. 
+ *
+ * If the current process is a master (`cluster.isMaster`), then this will be a "master appender".
+ * Otherwise this will be a worker appender, that just sends loggingEvents to the master process.
+ *
+ * If you are using this method directly, make sure to provide it with `config.actualAppenders` array 
+ * of actual appender instances.
+ *
+ * Or better use `configure(config, options)`
+ */
+function createAppender(config) {
+
+	if (cluster.isMaster) {
+
+		var masterAppender = function(loggingEvent) {
+	
+			if (config.actualAppenders) {
+				var size = config.actualAppenders.length;
+				for(var i = 0; i < size; i++) {
+			                if (!config.appenders[i].category || config.appenders[i].category === loggingEvent.categoryName) {
+						// Relying on the index is not a good practice but otherwise the change would have been bigger.
+						config.actualAppenders[i](loggingEvent);
+                    			}
+				}
+			}
+		}
+		
+		// Listen on new workers
+		cluster.on('fork', function(worker) {
+		
+			worker.on('message', function(message) {
+				if (message.type && message.type === '::log-message') {
+					// console.log("master : " + cluster.isMaster + " received message: " + JSON.stringify(message.event));
+					
+					var loggingEvent = deserializeLoggingEvent(message.event);
+					masterAppender(loggingEvent);
+				}
+			});
+		
+		});
+		
+		return masterAppender;
+		
+	} else {
+
+		return function(loggingEvent) {
+			// If inside the worker process, then send the logger event to master.
+			if (cluster.isWorker) {
+				// console.log("worker " + cluster.worker.id + " is sending message");
+				process.send({ type: '::log-message', event: serializeLoggingEvent(loggingEvent)});
+			}
+		}
+	}
+}
+
+function configure(config, options) {
+
+	if (config.appenders && cluster.isMaster) {
+	
+		var size = config.appenders.length;
+		config.actualAppenders = new Array(size);
+	
+		for(var i = 0; i < size; i++) {
+		
+			log4js.loadAppender(config.appenders[i].type);
+			config.actualAppenders[i] = log4js.appenderMakers[config.appenders[i].type](config.appenders[i], options);
+		
+		}
+	}
+	
+	return createAppender(config);
+}
+
+exports.appender = createAppender;
+exports.configure = configure; 

lib/appenders/console.js

@@ -1,19 +1,20 @@
-var layouts = require('../layouts'),
+"use strict";
-    consoleLog = console.log;
+var layouts = require('../layouts')
+, consoleLog = console.log.bind(console);
 
 function consoleAppender (layout) {
-    layout = layout || layouts.colouredLayout;
+  layout = layout || layouts.colouredLayout;
-    return function(loggingEvent) {
+  return function(loggingEvent) {
-	consoleLog(layout(loggingEvent));
+    consoleLog(layout(loggingEvent));
-    };
+  };
 }
 
 function configure(config) {
-    var layout;
+  var layout;
-    if (config.layout) {
+  if (config.layout) {
-	layout = layouts.layout(config.layout.type, config.layout);
+    layout = layouts.layout(config.layout.type, config.layout);
-    }
+  }
-    return consoleAppender(layout);
+  return consoleAppender(layout);
 }
 
 exports.appender = consoleAppender;

lib/appenders/dateFile.js

@@ -1,15 +1,17 @@
-var streams = require('../streams'),
+"use strict";
-    layouts = require('../layouts'),
+var streams = require('../streams')
-    path = require('path'),
+, layouts = require('../layouts')
-    os = require('os'),
+, async = require('async')
-    eol = os.EOL || '\n',
+, path = require('path')
-    openFiles = [];
+, os = require('os')
+, eol = os.EOL || '\n'
+, openFiles = [];
 
 //close open files on process exit.
 process.on('exit', function() {
-    openFiles.forEach(function (file) {
+  openFiles.forEach(function (file) {
-        file.end();
+    file.end();
-    });
+  });
 });
 
 /**
@@ -20,34 +22,51 @@ process.on('exit', function() {
  * @layout layout function for log messages - defaults to basicLayout
  */
 function appender(filename, pattern, alwaysIncludePattern, layout) {
-    layout = layout || layouts.basicLayout;
+  layout = layout || layouts.basicLayout;
 
-    var logFile = new streams.DateRollingFileStream(filename, pattern, { alwaysIncludePattern: alwaysIncludePattern });
+  var logFile = new streams.DateRollingFileStream(
-    openFiles.push(logFile);
+    filename,
+    pattern,
+    { alwaysIncludePattern: alwaysIncludePattern }
+  );
+  openFiles.push(logFile);
 
-    return function(logEvent) {
+  return function(logEvent) {
-        logFile.write(layout(logEvent) + eol, "utf8");
+    logFile.write(layout(logEvent) + eol, "utf8");
-    };
+  };
 
 }
 
 function configure(config, options) {
-    var layout;
+  var layout;
 
-    if (config.layout) {
+  if (config.layout) {
-	    layout = layouts.layout(config.layout.type, config.layout);
+    layout = layouts.layout(config.layout.type, config.layout);
-    }
+  }
-    
-    if (!config.alwaysIncludePattern) {
-        config.alwaysIncludePattern = false;
-    }
 
-    if (options && options.cwd && !config.absolute) {
+  if (!config.alwaysIncludePattern) {
-        config.filename = path.join(options.cwd, config.filename);
+    config.alwaysIncludePattern = false;
-    }
+  }
 
-    return appender(config.filename, config.pattern, config.alwaysIncludePattern, layout);
+  if (options && options.cwd && !config.absolute) {
+    config.filename = path.join(options.cwd, config.filename);
+  }
+
+  return appender(config.filename, config.pattern, config.alwaysIncludePattern, layout);
+}
+
+function shutdown(cb) {
+  async.forEach(openFiles, function(file, done) {
+    if (!file.write(eol, "utf-8")) {
+      file.once('drain', function() {
+        file.end(done);
+      });
+    } else {
+      file.end(done);
+    }
+  }, cb);
 }
 
 exports.appender = appender;
 exports.configure = configure;
+exports.shutdown = shutdown;

lib/appenders/file.js

@@ -1,25 +1,30 @@
+"use strict";
 var layouts = require('../layouts')
-  , path = require('path')
+, async = require('async')
-  , fs = require('fs')
+, path = require('path')
-  , streams = require('../streams')
+, fs = require('fs')
-  , os = require('os')
+, streams = require('../streams')
-  , eol = os.EOL || '\n'
+, os = require('os')
-  , openFiles = [];
+, eol = os.EOL || '\n'
+, openFiles = [];
 
 //close open files on process exit.
 process.on('exit', function() {
-    openFiles.forEach(function (file) {
+  openFiles.forEach(function (file) {
-        file.end();
+    file.end();
-    });
+  });
 });
 
 /**
  * File Appender writing the logs to a text file. Supports rolling of logs by size.
  *
  * @param file file log messages will be written to
- * @param layout a function that takes a logevent and returns a string (defaults to basicLayout).
+ * @param layout a function that takes a logevent and returns a string 
- * @param logSize - the maximum size (in bytes) for a log file, if not provided then logs won't be rotated.
+ *   (defaults to basicLayout).
- * @param numBackups - the number of log files to keep after logSize has been reached (default 5)
+ * @param logSize - the maximum size (in bytes) for a log file, 
+ *   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)
  */
 function fileAppender (file, layout, logSize, numBackups) {
   var bytesWritten = 0;
@@ -38,7 +43,12 @@ function fileAppender (file, layout, logSize, numBackups) {
         numFiles
       );
     } else {
-      stream = fs.createWriteStream(file, { encoding: "utf8", mode: 0644, flags: 'a' });
+      stream = fs.createWriteStream(
+        file, 
+        { encoding: "utf8", 
+          mode: parseInt('0644', 8), 
+          flags: 'a' }
+      );
     }
     stream.on("error", function (err) {
       console.error("log4js.fileAppender - Writing to file %s, error happened ", file, err);
@@ -69,5 +79,18 @@ function configure(config, options) {
   return fileAppender(config.filename, layout, config.maxLogSize, config.backups);
 }
 
+function shutdown(cb) {
+  async.forEach(openFiles, function(file, done) {
+    if (!file.write(eol, "utf-8")) {
+      file.once('drain', function() {
+        file.end(done);
+      });
+    } else {
+      file.end(done);
+    }
+  }, cb);
+}  
+
 exports.appender = fileAppender;
 exports.configure = configure;
+exports.shutdown = shutdown;

lib/appenders/fileSync.js

@@ -0,0 +1,187 @@
+"use strict";
+var debug = require('../debug')('fileSync')
+, layouts = require('../layouts')
+, path = require('path')
+, fs = require('fs')
+, streams = require('../streams')
+, os = require('os')
+, eol = os.EOL || '\n'
+;
+
+function RollingFileSync (filename, size, backups, options) {
+  debug("In RollingFileStream");
+
+  function throwErrorIfArgumentsAreNotValid() {
+    if (!filename || !size || size <= 0) {
+      throw new Error("You must specify a filename and file size");
+    }
+  }
+  
+  throwErrorIfArgumentsAreNotValid();
+  
+  this.filename = filename;
+  this.size = size;
+  this.backups = backups || 1;
+  this.options = options || { encoding: 'utf8', mode: parseInt('0644', 8), flags: 'a' };
+  this.currentSize = 0;
+  
+  function currentFileSize(file) {
+    var fileSize = 0;
+    try {
+      fileSize = fs.statSync(file).size;
+    } catch (e) {
+      // file does not exist
+      fs.appendFileSync(filename, '');
+    }
+    return fileSize;
+  }
+
+  this.currentSize = currentFileSize(this.filename);
+}
+
+RollingFileSync.prototype.shouldRoll = function() {
+  debug("should roll with current size %d, and max size %d", this.currentSize, this.size);
+  return this.currentSize >= this.size;
+};
+
+RollingFileSync.prototype.roll = function(filename) {
+  var that = this,
+  nameMatcher = new RegExp('^' + path.basename(filename));
+  
+  function justTheseFiles (item) {
+    return nameMatcher.test(item);
+  }
+  
+  function index(filename_) {
+    return parseInt(filename_.substring((path.basename(filename) + '.').length), 10) || 0;
+  }
+  
+  function byIndex(a, b) {
+    if (index(a) > index(b)) {
+      return 1;
+    } else if (index(a) < index(b) ) {
+      return -1;
+    } else {
+      return 0;
+    }
+  }
+
+  function increaseFileIndex (fileToRename) {
+    var idx = index(fileToRename);
+    debug('Index of ' + fileToRename + ' is ' + idx);
+    if (idx < that.backups) {
+      //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
+      try {
+        fs.unlinkSync(filename + '.' + (idx+1));
+      } catch(e) {
+        //ignore err: if we could not delete, it's most likely that it doesn't exist
+      }
+      
+      debug('Renaming ' + fileToRename + ' -> ' + filename + '.' + (idx+1));
+      fs.renameSync(path.join(path.dirname(filename), fileToRename), filename + '.' + (idx + 1));
+    }
+  }
+
+  function renameTheFiles() {
+    //roll the backups (rename file.n to file.n+1, where n <= numBackups)
+    debug("Renaming the old files");
+    
+    var files = fs.readdirSync(path.dirname(filename));
+    files.filter(justTheseFiles).sort(byIndex).reverse().forEach(increaseFileIndex);
+  }
+
+  debug("Rolling, rolling, rolling");
+  renameTheFiles();
+};
+
+RollingFileSync.prototype.write = function(chunk, encoding) {
+  var that = this;
+  
+  
+  function writeTheChunk() {
+    debug("writing the chunk to the file");
+    that.currentSize += chunk.length;
+    fs.appendFileSync(that.filename, chunk);
+  }
+
+  debug("in write");
+  
+
+  if (this.shouldRoll()) {
+    this.currentSize = 0;
+    this.roll(this.filename);
+  }
+  
+  writeTheChunk();
+};
+
+
+/**
+ * File Appender writing the logs to a text file. Supports rolling of logs by size.
+ *
+ * @param file file log messages will be written to
+ * @param layout a function that takes a logevent and returns a string 
+ *   (defaults to basicLayout).
+ * @param logSize - the maximum size (in bytes) for a log file, 
+ *   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)
+ */
+function fileAppender (file, layout, logSize, numBackups) {
+  debug("fileSync appender created");
+  var bytesWritten = 0;
+  file = path.normalize(file);
+  layout = layout || layouts.basicLayout;
+  numBackups = numBackups === undefined ? 5 : numBackups;
+  //there has to be at least one backup if logSize has been specified
+  numBackups = numBackups === 0 ? 1 : numBackups;
+
+  function openTheStream(file, fileSize, numFiles) {
+    var stream;
+    
+    if (fileSize) {
+      stream = new RollingFileSync(
+        file,
+        fileSize,
+        numFiles
+      );
+    } else {
+      stream = (function(f) {
+        // create file if it doesn't exist
+        if (!fs.existsSync(f))
+            fs.appendFileSync(f, '');
+        
+        return {
+            write: function(data) {
+                fs.appendFileSync(f, data);
+            }
+        };
+      })(file);
+    }
+
+    return stream;
+  }
+
+  var logFile = openTheStream(file, logSize, numBackups);
+  
+  return function(loggingEvent) {
+    logFile.write(layout(loggingEvent) + eol);
+  };
+}
+
+function configure(config, options) {
+  var layout;
+  if (config.layout) {
+    layout = layouts.layout(config.layout.type, config.layout);
+  }
+
+  if (options && options.cwd && !config.absolute) {
+    config.filename = path.join(options.cwd, config.filename);
+  }
+
+  return fileAppender(config.filename, layout, config.maxLogSize, config.backups);
+}
+
+exports.appender = fileAppender;
+exports.configure = configure;

lib/appenders/gelf.js

@@ -1,8 +1,10 @@
+"use strict";
 var zlib = require('zlib');
 var layouts = require('../layouts');
 var levels = require('../levels');
 var dgram = require('dgram');
 var util = require('util');
+var debug = require('../debug')('GELF Appender');
 
 var LOG_EMERG=0;    // system is unusable
 var LOG_ALERT=1;    // action must be taken immediately
@@ -33,60 +35,107 @@ levelMapping[levels.FATAL] = LOG_CRIT;
  * @param facility - facility to log to (default:nodejs-server)
  */
 function gelfAppender (layout, host, port, hostname, facility) {
+  var config, customFields;
+  if (typeof(host) === 'object') {
+    config = host;
+    host = config.host;
+    port = config.port;
+    hostname = config.hostname;
+    facility = config.facility;
+    customFields = config.customFields;
+  }
+  
+  host = host || 'localhost';
+  port = port || 12201;
+  hostname = hostname || require('os').hostname();
+  layout = layout || layouts.messagePassThroughLayout;
 
-    host = host || 'localhost';
+  var defaultCustomFields = customFields || {};
-    port = port || 12201;
-    hostname = hostname || require('os').hostname();
-    facility = facility || 'nodejs-server';
-    layout = layout || layouts.messagePassThroughLayout;
 
-    var client = dgram.createSocket("udp4");
+  if(facility) {
+    defaultCustomFields['_facility'] = facility;
+  }
 
-    process.on('exit', function() {
+  var client = dgram.createSocket("udp4");
-        if (client) client.close();
+  
+  process.on('exit', function() {
+    if (client) client.close();
+  });
+
+  /**
+   * Add custom fields (start with underscore ) 
+   * - if the first object passed to the logger contains 'GELF' field, 
+   *   copy the underscore fields to the message
+   * @param loggingEvent
+   * @param msg
+   */
+  function addCustomFields(loggingEvent, msg){
+
+    /* append defaultCustomFields firsts */
+    Object.keys(defaultCustomFields).forEach(function(key) {
+      // skip _id field for graylog2, skip keys not starts with UNDERSCORE
+      if (key.match(/^_/) && key !== "_id") { 
+        msg[key] = defaultCustomFields[key];
+      }
     });
 
-    function preparePacket(loggingEvent) {
+    /* append custom fields per message */
-        var msg = {};
+    var data = loggingEvent.data;
-        msg.full_message = layout(loggingEvent);
+    if (!Array.isArray(data) || data.length === 0) return;
-        msg.short_message = msg.full_message;
+    var firstData = data[0];
+    
+    if (!firstData.GELF) return; // identify with GELF field defined
+    Object.keys(firstData).forEach(function(key) {
+      // skip _id field for graylog2, skip keys not starts with UNDERSCORE
+      if (key.match(/^_/) || key !== "_id") { 
+        msg[key] = firstData[key];
+      }
+    });
+    
+    /* the custom field object should be removed, so it will not be looged by the later appenders */
+    loggingEvent.data.shift(); 
+  }
+ 
+  function preparePacket(loggingEvent) {
+    var msg = {};
+    addCustomFields(loggingEvent, msg);
+    msg.short_message = layout(loggingEvent);
+    
+    msg.version="1.1";
+    msg.timestamp = msg.timestamp || new Date().getTime() / 1000; // log should use millisecond 
+    msg.host = hostname;
+    msg.level = levelMapping[loggingEvent.level || levels.DEBUG];
+    return msg;
+  }
+  
+  function sendPacket(packet) {
+    try {
+      client.send(packet, 0, packet.length, port, host);
+    } catch(e) {}
+  }
 
-        msg.version="1.0";
+  return function(loggingEvent) {
-        msg.timestamp = msg.timestamp || new Date().getTime() / 1000 >> 0;
+    var message = preparePacket(loggingEvent);
-        msg.host = hostname;
+    zlib.gzip(new Buffer(JSON.stringify(message)), function(err, packet) {
-        msg.level = levelMapping[loggingEvent.level || levels.DEBUG];
+      if (err) {
-        msg.facility = facility;
+        console.error(err.stack);
-        return msg;
+      } else {
-    }
+        if (packet.length > 8192) {
-
+          debug("Message packet length (" + packet.length + ") is larger than 8k. Not sending");
-    function sendPacket(packet) {
+        } else {
-        try {
+          sendPacket(packet);
-            client.send(packet, 0, packet.length, port, host);
+        }
-        } catch(e) {}
+      }
-    }
+    });
-
+  };
-    return function(loggingEvent) {
-        var message = preparePacket(loggingEvent);
-        zlib.gzip(new Buffer(JSON.stringify(message)), function(err, packet) {
-            if (err) {
-                console.error(err.stack);
-            } else {
-                if (packet.length > 8192) {
-                    util.debug("Message packet length (" + packet.length + ") is larger than 8k. Not sending");
-                } else {
-                    sendPacket(packet);
-                }
-            }
-        });
-    };
 }
 
 function configure(config) {
-    var layout;
+  var layout;
-    if (config.layout) {
+  if (config.layout) {
-        layout = layouts.layout(config.layout.type, config.layout);
+    layout = layouts.layout(config.layout.type, config.layout);
-    }
+  }
-    return gelfAppender(layout, config.host, config.port, config.hostname, config.facility);
+  return gelfAppender(layout, config);
 }
 
 exports.appender = gelfAppender;

lib/appenders/hookio.js

@@ -1,75 +0,0 @@
-var log4js = require('../log4js');
-var layouts = require('../layouts');
-var Hook = require('hook.io').Hook;
-var util = require('util');
-
-var Logger = function createLogger(options) {
-  var self = this;
-  var actualAppender = options.actualAppender;
-  Hook.call(self, options);
-  self.on('hook::ready', function hookReady() {
-    self.on('*::' + options.name + '::log', function log(loggingEvent) {
-      deserializeLoggingEvent(loggingEvent);
-      actualAppender(loggingEvent);
-    });
-  });
-}
-util.inherits(Logger, Hook);
-
-function deserializeLoggingEvent(loggingEvent) {
-  loggingEvent.startTime = new Date(loggingEvent.startTime);
-  loggingEvent.level.toString = function levelToString() {
-    return loggingEvent.level.levelStr;
-  };
-}
-
-function initHook(hookioOptions) {
-  var loggerHook;
-  if (hookioOptions.mode === 'master') {
-    // Start the master hook, handling the actual logging
-    loggerHook = new Logger(hookioOptions);
-  } else {
-    // Start a worker, just emitting events for a master
-    loggerHook = new Hook(hookioOptions);
-  }
-  loggerHook.start();
-  return loggerHook;
-}
-
-function getBufferedHook(hook, eventName) {
-  var hookBuffer = [];
-  var hookReady = false;
-  hook.on('hook::ready', function emptyBuffer() {
-    hookBuffer.forEach(function logBufferItem(loggingEvent) {
-      hook.emit(eventName, loggingEvent);
-    })
-    hookReady = true;
-  });
-
-  return function log(loggingEvent) {
-    if (hookReady) {
-      hook.emit(eventName, loggingEvent);
-    } else {
-      hookBuffer.push(loggingEvent);
-    }
-  }
-}
-
-function createAppender(hookioOptions) {
-  var loggerHook = initHook(hookioOptions);
-  var loggerEvent = hookioOptions.name + '::log';
-  return getBufferedHook(loggerHook, loggerEvent);
-}
-
-function configure(config) {
-  var actualAppender;
-  if (config.appender && config.mode === 'master') {
-    log4js.loadAppender(config.appender.type);
-    actualAppender = log4js.appenderMakers[config.appender.type](config.appender);
-    config.actualAppender = actualAppender;
-  }
-  return createAppender(config);
-}
-
-exports.appender = createAppender;
-exports.configure = configure;

lib/appenders/logLevelFilter.js

@@ -1,19 +1,20 @@
-var levels = require('../levels');
+"use strict";
-var log4js = require('../log4js');
+var levels = require('../levels')
+, log4js = require('../log4js');
 
 function logLevelFilter (levelString, appender) {
-    var level = levels.toLevel(levelString);
+  var level = levels.toLevel(levelString);
-    return function(logEvent) {
+  return function(logEvent) {
-	if (logEvent.level.isGreaterThanOrEqualTo(level)) {
+    if (logEvent.level.isGreaterThanOrEqualTo(level)) {
-	    appender(logEvent);
+      appender(logEvent);
-	}
     }
+  };
 }
 
 function configure(config) {
-    log4js.loadAppender(config.appender.type);
+  log4js.loadAppender(config.appender.type);
-    var appender = log4js.appenderMakers[config.appender.type](config.appender);
+  var appender = log4js.appenderMakers[config.appender.type](config.appender);
-    return logLevelFilter(config.level, appender);
+  return logLevelFilter(config.level, appender);
 }
 
 exports.appender = logLevelFilter;

lib/appenders/loggly.js

@@ -0,0 +1,44 @@
+'use strict';
+var layouts = require('../layouts')
+, loggly = require('loggly')
+, os = require('os')
+, passThrough = layouts.messagePassThroughLayout;
+
+
+/**
+ * Loggly Appender. Sends logging events to Loggly using node-loggly 
+ *
+ * @param config object with loggly configuration data
+ * {
+ *   token: 'your-really-long-input-token',
+ *   subdomain: 'your-subdomain',
+ *   tags: ['loggly-tag1', 'loggly-tag2', .., 'loggly-tagn'] 
+ * }
+ * @param layout a function that takes a logevent and returns a string (defaults to objectLayout).
+ */
+function logglyAppender(config, layout) {
+	var client = loggly.createClient(config);
+  if(!layout) layout = passThrough;
+
+  return function(loggingEvent) {
+		var msg = layout(loggingEvent);
+		client.log({
+			msg: msg,
+			level: loggingEvent.level.levelStr,
+			category: loggingEvent.categoryName,
+			hostname: os.hostname().toString(),
+		});
+  }
+}
+
+function configure(config) {
+	var layout;
+	if (config.layout) {
+		layout = layouts.layout(config.layout.type, config.layout);
+	}
+	return logglyAppender(config, layout);
+}
+
+exports.name      = 'loggly';
+exports.appender  = logglyAppender;
+exports.configure = configure;

lib/appenders/multiprocess.js

@@ -1,6 +1,7 @@
-var log4js = require('../log4js'),
+"use strict";
-    net = require('net'),
+var log4js = require('../log4js')
-    END_MSG = '__LOG4JS__';
+, net = require('net')
+, END_MSG = '__LOG4JS__';
 
 /**
  * Creates a server, listening on config.loggerPort, config.loggerHost.
@@ -8,120 +9,125 @@ var log4js = require('../log4js'),
  * set up that appender).
  */
 function logServer(config) {
-
+  
-    /**
+  /**
-     * Takes a utf-8 string, returns an object with
+   * Takes a utf-8 string, returns an object with
-     * the correct log properties.
+   * the correct log properties.
-     */
+   */
-    function deserializeLoggingEvent(clientSocket, msg) {
+  function deserializeLoggingEvent(clientSocket, msg) {
-        var loggingEvent;
+    var loggingEvent;
-        try {
+    try {
-          loggingEvent = JSON.parse(msg);
+      loggingEvent = JSON.parse(msg);
-          loggingEvent.startTime = new Date(loggingEvent.startTime);
+      loggingEvent.startTime = new Date(loggingEvent.startTime);
-	        loggingEvent.level = log4js.levels.toLevel(loggingEvent.level.levelStr);
+      loggingEvent.level = log4js.levels.toLevel(loggingEvent.level.levelStr);
-        } catch (e) {
+    } catch (e) {
-            // JSON.parse failed, just log the contents probably a naughty.
+      // JSON.parse failed, just log the contents probably a naughty.
-            loggingEvent = {
+      loggingEvent = {
-                startTime: new Date(),
+        startTime: new Date(),
-                categoryName: 'log4js',
+        categoryName: 'log4js',
-                level: log4js.levels.ERROR,
+        level: log4js.levels.ERROR,
-                data: [ 'Unable to parse log:', msg ]
+        data: [ 'Unable to parse log:', msg ]
-            };
+      };
-        }
-
-        loggingEvent.remoteAddress = clientSocket.remoteAddress;
-        loggingEvent.remotePort = clientSocket.remotePort;
-
-        return loggingEvent;
     }
 
-    var actualAppender = config.actualAppender,
+    loggingEvent.remoteAddress = clientSocket.remoteAddress;
-        server = net.createServer(function serverCreated(clientSocket) {
+    loggingEvent.remotePort = clientSocket.remotePort;
-            clientSocket.setEncoding('utf8');
+    
-            var logMessage = '';
+    return loggingEvent;
-
+  }
-            function logTheMessage(msg) {
+  
-                if (logMessage.length > 0) {
+  var actualAppender = config.actualAppender,
-                    actualAppender(deserializeLoggingEvent(clientSocket, msg));
+  server = net.createServer(function serverCreated(clientSocket) {
-                }
+    clientSocket.setEncoding('utf8');
-            }
+    var logMessage = '';
-
+    
-            function chunkReceived(chunk) {
+    function logTheMessage(msg) {
-                var event;
+      if (logMessage.length > 0) {
-                logMessage += chunk || '';
+        actualAppender(deserializeLoggingEvent(clientSocket, msg));
-                if (logMessage.indexOf(END_MSG) > -1) {
+      }
-                    event = logMessage.substring(0, logMessage.indexOf(END_MSG));
+    }
-                    logTheMessage(event);
+    
-                    logMessage = logMessage.substring(event.length + END_MSG.length) || '';
+    function chunkReceived(chunk) {
-                    //check for more, maybe it was a big chunk
+      var event;
-                    chunkReceived();
+      logMessage += chunk || '';
-                }
+      if (logMessage.indexOf(END_MSG) > -1) {
-            }
+        event = logMessage.substring(0, logMessage.indexOf(END_MSG));
-
+        logTheMessage(event);
-            clientSocket.on('data', chunkReceived);
+        logMessage = logMessage.substring(event.length + END_MSG.length) || '';
-            clientSocket.on('end', chunkReceived);
+        //check for more, maybe it was a big chunk
-        });
+        chunkReceived();
-        
+      }
-    server.listen(config.loggerPort || 5000, config.loggerHost || 'localhost');
+    }
-
+    
-    return actualAppender;
+    clientSocket.on('data', chunkReceived);
+    clientSocket.on('end', chunkReceived);
+  });
+  
+  server.listen(config.loggerPort || 5000, config.loggerHost || 'localhost');
+  
+  return actualAppender;
 }
 
 function workerAppender(config) {
-    var canWrite = false,
+  var canWrite = false,
-        buffer = [],
+  buffer = [],
-        socket;
+  socket;
-
+  
-    createSocket();
+  createSocket();
-
+  
-    function createSocket() {
+  function createSocket() {
-        socket = net.createConnection(config.loggerPort || 5000, config.loggerHost || 'localhost');
+    socket = net.createConnection(config.loggerPort || 5000, config.loggerHost || 'localhost');
-        socket.on('connect', function() {
+    socket.on('connect', function() {
-            emptyBuffer();
+      emptyBuffer();
-            canWrite = true;
+      canWrite = true;
-        });
+    });
-        socket.on('timeout', socket.end.bind(socket));
+    socket.on('timeout', socket.end.bind(socket));
-        //don't bother listening for 'error', 'close' gets called after that anyway
+    //don't bother listening for 'error', 'close' gets called after that anyway
-        socket.on('close', createSocket);
+    socket.on('close', createSocket);
+  }
+  
+  function emptyBuffer() {
+    var evt;
+    while ((evt = buffer.shift())) {
+      write(evt);
     }
-
+  }
-    function emptyBuffer() {
+  
-        var evt;
+  function write(loggingEvent) {
-        while ((evt = buffer.shift())) {
+	// JSON.stringify(new Error('test')) returns {}, which is not really useful for us.
-            write(evt);
+	// The following allows us to serialize errors correctly.
-        }
+	if (loggingEvent && loggingEvent.stack && JSON.stringify(loggingEvent) === '{}') { // Validate that we really are in this case
+		loggingEvent = {stack : loggingEvent.stack};
+	}
+    socket.write(JSON.stringify(loggingEvent), 'utf8');
+    socket.write(END_MSG, 'utf8');
+  }
+  
+  return function log(loggingEvent) {
+    if (canWrite) {
+      write(loggingEvent);
+    } else {
+      buffer.push(loggingEvent);
     }
-
+  };
-    function write(loggingEvent) {
-        socket.write(JSON.stringify(loggingEvent), 'utf8');
-        socket.write(END_MSG, 'utf8');
-    }
-
-    return function log(loggingEvent) {
-        if (canWrite) {
-            write(loggingEvent);
-        } else {
-            buffer.push(loggingEvent);
-        }
-    };
 }
 
 function createAppender(config) {
-    if (config.mode === 'master') {
+  if (config.mode === 'master') {
-        return logServer(config);
+    return logServer(config);
-    } else {
+  } else {
-        return workerAppender(config);
+    return workerAppender(config);
-    }
+  }
 }
 
 function configure(config, options) {
-    var actualAppender;
+  var actualAppender;
-    if (config.appender && config.mode === 'master') {
+  if (config.appender && config.mode === 'master') {
-        log4js.loadAppender(config.appender.type);
+    log4js.loadAppender(config.appender.type);
-        actualAppender = log4js.appenderMakers[config.appender.type](config.appender, options);
+    actualAppender = log4js.appenderMakers[config.appender.type](config.appender, options);
-        config.actualAppender = actualAppender;
+    config.actualAppender = actualAppender;
-    }
+  }
-    return createAppender(config);
+  return createAppender(config);
 }
 
 exports.appender = createAppender;

lib/appenders/smtp.js

@@ -1,14 +1,17 @@
-var layouts = require("../layouts"),
+"use strict";
-	mailer = require("nodemailer"),
+var layouts = require("../layouts")
-	os = require('os');
+, mailer = require("nodemailer")
+, os = require('os');
 
 /**
 * SMTP Appender. Sends logging events using SMTP protocol. 
-* It can either send an email on each event or group several logging events gathered during specified interval.
+* It can either send an email on each event or group several 
+* logging events gathered during specified interval.
 *
 * @param config appender configuration data
+*    config.sendInterval time between log emails (in seconds), if 0
+*    then every event sends an email
 * @param layout a function that takes a logevent and returns a string (defaults to basicLayout).
-* all events are buffered and sent in one email during this time; if 0 than every event sends an email
 */
 function smtpAppender(config, layout) {
 	layout = layout || layouts.basicLayout;
@@ -17,47 +20,51 @@ function smtpAppender(config, layout) {
 	
 	var logEventBuffer = [];
 	var sendTimer;
-	var transport = mailer.createTransport(config.transport, config[config.transport]);
 	
 	function sendBuffer() {
-		if (logEventBuffer.length == 0)
+    if (logEventBuffer.length > 0) {
-			return;
 		
-		var firstEvent = logEventBuffer[0];
+      var transport = mailer.createTransport(config.transport, config[config.transport]);
-		var body = "";
+      var firstEvent = logEventBuffer[0];
-		while (logEventBuffer.length > 0) {
+      var body = "";
-			body += layout(logEventBuffer.shift()) + "\n";
+      while (logEventBuffer.length > 0) {
-		}
+        body += layout(logEventBuffer.shift()) + "\n";
-		
+      }
-		var msg = {
+
-				to: config.recipients,
+      var msg = {
-				subject: config.subject || subjectLayout(firstEvent),
+        to: config.recipients,
-				text: body,
+        subject: config.subject || subjectLayout(firstEvent),
-				headers: {"Hostname": os.hostname()}
+        text: body,
-			};
+        headers: { "Hostname": os.hostname() }
-		if (config.sender)
+      };
-			msg.from = config.sender;
+      if (config.sender) {
-		transport.sendMail(msg, function(error, success) {
+        msg.from = config.sender;
-			if (error) {
+      }
-				console.error("log4js.smtpAppender - Error happened ", error);
+      transport.sendMail(msg, function(error, success) {
-			}
+        if (error) {
-		});
+          console.error("log4js.smtpAppender - Error happened", error);
+        }
+        transport.close();
+      });
+    }
 	}
 	
 	function scheduleSend() {
-		if (!sendTimer)
+		if (!sendTimer) {
 			sendTimer = setTimeout(function() {
 				sendTimer = null; 
 				sendBuffer();
 			}, sendInterval);
+    }
 	}
 	
 	return function(loggingEvent) {
 		logEventBuffer.push(loggingEvent);
-		if (sendInterval > 0)
+		if (sendInterval > 0) {
 			scheduleSend();
-		else
+		} else {
 			sendBuffer();
+    }
 	};
 }
 

lib/connect-logger.js

@@ -1,11 +1,16 @@
+"use strict";
 var levels = require("./levels");
+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.
  *
  * Options:
  *
  *   - `format`        Format string, see below for tokens
- *   - `level`         A log4js levels instance.
+ *   - `level`         A log4js levels instance. Supports also 'auto'
  *
  * Tokens:
  *
@@ -27,63 +32,78 @@ var levels = require("./levels");
  */
 
 function getLogger(logger4js, options) {
-    if ('object' == typeof options) {
+	if ('object' == typeof options) {
-	options = options || {};
+		options = options || {};
-    } else if (options) {
+	} else if (options) {
-	options = { format: options };
+		options = { format: options };
-    } else {
+	} else {
-	options = {};
+		options = {};
-    }
-
-    var thislogger = logger4js
-  , level = levels.toLevel(options.level, levels.INFO)
-  , fmt = options.format || ':remote-addr - - ":method :url HTTP/:http-version" :status :content-length ":referrer" ":user-agent"'
-  , nolog = options.nolog ? createNoLogCondition(options.nolog) : null;
-
-    return function (req, res, next) {
-
-	// mount safety
-	if (req._logging) return next();
-
-        // nologs
-        if (nolog && nolog.test(req.originalUrl)) return next();
-
-	if (thislogger.isLevelEnabled(level)) {
-
-	    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;
-		res.writeHead(code, headers);
-		res.__statusCode = statusCode = code;
-		res.__headers = headers || {};
-	    };
-
-	    // proxy end to output a line to the provided logger.
-	    res.end = function(chunk, encoding) {
-		res.end = end;
-		res.end(chunk, encoding);
-		res.responseTime = +new Date - start;
-		if ('function' == typeof fmt) {
-		    var line = fmt(req, res, function(str){ return format(str, req, res); });
-		    if (line) thislogger.log(level, line);
-		} else {
-		    thislogger.log(level, format(fmt, req, res));
-		}
-	    };
 	}
 
-	//ensure next gets always called
+	var thislogger = logger4js
-	next();
+  , level = levels.toLevel(options.level, levels.INFO)
-    };
+  , fmt = options.format || DEFAULT_FORMAT
+  , nolog = options.nolog ? createNoLogCondition(options.nolog) : null;
+
+  return function (req, res, next) {
+    // mount safety
+    if (req._logging) return next();
+
+		// 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;
+				res.writeHead(code, headers);
+				res.__statusCode = statusCode = code;
+				res.__headers = headers || {};
+
+				//status code response level handling
+				if(options.level === 'auto'){
+					level = levels.INFO;
+					if(code >= 300) level = levels.WARN;
+					if(code >= 400) level = levels.ERROR;
+				} else {
+					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);
+				res.responseTime = new Date() - start;
+				//status code response level handling
+				if(res.statusCode && options.level === 'auto'){
+					level = levels.INFO;
+					if(res.statusCode >= 300) level = levels.WARN;
+					if(res.statusCode >= 400) level = levels.ERROR;
+				}
+				if (thislogger.isLevelEnabled(level)) {
+					if (typeof fmt === 'function') {
+						var line = fmt(req, res, function(str){ return format(str, req, res); });
+						if (line) thislogger.log(level, line);
+					} else {
+						thislogger.log(level, format(fmt, req, res));
+					}
+				}
+			};
+		}
+    
+    //ensure next gets always called
+    next();
+  };
 }
 
 /**
@@ -97,23 +117,32 @@ function getLogger(logger4js, options) {
  */
 
 function format(str, req, res) {
-    return str
+	return str
-      .replace(':url', req.originalUrl)
+    .replace(':url', req.originalUrl)
-	.replace(':method', req.method)
+    .replace(':method', req.method)
-	  .replace(':status', res.__statusCode || res.statusCode)
+    .replace(':status', res.__statusCode || res.statusCode)
-	    .replace(':response-time', res.responseTime)
+    .replace(':response-time', res.responseTime)
-	      .replace(':date', new Date().toUTCString())
+    .replace(':date', new Date().toUTCString())
-		.replace(':referrer', req.headers['referer'] || req.headers['referrer'] || '')
+    .replace(':referrer', req.headers.referer || req.headers.referrer || '')
-		  .replace(':http-version', req.httpVersionMajor + '.' + req.httpVersionMinor)
+    .replace(':http-version', req.httpVersionMajor + '.' + req.httpVersionMinor)
-		    .replace(':remote-addr', req.socket && (req.socket.remoteAddress || (req.socket.socket && req.socket.socket.remoteAddress)))
+    .replace(
-		      .replace(':user-agent', req.headers['user-agent'] || '')
+      ':remote-addr', req.ip || req._remoteAddress || ( 
-                        .replace(':content-length', (res._headers && res._headers['content-length']) || (res.__headers && res.__headers['Content-Length']) || '-')
+      req.socket && 
-		          .replace(/:req\[([^\]]+)\]/g, function(_, field){ return req.headers[field.toLowerCase()]; })
+        (req.socket.remoteAddress || (req.socket.socket && req.socket.socket.remoteAddress))
-		            .replace(/:res\[([^\]]+)\]/g, function(_, field){
+    ))
-		                return res._headers
+    .replace(':user-agent', req.headers['user-agent'] || '')
-			      ? (res._headers[field.toLowerCase()] || res.__headers[field])
+    .replace(
-			      : (res.__headers && res.__headers[field]);
+      ':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]);
+    });
 }
 
 /**
@@ -122,17 +151,17 @@ function format(str, req, res) {
  * @param  {String} nolog
  * @return {RegExp}
  * @api private
- */
+ *
-
-/**
  * syntax
  *  1. String
  *   1.1 "\\.gif"
  *         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 http://example.com/hoge.gif?fuga and http://example.com/hoge.jpg?fuga
+ *         NOT LOGGING http://example.com/hoge.gif and 
- *         LOGGING http://example.com/hoge.agif, http://example.com/hoge.ajpg and http://example.com/hoge.jpg?hoge
+ *           http://example.com/hoge.gif?fuga and http://example.com/hoge.jpg?fuga
+ *         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
  *         LOGGING http://example.com/hoge.gif?uid=2 and http://example.com/hoge.jpg?pid=3
@@ -143,26 +172,29 @@ function format(str, req, res) {
  *   3.1 ["\\.jpg$", "\\.png", "\\.gif"]
  *         SAME AS "\\.jpg|\\.png|\\.gif"
  */
-function createNoLogCondition(nolog, type) {
+function createNoLogCondition(nolog) {
-  if(!nolog) return null;
+  var regexp = null;
-  type = type || '';
 
-  if(nolog instanceof RegExp){
+	if (nolog) {
-    if(type === 'string')
+    if (nolog instanceof RegExp) {
-      return nolog.source;
+      regexp = nolog;
-    return nolog;
+    } 
-  } else if(typeof nolog === 'string'){
+    
-    if(type === 'string')
+    if (typeof nolog === 'string') {
-      return nolog;
+      regexp = new RegExp(nolog);
-    try{
+    }
-      return new RegExp(nolog);
+    
-    } catch (ex) {
+    if (Array.isArray(nolog)) {
-      return null;
+      var regexpsAsStrings = nolog.map(
+        function convertToStrings(o) { 
+          return o.source ? o.source : o;
+        }
+      );
+      regexp = new RegExp(regexpsAsStrings.join('|'));
     }
-  } else if(nolog instanceof Array){
-    var regexps = nolog.map(function(o){ return createNoLogCondition(o, 'string')});
-    return new RegExp(regexps.join('|'));
   }
+
+  return regexp;
 }
 
 exports.connectLogger = getLogger;

lib/date_format.js

@@ -1,60 +1,66 @@
+"use strict";
 exports.ISO8601_FORMAT = "yyyy-MM-dd hh:mm:ss.SSS";
 exports.ISO8601_WITH_TZ_OFFSET_FORMAT = "yyyy-MM-ddThh:mm:ssO";
 exports.DATETIME_FORMAT = "dd MM yyyy hh:mm:ss.SSS";
 exports.ABSOLUTETIME_FORMAT = "hh:mm:ss.SSS";
 
+function padWithZeros(vNumber, width) {
+  var numAsString = vNumber + "";
+  while (numAsString.length < width) {
+    numAsString = "0" + numAsString;
+  }
+  return numAsString;
+}
+  
+function addZero(vNumber) {
+  return padWithZeros(vNumber, 2);
+}
+
+/**
+ * Formats the TimeOffest
+ * Thanks to http://www.svendtofte.com/code/date_format/
+ * @private
+ */
+function offset(date) {
+  // Difference to Greenwich time (GMT) in hours
+  var os = Math.abs(date.getTimezoneOffset());
+  var h = String(Math.floor(os/60));
+  var m = String(os%60);
+  if (h.length == 1) {
+    h = "0" + h;
+  }
+  if (m.length == 1) {
+    m = "0" + m;
+  }
+  return date.getTimezoneOffset() < 0 ? "+"+h+m : "-"+h+m;
+}
+
 exports.asString = function(/*format,*/ date) {
-    var format = exports.ISO8601_FORMAT;
+  var format = exports.ISO8601_FORMAT;
-    if (typeof(date) === "string") {
+  if (typeof(date) === "string") {
-        format = arguments[0];
+    format = arguments[0];
-        date = arguments[1];
+    date = arguments[1];
-    }
+  }
 
-    var vDay = addZero(date.getDate());
+  var vDay = addZero(date.getDate());
-    var vMonth = addZero(date.getMonth()+1);
+  var vMonth = addZero(date.getMonth()+1);
-    var vYearLong = addZero(date.getFullYear());
+  var vYearLong = addZero(date.getFullYear());
-    var vYearShort = addZero(date.getFullYear().toString().substring(3,4));
+  var vYearShort = addZero(date.getFullYear().toString().substring(2,4));
-    var vYear = (format.indexOf("yyyy") > -1 ? vYearLong : vYearShort);
+  var vYear = (format.indexOf("yyyy") > -1 ? vYearLong : vYearShort);
-    var vHour  = addZero(date.getHours());
+  var vHour  = addZero(date.getHours());
-    var vMinute = addZero(date.getMinutes());
+  var vMinute = addZero(date.getMinutes());
-    var vSecond = addZero(date.getSeconds());
+  var vSecond = addZero(date.getSeconds());
-    var vMillisecond = padWithZeros(date.getMilliseconds(), 3);
+  var vMillisecond = padWithZeros(date.getMilliseconds(), 3);
-    var vTimeZone = offset(date);
+  var vTimeZone = offset(date);
-    var formatted = format
+  var formatted = format
-                      .replace(/dd/g, vDay)
+    .replace(/dd/g, vDay)
-                      .replace(/MM/g, vMonth)
+    .replace(/MM/g, vMonth)
-                      .replace(/y{1,4}/g, vYear)
+    .replace(/y{1,4}/g, vYear)
-                      .replace(/hh/g, vHour)
+    .replace(/hh/g, vHour)
-                      .replace(/mm/g, vMinute)
+    .replace(/mm/g, vMinute)
-                      .replace(/ss/g, vSecond)
+    .replace(/ss/g, vSecond)
-                      .replace(/SSS/g, vMillisecond)
+    .replace(/SSS/g, vMillisecond)
-                      .replace(/O/g, vTimeZone);
+    .replace(/O/g, vTimeZone);
-    return formatted;
+  return formatted;
 
-    function padWithZeros(vNumber, width) {
-	var numAsString = vNumber + "";
-	while (numAsString.length < width) {
-	    numAsString = "0" + numAsString;
-	}
-	return numAsString;
-    }
-
-    function addZero(vNumber) {
-	return padWithZeros(vNumber, 2);
-    }
-
-    /**
-     * Formats the TimeOffest
-     * Thanks to http://www.svendtofte.com/code/date_format/
-     * @private
-     */
-    function offset(date) {
-	// Difference to Greenwich time (GMT) in hours
-	var os = Math.abs(date.getTimezoneOffset());
-	var h = String(Math.floor(os/60));
-	var m = String(os%60);
-	h.length == 1? h = "0"+h:1;
-	m.length == 1? m = "0"+m:1;
-	return date.getTimezoneOffset() < 0 ? "+"+h+m : "-"+h+m;
-    }
 };

lib/debug.js

@@ -0,0 +1,15 @@
+"use strict";
+
+module.exports = function(label) {
+  var debug;
+
+  if (process.env.NODE_DEBUG && /\blog4js\b/.test(process.env.NODE_DEBUG)) {
+    debug = function(message) { 
+      console.error('LOG4JS: (%s) %s', label, message); 
+    };
+  } else {
+    debug = function() { };
+  }
+
+  return debug;
+};

lib/layouts.js

@@ -1,106 +1,87 @@
+"use strict";
 var dateFormat = require('./date_format')
-  , os = require('os')
+, os = require('os')
-  , eol = os.EOL || '\n'
+, eol = os.EOL || '\n'
-  , util = require('util')
+, util = require('util')
-  , replacementRegExp = /%[sdj]/g
+, replacementRegExp = /%[sdj]/g
-  , layoutMakers = {
+, layoutMakers = {
-      "messagePassThrough": function() { return messagePassThroughLayout; }
+  "messagePassThrough": function() { return messagePassThroughLayout; }, 
-    , "basic": function() { return basicLayout; }
+  "basic": function() { return basicLayout; }, 
-    , "colored": function() { return colouredLayout; }
+  "colored": function() { return colouredLayout; }, 
-    , "coloured": function() { return colouredLayout; }
+  "coloured": function() { return colouredLayout; }, 
-    , "pattern": function (config) {
+  "pattern": function (config) {
-	  var pattern = config.pattern || undefined;
+    return patternLayout(config && config.pattern, config && config.tokens);
-	  var tokens = config.tokens || undefined;
-	  return patternLayout(pattern, tokens);
 	}
-  }
+}
-  , colours = {
+, colours = {
-      ALL: "grey"
+  ALL: "grey", 
-    , TRACE: "blue"
+  TRACE: "blue", 
-    , DEBUG: "cyan"
+  DEBUG: "cyan", 
-    , INFO: "green"
+  INFO: "green", 
-    , WARN: "yellow"
+  WARN: "yellow", 
-    , ERROR: "red"
+  ERROR: "red", 
-    , FATAL: "magenta"
+  FATAL: "magenta", 
-    , OFF: "grey"
+  OFF: "grey"
-  };
+};
+
+function wrapErrorsWithInspect(items) {
+  return items.map(function(item) {
+    if ((item instanceof Error) && item.stack) {
+      return { inspect: function() { return util.format(item) + '\n' + item.stack; } };
+    } else {
+      return item;
+    }
+  });
+}
 
 function formatLogData(logData) {
-    var output = ""
+  var data = Array.isArray(logData) ? logData : Array.prototype.slice.call(arguments);
-      , data = Array.isArray(logData) ? logData.slice() : Array.prototype.slice.call(arguments)
+  return util.format.apply(util, wrapErrorsWithInspect(data));
-      , format = data.shift();
-
-    if (typeof format  === "string") {
-        output = format.replace(replacementRegExp, function(match) {
-            switch (match) {
-            case "%s": return new String(data.shift());
-            case "%d": return new Number(data.shift());
-            case "%j": return JSON.stringify(data.shift());
-            default:
-                return match;
-            };
-        });
-    } else {
-        //put it back, it's not a format string
-        data.unshift(format);
-    }
-
-    data.forEach(function (item) {
-        if (output) {
-            output += ' ';
-        }
-        output += util.inspect(item);
-        if (item && item.stack) {
-            output += "\n" + item.stack;
-        }
-    });
-
-    return output;
 }
 
 var styles = {
     //styles
-    'bold'      : [1,  22],
+  'bold'      : [1,  22],
-    'italic'    : [3,  23],
+  'italic'    : [3,  23],
-    'underline' : [4,  24],
+  'underline' : [4,  24],
-    'inverse'   : [7,  27],
+  'inverse'   : [7,  27],
-    //grayscale
+  //grayscale
-    'white'     : [37, 39],
+  'white'     : [37, 39],
-    'grey'      : [90, 39],
+  'grey'      : [90, 39],
-    'black'     : [90, 39],
+  'black'     : [90, 39],
-    //colors
+  //colors
-    'blue'      : [34, 39],
+  'blue'      : [34, 39],
-    'cyan'      : [36, 39],
+  'cyan'      : [36, 39],
-    'green'     : [32, 39],
+  'green'     : [32, 39],
-    'magenta'   : [35, 39],
+  'magenta'   : [35, 39],
-    'red'       : [31, 39],
+  'red'       : [31, 39],
-    'yellow'    : [33, 39]
+  'yellow'    : [33, 39]
 };
 
 function colorizeStart(style) {
-  return style ? '\033[' + styles[style][0] + 'm' : '';
+  return style ? '\x1B[' + styles[style][0] + 'm' : '';
 }
 function colorizeEnd(style) {
-  return style ? '\033[' + styles[style][1] + 'm' : '';
+  return style ? '\x1B[' + styles[style][1] + 'm' : '';
 }
 /**
  * Taken from masylum's fork (https://github.com/masylum/log4js-node)
  */
 function colorize (str, style) {
-    return colorizeStart(style) + str + colorizeEnd(style);
+  return colorizeStart(style) + str + colorizeEnd(style);
 }
 
 function timestampLevelAndCategory(loggingEvent, colour) {
-    var output = colorize(
+  var output = colorize(
-        formatLogData(
+    formatLogData(
-            '[%s] [%s] %s - '
+      '[%s] [%s] %s - '
-          , dateFormat.asString(loggingEvent.startTime)
+      , dateFormat.asString(loggingEvent.startTime)
-          , loggingEvent.level
+      , loggingEvent.level
-          , loggingEvent.categoryName
+      , loggingEvent.categoryName
-        )
+    )
-      , colour
+    , colour
-    );
+  );
-    return output;
+  return output;
 }
 
 /**
@@ -113,7 +94,7 @@ function timestampLevelAndCategory(loggingEvent, colour) {
  * @author Stephan Strittmatter
  */
 function basicLayout (loggingEvent) {
-    return timestampLevelAndCategory(loggingEvent) + formatLogData(loggingEvent.data);
+  return timestampLevelAndCategory(loggingEvent) + formatLogData(loggingEvent.data);
 }
 
 /**
@@ -121,11 +102,14 @@ function basicLayout (loggingEvent) {
  * same as basicLayout, but with colours.
  */
 function colouredLayout (loggingEvent) {
-    return timestampLevelAndCategory(loggingEvent, colours[loggingEvent.level.toString()]) + formatLogData(loggingEvent.data);
+  return timestampLevelAndCategory(
+    loggingEvent,
+    colours[loggingEvent.level.toString()]
+  ) + formatLogData(loggingEvent.data);
 }
 
 function messagePassThroughLayout (loggingEvent) {
-    return formatLogData(loggingEvent.data);
+  return formatLogData(loggingEvent.data);
 }
 
 /**
@@ -136,10 +120,12 @@ function messagePassThroughLayout (loggingEvent) {
  *  - %r time in toLocaleTimeString format
  *  - %p log level
  *  - %c log category
+ *  - %h hostname
  *  - %m log data
  *  - %d date in various formats
  *  - %% %
  *  - %n newline
+ *  - %z pid
  *  - %x{<tokenname>} add dynamic tokens to your log. Tokens are specified in the tokens parameter
  * You can use %[ and %] to define a colored block.
  *
@@ -158,140 +144,181 @@ function messagePassThroughLayout (loggingEvent) {
  * @author Jan Schmidle
  */
 function patternLayout (pattern, tokens) {
-    var TTCC_CONVERSION_PATTERN  = "%r %p %c - %m%n";
+  var TTCC_CONVERSION_PATTERN  = "%r %p %c - %m%n";
-    var regex = /%(-?[0-9]+)?(\.?[0-9]+)?([\[\]cdmnprx%])(\{([^\}]+)\})?|([^%]+)/;
+  var regex = /%(-?[0-9]+)?(\.?[0-9]+)?([\[\]cdhmnprzx%])(\{([^\}]+)\})?|([^%]+)/;
+  
+  pattern = pattern || TTCC_CONVERSION_PATTERN;
 
-    pattern = pattern || TTCC_CONVERSION_PATTERN;
+  function categoryName(loggingEvent, specifier) {
+    var loggerName = loggingEvent.categoryName;
+    if (specifier) {
+      var precision = parseInt(specifier, 10);
+      var loggerNameBits = loggerName.split(".");
+      if (precision < loggerNameBits.length) {
+        loggerName = loggerNameBits.slice(loggerNameBits.length - precision).join(".");
+      }
+    }
+    return loggerName;
+  }
 
-    return function(loggingEvent) {
+  function formatAsDate(loggingEvent, specifier) {
-	var formattedString = "";
+    var format = dateFormat.ISO8601_FORMAT;
-	var result;
+    if (specifier) {
-	var searchString = pattern;
+      format = specifier;
+      // Pick up special cases
+      if (format == "ISO8601") {
+        format = dateFormat.ISO8601_FORMAT;
+      } else if (format == "ISO8601_WITH_TZ_OFFSET") {
+        format = dateFormat.ISO8601_WITH_TZ_OFFSET_FORMAT; 
+      } else if (format == "ABSOLUTE") {
+        format = dateFormat.ABSOLUTETIME_FORMAT;
+      } else if (format == "DATE") {
+        format = dateFormat.DATETIME_FORMAT;
+      }
+    }
+    // Format the date
+    return dateFormat.asString(format, loggingEvent.startTime);
+  }
+  
+  function hostname() {
+    return os.hostname().toString();
+  }
 
-	while ((result = regex.exec(searchString))) {
+  function formatMessage(loggingEvent) {
-	    var matchedString = result[0];
+    return formatLogData(loggingEvent.data);
-	    var padding = result[1];
+  }
-	    var truncation = result[2];
+  
-	    var conversionCharacter = result[3];
+  function endOfLine() {
-	    var specifier = result[5];
+    return eol;
-	    var text = result[6];
+  }
 
-	    // Check if the pattern matched was just normal text
+  function logLevel(loggingEvent) {
-	    if (text) {
+    return loggingEvent.level.toString();
-		formattedString += "" + text;
+  }
-	    } else {
-		// Create a raw replacement string based on the conversion
-		// character and specifier
-		var replacement = "";
-		switch(conversionCharacter) {
-		case "c":
-		    var loggerName = loggingEvent.categoryName;
-		    if (specifier) {
-			var precision = parseInt(specifier, 10);
-			var loggerNameBits = loggingEvent.categoryName.split(".");
-			if (precision >= loggerNameBits.length) {
-			    replacement = loggerName;
-			} else {
-			    replacement = loggerNameBits.slice(loggerNameBits.length - precision).join(".");
-			}
-		    } else {
-			replacement = loggerName;
-		    }
-		    break;
-		case "d":
-		    var format = dateFormat.ISO8601_FORMAT;
-		    if (specifier) {
-			format = specifier;
-			// Pick up special cases
-			if (format == "ISO8601") {
-			    format = dateFormat.ISO8601_FORMAT;
-			} else if (format == "ABSOLUTE") {
-			    format = dateFormat.ABSOLUTETIME_FORMAT;
-			} else if (format == "DATE") {
-			    format = dateFormat.DATETIME_FORMAT;
-			}
-		    }
-		    // Format the date
-		    replacement = dateFormat.asString(format, loggingEvent.startTime);
-		    break;
-		case "m":
-		    replacement = formatLogData(loggingEvent.data);
-		    break;
-		case "n":
-		    replacement = eol;
-		    break;
-		case "p":
-		    replacement = loggingEvent.level.toString();
-		    break;
-		case "r":
-		    replacement = "" + loggingEvent.startTime.toLocaleTimeString();
-		    break;
-		case "[":
-		    replacement = colorizeStart(colours[loggingEvent.level.toString()]);
-		    break;
-		case "]":
-		    replacement = colorizeEnd(colours[loggingEvent.level.toString()]);
-		    break;
-		case "%":
-		    replacement = "%";
-		    break;
-		case "x":
-			if(typeof(tokens[specifier]) !== 'undefined') {
-				if(typeof(tokens[specifier]) === 'function') {
-					replacement = tokens[specifier]();
-				} else {
-					replacement = tokens[specifier];
-				}
-			} else {
-				replacement = matchedString;
-			}
-			break;
-		default:
-		    replacement = matchedString;
-		    break;
-		}
-		// Format the replacement according to any padding or
-		// truncation specified
 
-		var len;
+  function startTime(loggingEvent) {
+    return "" + loggingEvent.startTime.toLocaleTimeString();
+  }
 
-		// First, truncation
+  function startColour(loggingEvent) {
-		if (truncation) {
+    return colorizeStart(colours[loggingEvent.level.toString()]);
-		    len = parseInt(truncation.substr(1), 10);
+  }
-		    replacement = replacement.substring(0, len);
-		}
-		// Next, padding
-		if (padding) {
-		    if (padding.charAt(0) == "-") {
-			len = parseInt(padding.substr(1), 10);
-			// Right pad with spaces
-			while (replacement.length < len) {
-			    replacement += " ";
-			}
-		    } else {
-			len = parseInt(padding, 10);
-			// Left pad with spaces
-			while (replacement.length < len) {
-			    replacement = " " + replacement;
-			}
-		    }
-		}
-		formattedString += replacement;
-	    }
-	    searchString = searchString.substr(result.index + result[0].length);
-	}
-	return formattedString;
-    };
 
-};
+  function endColour(loggingEvent) {
+    return colorizeEnd(colours[loggingEvent.level.toString()]);
+  }
+
+  function percent() {
+    return '%';
+  }
+
+  function pid() {
+    return process.pid;
+  }
+
+  function userDefined(loggingEvent, specifier) {
+    if (typeof(tokens[specifier]) !== 'undefined') {
+      if (typeof(tokens[specifier]) === 'function') {
+        return tokens[specifier](loggingEvent);
+      } else {
+        return tokens[specifier];
+      }
+    }
+    return null;
+  }
+
+  var replacers = {
+    'c': categoryName,
+    'd': formatAsDate,
+    'h': hostname,
+    'm': formatMessage,
+    'n': endOfLine,
+    'p': logLevel,
+    'r': startTime,
+    '[': startColour,
+    ']': endColour,
+    'z': pid,
+    '%': percent,
+    'x': userDefined
+  };
+
+  function replaceToken(conversionCharacter, loggingEvent, specifier) {
+    return replacers[conversionCharacter](loggingEvent, specifier);
+  }
+
+  function truncate(truncation, toTruncate) {
+    var len;
+    if (truncation) {
+      len = parseInt(truncation.substr(1), 10);
+      return toTruncate.substring(0, len);
+    }
+
+    return toTruncate;
+  }
+
+  function pad(padding, toPad) {
+    var len;
+    if (padding) {
+      if (padding.charAt(0) == "-") {
+        len = parseInt(padding.substr(1), 10);
+        // Right pad with spaces
+        while (toPad.length < len) {
+          toPad += " ";
+        }
+      } else {
+        len = parseInt(padding, 10);
+        // Left pad with spaces
+        while (toPad.length < len) {
+          toPad = " " + toPad;
+        }
+      }
+    }
+    return toPad;
+  }
+  
+  return function(loggingEvent) {
+    var formattedString = "";
+    var result;
+    var searchString = pattern;
+    
+    while ((result = regex.exec(searchString))) {
+      var matchedString = result[0];
+      var padding = result[1];
+      var truncation = result[2];
+      var conversionCharacter = result[3];
+      var specifier = result[5];
+      var text = result[6];
+      
+      // Check if the pattern matched was just normal text
+      if (text) {
+        formattedString += "" + text;
+      } else {
+        // Create a raw replacement string based on the conversion
+        // character and specifier
+        var replacement = 
+          replaceToken(conversionCharacter, loggingEvent, specifier) || 
+          matchedString;
+
+        // Format the replacement according to any padding or
+        // truncation specified
+        replacement = truncate(truncation, replacement);
+        replacement = pad(padding, replacement);
+        formattedString += replacement;
+      }
+      searchString = searchString.substr(result.index + result[0].length);
+    }
+    return formattedString;
+  };
+
+}
 
 module.exports = {
-    basicLayout: basicLayout
+  basicLayout: basicLayout, 
-  , messagePassThroughLayout: messagePassThroughLayout
+  messagePassThroughLayout: messagePassThroughLayout, 
-  , patternLayout: patternLayout
+  patternLayout: patternLayout, 
-  , colouredLayout: colouredLayout
+  colouredLayout: colouredLayout, 
-  , coloredLayout: colouredLayout
+  coloredLayout: colouredLayout, 
-  , layout: function(name, config) {
+  layout: function(name, config) {
-        return layoutMakers[name] && layoutMakers[name](config);
+    return layoutMakers[name] && layoutMakers[name](config);
-    }
+  }
 };

lib/levels.js

@@ -1,6 +1,8 @@
+"use strict";
+
 function Level(level, levelStr) {
-    this.level = level;
+  this.level = level;
-    this.levelStr = levelStr;
+  this.levelStr = levelStr;
 }
 
 /**
@@ -13,55 +15,54 @@ function Level(level, levelStr) {
 function toLevel(sArg, defaultLevel) {
 
   if (!sArg) {
-      return defaultLevel;
+    return defaultLevel;
   }
 
   if (typeof sArg == "string") {
-      var s = sArg.toUpperCase();
+    var s = sArg.toUpperCase();
-      if (module.exports[s]) {
+    if (module.exports[s]) {
-	  return module.exports[s];
+      return module.exports[s];
-      } else {
+    } else {
-	  return defaultLevel;
+      return defaultLevel;
-      }
+    }
   }
 
   return toLevel(sArg.toString());
-
+}
-};
 
 Level.prototype.toString = function() {
-    return this.levelStr;
+  return this.levelStr;
 };
 
 Level.prototype.isLessThanOrEqualTo = function(otherLevel) {
-    if (typeof otherLevel === "string") {
+  if (typeof otherLevel === "string") {
-        otherLevel = toLevel(otherLevel);
+    otherLevel = toLevel(otherLevel);
-    }
+  }
-    return this.level <= otherLevel.level;
+  return this.level <= otherLevel.level;
 };
 
 Level.prototype.isGreaterThanOrEqualTo = function(otherLevel) {
-    if (typeof otherLevel === "string") {
+  if (typeof otherLevel === "string") {
-        otherLevel = toLevel(otherLevel);
+    otherLevel = toLevel(otherLevel);
-    }
+  }
-    return this.level >= otherLevel.level;
+  return this.level >= otherLevel.level;
 };
 
 Level.prototype.isEqualTo = function(otherLevel) {
-    if (typeof otherLevel == "string") {
+  if (typeof otherLevel == "string") {
-        otherLevel = toLevel(otherLevel);
+    otherLevel = toLevel(otherLevel);
-    }
+  }
-    return this.level === otherLevel.level;
+  return this.level === otherLevel.level;
-}
+};
 
 module.exports = {
-    ALL: new Level(Number.MIN_VALUE, "ALL")
+  ALL: new Level(Number.MIN_VALUE, "ALL"), 
-  , TRACE: new Level(5000, "TRACE")
+  TRACE: new Level(5000, "TRACE"), 
-  , DEBUG: new Level(10000, "DEBUG")
+  DEBUG: new Level(10000, "DEBUG"), 
-  , INFO: new Level(20000, "INFO")
+  INFO: new Level(20000, "INFO"), 
-  , WARN: new Level(30000, "WARN")
+  WARN: new Level(30000, "WARN"), 
-  , ERROR: new Level(40000, "ERROR")
+  ERROR: new Level(40000, "ERROR"), 
-  , FATAL: new Level(50000, "FATAL")
+  FATAL: new Level(50000, "FATAL"), 
-  , OFF: new Level(Number.MAX_VALUE, "OFF")
+  OFF: new Level(Number.MAX_VALUE, "OFF"), 
-  , toLevel: toLevel
+  toLevel: toLevel
 };

lib/log4js.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -12,8 +13,6 @@
  * limitations under the License.
  */
 
-/*jsl:option explicit*/
-
 /**
  * @fileoverview log4js is a library to log in JavaScript in similar manner
  * than in log4j for Java. The API should be nearly the same.
@@ -45,24 +44,55 @@
  * Website: http://log4js.berlios.de
  */
 var events = require('events')
+, async = require('async')
 , fs = require('fs')
 , path = require('path')
 , util = require('util')
 , layouts = require('./layouts')
 , levels = require('./levels')
-, LoggingEvent = require('./logger').LoggingEvent
+, loggerModule = require('./logger')
-, Logger = require('./logger').Logger
+, LoggingEvent = loggerModule.LoggingEvent
+, Logger = loggerModule.Logger
 , ALL_CATEGORIES = '[all]'
 , appenders = {}
 , loggers = {}
 , appenderMakers = {}
+, appenderShutdowns = {}
 , defaultConfig =   {
-    appenders: [
+  appenders: [
-        { type: "console" }
+    { type: "console" }
-    ],
+  ],
-    replaceConsole: false
+  replaceConsole: false
 };
 
+function hasLogger(logger) {
+  return loggers.hasOwnProperty(logger);
+}
+
+
+function getBufferedLogger(categoryName) {
+    var base_logger = getLogger(categoryName);
+    var logger = {};
+    logger.temp = [];
+    logger.target = base_logger;
+    logger.flush = function () {
+        for (var i = 0; i < logger.temp.length; i++) {
+            var log = logger.temp[i];
+            logger.target[log.level](log.message);
+            delete logger.temp[i];
+        }
+    };
+    logger.trace = function (message) { logger.temp.push({level: 'trace', message: message}); };
+    logger.debug = function (message) { logger.temp.push({level: 'debug', message: message}); };
+    logger.info = function (message) { logger.temp.push({level: 'info', message: message}); };
+    logger.warn = function (message) { logger.temp.push({level: 'warn', message: message}); };
+    logger.error = function (message) { logger.temp.push({level: 'error', message: message}); };
+    logger.fatal = function (message) { logger.temp.push({level: 'fatal', message: message}); };
+
+    return logger;
+}
+
+
 /**
  * Get a logger instance. Instance is cached on categoryName level.
  * @param  {String} categoryName name of category to log to.
@@ -71,102 +101,113 @@ var events = require('events')
  */
 function getLogger (categoryName) {
 
-    // Use default logger if categoryName is not specified or invalid
+  // Use default logger if categoryName is not specified or invalid
-    if (!(typeof categoryName == "string")) {
+  if (typeof categoryName !== "string") {
-        categoryName = Logger.DEFAULT_CATEGORY;
+    categoryName = Logger.DEFAULT_CATEGORY;
-    }
+  }
 
-    var appenderList;
+  var appenderList;
-    if (!loggers[categoryName]) {
+  if (!hasLogger(categoryName)) {
-        // Create the logger for this name if it doesn't already exist
+    // Create the logger for this name if it doesn't already exist
-        loggers[categoryName] = new Logger(categoryName);
+    loggers[categoryName] = new Logger(categoryName);
-        if (appenders[categoryName]) {
+    if (appenders[categoryName]) {
-            appenderList = appenders[categoryName];
+      appenderList = appenders[categoryName];
-            appenderList.forEach(function(appender) {
+      appenderList.forEach(function(appender) {
-                loggers[categoryName].addListener("log", appender);
+        loggers[categoryName].addListener("log", appender);
-            });
+      });
-        }
-        if (appenders[ALL_CATEGORIES]) {
-            appenderList = appenders[ALL_CATEGORIES];
-            appenderList.forEach(function(appender) {
-                loggers[categoryName].addListener("log", appender);
-            });
-        }
     }
-
+    if (appenders[ALL_CATEGORIES]) {
-    return loggers[categoryName];
+      appenderList = appenders[ALL_CATEGORIES];
+      appenderList.forEach(function(appender) {
+        loggers[categoryName].addListener("log", appender);
+      });
+    }
+  }
+  
+  return loggers[categoryName];
 }
 
 /**
  * args are appender, then zero or more categories
  */
 function addAppender () {
-    var args = Array.prototype.slice.call(arguments);
+  var args = Array.prototype.slice.call(arguments);
-    var appender = args.shift();
+  var appender = args.shift();
-    if (args.length == 0 || args[0] === undefined) {
+  if (args.length === 0 || args[0] === undefined) {
-        args = [ ALL_CATEGORIES ];
+    args = [ ALL_CATEGORIES ];
+  }
+  //argument may already be an array
+  if (Array.isArray(args[0])) {
+    args = args[0];
+  }
+  
+  args.forEach(function(category) {
+    addAppenderToCategory(appender, category);
+    
+    if (category === ALL_CATEGORIES) {
+      addAppenderToAllLoggers(appender);
+    } else if (hasLogger(category)) {
+      loggers[category].addListener("log", appender);
     }
-    //argument may already be an array
+  });
-    if (Array.isArray(args[0])) {
+}
-        args = args[0];
+
+function addAppenderToAllLoggers(appender) {
+  for (var logger in loggers) {
+    if (hasLogger(logger)) {
+      loggers[logger].addListener("log", appender);
     }
+  }
+}
 
-    args.forEach(function(category) {
+function addAppenderToCategory(appender, category) {
-        if (!appenders[category]) {
+  if (!appenders[category]) {
-            appenders[category] = [];
+    appenders[category] = [];
-        }
+  }
-        appenders[category].push(appender);
+  appenders[category].push(appender);
-
-        if (category === ALL_CATEGORIES) {
-            for (var logger in loggers) {
-                if (loggers.hasOwnProperty(logger)) {
-                    loggers[logger].addListener("log", appender);
-                }
-            }
-        } else if (loggers[category]) {
-            loggers[category].addListener("log", appender);
-        }
-    });
 }
 
 function clearAppenders () {
-    appenders = {};
+  appenders = {};
-    for (var logger in loggers) {
+  for (var logger in loggers) {
-        if (loggers.hasOwnProperty(logger)) {
+    if (hasLogger(logger)) {
-            loggers[logger].removeAllListeners("log");
+      loggers[logger].removeAllListeners("log");
-        }
     }
+  }
 }
 
 function configureAppenders(appenderList, options) {
-    clearAppenders();
+  clearAppenders();
-    if (appenderList) {
+  if (appenderList) {
-        appenderList.forEach(function(appenderConfig) {
+    appenderList.forEach(function(appenderConfig) {
-            loadAppender(appenderConfig.type);
+      loadAppender(appenderConfig.type);
-            var appender;
+      var appender;
-            appenderConfig.makers = appenderMakers;
+      appenderConfig.makers = appenderMakers;
-            appender = appenderMakers[appenderConfig.type](appenderConfig, options);
+      try {
-            if (appender) {
+        appender = appenderMakers[appenderConfig.type](appenderConfig, options);
-                addAppender(appender, appenderConfig.category);
+        addAppender(appender, appenderConfig.category);
-            } else {
+      } catch(e) {
-                throw new Error("log4js configuration problem for "+util.inspect(appenderConfig));
+        throw new Error("log4js configuration problem for " + util.inspect(appenderConfig), e);
-            }
+      }
-        });
+    });
-    }
+  }
 }
 
 function configureLevels(levels) {
-    if (levels) {
+  if (levels) {
-        for (var category in levels) {
+    for (var category in levels) {
-            if (levels.hasOwnProperty(category)) {
+      if (levels.hasOwnProperty(category)) {
-                getLogger(category).setLevel(levels[category]);
+        if(category === ALL_CATEGORIES) {
-            }
+          setGlobalLogLevel(levels[category]);
         }
+        getLogger(category).setLevel(levels[category]);
+      }
     }
+  }
 }
 
 function setGlobalLogLevel(level) {
-    Logger.prototype.level = levels.toLevel(level, levels.TRACE);
+  Logger.prototype.level = levels.toLevel(level, levels.TRACE);
 }
 
 /**
@@ -175,143 +216,209 @@ function setGlobalLogLevel(level) {
  * @static
  */
 function getDefaultLogger () {
-    return getLogger(Logger.DEFAULT_CATEGORY);
+  return getLogger(Logger.DEFAULT_CATEGORY);
 }
 
 var configState = {};
 
 function loadConfigurationFile(filename) {
-    if (filename && (!configState.lastFilename || filename !== configState.lastFilename ||
+  if (filename) {
-                     !configState.lastMTime || fs.statSync(filename).mtime !== configState.lastMTime)) {
+    return JSON.parse(fs.readFileSync(filename, "utf8"));
-        configState.lastFilename = filename;
+  }
-        configState.lastMTime = fs.statSync(filename).mtime;
+  return undefined;
-        return JSON.parse(fs.readFileSync(filename, "utf8"));
-    }
-    return undefined;
 }
 
 function configureOnceOff(config, options) {
-    if (config) {
+  if (config) {
-        try {
+    try {
-            configureAppenders(config.appenders, options);
+      configureAppenders(config.appenders, options);
-            configureLevels(config.levels);
+      configureLevels(config.levels);
-
+      
-            if (config.replaceConsole) {
+      if (config.replaceConsole) {
-                replaceConsole();
+        replaceConsole();
-            } else {
+      } else {
-                restoreConsole();
+        restoreConsole();
-            }
+      }
-        } catch (e) {
+    } catch (e) {
-            throw new Error("Problem reading log4js config " + util.inspect(config) + ". Error was \"" + e.message + "\" ("+e.stack+")");
+      throw new Error(
-        }
+        "Problem reading log4js config " + util.inspect(config) + 
+          ". Error was \"" + e.message + "\" (" + e.stack + ")"
+      );
     }
+  }
 }
 
 function reloadConfiguration() {
-    var filename = configState.filename,
+  var mtime = getMTime(configState.filename);
-    mtime;
+  if (!mtime) return;
-    if (!filename) {
+
-        // can't find anything to reload
+  if (configState.lastMTime && (mtime.getTime() > configState.lastMTime.getTime())) {
-        return;
+    configureOnceOff(loadConfigurationFile(configState.filename));
-    }
+  }
-    try {
+  configState.lastMTime = mtime;
-        mtime = fs.statSync(filename).mtime;
+}
-    } catch (e) {
+
-        getLogger('log4js').warn('Failed to load configuration file ' + filename);
+function getMTime(filename) {
-        return;
+  var mtime;
-    }
+  try {
-    if (configState.lastFilename && configState.lastFilename === filename) {
+    mtime = fs.statSync(configState.filename).mtime;
-        if (mtime.getTime() > configState.lastMTime.getTime()) {
+  } catch (e) {
-            configureOnceOff(loadConfigurationFile(filename));
+    getLogger('log4js').warn('Failed to load configuration file ' + filename);
-        }
+  }
-    } else {
+  return mtime;
-        configureOnceOff(loadConfigurationFile(filename));
-    }
 }
 
 function initReloadConfiguration(filename, options) {
-    if (configState.timerId) {
+  if (configState.timerId) {
-        clearInterval(configState.timerId);
+    clearInterval(configState.timerId);
-        delete configState.timerId;
+    delete configState.timerId;
-    }
+  }
-    configState.filename = filename;
+  configState.filename = filename;
-    configState.timerId = setInterval(reloadConfiguration, options.reloadSecs*1000);
+  configState.lastMTime = getMTime(filename);
+  configState.timerId = setInterval(reloadConfiguration, options.reloadSecs*1000);
 }
 
 function configure(configurationFileOrObject, options) {
-    var config = configurationFileOrObject;
+  var config = configurationFileOrObject;
-    config = config || process.env.LOG4JS_CONFIG;
+  config = config || process.env.LOG4JS_CONFIG;
-    options = options || {};
+  options = options || {};
   
-    if (config === undefined || config === null || typeof(config) === 'string') {
+  if (config === undefined || config === null || typeof(config) === 'string') {
-        if (options.reloadSecs) {
+    if (options.reloadSecs) {
-            initReloadConfiguration(config, options);
+      initReloadConfiguration(config, options);
-        }
-        config = loadConfigurationFile(config) || defaultConfig;
-    } else {
-        if (options.reloadSecs) {
-            getLogger('log4js').warn('Ignoring configuration reload parameter for "object" configuration.');
-        }
     }
-    configureOnceOff(config, options);
+    config = loadConfigurationFile(config) || defaultConfig;
+  } else {
+    if (options.reloadSecs) {
+      getLogger('log4js').warn(
+        'Ignoring configuration reload parameter for "object" configuration.'
+      );
+    }
+  }
+  configureOnceOff(config, options);
 }
 
 var originalConsoleFunctions = {
-    log: console.log,
+  log: console.log,
-    debug: console.debug,
+  debug: console.debug,
-    info: console.info,
+  info: console.info,
-    warn: console.warn,
+  warn: console.warn,
-    error: console.error
+  error: console.error
 };
 
 function replaceConsole(logger) {
-    function replaceWith(fn) {
+  function replaceWith(fn) {
-        return function() {
+    return function() {
-            fn.apply(logger, arguments);
+      fn.apply(logger, arguments);
-        }
+    };
-    }
+  }
-    logger = logger || getLogger("console");
+  logger = logger || getLogger("console");
-    ['log','debug','info','warn','error'].forEach(function (item) {
+  ['log','debug','info','warn','error'].forEach(function (item) {
-        console[item] = replaceWith(item === 'log' ? logger.info : logger[item]);
+    console[item] = replaceWith(item === 'log' ? logger.info : logger[item]);
-    });
+  });
 }
 
 function restoreConsole() {
-    ['log', 'debug', 'info', 'warn', 'error'].forEach(function (item) {
+  ['log', 'debug', 'info', 'warn', 'error'].forEach(function (item) {
-        console[item] = originalConsoleFunctions[item];
+    console[item] = originalConsoleFunctions[item];
-    });
+  });
 }
 
-function loadAppender(appender) {
+/**
-    var appenderModule;
+ * Load an appenderModule based on the provided appender filepath. Will first
-    try {
+ * check if the appender path is a subpath of the log4js "lib/appenders" directory.
-        appenderModule = require('./appenders/' + appender);
+ * If not, it will attempt to load the the appender as complete path.
-    } catch (e) {
+ *
-        appenderModule = require(appender);
+ * @param {string} appender The filepath for the appender.
-    }
+ * @returns {Object|null} The required appender or null if appender could not be loaded.
-    module.exports.appenders[appender] = appenderModule.appender.bind(appenderModule);
+ * @private
-    appenderMakers[appender] = appenderModule.configure.bind(appenderModule);
+ */
+function requireAppender(appender) {
+  var appenderModule;
+  try {
+    appenderModule = require('./appenders/' + appender);
+  } catch (e) {
+    appenderModule = require(appender);
+  }
+  return appenderModule;
+}
+
+/**
+ * Load an appender. Provided the appender path to be loaded. If appenderModule is defined,
+ * it will be used in place of requiring the appender module.
+ *
+ * @param {string} appender The path to the appender module.
+ * @param {Object|void} [appenderModule] The pre-required appender module. When provided,
+ * instead of requiring the appender by its path, this object will be used.
+ * @returns {void}
+ * @private
+ */
+function loadAppender(appender, appenderModule) {
+  appenderModule = appenderModule || requireAppender(appender);
+
+  if (!appenderModule) {
+    throw new Error("Invalid log4js appender: " + util.inspect(appender));
+  }
+
+  module.exports.appenders[appender] = appenderModule.appender.bind(appenderModule);
+  if (appenderModule.shutdown) {
+    appenderShutdowns[appender] = appenderModule.shutdown.bind(appenderModule);
+  }
+  appenderMakers[appender] = appenderModule.configure.bind(appenderModule);
+}
+
+/**
+ * Shutdown all log appenders. This will first disable all writing to appenders
+ * and then call the shutdown function each appender.
+ *
+ * @params {Function} cb - The callback to be invoked once all appenders have
+ *  shutdown. If an error occurs, the callback will be given the error object
+ *  as the first argument.
+ * @returns {void}
+ */
+function shutdown(cb) {
+  // First, disable all writing to appenders. This prevents appenders from
+  // not being able to be drained because of run-away log writes.
+  loggerModule.disableAllLogWrites();
+
+  // Next, get all the shutdown functions for appenders as an array.
+  var shutdownFunctions = Object.keys(appenderShutdowns).reduce(
+    function(accum, category) {
+      return accum.concat(appenderShutdowns[category]);
+    }, []);
+
+  // Call each of the shutdown functions.
+  async.forEach(
+    shutdownFunctions,
+    function(shutdownFn, done) {
+      shutdownFn(done);
+    },
+		cb
+  );
 }
 
 module.exports = {
-    getLogger: getLogger,
+  getBufferedLogger: getBufferedLogger,
-    getDefaultLogger: getDefaultLogger,
+  getLogger: getLogger,
-
+  getDefaultLogger: getDefaultLogger,
-    addAppender: addAppender,
+  hasLogger: hasLogger,
-    loadAppender: loadAppender,
+  
-    clearAppenders: clearAppenders,
+  addAppender: addAppender,
-    configure: configure,
+  loadAppender: loadAppender,
-
+  clearAppenders: clearAppenders,
-    replaceConsole: replaceConsole,
+  configure: configure,
-    restoreConsole: restoreConsole,
+  shutdown: shutdown,
-
+  
-    levels: levels,
+  replaceConsole: replaceConsole,
-    setGlobalLogLevel: setGlobalLogLevel,
+  restoreConsole: restoreConsole,
-
+  
-    layouts: layouts,
+  levels: levels,
-    appenders: {},
+  setGlobalLogLevel: setGlobalLogLevel,
-    appenderMakers: appenderMakers,
+  
-    connectLogger: require('./connect-logger').connectLogger
+  layouts: layouts,
+  appenders: {},
+  appenderMakers: appenderMakers,
+  connectLogger: require('./connect-logger').connectLogger
 };
 
 //set ourselves up

lib/logger.js

@@ -1,7 +1,10 @@
-var levels = require('./levels'),
+"use strict";
-    util = require('util'),
+var levels = require('./levels')
-    events = require('events'),
+, util = require('util')
-    DEFAULT_CATEGORY = '[default]';
+, events = require('events')
+, DEFAULT_CATEGORY = '[default]';
+
+var logWritesEnabled = true;
 
 /**
  * Models a logging event.
@@ -13,11 +16,11 @@ var levels = require('./levels'),
  * @author Seth Chisamore
  */
 function LoggingEvent (categoryName, level, data, logger) {
-    this.startTime = new Date();
+  this.startTime = new Date();
-    this.categoryName = categoryName;
+  this.categoryName = categoryName;
-    this.data = data;
+  this.data = data;
-    this.level = level;
+  this.level = level;
-    this.logger = logger;
+  this.logger = logger;
 }
 
 /**
@@ -28,51 +31,72 @@ function LoggingEvent (categoryName, level, data, logger) {
  * @author Stephan Strittmatter
  */
 function Logger (name, level) {
-    this.category = name || DEFAULT_CATEGORY;
+  this.category = name || DEFAULT_CATEGORY;
-
+  
-    if (! this.level) {
+  if (level) {
-        this.__proto__.level = levels.TRACE;
+    this.setLevel(level);
-    }
+  }
 }
 util.inherits(Logger, events.EventEmitter);
 Logger.DEFAULT_CATEGORY = DEFAULT_CATEGORY;
+Logger.prototype.level = levels.TRACE;
 
 Logger.prototype.setLevel = function(level) {
-    this.level = levels.toLevel(level, this.level || levels.TRACE);
+  this.level = levels.toLevel(level, this.level || levels.TRACE);
 };
 
 Logger.prototype.removeLevel = function() {
-    delete this.level;
+  delete this.level;
 };
 
 Logger.prototype.log = function() {
-    var args = Array.prototype.slice.call(arguments)
+  var args = Array.prototype.slice.call(arguments)
-  , logLevel = args.shift()
+  , logLevel = levels.toLevel(args.shift())
-  , loggingEvent = new LoggingEvent(this.category, logLevel, args, this);
+  , loggingEvent;
+  if (this.isLevelEnabled(logLevel)) {
+    loggingEvent = new LoggingEvent(this.category, logLevel, args, this);
     this.emit("log", loggingEvent);
+  }
 };
 
 Logger.prototype.isLevelEnabled = function(otherLevel) {
-    return this.level.isLessThanOrEqualTo(otherLevel);
+  return this.level.isLessThanOrEqualTo(otherLevel);
 };
 
 ['Trace','Debug','Info','Warn','Error','Fatal'].forEach(
-    function(levelString) {
+  function(levelString) {
-        var level = levels.toLevel(levelString);
+    var level = levels.toLevel(levelString);
-        Logger.prototype['is'+levelString+'Enabled'] = function() {
+    Logger.prototype['is'+levelString+'Enabled'] = function() {
-            return this.isLevelEnabled(level);
+      return this.isLevelEnabled(level);
-        };
+    };
-
+    
-        Logger.prototype[levelString.toLowerCase()] = function () {
+    Logger.prototype[levelString.toLowerCase()] = function () {
-            if (this.isLevelEnabled(level)) {
+      if (logWritesEnabled && this.isLevelEnabled(level)) {
-                var args = Array.prototype.slice.call(arguments);
+        var args = Array.prototype.slice.call(arguments);
-                args.unshift(level);
+        args.unshift(level);
-                Logger.prototype.log.apply(this, args);
+        Logger.prototype.log.apply(this, args);
-            }
+      }
-        };
+    };
-    }
+  }
 );
 
+/**
+ * Disable all log writes.
+ * @returns {void}
+ */
+function disableAllLogWrites() {
+  logWritesEnabled = false;
+}
+
+/**
+ * Enable log writes.
+ * @returns {void}
+ */
+function enableAllLogWrites() {
+  logWritesEnabled = true;
+}
 
 exports.LoggingEvent = LoggingEvent;
 exports.Logger = Logger;
+exports.disableAllLogWrites = disableAllLogWrites;
+exports.enableAllLogWrites = enableAllLogWrites;

lib/streams/BaseRollingFileStream.js

@@ -1,7 +1,9 @@
-var fs = require('fs'),
+"use strict";
-stream,
+var fs = require('fs')
-util = require('util'),
+, stream
-semver = require('semver');
+, debug = require('../debug')('BaseRollingFileStream')
+, util = require('util')
+, semver = require('semver');
 
 if (semver.satisfies(process.version, '>=0.10.0')) {
   stream = require('stream');
@@ -9,21 +11,14 @@ if (semver.satisfies(process.version, '>=0.10.0')) {
   stream = require('readable-stream');
 }
 
-var debug;
-if (process.env.NODE_DEBUG && /\blog4js\b/.test(process.env.NODE_DEBUG)) {
-    debug = function(message) { console.error('LOG4JS: (BaseRollingFileStream) %s', message); };
-} else {
-    debug = function() { };
-}
-
 module.exports = BaseRollingFileStream;
 
 function BaseRollingFileStream(filename, options) {
   debug("In BaseRollingFileStream");
   this.filename = filename;
-  this.options = options || { encoding: 'utf8', mode: 0644, flags: 'a' };
+  this.options = options || { encoding: 'utf8', mode: parseInt('0644', 8), flags: 'a' };
   this.currentSize = 0;
-
+  
   function currentFileSize(file) {
     var fileSize = 0;
     try {
@@ -53,7 +48,13 @@ BaseRollingFileStream.prototype._write = function(chunk, encoding, callback) {
   function writeTheChunk() {
     debug("writing the chunk to the underlying stream");
     that.currentSize += chunk.length;
-    that.theStream.write(chunk, encoding, callback);
+    try {
+      that.theStream.write(chunk, encoding, callback);
+    }
+    catch (err){
+      debug(err);
+      callback();
+    }
   }
 
   debug("in _write");
@@ -80,10 +81,10 @@ BaseRollingFileStream.prototype.closeTheStream = function(cb) {
 };
 
 BaseRollingFileStream.prototype.shouldRoll = function() {
-    return false; // default behaviour is never to roll
+  return false; // default behaviour is never to roll
 };
 
 BaseRollingFileStream.prototype.roll = function(filename, callback) {
-    callback(); // default behaviour is not to do anything
+  callback(); // default behaviour is not to do anything
 };
 

lib/streams/DateRollingFileStream.js

@@ -1,18 +1,13 @@
-var BaseRollingFileStream = require('./BaseRollingFileStream'),
+"use strict";
-    format = require('../date_format'),
+var BaseRollingFileStream = require('./BaseRollingFileStream')
-    async = require('async'),
+, debug = require('../debug')('DateRollingFileStream')
-    fs = require('fs'),
+, format = require('../date_format')
-    util = require('util');
+, async = require('async')
+, fs = require('fs')
+, util = require('util');
 
 module.exports = DateRollingFileStream;
 
-var debug;
-if (process.env.NODE_DEBUG && /\blog4js\b/.test(process.env.NODE_DEBUG)) {
-    debug = function(message) { console.error('LOG4JS: (DateRollingFileStream) %s', message); };
-} else {
-    debug = function() { };
-}
-
 function DateRollingFileStream(filename, pattern, options, now) {
   debug("Now is " + now);
   if (pattern && typeof(pattern) === 'object') {
@@ -22,61 +17,79 @@ function DateRollingFileStream(filename, pattern, options, now) {
   }
   this.pattern = pattern || '.yyyy-MM-dd';
   this.now = now || Date.now;
-  this.lastTimeWeWroteSomething = format.asString(this.pattern, new Date(this.now()));
+
+  if (fs.existsSync(filename)) {
+    var stat = fs.statSync(filename);
+    this.lastTimeWeWroteSomething = format.asString(this.pattern, stat.mtime);
+  } else {
+    this.lastTimeWeWroteSomething = format.asString(this.pattern, new Date(this.now()));
+  }
+
   this.baseFilename = filename;
-    
+  this.alwaysIncludePattern = false;
+  
   if (options) {
     if (options.alwaysIncludePattern) {
-      filename = filename + this.lastTimeWeWroteSomething;
+      this.alwaysIncludePattern = true;
+      filename = this.baseFilename + this.lastTimeWeWroteSomething;
     }
     delete options.alwaysIncludePattern;
-    if (options === {}) { 
+    if (Object.keys(options).length === 0) { 
       options = null; 
     }
   }
   debug("this.now is " + this.now + ", now is " + now);
-
+  
   DateRollingFileStream.super_.call(this, filename, options);
 }
 util.inherits(DateRollingFileStream, BaseRollingFileStream);
 
 DateRollingFileStream.prototype.shouldRoll = function() {
-    var lastTime = this.lastTimeWeWroteSomething,
+  var lastTime = this.lastTimeWeWroteSomething,
-        thisTime = format.asString(this.pattern, new Date(this.now()));
+  thisTime = format.asString(this.pattern, new Date(this.now()));
-
+  
-    debug("DateRollingFileStream.shouldRoll with now = " + this.now() + ", thisTime = " + thisTime + ", lastTime = " + lastTime);
+  debug("DateRollingFileStream.shouldRoll with now = " + 
-
+        this.now() + ", thisTime = " + thisTime + ", lastTime = " + lastTime);
-    this.lastTimeWeWroteSomething = thisTime;
+  
-    this.previousTime = lastTime;
+  this.lastTimeWeWroteSomething = thisTime;
-
+  this.previousTime = lastTime;
-    return thisTime !== lastTime;
+  
+  return thisTime !== lastTime;
 };
 
 DateRollingFileStream.prototype.roll = function(filename, callback) {
-    var that = this,
+  var that = this;
-        newFilename = this.baseFilename + this.previousTime;
+  
-
+  debug("Starting roll");
-    debug("Starting roll");
+  
-
+  if (this.alwaysIncludePattern) {
+    this.filename = this.baseFilename + this.lastTimeWeWroteSomething;
+    async.series([
+      this.closeTheStream.bind(this),
+      this.openTheStream.bind(this)
+    ], callback);
+  } else {
+    var newFilename = this.baseFilename + this.previousTime;
     async.series([
       this.closeTheStream.bind(this),
       deleteAnyExistingFile,
       renameTheCurrentFile,
       this.openTheStream.bind(this)
     ], callback);
+  }
+  
+  function deleteAnyExistingFile(cb) {
+    //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(newFilename, function (err) {
+      //ignore err: if we could not delete, it's most likely that it doesn't exist
+      cb();
+    });
+  }
 
-    function deleteAnyExistingFile(cb) {
+  function renameTheCurrentFile(cb) {
-        //on windows, you can get a EEXIST error if you rename a file to an existing file
+    debug("Renaming the " + filename + " -> " + newFilename);
-        //so, we'll try to delete the file we're renaming to first
+    fs.rename(filename, newFilename, cb);
-        fs.unlink(newFilename, function (err) {
+  }
-            //ignore err: if we could not delete, it's most likely that it doesn't exist
-            cb();
-        });
-    }
-
-    function renameTheCurrentFile(cb) {
-        debug("Renaming the " + filename + " -> " + newFilename);
-        fs.rename(filename, newFilename, cb);
-    }
 
 };

lib/streams/RollingFileStream.js

@@ -1,88 +1,83 @@
-var BaseRollingFileStream = require('./BaseRollingFileStream'),
+"use strict";
-    util = require('util'),
+var BaseRollingFileStream = require('./BaseRollingFileStream')
-    path = require('path'),
+, debug = require('../debug')('RollingFileStream')
-    fs = require('fs'),
+, util = require('util')
-    async = require('async');
+, path = require('path')
-
+, fs = require('fs')
-var debug;
+, async = require('async');
-if (process.env.NODE_DEBUG && /\blog4js\b/.test(process.env.NODE_DEBUG)) {
-    debug = function(message) { console.error('LOG4JS: (RollingFileStream) %s', message); };
-} else {
-    debug = function() { };
-}
 
 module.exports = RollingFileStream;
 
 function RollingFileStream (filename, size, backups, options) {
-    this.size = size;
+  this.size = size;
-    this.backups = backups || 1;
+  this.backups = backups || 1;
-
+  
-    function throwErrorIfArgumentsAreNotValid() {
+  function throwErrorIfArgumentsAreNotValid() {
-        if (!filename || !size || size <= 0) {
+    if (!filename || !size || size <= 0) {
-            throw new Error("You must specify a filename and file size");
+      throw new Error("You must specify a filename and file size");
-        }
     }
-
+  }
-    throwErrorIfArgumentsAreNotValid();
+  
-
+  throwErrorIfArgumentsAreNotValid();
-    RollingFileStream.super_.call(this, filename, options);
+  
+  RollingFileStream.super_.call(this, filename, options);
 }
 util.inherits(RollingFileStream, BaseRollingFileStream);
 
 RollingFileStream.prototype.shouldRoll = function() {
   debug("should roll with current size %d, and max size %d", this.currentSize, this.size);
-    return this.currentSize >= this.size;
+  return this.currentSize >= this.size;
 };
 
 RollingFileStream.prototype.roll = function(filename, callback) {
-    var that = this,
+  var that = this,
-        nameMatcher = new RegExp('^' + path.basename(filename));
+  nameMatcher = new RegExp('^' + path.basename(filename));
-
+  
-    function justTheseFiles (item) {
+  function justTheseFiles (item) {
-        return nameMatcher.test(item);
+    return nameMatcher.test(item);
+  }
+  
+  function index(filename_) {
+    return parseInt(filename_.substring((path.basename(filename) + '.').length), 10) || 0;
+  }
+  
+  function byIndex(a, b) {
+    if (index(a) > index(b)) {
+      return 1;
+    } else if (index(a) < index(b) ) {
+      return -1;
+    } else {
+      return 0;
     }
+  }
 
-    function index(filename_) {
+  function increaseFileIndex (fileToRename, cb) {
-        return parseInt(filename_.substring((path.basename(filename) + '.').length), 10) || 0;
+    var idx = index(fileToRename);
+    debug('Index of ' + fileToRename + ' is ' + idx);
+    if (idx < that.backups) {
+      //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) {
+        //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);
+      });
+    } else {
+      cb();
     }
+  }
 
-    function byIndex(a, b) {
+  function renameTheFiles(cb) {
-        if (index(a) > index(b)) {
+    //roll the backups (rename file.n to file.n+1, where n <= numBackups)
-            return 1;
+    debug("Renaming the old files");
-        } else if (index(a) < index(b) ) {
+    fs.readdir(path.dirname(filename), function (err, files) {
-            return -1;
+      async.forEachSeries(
-        } else {
+        files.filter(justTheseFiles).sort(byIndex).reverse(),
-            return 0;
+        increaseFileIndex,
-        }
+        cb
-    }
+      );
-
+    });
-    function increaseFileIndex (fileToRename, cb) {
+  }
-        var idx = index(fileToRename);
-        debug('Index of ' + fileToRename + ' is ' + idx);
-        if (idx < that.backups) {
-            //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) {
-                //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);
-            });
-        } else {
-            cb();
-        }
-    }
-
-    function renameTheFiles(cb) {
-        //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(
-                files.filter(justTheseFiles).sort(byIndex).reverse(),
-                increaseFileIndex,
-                cb
-            );
-        });
-    }
 
   debug("Rolling, rolling, rolling");
   async.series([

package.json

@@ -1,6 +1,6 @@
 {
   "name": "log4js",
-  "version": "0.6.3",
+  "version": "0.6.19",
   "description": "Port of Log4js to work with node.",
   "keywords": [
     "logging",
@@ -9,7 +9,7 @@
     "node"
   ],
   "main": "./lib/log4js",
-  "author": "Gareth Jones <gareth.jones@sensis.com.au>",
+  "author": "Gareth Jones <gareth.nomiddlename@gmail.com>",
   "repository": {
     "type": "git",
     "url": "https://github.com/nomiddlename/log4js-node.git"
@@ -29,14 +29,15 @@
   },
   "dependencies": {
     "async": "0.1.15",
-    "dequeue": "1.0.3",
     "semver": "~1.1.4",
     "readable-stream": "~1.0.2"
   },
   "devDependencies": {
     "vows": "0.7.0",
     "sandboxed-module": "0.1.3",
-    "hook.io": "0.8.10",
     "underscore": "1.2.1"
+  },
+  "browser": {
+    "os": false
   }
 }

test/categoryFilter-test.js

@@ -0,0 +1,84 @@
+'use strict';
+
+var vows = require('vows')
+, fs = require('fs')
+, assert = require('assert')
+, EOL = require('os').EOL || '\n';
+
+function remove(filename) {
+  try {
+    fs.unlinkSync(filename);
+  } catch (e) {
+    //doesn't really matter if it failed
+  }
+}
+
+vows.describe('log4js categoryFilter').addBatch({
+  'appender': {
+    topic: function() {
+
+      var log4js = require('../lib/log4js'), logEvents = [], webLogger, appLogger;
+      log4js.clearAppenders();
+      var appender = require('../lib/appenders/categoryFilter')
+        .appender(
+          ['app'],
+          function(evt) { logEvents.push(evt); }
+        );
+      log4js.addAppender(appender, ["app","web"]);
+
+      webLogger = log4js.getLogger("web");
+      appLogger = log4js.getLogger("app");
+
+      webLogger.debug('This should get logged');
+      appLogger.debug('This should not');
+      webLogger.debug('Hello again');
+      log4js.getLogger('db').debug('This shouldn\'t be included by the appender anyway');
+
+      return logEvents;
+    },
+    'should only pass matching category' : function(logEvents) {
+      assert.equal(logEvents.length, 2);
+      assert.equal(logEvents[0].data[0], 'This should get logged');
+      assert.equal(logEvents[1].data[0], 'Hello again');
+    }
+  },
+
+  'configure': {
+    topic: function() {
+      var log4js = require('../lib/log4js')
+      , logger, weblogger;
+
+      remove(__dirname + '/categoryFilter-web.log');
+      remove(__dirname + '/categoryFilter-noweb.log');
+
+      log4js.configure('test/with-categoryFilter.json');
+      logger = log4js.getLogger("app");
+      weblogger = log4js.getLogger("web");
+
+      logger.info('Loading app');
+      logger.debug('Initialising indexes');
+      weblogger.info('00:00:00 GET / 200');
+      weblogger.warn('00:00:00 GET / 500');
+      //wait for the file system to catch up
+      setTimeout(this.callback, 500);
+    },
+    'tmp-tests.log': {
+      topic: function() {
+        fs.readFile(__dirname + '/categoryFilter-noweb.log', 'utf8', this.callback);
+      },
+      'should contain all log messages': function(contents) {
+        var messages = contents.trim().split(EOL);
+        assert.deepEqual(messages, ['Loading app','Initialising indexes']);
+      }
+    },
+    'tmp-tests-web.log': {
+      topic: function() {
+        fs.readFile(__dirname + '/categoryFilter-web.log','utf8',this.callback);
+      },
+      'should contain only error and warning log messages': function(contents) {
+        var messages = contents.trim().split(EOL);
+        assert.deepEqual(messages, ['00:00:00 GET / 200','00:00:00 GET / 500']);
+      }
+    }
+  }
+}).export(module);

test/clusteredAppender-test.js

@@ -0,0 +1,128 @@
+"use strict";
+var assert = require('assert');
+var vows = require('vows');
+var layouts = require('../lib/layouts');
+var sandbox = require('sandboxed-module');
+var LoggingEvent = require('../lib/logger').LoggingEvent;
+var cluster = require('cluster');
+
+vows.describe('log4js cluster appender').addBatch({
+	'when in master mode': {
+		topic: function() {
+
+			var registeredClusterEvents = [];
+			var loggingEvents = [];
+			
+			// Fake cluster module, so no cluster listeners be really added 
+			var fakeCluster = {
+			
+				on: function(event, callback) {
+					registeredClusterEvents.push(event);
+				},
+				
+				isMaster: true,
+				isWorker: false,
+				
+			};
+		
+			var fakeActualAppender = function(loggingEvent) {
+				loggingEvents.push(loggingEvent);
+			}
+			
+			// Load appender and fake modules in it
+			var appenderModule = sandbox.require('../lib/appenders/clustered', {
+				requires: {
+					'cluster': fakeCluster,
+				}
+			});
+		
+			var masterAppender = appenderModule.appender({
+				actualAppenders: [fakeActualAppender, fakeActualAppender, fakeActualAppender],
+                                appenders: [{}, {category: "test"}, {category: "wovs"}]
+			});
+
+			// Actual test - log message using masterAppender
+			masterAppender(new LoggingEvent('wovs', 'Info', ['masterAppender test']));
+			
+			var returnValue = {
+				registeredClusterEvents: registeredClusterEvents,
+				loggingEvents: loggingEvents,
+			};
+		
+			return returnValue;
+		}, 
+		
+		"should register 'fork' event listener on 'cluster'": function(topic) { 
+			assert.equal(topic.registeredClusterEvents[0], 'fork');
+		},
+		
+		"should log using actual appender": function(topic) {
+                        assert.equal(topic.loggingEvents.length, 2)
+			assert.equal(topic.loggingEvents[0].data[0], 'masterAppender test');
+                        assert.equal(topic.loggingEvents[1].data[0], 'masterAppender test');
+		},
+		
+	},
+	
+	'when in worker mode': {
+		
+		topic: function() {
+			
+			var registeredProcessEvents = [];
+			
+			// Fake cluster module, to fake we're inside a worker process
+			var fakeCluster = {
+			
+				isMaster: false,
+				isWorker: true,
+				
+			};
+			
+			var fakeProcess = {
+			
+				send: function(data) {
+					registeredProcessEvents.push(data);
+				},
+				
+			};
+			
+			// Load appender and fake modules in it
+			var appenderModule = sandbox.require('../lib/appenders/clustered', {
+				requires: {
+					'cluster': fakeCluster,
+				},
+				globals: {
+					'process': fakeProcess,
+				}
+			});
+			
+			var workerAppender = appenderModule.appender();
+
+			// Actual test - log message using masterAppender
+			workerAppender(new LoggingEvent('wovs', 'Info', ['workerAppender test']));
+			workerAppender(new LoggingEvent('wovs', 'Info', [new Error('Error test')]));
+			
+			var returnValue = {
+				registeredProcessEvents: registeredProcessEvents,
+			};
+			
+			return returnValue;
+		
+		},
+		
+		"worker appender should call process.send" : function(topic) {
+			assert.equal(topic.registeredProcessEvents[0].type, '::log-message');
+			assert.equal(JSON.parse(topic.registeredProcessEvents[0].event).data[0], "workerAppender test");
+		},
+		
+		"worker should serialize an Error correctly" : function(topic) {
+			assert.equal(topic.registeredProcessEvents[1].type, '::log-message');
+			assert(JSON.parse(topic.registeredProcessEvents[1].event).data[0].stack);
+			var actual = JSON.parse(topic.registeredProcessEvents[1].event).data[0].stack;
+			var expectedRegex = /^Error: Error test/;
+			assert(actual.match(expectedRegex), "Expected: \n\n " + actual + "\n\n to match " + expectedRegex);
+		}
+		
+	}
+
+}).exportTo(module);

test/configuration-test.js

@@ -1,131 +1,149 @@
-var assert = require('assert'),
+"use strict";
-    vows = require('vows'),
+var assert = require('assert')
-    sandbox = require('sandboxed-module');
+, vows = require('vows')
+, sandbox = require('sandboxed-module');
 
 function makeTestAppender() {
-    return {
+  return {
-        configure: function(config, options) {
+    configure: function(config, options) {
-            this.configureCalled = true;
+      this.configureCalled = true;
-            this.config = config;
+      this.config = config;
-            this.options = options;
+      this.options = options;
-            return this.appender();
+      return this.appender();
-        },
+    },
-        appender: function() {
+    appender: function() {
-            var self = this;
+      var self = this;
-            return function(logEvt) { self.logEvt = logEvt; }
+      return function(logEvt) { self.logEvt = logEvt; };
-        }
+    }
-    };
+  };
 }
 
 vows.describe('log4js configure').addBatch({
-    'appenders': {
+  'appenders': {
-        'when specified by type': {
+    'when specified by type': {
-            topic: function() {
+      topic: function() {
-                var testAppender = makeTestAppender(),
+        var testAppender = makeTestAppender(),
-                    log4js = sandbox.require(
+        log4js = sandbox.require(
-                        '../lib/log4js',
+          '../lib/log4js',
-                        {
+          {
-                            requires: {
+            requires: {
-                                './appenders/cheese': testAppender
+              './appenders/cheese': testAppender
-                            }
-                        }
-                    );
-                log4js.configure(
-                    {
-                        appenders: [
-                            { type: "cheese", flavour: "gouda" }
-                        ]
-                    },
-                    { pants: "yes" }
-                );
-                return testAppender;
-            },
-            'should load appender': function(testAppender) {
-                assert.ok(testAppender.configureCalled);
-            },
-            'should pass config to appender': function(testAppender) {
-                assert.equal(testAppender.config.flavour, 'gouda');
-            },
-            'should pass log4js options to appender': function(testAppender) {
-                assert.equal(testAppender.options.pants, 'yes');
             }
-        },
-        'when core appender loaded via loadAppender': {
-            topic: function() {
-                var testAppender = makeTestAppender(),
-                    log4js = sandbox.require(
-                        '../lib/log4js',
-                        { requires: { './appenders/cheese': testAppender } }
-                    );
-
-                log4js.loadAppender('cheese');
-                return log4js;
-            },
-            'should load appender from ../lib/appenders': function(log4js) {
-                assert.ok(log4js.appenders.cheese);
-            },
-            'should add appender configure function to appenderMakers' : function(log4js) {
-                assert.isFunction(log4js.appenderMakers.cheese);
-            }
-        },
-        'when appender in node_modules loaded via loadAppender': {
-            topic: function() {
-                var testAppender = makeTestAppender(),
-                log4js = sandbox.require(
-                    '../lib/log4js',
-                    { requires: { 'some/other/external': testAppender } }
-                );
-                log4js.loadAppender('some/other/external');
-                return log4js;
-            },
-            'should load appender via require': function(log4js) {
-                assert.ok(log4js.appenders['some/other/external']);
-            },
-            'should add appender configure function to appenderMakers': function(log4js) {
-                assert.isFunction(log4js.appenderMakers['some/other/external']);
-            }
-        },
-        'when configuration file loaded via LOG4JS_CONFIG environment variable': {
-          topic: function() {
-            process.env.LOG4JS_CONFIG = 'some/path/to/mylog4js.json';
-            var fileRead = 0,
-            modulePath = 'some/path/to/mylog4js.json',
-            pathsChecked = [],
-            mtime = new Date(),
-            fakeFS = {
-                config: { appenders: [ { type: 'console', layout: { type: 'messagePassThrough' } } ],
-                          levels: { 'a-test' : 'INFO' } },
-                readdirSync: function(dir) {
-                    return require('fs').readdirSync(dir);
-                },
-                readFileSync: function (file, encoding) {
-                    fileRead += 1;
-                    assert.isString(file);
-                    assert.equal(file, modulePath);
-                    assert.equal(encoding, 'utf8');
-                    return JSON.stringify(fakeFS.config);
-                },
-                statSync: function (path) {
-                    pathsChecked.push(path);
-                    if (path === modulePath) {
-                        return { mtime: mtime };
-                    } else {
-                        throw new Error("no such file");
-                    }
-                }
-            },
-            log4js = sandbox.require('../lib/log4js',
-                                     {
-                                       requires: {
-                                         'fs': fakeFS,
-                                       }
-                                     });
-            delete process.env.LOG4JS_CONFIG;
-            return fileRead;
-          },
-          'should load the specified local configuration file' : function(fileRead) {
-            assert.equal(fileRead, 1);
           }
-        }
+        );
+        log4js.configure(
+          {
+            appenders: [
+              { type: "cheese", flavour: "gouda" }
+            ]
+          },
+          { pants: "yes" }
+        );
+        return testAppender;
+      },
+      'should load appender': function(testAppender) {
+        assert.ok(testAppender.configureCalled);
+      },
+      'should pass config to appender': function(testAppender) {
+        assert.equal(testAppender.config.flavour, 'gouda');
+      },
+      'should pass log4js options to appender': function(testAppender) {
+        assert.equal(testAppender.options.pants, 'yes');
+      }
+    },
+    'when core appender loaded via loadAppender': {
+      topic: function() {
+        var testAppender = makeTestAppender(),
+        log4js = sandbox.require(
+          '../lib/log4js',
+          { requires: { './appenders/cheese': testAppender } }
+        );
+        
+        log4js.loadAppender('cheese');
+        return log4js;
+      },
+      'should load appender from ../lib/appenders': function(log4js) {
+        assert.ok(log4js.appenders.cheese);
+      },
+      'should add appender configure function to appenderMakers' : function(log4js) {
+        assert.isFunction(log4js.appenderMakers.cheese);
+      }
+    },
+    'when appender in node_modules loaded via loadAppender': {
+      topic: function() {
+        var testAppender = makeTestAppender(),
+        log4js = sandbox.require(
+          '../lib/log4js',
+          { requires: { 'some/other/external': testAppender } }
+        );
+        log4js.loadAppender('some/other/external');
+        return log4js;
+      },
+      'should load appender via require': function(log4js) {
+        assert.ok(log4js.appenders['some/other/external']);
+      },
+      'should add appender configure function to appenderMakers': function(log4js) {
+        assert.isFunction(log4js.appenderMakers['some/other/external']);
+      }
+    },
+    'when appender object loaded via loadAppender': {
+      topic: function() {
+        var testAppender = makeTestAppender(),
+            log4js = sandbox.require('../lib/log4js');
+
+        log4js.loadAppender('some/other/external', testAppender);
+        return log4js;
+      },
+      'should load appender with provided object': function(log4js) {
+        assert.ok(log4js.appenders['some/other/external']);
+      },
+      'should add appender configure function to appenderMakers': function(log4js) {
+        assert.isFunction(log4js.appenderMakers['some/other/external']);
+      }
+    },
+    'when configuration file loaded via LOG4JS_CONFIG environment variable': {
+      topic: function() {
+        process.env.LOG4JS_CONFIG = 'some/path/to/mylog4js.json';
+        var fileRead = 0,
+        modulePath = 'some/path/to/mylog4js.json',
+        pathsChecked = [],
+        mtime = new Date(),
+        fakeFS = {
+          config: { appenders: [ { type: 'console', layout: { type: 'messagePassThrough' } } ],
+                    levels: { 'a-test' : 'INFO' } },
+          readdirSync: function(dir) {
+            return require('fs').readdirSync(dir);
+          },
+          readFileSync: function (file, encoding) {
+            fileRead += 1;
+            assert.isString(file);
+            assert.equal(file, modulePath);
+            assert.equal(encoding, 'utf8');
+            return JSON.stringify(fakeFS.config);
+          },
+          statSync: function (path) {
+            pathsChecked.push(path);
+            if (path === modulePath) {
+              return { mtime: mtime };
+            } else {
+              throw new Error("no such file");
+            }
+          }
+        },
+        log4js = sandbox.require(
+          '../lib/log4js',
+          {
+            requires: {
+              'fs': fakeFS,
+            }
+          }
+        );
+        delete process.env.LOG4JS_CONFIG;
+        return fileRead;
+      },
+      'should load the specified local configuration file' : function(fileRead) {
+        assert.equal(fileRead, 1);
+      }
     }
+  }
 }).exportTo(module);

test/configureNoLevels-test.js

@@ -1,7 +1,10 @@
+"use strict";
 // This test shows unexpected behaviour for log4js.configure() in log4js-node@0.4.3 and earlier:
-// 1) log4js.configure(), log4js.configure(null), log4js.configure({}), log4js.configure(<some object with no levels prop>)
+// 1) log4js.configure(), log4js.configure(null),
+// log4js.configure({}), log4js.configure(<some object with no levels prop>)
 // all set all loggers levels to trace, even if they were previously set to something else.
-// 2) log4js.configure({levels:{}}), log4js.configure({levels: {foo: bar}}) leaves previously set logger levels intact.
+// 2) log4js.configure({levels:{}}), log4js.configure({levels: {foo:
+// bar}}) leaves previously set logger levels intact.
 //
 
 // Basic set up
@@ -28,7 +31,7 @@ var configs = {
   'has empty levels': {levels: {}},
   'has random levels': {levels: {foo: 'bar'}},
   'has some valid levels': {levels: {A: 'INFO'}}
-}
+};
 
 // Set up the basic vows batches for this test
 var batches = [];
@@ -60,13 +63,85 @@ function getTopLevelContext(nop, configToTest, name) {
       }
       return log4js;
     }
-  }
+  };
-};
+}
 
 showProgress('Populating batch object...');
 
-// Populating the batches programmatically,
+function checkForMismatch(topic) {
-// as there are (configs.length x strLevels.length x strLevels.length) = 324 possible test combinations
+  var er = topic.log4js.levels.toLevel(topic.baseLevel)
+    .isLessThanOrEqualTo(topic.log4js.levels.toLevel(topic.comparisonLevel));
+
+  assert.equal(
+    er, 
+    topic.expectedResult, 
+    'Mismatch: for setLevel(' + topic.baseLevel + 
+      ') was expecting a comparison with ' + topic.comparisonLevel + 
+      ' to be ' + topic.expectedResult
+  );
+}
+
+function checkExpectedResult(topic) {
+  var result = topic.log4js
+    .getLogger(getLoggerName(topic.baseLevel))
+    .isLevelEnabled(topic.log4js.levels.toLevel(topic.comparisonLevel));
+  
+  assert.equal(
+    result, 
+    topic.expectedResult, 
+    'Failed: ' + getLoggerName(topic.baseLevel) + 
+      '.isLevelEnabled( ' + topic.comparisonLevel + ' ) returned ' + result
+  );
+}
+
+function setupBaseLevelAndCompareToOtherLevels(baseLevel) {
+  var baseLevelSubContext = 'and checking the logger whose level was set to '+baseLevel ;
+  var subContext = { topic: baseLevel };
+  batch[context][baseLevelSubContext] = subContext;
+
+  // each logging level has strLevels sub-contexts,
+  // to exhaustively test all the combinations of 
+  // setLevel(baseLevel) and isLevelEnabled(comparisonLevel) per config
+  strLevels.forEach(compareToOtherLevels(subContext));
+}
+
+function compareToOtherLevels(subContext) {
+  var baseLevel = subContext.topic;
+
+  return function (comparisonLevel) {
+    var comparisonLevelSubContext = 'with isLevelEnabled('+comparisonLevel+')';
+
+    // calculate this independently of log4js, but we'll add a vow 
+    // later on to check that we're not mismatched with log4js
+    var expectedResult = strLevels.indexOf(baseLevel) <= strLevels.indexOf(comparisonLevel);
+
+    // the topic simply gathers all the parameters for the vow 
+    // into an object, to simplify the vow's work.
+    subContext[comparisonLevelSubContext] = {
+      topic: function(baseLevel, log4js) {
+        return {
+          comparisonLevel: comparisonLevel, 
+          baseLevel: baseLevel, 
+          log4js: log4js, 
+          expectedResult: expectedResult
+        };
+      }
+    };
+
+    var vow = 'should return '+expectedResult;
+    subContext[comparisonLevelSubContext][vow] = checkExpectedResult;
+    
+    // the extra vow to check the comparison between baseLevel and
+    // comparisonLevel we performed earlier matches log4js'
+    // comparison too
+    var subSubContext = subContext[comparisonLevelSubContext];
+    subSubContext['finally checking for comparison mismatch with log4js'] = checkForMismatch;
+  };
+}
+
+// Populating the batches programmatically, as there are 
+// (configs.length x strLevels.length x strLevels.length) = 324 
+// possible test combinations
 for (var cfg in configs) {
   var configToTest = configs[cfg];
   var nop = configToTest === 'nop';
@@ -84,43 +159,15 @@ for (var cfg in configs) {
   batch[context]= getTopLevelContext(nop, configToTest, context);
   batches.push(batch);
 
-  // each top-level context has strLevels sub-contexts, one per logger which has set to a specific level in the top-level context's topic
+  // each top-level context has strLevels sub-contexts, one per logger 
-  strLevels.forEach(function (baseLevel) {
+  // which has set to a specific level in the top-level context's topic
-    var baseLevelSubContext = 'and checking the logger whose level was set to '+baseLevel ;
+  strLevels.forEach(setupBaseLevelAndCompareToOtherLevels);
-    batch[context][baseLevelSubContext] = {topic: baseLevel};
+}
-
-    // each logging level has strLevels sub-contexts,
-    // to exhaustively test all the combinations of setLevel(baseLevel) and isLevelEnabled(comparisonLevel) per config
-    strLevels.forEach(function (comparisonLevel) {
-      var comparisonLevelSubContext = 'with isLevelEnabled('+comparisonLevel+')';
-
-      // calculate this independently of log4js, but we'll add a vow later on to check that we're not mismatched with log4js
-      var expectedResult = strLevels.indexOf(baseLevel) <= strLevels.indexOf(comparisonLevel);
-
-      // the topic simply gathers all the parameters for the vow into an object, to simplify the vow's work.
-      batch[context][baseLevelSubContext][comparisonLevelSubContext] = {topic: function(baseLevel, log4js){
-        return {comparisonLevel: comparisonLevel, baseLevel: baseLevel, log4js: log4js, expectedResult: expectedResult};
-      }};
-
-      var vow = 'should return '+expectedResult;
-      batch[context][baseLevelSubContext][comparisonLevelSubContext][vow] = function(topic){
-        var result = topic.log4js.getLogger(getLoggerName(topic.baseLevel)).isLevelEnabled(topic.log4js.levels.toLevel(topic.comparisonLevel));
-        assert.equal(result, topic.expectedResult, 'Failed: '+getLoggerName(topic.baseLevel)+'.isLevelEnabled( '+topic.comparisonLevel+' ) returned '+result);
-      };
-
-      // the extra vow to check the comparison between baseLevel and comparisonLevel we performed earlier matches log4js' comparison too
-      batch[context][baseLevelSubContext][comparisonLevelSubContext]['finally checking for comparison mismatch with log4js'] = function(topic){
-        var er = topic.log4js.levels.toLevel(topic.baseLevel).isLessThanOrEqualTo(topic.log4js.levels.toLevel(topic.comparisonLevel));
-        assert.equal(er, topic.expectedResult, 'Mismatch: for setLevel('+topic.baseLevel+') was expecting a comparison with '+topic.comparisonLevel+' to be '+topic.expectedResult);
-      };
-    });
-  });
-};
 
 showProgress('Running tests');
 var v = vows.describe('log4js.configure(), with or without a "levels" property');
 
-batches.forEach(function(batch) {v=v.addBatch(batch)});
+batches.forEach(function(batch) {v=v.addBatch(batch);});
 
 v.export(module);
 

test/connect-logger-test.js

@@ -1,128 +1,226 @@
+/* jshint maxparams:7 */
+"use strict";
 var vows = require('vows')
 , assert = require('assert')
 , levels = require('../lib/levels');
 
 function MockLogger() {
 
-    var that = this;
+  var that = this;
-    this.messages = [];
+  this.messages = [];
+  
+  this.log = function(level, message, exception) {
+    that.messages.push({ level: level, message: message });
+  };
 
-    this.log = function(level, message, exception) {
+  this.isLevelEnabled = function(level) {
-	that.messages.push({ level: level, message: message });
+    return level.isGreaterThanOrEqualTo(that.level);
-    };
+  };
-
+  
-    this.isLevelEnabled = function(level) {
+  this.level = levels.TRACE;
-        return level.isGreaterThanOrEqualTo(that.level);
-    };
-
-    this.level = levels.TRACE;
 
 }
 
-function MockRequest(remoteAddr, method, originalUrl) {
+function MockRequest(remoteAddr, method, originalUrl, headers) {
 
-    this.socket = { remoteAddress: remoteAddr };
+  this.socket = { remoteAddress: remoteAddr };
-    this.originalUrl = originalUrl;
+  this.originalUrl = originalUrl;
-    this.method = method;
+  this.method = method;
-    this.httpVersionMajor = '5';
+  this.httpVersionMajor = '5';
-    this.httpVersionMinor = '0';
+  this.httpVersionMinor = '0';
-    this.headers = {}
+  this.headers = headers || {};
+
+  var self = this;
+  Object.keys(this.headers).forEach(function(key) {
+    self.headers[key.toLowerCase()] = self.headers[key];
+  });
+}
+
+function MockResponse() {
+  
+  this.end = function(chunk, encoding) {    
+  };
+
+  this.writeHead = function(code, headers) {
+  };
 
 }
 
-function MockResponse(statusCode) {
+function request(cl, method, url, code, reqHeaders, resHeaders) {
-
+  var req = new MockRequest('my.remote.addr', method, url, reqHeaders);
-    this.statusCode = statusCode;
+  var res = new MockResponse();
-
+  cl(req, res, function() {});
-    this.end = function(chunk, encoding) {
+  res.writeHead(code, resHeaders);
-
+  res.end('chunk','encoding');
-    }
-
 }
 
 vows.describe('log4js connect logger').addBatch({
-    'getConnectLoggerModule': {
+  'getConnectLoggerModule': {
-	topic: function() {
+    topic: function() {
-	    var clm = require('../lib/connect-logger');
+      var clm = require('../lib/connect-logger');
-	    return clm;
+      return clm;
-	},
+    },
+    
+    'should return a "connect logger" factory' : function(clm) {
+      assert.isObject(clm);
+    },
 
-	'should return a "connect logger" factory' : function(clm) {
+    'take a log4js logger and return a "connect logger"' : {
-	    assert.isObject(clm);
+      topic: function(clm) {
-	},
+        var ml = new MockLogger();
+        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);
+        request(cl, 'GET', 'http://url', 200);
+        return ml.messages;
+      },
 
-	'take a log4js logger and return a "connect logger"' : {
+      'check message': function(messages) {
-	    topic: function(clm) {
+        assert.isArray(messages);
-		var ml = new MockLogger();
+        assert.equal(messages.length, 1);
-		var cl = clm.connectLogger(ml);
+        assert.ok(levels.INFO.isEqualTo(messages[0].level));
-		return cl;
+        assert.include(messages[0].message, 'GET');
-	    },
+        assert.include(messages[0].message, 'http://url');
+        assert.include(messages[0].message, 'my.remote.addr');
+        assert.include(messages[0].message, '200');
+      }
+    },
 
-	    'should return a "connect logger"': function(cl) {
+    'log events with level below logging level' : {
-		assert.isFunction(cl);
+      topic: function(clm) {
-	    }
+        var ml = new MockLogger();
-	},
+        ml.level = levels.FATAL;
+        var cl = clm.connectLogger(ml);
+        request(cl, 'GET', 'http://url', 200);
+        return ml.messages;
+      },
+      
+      'check message': function(messages) {
+        assert.isArray(messages);
+        assert.isEmpty(messages);
+      }
+    },
 
-	'log events' : {
+    'log events with non-default level and custom format' : {
-	    topic: function(clm) {
+      topic: function(clm) {
-		var ml = new MockLogger();
+        var ml = new MockLogger();
-		var cl = clm.connectLogger(ml);
+        ml.level = levels.INFO;
-		var req = new MockRequest('my.remote.addr', 'GET', 'http://url');
+        var cl = clm.connectLogger(ml, { level: levels.INFO, format: ':method :url' } );
-		var res = new MockResponse(200);
+        request(cl, 'GET', 'http://url', 200);
-		cl(req, res, function() { });
+        return ml.messages;
-        	res.end('chunk', 'encoding');
+      },
-        	return ml.messages;
+      
-	    },
+      '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');
+      }
+    },
 
-	    'check message': function(messages) {
+    'logger with options as string': {
-		assert.isArray(messages);
+      topic: function(clm) {
-		assert.equal(messages.length, 1);
+        var ml = new MockLogger();
-		assert.ok(levels.INFO.isEqualTo(messages[0].level));
+        ml.level = levels.INFO;
-		assert.include(messages[0].message, 'GET');
+        var cl = clm.connectLogger(ml, ':method :url');
-		assert.include(messages[0].message, 'http://url');
+        request(cl, 'POST', 'http://meh', 200);
-		assert.include(messages[0].message, 'my.remote.addr');
+        return ml.messages;
-		assert.include(messages[0].message, '200');
+      },
-	    }
+      'should use the passed in format': function(messages) {
-	},
+        assert.equal(messages[0].message, 'POST http://meh');
+      }
+    },
 
-	'log events with level below logging level' : {
+    'auto log levels': {
-	    topic: function(clm) {
+      topic: function(clm) {
-		var ml = new MockLogger();
+        var ml = new MockLogger();
-		ml.level = levels.FATAL;
+        ml.level = levels.INFO;
-		var cl = clm.connectLogger(ml);
+        var cl = clm.connectLogger(ml, { level: 'auto', format: ':method :url' });
-		var req = new MockRequest('my.remote.addr', 'GET', 'http://url');
+        request(cl, 'GET', 'http://meh', 200);
-		var res = new MockResponse(200);
+        request(cl, 'GET', 'http://meh', 201);
-		cl(req, res, function() { });
+        request(cl, 'GET', 'http://meh', 302);
-		res.end('chunk', 'encoding');
+        request(cl, 'GET', 'http://meh', 404);
-		return ml.messages;
+        request(cl, 'GET', 'http://meh', 500);
-	    },
+        return ml.messages;
+      },
 
-	    'check message': function(messages) {
+      'should use INFO for 2xx': function(messages) {
-		assert.isArray(messages);
+        assert.ok(levels.INFO.isEqualTo(messages[0].level));
-		assert.isEmpty(messages);
+        assert.ok(levels.INFO.isEqualTo(messages[1].level));
-	    }
+      },
-	},
 
-	'log events with non-default level and custom format' : {
+      'should use WARN for 3xx': function(messages) {
-	    topic: function(clm) {
+        assert.ok(levels.WARN.isEqualTo(messages[2].level));
-		var ml = new MockLogger();
+      },
-		ml.level = levels.INFO;
-		var cl = clm.connectLogger(ml, { level: levels.INFO, format: ':method :url' } );
-		var req = new MockRequest('my.remote.addr', 'GET', 'http://url');
-		var res = new MockResponse(200);
-		cl(req, res, function() { });
-		res.end('chunk', 'encoding');
-		return ml.messages;
-	    },
 
-	    'check message': function(messages) {
+      'should use ERROR for 4xx': function(messages) {
-		assert.isArray(messages);
+        assert.ok(levels.ERROR.isEqualTo(messages[3].level));
-		assert.equal(messages.length, 1);
+      },
-		assert.ok(levels.INFO.isEqualTo(messages[0].level));
-		assert.equal(messages[0].message, 'GET http://url');
-	    }
-	}
 
-    }
+      'should use ERROR for 5xx': function(messages) {
+        assert.ok(levels.ERROR.isEqualTo(messages[4].level));
+      }
+    },
 
+    'format using a function': {
+      topic: function(clm) {
+        var ml = new MockLogger();
+        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;
+      },
+
+      'should call the format function': function(messages) {
+        assert.equal(messages[0].message, 'I was called');
+      }
+    },
+
+    'format that includes request headers': {
+      topic: function(clm) {
+        var ml = new MockLogger();
+        ml.level = levels.INFO;
+        var cl = clm.connectLogger(ml, ':req[Content-Type]');
+        request(
+          cl, 
+          'GET', 'http://blah', 200, 
+          { 'Content-Type': 'application/json' }
+        );
+        return ml.messages;
+      },
+      'should output the request header': function(messages) {
+        assert.equal(messages[0].message, 'application/json');
+      }
+    },
+
+    'format that includes response headers': {
+      topic: function(clm) {
+        var ml = new MockLogger();
+        ml.level = levels.INFO;
+        var cl = clm.connectLogger(ml, ':res[Content-Type]');
+        request(
+          cl,
+          'GET', 'http://blah', 200,
+          null,
+          { 'Content-Type': 'application/cheese' }
+        );
+        return ml.messages;
+      },
+
+      'should output the response header': function(messages) {
+        assert.equal(messages[0].message, 'application/cheese');
+      }
+    }                                          
+    
+  }
 }).export(module);

test/consoleAppender-test.js

@@ -0,0 +1,33 @@
+"use strict";
+var assert = require('assert')
+, vows = require('vows')
+, layouts = require('../lib/layouts')
+, sandbox = require('sandboxed-module');
+
+vows.describe('../lib/appenders/console').addBatch({
+  'appender': {
+    topic: function() {
+      var messages = []
+      , fakeConsole = {
+        log: function(msg) { messages.push(msg); }
+      }
+      , appenderModule = sandbox.require(
+        '../lib/appenders/console',
+        {
+          globals: {
+            'console': fakeConsole
+          }
+        }
+      )
+      , appender = appenderModule.appender(layouts.messagePassThroughLayout);
+
+      appender({ data: ["blah"] });
+      return messages;
+    },
+
+    'should output to console': function(messages) {
+      assert.equal(messages[0], 'blah');
+    }
+  }
+          
+}).exportTo(module);

test/dateFileAppender-test.js

@@ -1,8 +1,11 @@
-var vows = require('vows'),
+"use strict";
-    assert = require('assert'),
+var vows = require('vows')
-    path = require('path'),
+, assert = require('assert')
-    fs = require('fs'),
+, path = require('path')
-    log4js = require('../lib/log4js');
+, fs = require('fs')
+, sandbox = require('sandboxed-module')
+, log4js = require('../lib/log4js')
+, EOL = require('os').EOL || '\n';
 
 function removeFile(filename) {
   return function() {
@@ -15,115 +18,206 @@ function removeFile(filename) {
 }
 
 vows.describe('../lib/appenders/dateFile').addBatch({
-    'appender': {
+  'appender': {
-        'adding multiple dateFileAppenders': {
+    'adding multiple dateFileAppenders': {
-            topic: function () {
+      topic: function () {
-                var listenersCount = process.listeners('exit').length,
+        var listenersCount = process.listeners('exit').length,
-                    dateFileAppender = require('../lib/appenders/dateFile'),
+        dateFileAppender = require('../lib/appenders/dateFile'),
-                    count = 5,
+        count = 5,
-                    logfile;
+        logfile;
-
+        
-                while (count--) {
+        while (count--) {
-                    logfile = path.join(__dirname, 'datefa-default-test' + count + '.log');
+          logfile = path.join(__dirname, 'datefa-default-test' + count + '.log');
-                    log4js.addAppender(dateFileAppender.appender(logfile));
+          log4js.addAppender(dateFileAppender.appender(logfile));
-                }
-
-                return listenersCount;
-            },
-            teardown: function() {
-                removeFile('datefa-default-test0.log')();
-                removeFile('datefa-default-test1.log')();
-                removeFile('datefa-default-test2.log')();
-                removeFile('datefa-default-test3.log')();
-                removeFile('datefa-default-test4.log')();
-            },
-
-            'should only add one `exit` listener': function (initialCount) {
-                assert.equal(process.listeners('exit').length, initialCount + 1);
-            }
-        },
-
-        'with default settings': {
-            topic: function() {
-                var that = this,
-                    testFile = path.join(__dirname, 'date-appender-default.log'),
-                    appender = require('../lib/appenders/dateFile').appender(testFile),
-                    logger = log4js.getLogger('default-settings');
-                log4js.clearAppenders();
-                log4js.addAppender(appender, 'default-settings');
-
-                logger.info("This should be in the file.");
-
-                setTimeout(function() {
-                    fs.readFile(testFile, "utf8", that.callback);
-                }, 100);
-
-            },
-            teardown: removeFile('date-appender-default.log'),
-
-            'should write to the file': function(contents) {
-                assert.include(contents, 'This should be in the file');
-            },
-
-            'should use the basic layout': function(contents) {
-                assert.match(contents, /\[\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}\.\d{3}\] \[INFO\] default-settings - /);
-            }
         }
+        
+        return listenersCount;
+      },
+      teardown: function() {
+        removeFile('datefa-default-test0.log')();
+        removeFile('datefa-default-test1.log')();
+        removeFile('datefa-default-test2.log')();
+        removeFile('datefa-default-test3.log')();
+        removeFile('datefa-default-test4.log')();
+      },
+      
+      'should only add one `exit` listener': function (initialCount) {
+        assert.equal(process.listeners('exit').length, initialCount + 1);
+      },
 
+    },
+
+    'exit listener': {
+      topic: function() {
+        var exitListener
+        , openedFiles = []
+        , dateFileAppender = sandbox.require(
+          '../lib/appenders/dateFile',
+          {
+            globals: {
+              process: {
+                on: function(evt, listener) {
+                  exitListener = listener;
+                }
+              }
+            },
+            requires: {
+              '../streams': {
+                DateRollingFileStream: function(filename) {
+                  openedFiles.push(filename);
+
+                  this.end = function() {
+                    openedFiles.shift();
+                  };
+                }
+              }
+            }   
+          }
+        );
+        for (var i=0; i < 5; i += 1) {
+          dateFileAppender.appender('test' + i);
+        }
+        assert.isNotEmpty(openedFiles);
+        exitListener();
+        return openedFiles;
+      },
+      'should close all open files': function(openedFiles) {
+        assert.isEmpty(openedFiles);
+      }
+    },
+    
+    'with default settings': {
+      topic: function() {
+        var that = this,
+        testFile = path.join(__dirname, 'date-appender-default.log'),
+        appender = require('../lib/appenders/dateFile').appender(testFile),
+        logger = log4js.getLogger('default-settings');
+        log4js.clearAppenders();
+        log4js.addAppender(appender, 'default-settings');
+        
+        logger.info("This should be in the file.");
+        
+        setTimeout(function() {
+          fs.readFile(testFile, "utf8", that.callback);
+        }, 100);
+        
+      },
+      teardown: removeFile('date-appender-default.log'),
+      
+      'should write to the file': function(contents) {
+        assert.include(contents, 'This should be in the file');
+      },
+      
+      'should use the basic layout': function(contents) {
+        assert.match(
+          contents, 
+            /\[\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}\.\d{3}\] \[INFO\] default-settings - /
+        );
+      }
     }
+    
+  }
 }).addBatch({
   'configure': {
     'with dateFileAppender': {
-	    topic: function() {
+      topic: function() {
-	      var log4js = require('../lib/log4js')
+        var log4js = require('../lib/log4js')
         , logger;
-	      //this config file defines one file appender (to ./date-file-test.log)
+        //this config file defines one file appender (to ./date-file-test.log)
-	      //and sets the log level for "tests" to WARN
+        //and sets the log level for "tests" to WARN
         log4js.configure('test/with-dateFile.json');
         logger = log4js.getLogger('tests');
-	      logger.info('this should not be written to the file');
+        logger.info('this should not be written to the file');
-	      logger.warn('this should be written to the file');
+        logger.warn('this should be written to the file');
         
         fs.readFile(path.join(__dirname, 'date-file-test.log'), 'utf8', this.callback);
-	    },
+      },
       teardown: removeFile('date-file-test.log'),
       
-	    'should load appender configuration from a json file': function(err, contents) {
+      'should load appender configuration from a json file': function(err, contents) {
-	      assert.include(contents, 'this should be written to the file' + require('os').EOL);
+        if (err) {
+          throw err;
+        }
+        assert.include(contents, 'this should be written to the file' + EOL);
         assert.equal(contents.indexOf('this should not be written to the file'), -1);
-	    }
+      }
     },
-	  'with options.alwaysIncludePattern': {
+    'with options.alwaysIncludePattern': {
-	    topic: function() {
+      topic: function() {
-	      var log4js = require('../lib/log4js')
+        var self = this
-	      , format = require('../lib/date_format')
+        , log4js = require('../lib/log4js')
-	      , logger
+        , format = require('../lib/date_format')
-	      , options = {
+        , logger
-		      "appenders": [
+        , options = {
-		        {
+          "appenders": [
-		          "category": "tests", 
+            {
-		          "type": "dateFile", 
+              "category": "tests", 
-		          "filename": "test/date-file-test",
+              "type": "dateFile", 
-		          "pattern": "-from-MM-dd.log",
+              "filename": "test/date-file-test",
-		          "alwaysIncludePattern": true,
+              "pattern": "-from-MM-dd.log",
-		          "layout": { 
+              "alwaysIncludePattern": true,
-			          "type": "messagePassThrough" 
+              "layout": { 
-		          }
+                "type": "messagePassThrough" 
-		        }
+              }
-		      ]
+            }
-		    }
+          ]
-	      , thisTime = format.asString(options.appenders[0].pattern, new Date());
+        }
-	      log4js.clearAppenders();
+        , thisTime = format.asString(options.appenders[0].pattern, new Date());
-	      log4js.configure(options);
+        fs.writeFileSync(
-	      logger = log4js.getLogger('tests');
+          path.join(__dirname, 'date-file-test' + thisTime), 
-	      logger.warn('this should be written to the file with the appended date');
+          "this is existing data" + EOL,
+          'utf8'
+        );
+        log4js.clearAppenders();
+        log4js.configure(options);
+        logger = log4js.getLogger('tests');
+        logger.warn('this should be written to the file with the appended date');
         this.teardown = removeFile('date-file-test' + thisTime);
-	      fs.readFile(path.join(__dirname, 'date-file-test' + thisTime), 'utf8', this.callback);
+        //wait for filesystem to catch up
-	    },
+        setTimeout(function() {
-	    'should create file with the correct pattern': function(contents) {
+          fs.readFile(path.join(__dirname, 'date-file-test' + thisTime), 'utf8', self.callback);
-	      assert.include(contents, 'this should be written to the file with the appended date');
+        }, 100);
-	    }
+      },
-	  }
+      'should create file with the correct pattern': function(contents) {
-      
+        assert.include(contents, 'this should be written to the file with the appended date');
+      },
+      'should not overwrite the file on open (bug found in issue #132)': function(contents) {
+        assert.include(contents, 'this is existing data');
+      }
+    },
+    'with cwd option': {
+      topic: function () {
+        var fileOpened,
+        appender = sandbox.require(
+          '../lib/appenders/dateFile',
+          { requires:
+            { '../streams':
+              { DateRollingFileStream: 
+                function(file) {
+                  fileOpened = file;
+                  return {
+                    on: function() {},
+                    end: function() {}
+                  };
+                }
+              }
+            }
+          }
+        );
+        appender.configure(
+          { 
+            filename: "whatever.log", 
+            maxLogSize: 10 
+          }, 
+          { cwd: '/absolute/path/to' }
+        );
+        return fileOpened;
+      },
+      'should prepend options.cwd to config.filename': function (fileOpened) {
+        var expected = path.sep + path.join("absolute", "path", "to", "whatever.log");
+        assert.equal(fileOpened, expected);
+      }
+    }
+ 
   }
 }).exportTo(module);

test/date_format-test.js

@@ -1,23 +1,51 @@
+"use strict";
 var vows = require('vows')
 , assert = require('assert')
 , dateFormat = require('../lib/date_format');
 
 vows.describe('date_format').addBatch({
-    'Date extensions': {
+  'Date extensions': {
-        topic: function() {
+    topic: function() {
-            return new Date(2010, 0, 11, 14, 31, 30, 5);
+      return new Date(2010, 0, 11, 14, 31, 30, 5);
-        },
+    },
-        'should format a date as string using a pattern': function(date) {
+    'should format a date as string using a pattern': function(date) {
-            assert.equal(
+      assert.equal(
-                dateFormat.asString(dateFormat.DATETIME_FORMAT, date),
+        dateFormat.asString(dateFormat.DATETIME_FORMAT, date),
-                "11 01 2010 14:31:30.005"
+        "11 01 2010 14:31:30.005"
-            );
+      );
-        },
+    },
-        'should default to the ISO8601 format': function(date) {
+    'should default to the ISO8601 format': function(date) {
-            assert.equal(
+      assert.equal(
-                dateFormat.asString(date),
+        dateFormat.asString(date),
-                '2010-01-11 14:31:30.005'
+        '2010-01-11 14:31:30.005'
-            );
+      );
-        }
+    },
+    'should provide a ISO8601 with timezone offset format': function(date) {
+      date.getTimezoneOffset = function() { return -660; };
+      assert.equal(
+        dateFormat.asString(dateFormat.ISO8601_WITH_TZ_OFFSET_FORMAT, date),
+        "2010-01-11T14:31:30+1100"
+      );
+
+      date.getTimezoneOffset = function() { return 120; };
+      assert.equal(
+        dateFormat.asString(dateFormat.ISO8601_WITH_TZ_OFFSET_FORMAT, date),
+        "2010-01-11T14:31:30-0200"
+      );
+
+    },
+    'should provide a just-the-time format': function(date) {
+      assert.equal(
+        dateFormat.asString(dateFormat.ABSOLUTETIME_FORMAT, date),
+        '14:31:30.005'
+      );
+    },
+    'should provide a custom format': function(date) {
+      date.getTimezoneOffset = function() { return 120; };
+      assert.equal(
+        dateFormat.asString("O.SSS.ss.mm.hh.dd.MM.yy", date),
+        '-0200.005.30.31.14.11.01.10'
+      );
     }
+  }
 }).export(module);

test/debug-test.js

@@ -0,0 +1,72 @@
+"use strict";
+var vows = require('vows')
+, assert = require('assert')
+, sandbox = require('sandboxed-module')
+, fakeConsole = {
+  error: function(format, label, message) {
+    this.logged = [ format, label, message ];
+  }
+}
+, globals = function(debugValue) {
+  return {
+    process: {
+      env: {
+        'NODE_DEBUG': debugValue
+      }
+    },
+    console: fakeConsole
+  };
+};
+
+vows.describe('../lib/debug').addBatch({
+  'when NODE_DEBUG is set to log4js': {
+    topic: function() {
+      var debug = sandbox.require(
+        '../lib/debug', 
+        { 'globals': globals('log4js') }
+      );
+
+      fakeConsole.logged = [];
+      debug('cheese')('biscuits');
+      return fakeConsole.logged;
+    },
+    'it should log to console.error': function(logged) {
+      assert.equal(logged[0], 'LOG4JS: (%s) %s');
+      assert.equal(logged[1], 'cheese');
+      assert.equal(logged[2], 'biscuits');
+    }
+  },
+
+  'when NODE_DEBUG is set to not log4js': {
+    topic: function() {
+      var debug = sandbox.require(
+        '../lib/debug',
+        { globals: globals('other_module') }
+      );
+
+      fakeConsole.logged = [];
+      debug('cheese')('biscuits');
+      return fakeConsole.logged;
+    },
+    'it should not log to console.error': function(logged) {
+      assert.equal(logged.length, 0);
+    }
+  },
+
+  'when NODE_DEBUG is not set': {
+    topic: function() {
+      var debug = sandbox.require(
+        '../lib/debug',
+        { globals: globals(null) }
+      );
+
+      fakeConsole.logged = [];
+      debug('cheese')('biscuits');
+      return fakeConsole.logged;
+    },
+    'it should not log to console.error': function(logged) {
+      assert.equal(logged.length, 0);
+    }
+  }
+
+}).exportTo(module);

test/fileAppender-test.js

@@ -1,179 +1,281 @@
+"use strict";
 var vows = require('vows')
 , fs = require('fs')
 , path = require('path')
+, sandbox = require('sandboxed-module')
 , log4js = require('../lib/log4js')
-, assert = require('assert');
+, assert = require('assert')
+, EOL = require('os').EOL || '\n';
 
 log4js.clearAppenders();
 
 function remove(filename) {
-    try {
+  try {
-        fs.unlinkSync(filename);
+    fs.unlinkSync(filename);
-    } catch (e) {
+  } catch (e) {
-        //doesn't really matter if it failed
+    //doesn't really matter if it failed
-    }
+  }
 }
 
 vows.describe('log4js fileAppender').addBatch({
-    'adding multiple fileAppenders': {
+  'adding multiple fileAppenders': {
-      topic: function () {
+    topic: function () {
-          var listenersCount = process.listeners('exit').length
+      var listenersCount = process.listeners('exit').length
-            , logger = log4js.getLogger('default-settings')
+      , logger = log4js.getLogger('default-settings')
-            , count = 5, logfile;
+      , count = 5, logfile;
-
+      
-          while (count--) {
+      while (count--) {
-              logfile = path.join(__dirname, '/fa-default-test' + count + '.log');
+        logfile = path.join(__dirname, '/fa-default-test' + count + '.log');
-              log4js.addAppender(require('../lib/appenders/file').appender(logfile), 'default-settings');
+        log4js.addAppender(require('../lib/appenders/file').appender(logfile), 'default-settings');
-          }
-
-          return listenersCount;
-      },
-
-      'does not adds more than one `exit` listeners': function (initialCount) {
-          assert.ok(process.listeners('exit').length <= initialCount + 1);
       }
+      
+      return listenersCount;
     },
-
+    
-    'with default fileAppender settings': {
+    'does not add more than one `exit` listeners': function (initialCount) {
-        topic: function() {
+      assert.ok(process.listeners('exit').length <= initialCount + 1);
-            var that = this
-          , testFile = path.join(__dirname, '/fa-default-test.log')
-          , logger = log4js.getLogger('default-settings');
-            remove(testFile);
-            //log4js.configure({ appenders:[ { type: "file", filename: testFile, category: 'default-settings' } ] });
-            log4js.clearAppenders();
-            log4js.addAppender(require('../lib/appenders/file').appender(testFile), 'default-settings');
-
-            logger.info("This should be in the file.");
-
-            setTimeout(function() {
-                fs.readFile(testFile, "utf8", that.callback);
-            }, 100);
-        },
-        'should write log messages to the file': function(err, fileContents) {
-            assert.include(fileContents, "This should be in the file.\n");
-        },
-        'log messages should be in the basic layout format': function(err, fileContents) {
-            assert.match(fileContents, /\[\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}\.\d{3}\] \[INFO\] default-settings - /);
-        }
-    },
-    'with a max file size and no backups': {
-        topic: function() {
-            var testFile = path.join(__dirname, '/fa-maxFileSize-test.log')
-          , logger = log4js.getLogger('max-file-size')
-          , that = this;
-            remove(testFile);
-            remove(testFile + '.1');
-            //log file of 100 bytes maximum, no backups
-            log4js.clearAppenders();
-            log4js.addAppender(require('../lib/appenders/file').appender(testFile, log4js.layouts.basicLayout, 100, 0), 'max-file-size');
-            logger.info("This is the first log message.");
-            logger.info("This is an intermediate log message.");
-            logger.info("This is the second log message.");
-            //wait for the file system to catch up
-            setTimeout(function() {
-                fs.readFile(testFile, "utf8", that.callback);
-            }, 100);
-        },
-        'log file should only contain the second message': function(err, fileContents) {
-            assert.include(fileContents, "This is the second log message.\n");
-            assert.equal(fileContents.indexOf("This is the first log message."), -1);
-        },
-        'the number of files': {
-            topic: function() {
-                fs.readdir(__dirname, this.callback);
-            },
-            'starting with the test file name should be two': function(err, files) {
-                //there will always be one backup if you've specified a max log size
-                var logFiles = files.filter(function(file) { return file.indexOf('fa-maxFileSize-test.log') > -1; });
-                assert.equal(logFiles.length, 2);
-            }
-        }
-    },
-    'with a max file size and 2 backups': {
-        topic: function() {
-            var testFile = path.join(__dirname, '/fa-maxFileSize-with-backups-test.log')
-          , logger = log4js.getLogger('max-file-size-backups');
-            remove(testFile);
-            remove(testFile+'.1');
-            remove(testFile+'.2');
-
-            //log file of 50 bytes maximum, 2 backups
-            log4js.clearAppenders();
-            log4js.addAppender(require('../lib/appenders/file').appender(testFile, log4js.layouts.basicLayout, 50, 2), '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); 
-		}
-	      });
-            }, 200);
-        },
-        'the log files': {
-            topic: function(files) {
-                var logFiles = files.filter(function(file) { return file.indexOf('fa-maxFileSize-with-backups-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-test.log', 'fa-maxFileSize-with-backups-test.log.1', 'fa-maxFileSize-with-backups-test.log.2']);
-            },
-            '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) {
-                  fs.readFile(path.join(__dirname, logFiles[1]), "utf8", this.callback);
-                },
-                'should be the third log message': function(contents) {
-                    assert.include(contents, 'This is the third log message.');
-                }
-            },
-            'and the contents of the third file': {
-                topic: function(logFiles) {
-                  fs.readFile(path.join(__dirname, logFiles[2]), "utf8", this.callback);
-                },
-                'should be the second log message': function(contents) {
-                    assert.include(contents, 'This is the second log message.');
-                }
-            }
-        }
     }
+  },
+
+  'exit listener': {
+    topic: function() {
+      var exitListener
+      , openedFiles = []
+      , fileAppender = sandbox.require(
+        '../lib/appenders/file',
+        {
+          globals: {
+            process: {
+              on: function(evt, listener) {
+                exitListener = listener;
+              }
+            }
+          },
+          requires: {
+            '../streams': {
+              RollingFileStream: function(filename) {
+                openedFiles.push(filename);
+                
+                this.end = function() {
+                  openedFiles.shift();
+                };
+
+                this.on = function() {};
+              }
+            }
+          }   
+        }
+      );
+      for (var i=0; i < 5; i += 1) {
+        fileAppender.appender('test' + i, null, 100);
+      }
+      assert.isNotEmpty(openedFiles);
+      exitListener();
+      return openedFiles;
+    },
+    'should close all open files': function(openedFiles) {
+      assert.isEmpty(openedFiles);
+    }
+  },
+  
+  'with default fileAppender settings': {
+    topic: function() {
+      var that = this
+      , testFile = path.join(__dirname, '/fa-default-test.log')
+      , logger = log4js.getLogger('default-settings');
+      remove(testFile);
+
+      log4js.clearAppenders();
+      log4js.addAppender(require('../lib/appenders/file').appender(testFile), 'default-settings');
+      
+      logger.info("This should be in the file.");
+      
+      setTimeout(function() {
+        fs.readFile(testFile, "utf8", that.callback);
+      }, 100);
+    },
+    'should write log messages to the file': function (err, fileContents) {
+      assert.include(fileContents, "This should be in the file." + EOL);
+    },
+    'log messages should be in the basic layout format': function(err, fileContents) {
+      assert.match(
+        fileContents, 
+          /\[\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}\.\d{3}\] \[INFO\] default-settings - /
+      );
+    }
+  },
+  'with a max file size and no backups': {
+    topic: function() {
+      var testFile = path.join(__dirname, '/fa-maxFileSize-test.log')
+      , logger = log4js.getLogger('max-file-size')
+      , that = this;
+      remove(testFile);
+      remove(testFile + '.1');
+      //log file of 100 bytes maximum, no backups
+      log4js.clearAppenders();
+      log4js.addAppender(
+        require('../lib/appenders/file').appender(testFile, log4js.layouts.basicLayout, 100, 0), 
+        'max-file-size'
+      );
+      logger.info("This is the first log message.");
+      logger.info("This is an intermediate log message.");
+      logger.info("This is the second log message.");
+      //wait for the file system to catch up
+      setTimeout(function() {
+        fs.readFile(testFile, "utf8", that.callback);
+      }, 100);
+    },
+    'log file should only contain the second message': function(err, fileContents) {
+      assert.include(fileContents, "This is the second log message.");
+      assert.equal(fileContents.indexOf("This is the first log message."), -1);
+    },
+    'the number of files': {
+      topic: function() {
+        fs.readdir(__dirname, this.callback);
+      },
+      'starting with the test file name should be two': function(err, files) {
+        //there will always be one backup if you've specified a max log size
+        var logFiles = files.filter(
+          function(file) { return file.indexOf('fa-maxFileSize-test.log') > -1; }
+        );
+        assert.equal(logFiles.length, 2);
+      }
+    }
+  },
+  'with a max file size and 2 backups': {
+    topic: function() {
+      var testFile = path.join(__dirname, '/fa-maxFileSize-with-backups-test.log')
+      , logger = log4js.getLogger('max-file-size-backups');
+      remove(testFile);
+      remove(testFile+'.1');
+      remove(testFile+'.2');
+      
+      //log file of 50 bytes maximum, 2 backups
+      log4js.clearAppenders();
+      log4js.addAppender(
+        require('../lib/appenders/file').appender(testFile, log4js.layouts.basicLayout, 50, 2), 
+        '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); 
+          }
+        });
+      }, 200);
+    },
+    'the log files': {
+      topic: function(files) {
+        var logFiles = files.filter(
+          function(file) { return file.indexOf('fa-maxFileSize-with-backups-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-test.log', 
+          'fa-maxFileSize-with-backups-test.log.1', 
+          'fa-maxFileSize-with-backups-test.log.2'
+        ]);
+      },
+      '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) {
+          fs.readFile(path.join(__dirname, logFiles[1]), "utf8", this.callback);
+        },
+        'should be the third log message': function(contents) {
+          assert.include(contents, 'This is the third log message.');
+        }
+      },
+      'and the contents of the third file': {
+        topic: function(logFiles) {
+          fs.readFile(path.join(__dirname, logFiles[2]), "utf8", this.callback);
+        },
+        'should be the second log message': function(contents) {
+          assert.include(contents, 'This is the second log message.');
+        }
+      }
+    }
+  }
 }).addBatch({
-    'configure' : {
+  'configure' : {
-        'with fileAppender': {
+    'with fileAppender': {
-	    topic: function() {
+      topic: function() {
-	        var log4js = require('../lib/log4js')
+        var log4js = require('../lib/log4js')
-              , logger;
+        , logger;
-	        //this config file defines one file appender (to ./tmp-tests.log)
+        //this config file defines one file appender (to ./tmp-tests.log)
-	        //and sets the log level for "tests" to WARN
+        //and sets the log level for "tests" to WARN
-                log4js.configure('test/log4js.json');
+        log4js.configure('./test/log4js.json');
-                logger = log4js.getLogger('tests');
+        logger = log4js.getLogger('tests');
-	        logger.info('this should not be written to the file');
+        logger.info('this should not be written to the file');
-	        logger.warn('this should be written to the file');
+        logger.warn('this should be written to the file');
-
+        
-                fs.readFile('tmp-tests.log', 'utf8', this.callback);
+        fs.readFile('tmp-tests.log', 'utf8', this.callback);
-	    },
+      },
-	    'should load appender configuration from a json file': function(err, contents) {
+      'should load appender configuration from a json file': function (err, contents) {
-	        assert.include(contents, 'this should be written to the file\n');
+        assert.include(contents, 'this should be written to the file' + EOL);
-                assert.equal(contents.indexOf('this should not be written to the file'), -1);
+        assert.equal(contents.indexOf('this should not be written to the file'), -1);
-	    }
+      }
-        }
     }
+  }
+}).addBatch({
+  'when underlying stream errors': {
+    topic: function() {
+      var consoleArgs
+      , errorHandler
+      , fileAppender = sandbox.require(
+        '../lib/appenders/file',
+        {
+          globals: {
+            console: {
+              error: function() {
+                consoleArgs = Array.prototype.slice.call(arguments);
+              }
+            }
+          },
+          requires: {
+            '../streams': {
+              RollingFileStream: function(filename) {
+                
+                this.end = function() {};
+                this.on = function(evt, cb) {
+                  if (evt === 'error') {
+                    errorHandler = cb;
+                  }
+                };
+              }
+            }
+          }   
+        }
+      );
+      fileAppender.appender('test1.log', null, 100);
+      errorHandler({ error: 'aargh' });
+      return consoleArgs;
+    },
+    'should log the error to console.error': function(consoleArgs) {
+      assert.isNotEmpty(consoleArgs);
+      assert.equal(consoleArgs[0], 'log4js.fileAppender - Writing to file %s, error happened ');
+      assert.equal(consoleArgs[1], 'test1.log');
+      assert.equal(consoleArgs[2].error, 'aargh');
+    }
+  }
 
 }).export(module);

test/fileSyncAppender-test.js

@@ -0,0 +1,182 @@
+"use strict";
+var vows = require('vows')
+, fs = require('fs')
+, path = require('path')
+, sandbox = require('sandboxed-module')
+, log4js = require('../lib/log4js')
+, assert = require('assert')
+, EOL = require('os').EOL || '\n';
+
+log4js.clearAppenders();
+
+function remove(filename) {
+  try {
+    fs.unlinkSync(filename);
+  } catch (e) {
+    //doesn't really matter if it failed
+  }
+}
+
+vows.describe('log4js fileSyncAppender').addBatch({
+  'with default fileSyncAppender settings': {
+    topic: function() {
+      var that = this
+      , testFile = path.join(__dirname, '/fa-default-sync-test.log')
+      , logger = log4js.getLogger('default-settings');
+      remove(testFile);
+
+      log4js.clearAppenders();
+      log4js.addAppender(require('../lib/appenders/fileSync').appender(testFile), 'default-settings');
+      
+      logger.info("This should be in the file.");
+      
+      fs.readFile(testFile, "utf8", that.callback);
+    },
+    'should write log messages to the file': function (err, fileContents) {
+      assert.include(fileContents, "This should be in the file." + EOL);
+    },
+    'log messages should be in the basic layout format': function(err, fileContents) {
+      assert.match(
+        fileContents, 
+          /\[\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}\.\d{3}\] \[INFO\] default-settings - /
+      );
+    }
+  },
+  'with a max file size and no backups': {
+    topic: function() {
+      var testFile = path.join(__dirname, '/fa-maxFileSize-sync-test.log')
+      , logger = log4js.getLogger('max-file-size')
+      , that = this;
+      remove(testFile);
+      remove(testFile + '.1');
+      //log file of 100 bytes maximum, no backups
+      log4js.clearAppenders();
+      log4js.addAppender(
+        require('../lib/appenders/fileSync').appender(testFile, log4js.layouts.basicLayout, 100, 0), 
+        'max-file-size'
+      );
+      logger.info("This is the first log message.");
+      logger.info("This is an intermediate log message.");
+      logger.info("This is the second log message.");
+
+      fs.readFile(testFile, "utf8", that.callback);
+    },
+    'log file should only contain the second message': function (err, fileContents) {
+      assert.include(fileContents, "This is the second log message." + EOL);
+      assert.equal(fileContents.indexOf("This is the first log message."), -1);
+    },
+    'the number of files': {
+      topic: function() {
+        fs.readdir(__dirname, this.callback);
+      },
+      'starting with the test file name should be two': function(err, files) {
+        //there will always be one backup if you've specified a max log size
+        var logFiles = files.filter(
+          function(file) { return file.indexOf('fa-maxFileSize-sync-test.log') > -1; }
+        );
+        assert.equal(logFiles.length, 2);
+      }
+    }
+  },
+  'with a max file size and 2 backups': {
+    topic: function() {
+      var testFile = path.join(__dirname, '/fa-maxFileSize-with-backups-sync-test.log')
+      , logger = log4js.getLogger('max-file-size-backups');
+      remove(testFile);
+      remove(testFile+'.1');
+      remove(testFile+'.2');
+      
+      //log file of 50 bytes maximum, 2 backups
+      log4js.clearAppenders();
+      log4js.addAppender(
+        require('../lib/appenders/fileSync').appender(testFile, log4js.layouts.basicLayout, 50, 2), 
+        '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;
+      
+      fs.readdir(__dirname, function(err, files) { 
+        if (files) { 
+          that.callback(null, files.sort()); 
+        } else { 
+          that.callback(err, files); 
+        }
+      });
+    },
+    'the log files': {
+      topic: function(files) {
+        var logFiles = files.filter(
+          function(file) { return file.indexOf('fa-maxFileSize-with-backups-sync-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-sync-test.log', 
+          'fa-maxFileSize-with-backups-sync-test.log.1', 
+          'fa-maxFileSize-with-backups-sync-test.log.2'
+        ]);
+      },
+      '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) {
+          fs.readFile(path.join(__dirname, logFiles[1]), "utf8", this.callback);
+        },
+        'should be the third log message': function(contents) {
+          assert.include(contents, 'This is the third log message.');
+        }
+      },
+      'and the contents of the third file': {
+        topic: function(logFiles) {
+          fs.readFile(path.join(__dirname, logFiles[2]), "utf8", this.callback);
+        },
+        'should be the second log message': function(contents) {
+          assert.include(contents, 'This is the second log message.');
+        }
+      }
+    }
+  }
+}).addBatch({
+  'configure' : {
+    'with fileSyncAppender': {
+      topic: function() {
+        var log4js = require('../lib/log4js')
+        , logger;
+        //this config defines one file appender (to ./tmp-sync-tests.log)
+        //and sets the log level for "tests" to WARN
+        log4js.configure({
+            appenders: [{ 
+                category: "tests", 
+                type: "file", 
+                filename: "tmp-sync-tests.log", 
+                layout: { type: "messagePassThrough" } 
+            }],
+  
+            levels: { tests:  "WARN" }
+        });
+        logger = log4js.getLogger('tests');
+        logger.info('this should not be written to the file');
+        logger.warn('this should be written to the file');
+        
+        fs.readFile('tmp-sync-tests.log', 'utf8', this.callback);
+      },
+      'should load appender configuration from a json file': function(err, contents) {
+        assert.include(contents, 'this should be written to the file' + EOL);
+        assert.equal(contents.indexOf('this should not be written to the file'), -1);
+      }
+    }
+  }
+}).export(module);

test/gelfAppender-test.js

@@ -1,138 +1,256 @@
+"use strict";
 var vows = require('vows')
 , assert = require('assert')
 , sandbox = require('sandboxed-module')
 , log4js = require('../lib/log4js')
+, realLayouts = require('../lib/layouts')
 , setupLogging = function(options, category, compressedLength) {
-    var fakeDgram = {
+  var fakeDgram = {
-        sent: false,
+    sent: false,
-        socket: {
+    socket: {
-            packetLength: 0,
+      packetLength: 0,
-            close: function() {
+      closed: false,
-            },
+      close: function() {
-            send: function(pkt, offset, pktLength, port, host) {
+        this.closed = true;
-                fakeDgram.sent = true;
+      },
-                this.packet = pkt;
+      send: function(pkt, offset, pktLength, port, host) {
-                this.offset = offset;
+        fakeDgram.sent = true;
-                this.packetLength = pktLength;
+        this.packet = pkt;
-                this.port = port;
+        this.offset = offset;
-                this.host = host;
+        this.packetLength = pktLength;
-            }
+        this.port = port;
-        },
+        this.host = host;
-        createSocket: function(type) {
-            this.type = type;
-            return this.socket;
-        }
-    }
-  , fakeZlib = {
-      gzip: function(objectToCompress, callback) {
-          fakeZlib.uncompressed = objectToCompress;
-          if (compressedLength) {
-              callback(null, { length: compressedLength });
-          } else {
-              callback(null, "I've been compressed");
-          }
       }
+    },
+    createSocket: function(type) {
+      this.type = type;
+      return this.socket;
+    }
+  }
+  , fakeZlib = {
+    gzip: function(objectToCompress, callback) {
+      fakeZlib.uncompressed = objectToCompress;
+      if (this.shouldError) {
+        callback({ stack: "oh noes" });
+        return;
+      }
+
+      if (compressedLength) {
+        callback(null, { length: compressedLength });
+      } else {
+        callback(null, "I've been compressed");
+      }
+    }
+  }
+  , exitHandler
+  , fakeConsole = {
+    error: function(message) {
+      this.message = message;
+    }
+  }
+  , fakeLayouts = {
+    layout: function(type, options) {
+      this.type = type;
+      this.options = options;
+      return realLayouts.messagePassThroughLayout;
+    },
+    messagePassThroughLayout: realLayouts.messagePassThroughLayout
   }
   , appender = sandbox.require('../lib/appenders/gelf', {
-      requires: {
+    requires: {
-          dgram: fakeDgram,
+      dgram: fakeDgram,
-          zlib: fakeZlib
+      zlib: fakeZlib,
-      }
+      '../layouts': fakeLayouts
+    },
+    globals: {
+      process: {
+        on: function(evt, handler) {
+          if (evt === 'exit') {
+            exitHandler = handler;
+          }
+        }
+      },
+      console: fakeConsole
+    }
   });
 
-    log4js.clearAppenders();
+  log4js.clearAppenders();
-    log4js.addAppender(appender.configure(options || {}), category || "gelf-test");
+  log4js.addAppender(appender.configure(options || {}), category || "gelf-test");
-    return {
+  return {
-        dgram: fakeDgram,
+    dgram: fakeDgram,
-        compress: fakeZlib,
+    compress: fakeZlib,
-        logger: log4js.getLogger(category || "gelf-test")
+    exitHandler: exitHandler,
-    };
+    console: fakeConsole,
+    layouts: fakeLayouts,
+    logger: log4js.getLogger(category || "gelf-test")
+  };
 };
 
-//log4js.configure({ doNotReplaceConsole: true });
-
 vows.describe('log4js gelfAppender').addBatch({
 
-    'with default gelfAppender settings': {
+  'with default gelfAppender settings': {
-        topic: function() {
+    topic: function() {
-            var setup = setupLogging();
+      var setup = setupLogging();
-            setup.logger.info("This is a test");
+      setup.logger.info("This is a test");
-            return setup;
+      return setup;
-        },
-        'the dgram packet': {
-            topic: function(setup) {
-                return setup.dgram;
-            },
-            'should be sent via udp to the localhost gelf server': function(dgram) {
-                assert.equal(dgram.type, "udp4");
-                assert.equal(dgram.socket.host, "localhost");
-                assert.equal(dgram.socket.port, 12201);
-                assert.equal(dgram.socket.offset, 0);
-                assert.ok(dgram.socket.packetLength > 0, "Received blank message");
-            },
-            'should be compressed': function(dgram) {
-                assert.equal(dgram.socket.packet, "I've been compressed");
-            }
-        },
-        'the uncompressed log message': {
-            topic: function(setup) {
-                var message = JSON.parse(setup.compress.uncompressed);
-                return message;
-            },
-            'should be in the gelf format': function(message) {
-                assert.equal(message.version, '1.0');
-                assert.equal(message.host, require('os').hostname());
-                assert.equal(message.level, 6); //INFO
-                assert.equal(message.facility, 'nodejs-server');
-                assert.equal(message.full_message, message.short_message);
-                assert.equal(message.full_message, 'This is a test');
-            }
-        }
     },
-    'with a message longer than 8k': {
+    'the dgram packet': {
-        topic: function() {
+      topic: function(setup) {
-            var setup = setupLogging(undefined, undefined, 10240);
+        return setup.dgram;
-            setup.logger.info("Blah.");
+      },
-            return setup;
+      'should be sent via udp to the localhost gelf server': function(dgram) {
-        },
+        assert.equal(dgram.type, "udp4");
-        'the dgram packet': {
+        assert.equal(dgram.socket.host, "localhost");
-            topic: function(setup) {
+        assert.equal(dgram.socket.port, 12201);
-                return setup.dgram;
+        assert.equal(dgram.socket.offset, 0);
-            },
+        assert.ok(dgram.socket.packetLength > 0, "Received blank message");
-            'should not be sent': function(dgram) {
+      },
-                assert.equal(dgram.sent, false);
+      'should be compressed': function(dgram) {
-            }
+        assert.equal(dgram.socket.packet, "I've been compressed");
-        }
+      }
     },
-    'with non-default options': {
+    'the uncompressed log message': {
-        topic: function() {
+      topic: function(setup) {
-            var setup = setupLogging({
+        var message = JSON.parse(setup.compress.uncompressed);
-                host: 'somewhere',
+        return message;
-                port: 12345,
+      },
-                hostname: 'cheese',
+      'should be in the gelf format': function(message) {
-                facility: 'nonsense'
+        assert.equal(message.version, '1.1');
-            });
+        assert.equal(message.host, require('os').hostname());
-            setup.logger.debug("Just testing.");
+        assert.equal(message.level, 6); //INFO
-            return setup;
+        assert.equal(message.short_message, 'This is a test');
-        },
+      }
-        'the dgram packet': {
-            topic: function(setup) {
-                return setup.dgram;
-            },
-            'should pick up the options': function(dgram) {
-                assert.equal(dgram.socket.host, 'somewhere');
-                assert.equal(dgram.socket.port, 12345);
-            }
-        },
-        'the uncompressed packet': {
-            topic: function(setup) {
-                var message = JSON.parse(setup.compress.uncompressed);
-                return message;
-            },
-            'should pick up the options': function(message) {
-                assert.equal(message.host, 'cheese');
-                assert.equal(message.facility, 'nonsense');
-            }
-        }
     }
-}).export(module);
+  },
+  'with a message longer than 8k': {
+    topic: function() {
+      var setup = setupLogging(undefined, undefined, 10240);
+      setup.logger.info("Blah.");
+      return setup;
+    },
+    'the dgram packet': {
+      topic: function(setup) {
+        return setup.dgram;
+      },
+      'should not be sent': function(dgram) {
+        assert.equal(dgram.sent, false);
+      }
+    }
+  },
+  'with non-default options': {
+    topic: function() {
+      var setup = setupLogging({
+        host: 'somewhere',
+        port: 12345,
+        hostname: 'cheese',
+        facility: 'nonsense'
+      });
+      setup.logger.debug("Just testing.");
+      return setup;
+    },
+    'the dgram packet': {
+      topic: function(setup) {
+        return setup.dgram;
+      },
+      'should pick up the options': function(dgram) {
+        assert.equal(dgram.socket.host, 'somewhere');
+        assert.equal(dgram.socket.port, 12345);
+      }
+    },
+    'the uncompressed packet': {
+      topic: function(setup) {
+        var message = JSON.parse(setup.compress.uncompressed);
+        return message;
+      },
+      'should pick up the options': function(message) {
+        assert.equal(message.host, 'cheese');
+        assert.equal(message._facility, 'nonsense');
+      }
+    }
+  },
+
+  'on process.exit': {
+    topic: function() {
+      var setup = setupLogging();
+      setup.exitHandler();
+      return setup;
+    },
+    'should close open sockets': function(setup) {
+      assert.isTrue(setup.dgram.socket.closed);
+    }
+  },
+
+  'on zlib error': {
+    topic: function() {
+      var setup = setupLogging();
+      setup.compress.shouldError = true;
+      setup.logger.info('whatever');
+      return setup;
+    },
+    'should output to console.error': function(setup) {
+      assert.equal(setup.console.message, 'oh noes');
+    }
+  },
+
+  'with layout in configuration': {
+    topic: function() {
+      var setup = setupLogging({
+        layout: {
+          type: 'madeuplayout',
+          earlgrey: 'yes, please'
+        }
+      });
+      return setup;
+    },
+    'should pass options to layout': function(setup) {
+      assert.equal(setup.layouts.type, 'madeuplayout');
+      assert.equal(setup.layouts.options.earlgrey, 'yes, please');
+    }
+  },
+
+  'with custom fields options': {
+    topic: function() {
+      var setup = setupLogging({
+        host: 'somewhere',
+        port: 12345,
+        hostname: 'cheese',
+        facility: 'nonsense',
+        customFields: {
+          _every1: 'Hello every one',
+          _every2: 'Hello every two'
+        }
+      });
+      var myFields = {
+        GELF: true,
+        _every2: 'Overwritten!',
+        _myField: 'This is my field!'
+      };
+      setup.logger.debug(myFields, "Just testing.");
+      return setup;
+    },
+    'the dgram packet': {
+      topic: function(setup) {
+        return setup.dgram;
+      },
+      'should pick up the options': function(dgram) {
+        assert.equal(dgram.socket.host, 'somewhere');
+        assert.equal(dgram.socket.port, 12345);
+      }
+    },
+    'the uncompressed packet': {
+      topic: function(setup) {
+        var message = JSON.parse(setup.compress.uncompressed);
+        return message;
+      },
+      'should pick up the options': function(message) {
+        assert.equal(message.host, 'cheese');
+        assert.equal(message._facility, 'nonsense');
+        assert.equal(message._every1, 'Hello every one'); // the default value
+        assert.equal(message._every2, 'Overwritten!'); // the overwritten value
+        assert.equal(message._myField, 'This is my field!'); // the value for this message only
+        assert.equal(message.short_message, 'Just testing.'); // skip the field object
+      }
+    }
+  }
+
+}).export(module);

test/global-log-level-test.js

@@ -1,85 +1,121 @@
-var vows = require('vows'),
+"use strict";
-assert = require('assert');
+var vows = require('vows')
+, assert = require('assert');
 
 vows.describe('log4js global loglevel').addBatch({
-    'global loglevel' : {
+  'global loglevel' : {
-        topic: function() {
+    topic: function() {
-            var log4js = require('../lib/log4js');
+      var log4js = require('../lib/log4js');
-            return log4js;
+      return log4js;
-        },
+    },
 
-        'set global loglevel on creation': function(log4js) {
+    'set global loglevel on creation': function(log4js) {
-            var log1 = log4js.getLogger('log1');
+      var log1 = log4js.getLogger('log1');
-            var level = 'OFF';
+      var level = 'OFF';
-            if (log1.level.toString() == level) {
+      if (log1.level.toString() == level) {
-                level = 'TRACE';
+        level = 'TRACE';
-            }
+      }
-            assert.notEqual(log1.level.toString(), level);
+      assert.notEqual(log1.level.toString(), level);
 
-            log4js.setGlobalLogLevel(level);
+      log4js.setGlobalLogLevel(level);
-            assert.equal(log1.level.toString(), level);
+      assert.equal(log1.level.toString(), level);
 
-            var log2 = log4js.getLogger('log2');
+      var log2 = log4js.getLogger('log2');
-            assert.equal(log2.level.toString(), level);
+      assert.equal(log2.level.toString(), level);
-        },
+    },
 
-        'global change loglevel': function(log4js) {
+    'global change loglevel': function(log4js) {
-            var log1 = log4js.getLogger('log1');
+      var log1 = log4js.getLogger('log1');
-            var log2 = log4js.getLogger('log2');
+      var log2 = log4js.getLogger('log2');
-            var level = 'OFF';
+      var level = 'OFF';
-            if (log1.level.toString() == level) {
+      if (log1.level.toString() == level) {
-                level = 'TRACE';
+        level = 'TRACE';
-            }
+      }
-            assert.notEqual(log1.level.toString(), level);
+      assert.notEqual(log1.level.toString(), level);
 
-            log4js.setGlobalLogLevel(level);
+      log4js.setGlobalLogLevel(level);
-            assert.equal(log1.level.toString(), level);
+      assert.equal(log1.level.toString(), level);
-            assert.equal(log2.level.toString(), level);
+      assert.equal(log2.level.toString(), level);
-        },
+    },
 
-        'override loglevel': function(log4js) {
+    'override loglevel': function(log4js) {
-            var log1 = log4js.getLogger('log1');
+      var log1 = log4js.getLogger('log1');
-            var log2 = log4js.getLogger('log2');
+      var log2 = log4js.getLogger('log2');
-            var level = 'OFF';
+      var level = 'OFF';
-            if (log1.level.toString() == level) {
+      if (log1.level.toString() == level) {
-                level = 'TRACE';
+        level = 'TRACE';
-            }
+      }
-            assert.notEqual(log1.level.toString(), level);
+      assert.notEqual(log1.level.toString(), level);
 
-            var oldLevel = log1.level.toString();
+      var oldLevel = log1.level.toString();
-            assert.equal(log2.level.toString(), oldLevel);
+      assert.equal(log2.level.toString(), oldLevel);
 
-            log2.setLevel(level);
+      log2.setLevel(level);
-            assert.equal(log1.level.toString(), oldLevel);
+      assert.equal(log1.level.toString(), oldLevel);
-            assert.equal(log2.level.toString(), level);
+      assert.equal(log2.level.toString(), level);
-            assert.notEqual(oldLevel, level);
+      assert.notEqual(oldLevel, level);
 
-            log2.removeLevel();
+      log2.removeLevel();
-            assert.equal(log1.level.toString(), oldLevel);
+      assert.equal(log1.level.toString(), oldLevel);
-            assert.equal(log2.level.toString(), oldLevel);
+      assert.equal(log2.level.toString(), oldLevel);
-        },
+    },
 
-        'preload loglevel': function(log4js) {
+    'preload loglevel': function(log4js) {
-            var log1 = log4js.getLogger('log1');
+      var log1 = log4js.getLogger('log1');
-            var level = 'OFF';
+      var level = 'OFF';
-            if (log1.level.toString() == level) {
+      if (log1.level.toString() == level) {
-                level = 'TRACE';
+        level = 'TRACE';
-            }
+      }
-            assert.notEqual(log1.level.toString(), level);
+      assert.notEqual(log1.level.toString(), level);
 
-            var oldLevel = log1.level.toString();
+      var oldLevel = log1.level.toString();
-            log4js.getLogger('log2').setLevel(level);
+      log4js.getLogger('log2').setLevel(level);
 
-            assert.equal(log1.level.toString(), oldLevel);
+      assert.equal(log1.level.toString(), oldLevel);
 
-            // get again same logger but as different variable
+      // get again same logger but as different variable
-            var log2 = log4js.getLogger('log2');
+      var log2 = log4js.getLogger('log2');
-            assert.equal(log2.level.toString(), level);
+      assert.equal(log2.level.toString(), level);
-            assert.notEqual(oldLevel, level);
+      assert.notEqual(oldLevel, level);
 
-            log2.removeLevel();
+      log2.removeLevel();
-            assert.equal(log1.level.toString(), oldLevel);
+      assert.equal(log1.level.toString(), oldLevel);
-            assert.equal(log2.level.toString(), oldLevel);
+      assert.equal(log2.level.toString(), oldLevel);
+    },
+
+    'set level on all categories': function(log4js) {
+      // Get 2 loggers
+      var log1 = log4js.getLogger('log1');
+      var log2 = log4js.getLogger('log2');
+
+      // First a test with 2 categories with different levels
+      var config = {
+        'levels': {
+          'log1': 'ERROR',
+          'log2': 'WARN'
         }
+      };
+      log4js.configure(config);
+
+      // Check if the levels are set correctly
+      assert.equal('ERROR', log1.level.toString());
+      assert.equal('WARN', log2.level.toString());
+
+      log1.removeLevel();
+      log2.removeLevel();
+
+      // Almost identical test, but now we set
+      // level on all categories
+      var config2 = {
+        'levels': {
+          '[all]': 'DEBUG'
+        }
+      };
+      log4js.configure(config2);
+
+      // Check if the loggers got the DEBUG level
+      assert.equal('DEBUG', log1.level.toString());
+      assert.equal('DEBUG', log2.level.toString());
     }
+  }
 }).export(module);

test/hookioAppender-test.js

@@ -1,101 +0,0 @@
-var vows = require('vows');
-var assert = require('assert');
-var sandbox = require('sandboxed-module');
-
-function fancyResultingHookioAppender(opts) {
-  var result = { ons: {}, emissions: {}, logged: [], configs: [] };
-
-  var fakeLog4Js = {
-    appenderMakers: {}
-  };
-  fakeLog4Js.loadAppender = function (appender) {
-    fakeLog4Js.appenderMakers[appender] = function (config) {
-      result.actualLoggerConfig = config;
-      return function log(logEvent) {
-        result.logged.push(logEvent);
-      }
-    };
-  };
-
-  var fakeHookIo = { Hook: function(config) { result.configs.push(config); } };
-  fakeHookIo.Hook.prototype.start = function () {
-    result.startCalled = true;
-  };
-  fakeHookIo.Hook.prototype.on = function (eventName, functionToExec) {
-    result.ons[eventName] = { functionToExec: functionToExec };
-    if (eventName === 'hook::ready') {
-      functionToExec();
-    }
-  };
-  fakeHookIo.Hook.prototype.emit = function (eventName, data) {
-    result.emissions[eventName] = result.emissions[eventName] || [];
-    result.emissions[eventName].push({data: data});
-    var on = '*::' + eventName;
-    if (eventName !== 'hook::ready' && result.ons[on]) {
-      result.ons[on].callingCount = result.ons[on].callingCount ? result.ons[on].callingCount += 1 : 1;
-      result.ons[on].functionToExec(data);
-    }
-  };
-
-  return { theResult: result,
-    theModule: sandbox.require('../lib/appenders/hookio', {
-      requires: {
-        '../log4js': fakeLog4Js,
-        'hook.io': fakeHookIo
-      }
-    })
-  };
-}
-
-
-vows.describe('log4js hookioAppender').addBatch({
-  'master': {
-    topic: function() {
-      var fancy = fancyResultingHookioAppender();
-      var logger = fancy.theModule.configure({ name: 'ohno', mode: 'master', 'hook-port': 5001, appender: { type: 'file' } });
-      logger({ level: { levelStr: 'INFO' }, data: "ALRIGHTY THEN", startTime: '2011-10-27T03:53:16.031Z' });
-      logger({ level: { levelStr: 'DEBUG' }, data: "OH WOW", startTime: '2011-10-27T04:53:16.031Z'});
-      return fancy.theResult;
-    },
-
-    'should write to the actual appender': function (result) {
-      assert.isTrue(result.startCalled);
-      assert.equal(result.configs.length, 1);
-      assert.equal(result.configs[0]['hook-port'], 5001);
-      assert.equal(result.logged.length, 2);
-      assert.equal(result.emissions['ohno::log'].length, 2);
-      assert.equal(result.ons['*::ohno::log'].callingCount, 2);
-    },
-
-    'data written should be formatted correctly': function (result) {
-      assert.equal(result.logged[0].level.toString(), 'INFO');
-      assert.equal(result.logged[0].data, 'ALRIGHTY THEN');
-      assert.isTrue(typeof(result.logged[0].startTime) === 'object');
-      assert.equal(result.logged[1].level.toString(), 'DEBUG');
-      assert.equal(result.logged[1].data, 'OH WOW');
-      assert.isTrue(typeof(result.logged[1].startTime) === 'object');
-    },
-
-    'the actual logger should get the right config': function (result) {
-      assert.equal(result.actualLoggerConfig.type, 'file');
-    }
-  },
-  'worker': {
-    'should emit logging events to the master': {
-      topic: function() {
-        var fancy = fancyResultingHookioAppender();
-        var logger = fancy.theModule.configure({ name: 'ohno', mode: 'worker', appender: { type: 'file' } });
-        logger({ level: { levelStr: 'INFO' }, data: "ALRIGHTY THEN", startTime: '2011-10-27T03:53:16.031Z' });
-        logger({ level: { levelStr: 'DEBUG' }, data: "OH WOW", startTime: '2011-10-27T04:53:16.031Z'});
-        return fancy.theResult;
-      },
-
-      'should not write to the actual appender': function (result) {
-        assert.isTrue(result.startCalled);
-        assert.equal(result.logged.length, 0);
-        assert.equal(result.emissions['ohno::log'].length, 2);
-        assert.isUndefined(result.ons['*::ohno::log']);
-      }
-    }
-  }
-}).exportTo(module);

test/layouts-test.js

@@ -1,268 +1,304 @@
-var vows = require('vows'),
+"use strict";
-assert = require('assert');
+var vows = require('vows')
+, assert = require('assert')
+, os =  require('os')
+, EOL = os.EOL || '\n';
 
 //used for patternLayout tests.
 function test(args, pattern, value) {
-    var layout = args[0]
+  var layout = args[0]
-    , event = args[1]
+  , event = args[1]
-    , tokens = args[2];
+  , tokens = args[2];
 
-    assert.equal(layout(pattern, tokens)(event), value);
+  assert.equal(layout(pattern, tokens)(event), value);
 }
 
 vows.describe('log4js layouts').addBatch({
-    'colouredLayout': {
+  'colouredLayout': {
-        topic: function() {
+    topic: function() {
-            return require('../lib/layouts').colouredLayout;
+      return require('../lib/layouts').colouredLayout;
-        },
-
-        'should apply level colour codes to output': function(layout) {
-            var output = layout({
-                data: ["nonsense"],
-                startTime: new Date(2010, 11, 5, 14, 18, 30, 45),
-                categoryName: "cheese",
-                level: {
-                    toString: function() { return "ERROR"; }
-                }
-            });
-            assert.equal(output, '\033[31m[2010-12-05 14:18:30.045] [ERROR] cheese - \033[39mnonsense');
-        },
-
-        'should support the console.log format for the message': function(layout) {
-            var output = layout({
-                data: ["thing %d", 2],
-                startTime: new Date(2010, 11, 5, 14, 18, 30, 45),
-                categoryName: "cheese",
-                level: {
-                    toString: function() { return "ERROR"; }
-                }
-            });
-            assert.equal(output, '\033[31m[2010-12-05 14:18:30.045] [ERROR] cheese - \033[39mthing 2');
-        }
     },
 
-    'messagePassThroughLayout': {
+    'should apply level colour codes to output': function(layout) {
-        topic: function() {
+      var output = layout({
-            return require('../lib/layouts').messagePassThroughLayout;
+        data: ["nonsense"],
-        },
+        startTime: new Date(2010, 11, 5, 14, 18, 30, 45),
-        'should take a logevent and output only the message' : function(layout) {
+        categoryName: "cheese",
-            assert.equal(layout({
+        level: {
-                data: ["nonsense"],
+          toString: function() { return "ERROR"; }
-                startTime: new Date(2010, 11, 5, 14, 18, 30, 45),
-                categoryName: "cheese",
-                level: {
-                    colour: "green",
-                    toString: function() { return "ERROR"; }
-                }
-            }), "nonsense");
-        },
-        'should support the console.log format for the message' : function(layout) {
-              assert.equal(layout({
-                  data: ["thing %d", 1, "cheese"]
-                , startTime: new Date(2010, 11, 5, 14, 18, 30, 45)
-                , categoryName: "cheese"
-                , level : {
-                    colour: "green"
-                  , toString: function() { return "ERROR"; }
-                }
-              }), "thing 1 'cheese'");
-          },
-        'should output the first item even if it is not a string': function(layout) {
-            assert.equal(layout({
-                data: [ { thing: 1} ]
-              , startTime: new Date(2010, 11, 5, 14, 18, 30, 45)
-              , categoryName: "cheese"
-              , level: {
-                  colour: "green"
-                , toString: function() { return "ERROR"; }
-              }
-            }), "{ thing: 1 }");
-        },
-        'should print the stacks of a passed error objects': function(layout) {
-            assert.isArray(layout({
-                data: [ new Error() ]
-              , startTime: new Date(2010, 11, 5, 14, 18, 30, 45)
-              , categoryName: "cheese"
-              , level: {
-                  colour: "green"
-                , toString: function() { return "ERROR"; }
-              }
-            }).match(/Error\s+at Object\..*\s+\((.*)test[\\\/]layouts-test\.js\:\d+\:\d+\)\s+at runTest/)
-            , 'regexp did not return a match');
-        },
-        'with passed augmented errors':
-        { topic:
-          function(layout){
-              var e = new Error("My Unique Error Message");
-              e.augmented = "My Unique attribute value"
-              e.augObj = { at1: "at2" }
-              return layout({
-                  data: [ e ]
-                , startTime: new Date(2010, 11, 5, 14, 18, 30, 45)
-                , categoryName: "cheese"
-                , level: {
-                    colour: "green"
-                  , toString: function() { return "ERROR"; }
-                }
-              });
-          },
-          'should print error the contained error message': function(layoutOutput) {
-              var m = layoutOutput.match(/\{ \[Error: My Unique Error Message\]/);
-              assert.isArray(m);
-          },
-          'should print error augmented string attributes': function(layoutOutput) {
-              var m = layoutOutput.match(/augmented:\s'My Unique attribute value'/);
-              assert.isArray(m);
-          },
-          'should print error augmented object attributes': function(layoutOutput) {
-              var m = layoutOutput.match(/augObj:\s\{ at1: 'at2' \}/);
-              assert.isArray(m);
-          }
         }
-
+      });
-
+      assert.equal(output, '\x1B[31m[2010-12-05 14:18:30.045] [ERROR] cheese - \x1B[39mnonsense');
     },
-
+    'should support the console.log format for the message': function(layout) {
-    'basicLayout': {
+      var output = layout({
-        topic: function() {
+        data: ["thing %d", 2],
-            var layout = require('../lib/layouts').basicLayout,
+        startTime: new Date(2010, 11, 5, 14, 18, 30, 45),
-            event = {
+        categoryName: "cheese",
-                data: ['this is a test'],
+        level: {
-                startTime: new Date(2010, 11, 5, 14, 18, 30, 45),
+          toString: function() { return "ERROR"; }
-                categoryName: "tests",
-                level: {
-                    toString: function() { return "DEBUG"; }
-                }
-            };
-            return [layout, event];
-        },
-        'should take a logevent and output a formatted string': function(args) {
-            var layout = args[0], event = args[1];
-            assert.equal(layout(event), "[2010-12-05 14:18:30.045] [DEBUG] tests - this is a test");
-        },
-        'should output a stacktrace, message if the event has an error attached': function(args) {
-            var layout = args[0], event = args[1], output, lines,
-            error = new Error("Some made-up error"),
-            stack = error.stack.split(/\n/);
-
-            event.data = ['this is a test', error];
-            output = layout(event);
-            lines = output.split(/\n/);
-
-            assert.equal(lines.length - 1, stack.length);
-            assert.equal(lines[0], "[2010-12-05 14:18:30.045] [DEBUG] tests - this is a test [Error: Some made-up error]");
-
-            for (var i = 1; i < stack.length; i++) {
-                assert.equal(lines[i+2], stack[i+1]);
-            }
-        },
-        'should output any extra data in the log event as util.inspect strings': function(args) {
-            var layout = args[0], event = args[1], output, lines;
-            event.data = ['this is a test', {
-                    name: 'Cheese',
-                    message: 'Gorgonzola smells.'
-            }];
-            output = layout(event);
-            assert.equal(output, "[2010-12-05 14:18:30.045] [DEBUG] tests - this is a test { name: 'Cheese', message: 'Gorgonzola smells.' }");
         }
-    },
+      });
-
+      assert.equal(output, '\x1B[31m[2010-12-05 14:18:30.045] [ERROR] cheese - \x1B[39mthing 2');
-    'patternLayout': {
-        topic: function() {
-            var event = {
-                data: ['this is a test'],
-                startTime: new Date(2010, 11, 5, 14, 18, 30, 45),
-                categoryName: "multiple.levels.of.tests",
-                level: {
-                    toString: function() { return "DEBUG"; }
-                }
-            }, layout = require('../lib/layouts').patternLayout
-            , tokens = {
-                testString: 'testStringToken',
-                testFunction: function() { return 'testFunctionToken'; }
-            };
-            return [layout, event, tokens];
-        },
-
-        'should default to "time logLevel loggerName - message"': function(args) {
-            test(args, null, "14:18:30 DEBUG multiple.levels.of.tests - this is a test\n");
-        },
-        '%r should output time only': function(args) {
-            test(args, '%r', '14:18:30');
-        },
-        '%p should output the log level': function(args) {
-            test(args, '%p', 'DEBUG');
-        },
-        '%c should output the log category': function(args) {
-            test(args, '%c', 'multiple.levels.of.tests');
-        },
-        '%m should output the log data': function(args) {
-            test(args, '%m', 'this is a test');
-        },
-        '%n should output a new line': function(args) {
-            test(args, '%n', '\n');
-        },
-        '%c should handle category names like java-style package names': function(args) {
-            test(args, '%c{1}', 'tests');
-            test(args, '%c{2}', 'of.tests');
-            test(args, '%c{3}', 'levels.of.tests');
-            test(args, '%c{4}', 'multiple.levels.of.tests');
-            test(args, '%c{5}', 'multiple.levels.of.tests');
-            test(args, '%c{99}', 'multiple.levels.of.tests');
-        },
-        '%d should output the date in ISO8601 format': function(args) {
-            test(args, '%d', '2010-12-05 14:18:30.045');
-        },
-        '%d should allow for format specification': function(args) {
-            test(args, '%d{ISO8601}', '2010-12-05 14:18:30.045');
-            test(args, '%d{ABSOLUTE}', '14:18:30.045');
-            test(args, '%d{DATE}', '05 12 2010 14:18:30.045');
-            test(args, '%d{yyyy MM dd}', '2010 12 05');
-            test(args, '%d{yyyy MM dd hh mm ss SSS}', '2010 12 05 14 18 30 045');
-        },
-        '%% should output %': function(args) {
-            test(args, '%%', '%');
-        },
-        'should output anything not preceded by % as literal': function(args) {
-            test(args, 'blah blah blah', 'blah blah blah');
-        },
-        'should handle complicated patterns': function(args) {
-            test(args,
-                 '%m%n %c{2} at %d{ABSOLUTE} cheese %p%n',
-                 'this is a test\n of.tests at 14:18:30.045 cheese DEBUG\n'
-                );
-        },
-        'should truncate fields if specified': function(args) {
-            test(args, '%.4m', 'this');
-            test(args, '%.7m', 'this is');
-            test(args, '%.9m', 'this is a');
-            test(args, '%.14m', 'this is a test');
-            test(args, '%.2919102m', 'this is a test');
-        },
-        'should pad fields if specified': function(args) {
-            test(args, '%10p', '     DEBUG');
-            test(args, '%8p', '   DEBUG');
-            test(args, '%6p', ' DEBUG');
-            test(args, '%4p', 'DEBUG');
-            test(args, '%-4p', 'DEBUG');
-            test(args, '%-6p', 'DEBUG ');
-            test(args, '%-8p', 'DEBUG   ');
-            test(args, '%-10p', 'DEBUG     ');
-        },
-        '%[%r%] should output colored time': function(args) {
-            test(args, '%[%r%]', '\033[36m14:18:30\033[39m');
-        },
-        '%x{testString} should output the string stored in tokens': function(args) {
-            test(args, '%x{testString}', 'testStringToken');
-        },
-        '%x{testFunction} should output the result of the function stored in tokens': function(args) {
-            test(args, '%x{testFunction}', 'testFunctionToken');
-        },
-        '%x{doesNotExist} should output the string stored in tokens': function(args) {
-            test(args, '%x{doesNotExist}', '%x{doesNotExist}');
-        },
-        '%x should output the string stored in tokens': function(args) {
-            test(args, '%x', '%x');
-        },
     }
+  },
+
+  'messagePassThroughLayout': {
+    topic: function() {
+      return require('../lib/layouts').messagePassThroughLayout;
+    },
+    'should take a logevent and output only the message' : function(layout) {
+      assert.equal(layout({
+        data: ["nonsense"],
+        startTime: new Date(2010, 11, 5, 14, 18, 30, 45),
+        categoryName: "cheese",
+        level: {
+          colour: "green",
+          toString: function() { return "ERROR"; }
+        }
+      }), "nonsense");
+    },
+    'should support the console.log format for the message' : function(layout) {
+      assert.equal(layout({
+        data: ["thing %d", 1, "cheese"],
+        startTime: new Date(2010, 11, 5, 14, 18, 30, 45),
+        categoryName: "cheese",
+        level : {
+          colour: "green",
+          toString: function() { return "ERROR"; }
+        }
+      }), "thing 1 cheese");
+    },
+    'should output the first item even if it is not a string': function(layout) {
+      assert.equal(layout({
+        data: [ { thing: 1} ],
+        startTime: new Date(2010, 11, 5, 14, 18, 30, 45),
+        categoryName: "cheese",
+        level: {
+          colour: "green",
+          toString: function() { return "ERROR"; }
+        }
+      }), "{ thing: 1 }");
+    },
+    'should print the stacks of a passed error objects': function(layout) {
+      assert.isArray(layout({
+        data: [ new Error() ],
+        startTime: new Date(2010, 11, 5, 14, 18, 30, 45),
+        categoryName: "cheese",
+        level: {
+          colour: "green",
+          toString: function() { return "ERROR"; }
+        }
+      }).match(/Error\s+at Object\..*\s+\((.*)test[\\\/]layouts-test\.js\:\d+\:\d+\)\s+at runTest/)
+                     , 'regexp did not return a match');
+    },
+    'with passed augmented errors': {
+      topic: function(layout){
+        var e = new Error("My Unique Error Message");
+        e.augmented = "My Unique attribute value";
+        e.augObj = { at1: "at2" };
+        return layout({
+          data: [ e ],
+          startTime: new Date(2010, 11, 5, 14, 18, 30, 45),
+          categoryName: "cheese",
+          level: {
+            colour: "green",
+            toString: function() { return "ERROR"; }
+          }
+        });
+      },
+      'should print error the contained error message': function(layoutOutput) {
+        var m = layoutOutput.match(/\{ \[Error: My Unique Error Message\]/);
+        assert.isArray(m);
+      },
+      'should print error augmented string attributes': function(layoutOutput) {
+        var m = layoutOutput.match(/augmented:\s'My Unique attribute value'/);
+        assert.isArray(m);
+      },
+      'should print error augmented object attributes': function(layoutOutput) {
+        var m = layoutOutput.match(/augObj:\s\{ at1: 'at2' \}/);
+        assert.isArray(m);
+      }
+    }
+
+
+  },
+
+  'basicLayout': {
+    topic: function() {
+      var layout = require('../lib/layouts').basicLayout,
+      event = {
+        data: ['this is a test'],
+        startTime: new Date(2010, 11, 5, 14, 18, 30, 45),
+        categoryName: "tests",
+        level: {
+          toString: function() { return "DEBUG"; }
+        }
+      };
+      return [layout, event];
+    },
+    'should take a logevent and output a formatted string': function(args) {
+      var layout = args[0], event = args[1];
+      assert.equal(layout(event), "[2010-12-05 14:18:30.045] [DEBUG] tests - this is a test");
+    },
+    'should output a stacktrace, message if the event has an error attached': function(args) {
+      var layout = args[0], event = args[1], output, lines,
+      error = new Error("Some made-up error"),
+      stack = error.stack.split(/\n/);
+
+      event.data = ['this is a test', error];
+      output = layout(event);
+      lines = output.split(/\n/);
+
+      assert.equal(lines.length - 1, stack.length);
+      assert.equal(
+        lines[0],
+        "[2010-12-05 14:18:30.045] [DEBUG] tests - this is a test [Error: Some made-up error]"
+      );
+
+      for (var i = 1; i < stack.length; i++) {
+        assert.equal(lines[i+2], stack[i+1]);
+      }
+    },
+    'should output any extra data in the log event as util.inspect strings': function(args) {
+      var layout = args[0], event = args[1], output, lines;
+      event.data = ['this is a test', {
+        name: 'Cheese',
+        message: 'Gorgonzola smells.'
+      }];
+      output = layout(event);
+      assert.equal(
+        output,
+        "[2010-12-05 14:18:30.045] [DEBUG] tests - this is a test " +
+          "{ name: 'Cheese', message: 'Gorgonzola smells.' }"
+      );
+    }
+  },
+
+  'patternLayout': {
+    topic: function() {
+      var event = {
+        data: ['this is a test'],
+        startTime: new Date(2010, 11, 5, 14, 18, 30, 45),
+        categoryName: "multiple.levels.of.tests",
+        level: {
+          toString: function() { return "DEBUG"; }
+        }
+      }, layout = require('../lib/layouts').patternLayout
+      , tokens = {
+        testString: 'testStringToken',
+        testFunction: function() { return 'testFunctionToken'; },
+        fnThatUsesLogEvent: function(logEvent) { return logEvent.level.toString(); }
+      };
+
+      //override getTimezoneOffset
+      event.startTime.getTimezoneOffset = function() { return 0; };
+      return [layout, event, tokens];
+    },
+
+    'should default to "time logLevel loggerName - message"': function(args) {
+      test(args, null, "14:18:30 DEBUG multiple.levels.of.tests - this is a test" + EOL);
+    },
+    '%r should output time only': function(args) {
+      test(args, '%r', '14:18:30');
+    },
+    '%p should output the log level': function(args) {
+      test(args, '%p', 'DEBUG');
+    },
+    '%c should output the log category': function(args) {
+      test(args, '%c', 'multiple.levels.of.tests');
+    },
+    '%m should output the log data': function(args) {
+      test(args, '%m', 'this is a test');
+    },
+    '%n should output a new line': function(args) {
+      test(args, '%n', EOL);
+    },
+    '%h should output hostname' : function(args) {
+      test(args, '%h', os.hostname().toString());
+    },
+    '%z should output pid' : function(args) {
+      test(args, '%z', process.pid);
+    },
+    '%c should handle category names like java-style package names': function(args) {
+      test(args, '%c{1}', 'tests');
+      test(args, '%c{2}', 'of.tests');
+      test(args, '%c{3}', 'levels.of.tests');
+      test(args, '%c{4}', 'multiple.levels.of.tests');
+      test(args, '%c{5}', 'multiple.levels.of.tests');
+      test(args, '%c{99}', 'multiple.levels.of.tests');
+    },
+    '%d should output the date in ISO8601 format': function(args) {
+      test(args, '%d', '2010-12-05 14:18:30.045');
+    },
+    '%d should allow for format specification': function(args) {
+      test(args, '%d{ISO8601_WITH_TZ_OFFSET}', '2010-12-05T14:18:30-0000');
+      test(args, '%d{ISO8601}', '2010-12-05 14:18:30.045');
+      test(args, '%d{ABSOLUTE}', '14:18:30.045');
+      test(args, '%d{DATE}', '05 12 2010 14:18:30.045');
+      test(args, '%d{yy MM dd hh mm ss}', '10 12 05 14 18 30');
+      test(args, '%d{yyyy MM dd}', '2010 12 05');
+      test(args, '%d{yyyy MM dd hh mm ss SSS}', '2010 12 05 14 18 30 045');
+    },
+    '%% should output %': function(args) {
+      test(args, '%%', '%');
+    },
+    'should output anything not preceded by % as literal': function(args) {
+      test(args, 'blah blah blah', 'blah blah blah');
+    },
+    'should output the original string if no replacer matches the token': function(args) {
+      test(args, '%a{3}', 'a{3}');
+    },
+    'should handle complicated patterns': function(args) {
+      test(args,
+           '%m%n %c{2} at %d{ABSOLUTE} cheese %p%n',
+           'this is a test'+ EOL +' of.tests at 14:18:30.045 cheese DEBUG' + EOL
+          );
+    },
+    'should truncate fields if specified': function(args) {
+      test(args, '%.4m', 'this');
+      test(args, '%.7m', 'this is');
+      test(args, '%.9m', 'this is a');
+      test(args, '%.14m', 'this is a test');
+      test(args, '%.2919102m', 'this is a test');
+    },
+    'should pad fields if specified': function(args) {
+      test(args, '%10p', '     DEBUG');
+      test(args, '%8p', '   DEBUG');
+      test(args, '%6p', ' DEBUG');
+      test(args, '%4p', 'DEBUG');
+      test(args, '%-4p', 'DEBUG');
+      test(args, '%-6p', 'DEBUG ');
+      test(args, '%-8p', 'DEBUG   ');
+      test(args, '%-10p', 'DEBUG     ');
+    },
+    '%[%r%] should output colored time': function(args) {
+      test(args, '%[%r%]', '\x1B[36m14:18:30\x1B[39m');
+    },
+    '%x{testString} should output the string stored in tokens': function(args) {
+      test(args, '%x{testString}', 'testStringToken');
+    },
+    '%x{testFunction} should output the result of the function stored in tokens': function(args) {
+      test(args, '%x{testFunction}', 'testFunctionToken');
+    },
+    '%x{doesNotExist} should output the string stored in tokens': function(args) {
+      test(args, '%x{doesNotExist}', '%x{doesNotExist}');
+    },
+    '%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');
+    },
+  },
+  'layout makers': {
+    topic: require('../lib/layouts'),
+    'should have a maker for each layout': function(layouts) {
+      assert.ok(layouts.layout("messagePassThrough"));
+      assert.ok(layouts.layout("basic"));
+      assert.ok(layouts.layout("colored"));
+      assert.ok(layouts.layout("coloured"));
+      assert.ok(layouts.layout("pattern"));
+    }
+  }
 }).export(module);

test/levels-test.js

@@ -1,210 +1,404 @@
+"use strict";
 var vows = require('vows')
 , assert = require('assert')
 , levels = require('../lib/levels');
 
 function assertThat(level) {
-    function assertForEach(assertion, test, otherLevels) {
+  function assertForEach(assertion, test, otherLevels) {
-        otherLevels.forEach(function(other) {
+    otherLevels.forEach(function(other) {
-            assertion.call(assert, test.call(level, other));
+      assertion.call(assert, test.call(level, other));
-        });
+    });
-    }
+  }
 
-    return {
+  return {
-        isLessThanOrEqualTo: function(levels) {
+    isLessThanOrEqualTo: function(levels) {
-            assertForEach(assert.isTrue, level.isLessThanOrEqualTo, levels);
+      assertForEach(assert.isTrue, level.isLessThanOrEqualTo, levels);
-        },
+    },
-        isNotLessThanOrEqualTo: function(levels) {
+    isNotLessThanOrEqualTo: function(levels) {
-            assertForEach(assert.isFalse, level.isLessThanOrEqualTo, levels);
+      assertForEach(assert.isFalse, level.isLessThanOrEqualTo, levels);
-        },
+    },
-        isGreaterThanOrEqualTo: function(levels) {
+    isGreaterThanOrEqualTo: function(levels) {
-            assertForEach(assert.isTrue, level.isGreaterThanOrEqualTo, levels);
+      assertForEach(assert.isTrue, level.isGreaterThanOrEqualTo, levels);
-        },
+    },
-        isNotGreaterThanOrEqualTo: function(levels) {
+    isNotGreaterThanOrEqualTo: function(levels) {
-            assertForEach(assert.isFalse, level.isGreaterThanOrEqualTo, levels);
+      assertForEach(assert.isFalse, level.isGreaterThanOrEqualTo, levels);
-        },
+    },
-        isEqualTo: function(levels) {
+    isEqualTo: function(levels) {
-            assertForEach(assert.isTrue, level.isEqualTo, levels);
+      assertForEach(assert.isTrue, level.isEqualTo, levels);
-        },
+    },
-        isNotEqualTo: function(levels) {
+    isNotEqualTo: function(levels) {
-            assertForEach(assert.isFalse, level.isEqualTo, levels);
+      assertForEach(assert.isFalse, level.isEqualTo, levels);
-        }
+    }
-    };
+  };
 }
 
 vows.describe('levels').addBatch({
-    'values': {
+  'values': {
-        topic: levels,
+    topic: levels,
-        'should define some levels': function(levels) {
+    'should define some levels': function(levels) {
-            assert.isNotNull(levels.ALL);
+      assert.isNotNull(levels.ALL);
-            assert.isNotNull(levels.TRACE);
+      assert.isNotNull(levels.TRACE);
-            assert.isNotNull(levels.DEBUG);
+      assert.isNotNull(levels.DEBUG);
-            assert.isNotNull(levels.INFO);
+      assert.isNotNull(levels.INFO);
-            assert.isNotNull(levels.WARN);
+      assert.isNotNull(levels.WARN);
-            assert.isNotNull(levels.ERROR);
+      assert.isNotNull(levels.ERROR);
-            assert.isNotNull(levels.FATAL);
+      assert.isNotNull(levels.FATAL);
-            assert.isNotNull(levels.OFF);
+      assert.isNotNull(levels.OFF);
-        },
-        'ALL': {
-            topic: levels.ALL,
-            'should be less than the other levels': function(all) {
-                assertThat(all).isLessThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO, levels.WARN, levels.ERROR, levels.FATAL, levels.OFF]);
-            },
-            'should be greater than no levels': function(all) {
-                assertThat(all).isNotGreaterThanOrEqualTo([levels.TRACE, levels.DEBUG, levels.INFO, levels.WARN, levels.ERROR, levels.FATAL, levels.OFF]);
-            },
-            'should only be equal to ALL': function(all) {
-                assertThat(all).isEqualTo([levels.toLevel("ALL")]);
-                assertThat(all).isNotEqualTo([levels.TRACE, levels.DEBUG, levels.INFO, levels.WARN, levels.ERROR, levels.FATAL, levels.OFF]);
-            }
-        },
-        'TRACE': {
-            topic: levels.TRACE,
-            'should be less than DEBUG': function(trace) {
-                assertThat(trace).isLessThanOrEqualTo([levels.DEBUG, levels.INFO, levels.WARN, levels.ERROR, levels.FATAL, levels.OFF]);
-                assertThat(trace).isNotLessThanOrEqualTo([levels.ALL]);
-            },
-            'should be greater than ALL': function(trace) {
-                assertThat(trace).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE]);
-                assertThat(trace).isNotGreaterThanOrEqualTo([levels.DEBUG, levels.INFO, levels.WARN, levels.ERROR, levels.FATAL, levels.OFF]);
-            },
-            'should only be equal to TRACE': function(trace) {
-                assertThat(trace).isEqualTo([levels.toLevel("TRACE")]);
-                assertThat(trace).isNotEqualTo([levels.ALL, levels.DEBUG, levels.INFO, levels.WARN, levels.ERROR, levels.FATAL, levels.OFF]);
-            }
-        },
-        'DEBUG': {
-            topic: levels.DEBUG,
-            'should be less than INFO': function(debug) {
-                assertThat(debug).isLessThanOrEqualTo([levels.INFO, levels.WARN, levels.ERROR, levels.FATAL, levels.OFF]);
-                assertThat(debug).isNotLessThanOrEqualTo([levels.ALL, levels.TRACE]);
-            },
-            'should be greater than TRACE': function(debug) {
-                assertThat(debug).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE]);
-                assertThat(debug).isNotGreaterThanOrEqualTo([levels.INFO, levels.WARN, levels.ERROR, levels.FATAL, levels.OFF]);
-            },
-            'should only be equal to DEBUG': function(trace) {
-                assertThat(trace).isEqualTo([levels.toLevel("DEBUG")]);
-                assertThat(trace).isNotEqualTo([levels.ALL, levels.TRACE, levels.INFO, levels.WARN, levels.ERROR, levels.FATAL, levels.OFF]);
-            }
-        },
-        'INFO': {
-            topic: levels.INFO,
-            'should be less than WARN': function(info) {
-                assertThat(info).isLessThanOrEqualTo([levels.WARN, levels.ERROR, levels.FATAL, levels.OFF]);
-                assertThat(info).isNotLessThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG]);
-            },
-            'should be greater than DEBUG': function(info) {
-                assertThat(info).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG]);
-                assertThat(info).isNotGreaterThanOrEqualTo([levels.WARN, levels.ERROR, levels.FATAL, levels.OFF]);
-            },
-            'should only be equal to INFO': function(trace) {
-                assertThat(trace).isEqualTo([levels.toLevel("INFO")]);
-                assertThat(trace).isNotEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.WARN, levels.ERROR, levels.FATAL, levels.OFF]);
-            }
-        },
-        'WARN': {
-            topic: levels.WARN,
-            'should be less than ERROR': function(warn) {
-                assertThat(warn).isLessThanOrEqualTo([levels.ERROR, levels.FATAL, levels.OFF]);
-                assertThat(warn).isNotLessThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO]);
-            },
-            'should be greater than INFO': function(warn) {
-                assertThat(warn).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO]);
-                assertThat(warn).isNotGreaterThanOrEqualTo([levels.ERROR, levels.FATAL, levels.OFF]);
-            },
-            'should only be equal to WARN': function(trace) {
-                assertThat(trace).isEqualTo([levels.toLevel("WARN")]);
-                assertThat(trace).isNotEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO, levels.ERROR, levels.FATAL, levels.OFF]);
-            }
-        },
-        'ERROR': {
-            topic: levels.ERROR,
-            'should be less than FATAL': function(error) {
-                assertThat(error).isLessThanOrEqualTo([levels.FATAL, levels.OFF]);
-                assertThat(error).isNotLessThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO, levels.WARN]);
-            },
-            'should be greater than WARN': function(error) {
-                assertThat(error).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO, levels.WARN]);
-                assertThat(error).isNotGreaterThanOrEqualTo([levels.FATAL, levels.OFF]);
-            },
-            'should only be equal to ERROR': function(trace) {
-                assertThat(trace).isEqualTo([levels.toLevel("ERROR")]);
-                assertThat(trace).isNotEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO, levels.WARN, levels.FATAL, levels.OFF]);
-            }
-        },
-        'FATAL': {
-            topic: levels.FATAL,
-            'should be less than OFF': function(fatal) {
-                assertThat(fatal).isLessThanOrEqualTo([levels.OFF]);
-                assertThat(fatal).isNotLessThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO, levels.WARN, levels.ERROR]);
-            },
-            'should be greater than ERROR': function(fatal) {
-                assertThat(fatal).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO, levels.WARN, levels.ERROR]);
-                assertThat(fatal).isNotGreaterThanOrEqualTo([levels.OFF]);
-            },
-            'should only be equal to FATAL': function(fatal) {
-                assertThat(fatal).isEqualTo([levels.toLevel("FATAL")]);
-                assertThat(fatal).isNotEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO, levels.WARN, levels.ERROR, levels.OFF]);
-            }
-        },
-        'OFF': {
-            topic: levels.OFF,
-            'should not be less than anything': function(off) {
-                assertThat(off).isNotLessThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO, levels.WARN, levels.ERROR, levels.FATAL]);
-            },
-            'should be greater than everything': function(off) {
-                assertThat(off).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO, levels.WARN, levels.ERROR, levels.FATAL]);
-            },
-            'should only be equal to OFF': function(off) {
-                assertThat(off).isEqualTo([levels.toLevel("OFF")]);
-                assertThat(off).isNotEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO, levels.WARN, levels.ERROR, levels.FATAL]);
-            }
-        }
     },
-    'isGreaterThanOrEqualTo': {
+    'ALL': {
-        topic: levels.INFO,
+      topic: levels.ALL,
-        'should handle string arguments': function(info) {
+      'should be less than the other levels': function(all) {
-            assertThat(info).isGreaterThanOrEqualTo(["all", "trace", "debug"]);
+        assertThat(all).isLessThanOrEqualTo(
-            assertThat(info).isNotGreaterThanOrEqualTo(['warn', 'ERROR', 'Fatal', 'off']);
+          [ 
-        }
+            levels.ALL, 
+            levels.TRACE, 
+            levels.DEBUG, 
+            levels.INFO, 
+            levels.WARN, 
+            levels.ERROR, 
+            levels.FATAL, 
+            levels.OFF
+          ]
+        );
+      },
+      'should be greater than no levels': function(all) {
+        assertThat(all).isNotGreaterThanOrEqualTo(
+          [
+            levels.TRACE, 
+            levels.DEBUG, 
+            levels.INFO, 
+            levels.WARN, 
+            levels.ERROR, 
+            levels.FATAL, 
+            levels.OFF
+          ]
+        );
+      },
+      'should only be equal to ALL': function(all) {
+        assertThat(all).isEqualTo([levels.toLevel("ALL")]);
+        assertThat(all).isNotEqualTo(
+          [
+            levels.TRACE, 
+            levels.DEBUG, 
+            levels.INFO, 
+            levels.WARN, 
+            levels.ERROR, 
+            levels.FATAL, 
+            levels.OFF
+          ]
+        );
+      }
     },
-    'isLessThanOrEqualTo': {
+    'TRACE': {
-        topic: levels.INFO,
+      topic: levels.TRACE,
-        'should handle string arguments': function(info) {
+      'should be less than DEBUG': function(trace) {
-            assertThat(info).isNotLessThanOrEqualTo(["all", "trace", "debug"]);
+        assertThat(trace).isLessThanOrEqualTo(
-            assertThat(info).isLessThanOrEqualTo(['warn', 'ERROR', 'Fatal', 'off']);
+          [
-        }
+            levels.DEBUG, 
+            levels.INFO, 
+            levels.WARN, 
+            levels.ERROR, 
+            levels.FATAL, 
+            levels.OFF
+          ]
+        );
+        assertThat(trace).isNotLessThanOrEqualTo([levels.ALL]);
+      },
+      'should be greater than ALL': function(trace) {
+        assertThat(trace).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE]);
+        assertThat(trace).isNotGreaterThanOrEqualTo(
+          [
+            levels.DEBUG, 
+            levels.INFO, 
+            levels.WARN, 
+            levels.ERROR, 
+            levels.FATAL, 
+            levels.OFF
+          ]
+        );
+      },
+      'should only be equal to TRACE': function(trace) {
+        assertThat(trace).isEqualTo([levels.toLevel("TRACE")]);
+        assertThat(trace).isNotEqualTo(
+          [
+            levels.ALL, 
+            levels.DEBUG, 
+            levels.INFO, 
+            levels.WARN, 
+            levels.ERROR, 
+            levels.FATAL, 
+            levels.OFF
+          ]
+        );
+      }
     },
-    'toLevel': {
+    'DEBUG': {
-        'with lowercase argument': {
+      topic: levels.DEBUG,
-            topic: levels.toLevel("debug"),
+      'should be less than INFO': function(debug) {
-            'should take the string and return the corresponding level': function(level) {
+        assertThat(debug).isLessThanOrEqualTo(
-                assert.equal(level, levels.DEBUG);
+          [
-            }
+            levels.INFO, 
-        },
+            levels.WARN, 
-        'with uppercase argument': {
+            levels.ERROR, 
-            topic: levels.toLevel("DEBUG"),
+            levels.FATAL, 
-            'should take the string and return the corresponding level': function(level) {
+            levels.OFF
-                assert.equal(level, levels.DEBUG);
+          ]
-            }
+        );
-        },
+        assertThat(debug).isNotLessThanOrEqualTo([levels.ALL, levels.TRACE]);
-        'with varying case': {
+      },
-            topic: levels.toLevel("DeBuG"),
+      'should be greater than TRACE': function(debug) {
-            'should take the string and return the corresponding level': function(level) {
+        assertThat(debug).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE]);
-                assert.equal(level, levels.DEBUG);
+        assertThat(debug).isNotGreaterThanOrEqualTo(
-            }
+          [
-        },
+            levels.INFO, 
-        'with unrecognised argument': {
+            levels.WARN, 
-            topic: levels.toLevel("cheese"),
+            levels.ERROR, 
-            'should return undefined': function(level) {
+            levels.FATAL, 
-                assert.isUndefined(level);
+            levels.OFF
-            }
+          ]
-        },
+        );
-        'with unrecognised argument and default value': {
+      },
-            topic: levels.toLevel("cheese", levels.DEBUG),
+      'should only be equal to DEBUG': function(trace) {
-            'should return default value': function(level) {
+        assertThat(trace).isEqualTo([levels.toLevel("DEBUG")]);
-                assert.equal(level, levels.DEBUG);
+        assertThat(trace).isNotEqualTo(
-            }
+          [
-        }
+            levels.ALL, 
+            levels.TRACE, 
+            levels.INFO, 
+            levels.WARN, 
+            levels.ERROR, 
+            levels.FATAL, 
+            levels.OFF
+          ]
+        );
+      }
+    },
+    'INFO': {
+      topic: levels.INFO,
+      'should be less than WARN': function(info) {
+        assertThat(info).isLessThanOrEqualTo([
+          levels.WARN, 
+          levels.ERROR, 
+          levels.FATAL, 
+          levels.OFF
+        ]);
+        assertThat(info).isNotLessThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG]);
+      },
+      'should be greater than DEBUG': function(info) {
+        assertThat(info).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG]);
+        assertThat(info).isNotGreaterThanOrEqualTo([
+          levels.WARN, 
+          levels.ERROR, 
+          levels.FATAL, 
+          levels.OFF
+        ]);
+      },
+      'should only be equal to INFO': function(trace) {
+        assertThat(trace).isEqualTo([levels.toLevel("INFO")]);
+        assertThat(trace).isNotEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.WARN, 
+          levels.ERROR, 
+          levels.FATAL, 
+          levels.OFF
+        ]);
+      }
+    },
+    'WARN': {
+      topic: levels.WARN,
+      'should be less than ERROR': function(warn) {
+        assertThat(warn).isLessThanOrEqualTo([levels.ERROR, levels.FATAL, levels.OFF]);
+        assertThat(warn).isNotLessThanOrEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO
+        ]);
+      },
+      'should be greater than INFO': function(warn) {
+        assertThat(warn).isGreaterThanOrEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO
+        ]);
+        assertThat(warn).isNotGreaterThanOrEqualTo([levels.ERROR, levels.FATAL, levels.OFF]);
+      },
+      'should only be equal to WARN': function(trace) {
+        assertThat(trace).isEqualTo([levels.toLevel("WARN")]);
+        assertThat(trace).isNotEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO, 
+          levels.ERROR, 
+          levels.FATAL, 
+          levels.OFF
+        ]);
+      }
+    },
+    'ERROR': {
+      topic: levels.ERROR,
+      'should be less than FATAL': function(error) {
+        assertThat(error).isLessThanOrEqualTo([levels.FATAL, levels.OFF]);
+        assertThat(error).isNotLessThanOrEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO, 
+          levels.WARN
+        ]);
+      },
+      'should be greater than WARN': function(error) {
+        assertThat(error).isGreaterThanOrEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO, 
+          levels.WARN
+        ]);
+        assertThat(error).isNotGreaterThanOrEqualTo([levels.FATAL, levels.OFF]);
+      },
+      'should only be equal to ERROR': function(trace) {
+        assertThat(trace).isEqualTo([levels.toLevel("ERROR")]);
+        assertThat(trace).isNotEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO, 
+          levels.WARN, 
+          levels.FATAL, 
+          levels.OFF
+        ]);
+      }
+    },
+    'FATAL': {
+      topic: levels.FATAL,
+      'should be less than OFF': function(fatal) {
+        assertThat(fatal).isLessThanOrEqualTo([levels.OFF]);
+        assertThat(fatal).isNotLessThanOrEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO, 
+          levels.WARN, 
+          levels.ERROR
+        ]);
+      },
+      'should be greater than ERROR': function(fatal) {
+        assertThat(fatal).isGreaterThanOrEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO, 
+          levels.WARN, 
+          levels.ERROR
+        ]);
+        assertThat(fatal).isNotGreaterThanOrEqualTo([levels.OFF]);
+      },
+      'should only be equal to FATAL': function(fatal) {
+        assertThat(fatal).isEqualTo([levels.toLevel("FATAL")]);
+        assertThat(fatal).isNotEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO, 
+          levels.WARN, 
+          levels.ERROR, 
+          levels.OFF
+        ]);
+      }
+    },
+    'OFF': {
+      topic: levels.OFF,
+      'should not be less than anything': function(off) {
+        assertThat(off).isNotLessThanOrEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO, 
+          levels.WARN, 
+          levels.ERROR, 
+          levels.FATAL
+        ]);
+      },
+      'should be greater than everything': function(off) {
+        assertThat(off).isGreaterThanOrEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO, 
+          levels.WARN, 
+          levels.ERROR, 
+          levels.FATAL
+        ]);
+      },
+      'should only be equal to OFF': function(off) {
+        assertThat(off).isEqualTo([levels.toLevel("OFF")]);
+        assertThat(off).isNotEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO, 
+          levels.WARN, 
+          levels.ERROR, 
+          levels.FATAL
+        ]);
+      }
     }
+  },
+  'isGreaterThanOrEqualTo': {
+    topic: levels.INFO,
+    'should handle string arguments': function(info) {
+      assertThat(info).isGreaterThanOrEqualTo(["all", "trace", "debug"]);
+      assertThat(info).isNotGreaterThanOrEqualTo(['warn', 'ERROR', 'Fatal', 'off']);
+    }
+  },
+  'isLessThanOrEqualTo': {
+    topic: levels.INFO,
+    'should handle string arguments': function(info) {
+      assertThat(info).isNotLessThanOrEqualTo(["all", "trace", "debug"]);
+      assertThat(info).isLessThanOrEqualTo(['warn', 'ERROR', 'Fatal', 'off']);
+    }
+  },
+  'isEqualTo': {
+    topic: levels.INFO,
+    'should handle string arguments': function(info) {
+      assertThat(info).isEqualTo(["info", "INFO", "iNfO"]);
+    }
+  },
+  'toLevel': {
+    'with lowercase argument': {
+      topic: levels.toLevel("debug"),
+      'should take the string and return the corresponding level': function(level) {
+        assert.equal(level, levels.DEBUG);
+      }
+    },
+    'with uppercase argument': {
+      topic: levels.toLevel("DEBUG"),
+      'should take the string and return the corresponding level': function(level) {
+        assert.equal(level, levels.DEBUG);
+      }
+    },
+    'with varying case': {
+      topic: levels.toLevel("DeBuG"),
+      'should take the string and return the corresponding level': function(level) {
+        assert.equal(level, levels.DEBUG);
+      }
+    },
+    'with unrecognised argument': {
+      topic: levels.toLevel("cheese"),
+      'should return undefined': function(level) {
+        assert.isUndefined(level);
+      }
+    },
+    'with unrecognised argument and default value': {
+      topic: levels.toLevel("cheese", levels.DEBUG),
+      'should return default value': function(level) {
+        assert.equal(level, levels.DEBUG);
+      }
+    }
+  }
 }).export(module);

test/log-abspath-test.js

@@ -1,69 +1,77 @@
+"use strict";
 var vows = require('vows')
 , assert = require('assert')
+, path = require('path')
 , sandbox = require('sandboxed-module');
 
 vows.describe('log4js-abspath').addBatch({
-    'options': {
+  'options': {
-        topic: function() {
+    topic: function() {
-            var appenderOptions,
+      var appenderOptions,
-                log4js = sandbox.require(
+      log4js = sandbox.require(
-                    '../lib/log4js',
+        '../lib/log4js',
-                    { requires:
+        { requires:
-                      { './appenders/fake':
+          { './appenders/fake':
-                        {
+            { name: "fake",
-                            name: "fake",
+              appender: function() {},
-                            appender: function() {},
+              configure: function(configuration, options) {
-                            configure: function(configuration, options) {
+                appenderOptions = options;
-                                appenderOptions = options;
+                return function() {};
-                                return function() {};
+              }
-                            }
+            }
-                        }
+          }
-                      }
+        }
-                    }
+      ),
-                ),
+      config = {
-                config = {
+        "appenders": [
-                    "appenders": [
+          {
-                        {
+            "type" : "fake",
-                            "type" : "fake",
+            "filename" : "cheesy-wotsits.log"
-                            "filename" : "cheesy-wotsits.log"
+          }
-                        }
+        ]
-                    ]
+      };
+      
+      log4js.configure(config, {
+        cwd: '/absolute/path/to'
+      });
+      return appenderOptions;
+    },
+    'should be passed to appenders during configuration': function(options) {
+      assert.equal(options.cwd, '/absolute/path/to');
+    }
+  },
+
+  'file appender': {
+    topic: function() {
+      var fileOpened,
+      fileAppender = sandbox.require(
+        '../lib/appenders/file',
+        { requires:
+          { '../streams':
+            { RollingFileStream: 
+              function(file) {
+                fileOpened = file;
+                return {
+                  on: function() {},
+                  end: function() {}
                 };
-
+              }
-            log4js.configure(config, {
+            }
-                cwd: '/absolute/path/to'
+          }
-            });
-            return appenderOptions;
-        },
-        'should be passed to appenders during configuration': function(options) {
-            assert.equal(options.cwd, '/absolute/path/to');
         }
+      );
+      fileAppender.configure(
+        { 
+          filename: "whatever.log", 
+          maxLogSize: 10 
+        }, 
+        { cwd: '/absolute/path/to' }
+      );
+      return fileOpened;
     },
-
+    'should prepend options.cwd to config.filename': function(fileOpened) {
-    'file appender': {
+      var expected = path.sep + path.join("absolute", "path", "to", "whatever.log");
-        topic: function() {
+      assert.equal(fileOpened, expected);
-            var fileOpened,
+    }
-                fileAppender = sandbox.require(
+  },
-                    '../lib/appenders/file',
+}).export(module);
-                    { requires:
-                      { '../streams':
-                        {
-                            RollingFileStream: function(file) {
-                                fileOpened = file;
-			      return {
-				on: function() {},
-				end: function() {}
-			      };
-                            }
-                        }
-                      }
-                    }
-                );
-            fileAppender.configure({ filename: "whatever.log", maxLogSize: 10 }, { cwd: '/absolute/path/to' });
-            return fileOpened;
-        },
-        'should prepend options.cwd to config.filename': function(fileOpened) {
-            assert.equal(fileOpened, "/absolute/path/to/whatever.log");
-        }
-    },
-}).export(module);

test/logLevelFilter-test.js

@@ -1,69 +1,80 @@
+"use strict";
 var vows = require('vows')
 , fs = require('fs')
-, assert = require('assert');
+, assert = require('assert')
+, os = require('os')
+, EOL = require('os').EOL || '\n';
 
 function remove(filename) {
-    try {
+  try {
-        fs.unlinkSync(filename);
+    fs.unlinkSync(filename);
-    } catch (e) {
+  } catch (e) {
-        //doesn't really matter if it failed
+    //doesn't really matter if it failed
-    }
+  }
 }
 
 vows.describe('log4js logLevelFilter').addBatch({
-    'appender': {
+  'appender': {
-        topic: function() {
+    topic: function() {
-            var log4js = require('../lib/log4js'), logEvents = [], logger;
+      var log4js = require('../lib/log4js'), logEvents = [], logger;
-            log4js.clearAppenders();
+      log4js.clearAppenders();
-            log4js.addAppender(require('../lib/appenders/logLevelFilter').appender('ERROR', function(evt) { logEvents.push(evt); }), "logLevelTest");
+      log4js.addAppender(
-            logger = log4js.getLogger("logLevelTest");
+        require('../lib/appenders/logLevelFilter')
-            logger.debug('this should not trigger an event');
+          .appender(
-            logger.warn('neither should this');
+            'ERROR',
-            logger.error('this should, though');
+            function(evt) { logEvents.push(evt); }
-            logger.fatal('so should this');
+          ),
-            return logEvents;
+        "logLevelTest"
-        },
+      );
-        'should only pass log events greater than or equal to its own level' : function(logEvents) {
+
-            assert.equal(logEvents.length, 2);
+      logger = log4js.getLogger("logLevelTest");
-            assert.equal(logEvents[0].data[0], 'this should, though');
+      logger.debug('this should not trigger an event');
-            assert.equal(logEvents[1].data[0], 'so should this');
+      logger.warn('neither should this');
-        }
+      logger.error('this should, though');
+      logger.fatal('so should this');
+      return logEvents;
     },
-
+    'should only pass log events greater than or equal to its own level' : function(logEvents) {
-    'configure': {
+      assert.equal(logEvents.length, 2);
-        topic: function() {
+      assert.equal(logEvents[0].data[0], 'this should, though');
-            var log4js = require('../lib/log4js')
+      assert.equal(logEvents[1].data[0], 'so should this');
-          , logger;
-
-            remove(__dirname + '/logLevelFilter.log');
-            remove(__dirname + '/logLevelFilter-warnings.log');
-
-            log4js.configure('test/with-logLevelFilter.json');
-	    logger = log4js.getLogger("tests");
-	    logger.info('main');
-	    logger.error('both');
-	    logger.warn('both');
-	    logger.debug('main');
-            //wait for the file system to catch up
-            setTimeout(this.callback, 100);
-        },
-	'tmp-tests.log': {
-	    topic: function() {
-		fs.readFile(__dirname + '/logLevelFilter.log', 'utf8', this.callback);
-            },
-            'should contain all log messages': function(contents) {
-                var messages = contents.trim().split('\n');
-	        assert.deepEqual(messages, ['main','both','both','main']);
-            }
-        },
-        'tmp-tests-warnings.log': {
-	    topic: function() {
-		fs.readFile(__dirname + '/logLevelFilter-warnings.log','utf8',this.callback);
-            },
-            'should contain only error and warning log messages': function(contents) {
-                var messages = contents.trim().split('\n');
-	        assert.deepEqual(messages, ['both','both']);
-	    }
-        }
     }
+  },
+
+  'configure': {
+    topic: function() {
+      var log4js = require('../lib/log4js')
+      , logger;
+
+      remove(__dirname + '/logLevelFilter.log');
+      remove(__dirname + '/logLevelFilter-warnings.log');
+
+      log4js.configure('test/with-logLevelFilter.json');
+      logger = log4js.getLogger("tests");
+      logger.info('main');
+      logger.error('both');
+      logger.warn('both');
+      logger.debug('main');
+      //wait for the file system to catch up
+      setTimeout(this.callback, 500);
+    },
+    'tmp-tests.log': {
+      topic: function() {
+        fs.readFile(__dirname + '/logLevelFilter.log', 'utf8', this.callback);
+      },
+      'should contain all log messages': function (contents) {
+        var messages = contents.trim().split(EOL);
+        assert.deepEqual(messages, ['main','both','both','main']);
+      }
+    },
+    'tmp-tests-warnings.log': {
+      topic: function() {
+        fs.readFile(__dirname + '/logLevelFilter-warnings.log','utf8',this.callback);
+      },
+      'should contain only error and warning log messages': function(contents) {
+        var messages = contents.trim().split(EOL);
+        assert.deepEqual(messages, ['both','both']);
+      }
+    }
+  }
 }).export(module);

test/logger-test.js

@@ -0,0 +1,81 @@
+"use strict";
+var vows = require('vows')
+, assert = require('assert')
+, levels = require('../lib/levels')
+, loggerModule = require('../lib/logger')
+, Logger = loggerModule.Logger;
+
+vows.describe('../lib/logger').addBatch({
+  'constructor with no parameters': {
+    topic: new Logger(),
+    'should use default category': function(logger) {
+      assert.equal(logger.category, Logger.DEFAULT_CATEGORY);
+    },
+    'should use TRACE log level': function(logger) {
+      assert.equal(logger.level, levels.TRACE);
+    }
+  },
+
+  'constructor with category': {
+    topic: new Logger('cheese'),
+    'should use category': function(logger) {
+      assert.equal(logger.category, 'cheese');
+    },
+    'should use TRACE log level': function(logger) {
+      assert.equal(logger.level, levels.TRACE);
+    }
+  },
+
+  'constructor with category and level': {
+    topic: new Logger('cheese', 'debug'),
+    'should use category': function(logger) {
+      assert.equal(logger.category, 'cheese');
+    },
+    'should use level': function(logger) {
+      assert.equal(logger.level, levels.DEBUG);
+    }
+  },
+
+  'isLevelEnabled': {
+    topic: new Logger('cheese', 'info'),
+    'should provide a level enabled function for all levels': function(logger) {
+      assert.isFunction(logger.isTraceEnabled);
+      assert.isFunction(logger.isDebugEnabled);
+      assert.isFunction(logger.isInfoEnabled);
+      assert.isFunction(logger.isWarnEnabled);
+      assert.isFunction(logger.isErrorEnabled);
+      assert.isFunction(logger.isFatalEnabled);
+    },
+    'should return the right values': function(logger) {
+      assert.isFalse(logger.isTraceEnabled());
+      assert.isFalse(logger.isDebugEnabled());
+      assert.isTrue(logger.isInfoEnabled());
+      assert.isTrue(logger.isWarnEnabled());
+      assert.isTrue(logger.isErrorEnabled());
+      assert.isTrue(logger.isFatalEnabled());
+    }
+  },
+
+  'should emit log events': {
+    topic: function() {
+      var events = [],
+          logger = new Logger();
+      logger.addListener('log', function (logEvent) { events.push(logEvent); });
+      logger.debug('Event 1');
+      loggerModule.disableAllLogWrites();
+      logger.debug('Event 2');
+      loggerModule.enableAllLogWrites();
+      logger.debug('Event 3');
+      return events;
+    },
+
+    'when log writes are enabled': function(events) {
+      assert.equal(events[0].data[0], 'Event 1');
+    },
+
+    'but not when log writes are disabled': function(events) {
+      assert.equal(events.length, 2);
+      assert.equal(events[1].data[0], 'Event 3');
+    }
+  }
+}).exportTo(module);

test/logglyAppender-test.js

@@ -0,0 +1,82 @@
+"use strict";
+var vows = require('vows')
+, assert = require('assert')
+, log4js = require('../lib/log4js')
+, sandbox = require('sandboxed-module')
+;
+
+function setupLogging(category, options) {
+  var msgs = [];
+  
+  var fakeLoggly = {
+    createClient: function (options) {
+      return {
+        config: options,
+        log: function (msg, tags) {
+          msgs.push({
+            msg: msg,
+            tags: tags
+          });
+        }
+      };
+    }
+  };
+
+  var fakeLayouts = {
+    layout: function(type, config) {
+      this.type = type;
+      this.config = config;
+      return log4js.layouts.messagePassThroughLayout;
+    },
+    basicLayout: log4js.layouts.basicLayout,
+    messagePassThroughLayout: log4js.layouts.messagePassThroughLayout
+  };
+
+  var fakeConsole = {
+    errors: [],
+    error: function(msg, value) {
+      this.errors.push({ msg: msg, value: value });
+    }
+  };
+
+  var logglyModule = sandbox.require('../lib/appenders/loggly', {
+    requires: {
+      'loggly': fakeLoggly,
+      '../layouts': fakeLayouts
+    },
+    globals: {
+      console: fakeConsole
+    }
+  });
+
+  log4js.addAppender(logglyModule.configure(options), category);
+  
+  return {
+    logger: log4js.getLogger(category),
+    loggly: fakeLoggly,
+    layouts: fakeLayouts,
+    console: fakeConsole,
+    results: msgs
+  };
+}
+
+log4js.clearAppenders();
+vows.describe('log4js logglyAppender').addBatch({
+  'minimal config': {
+    topic: function() {
+      var setup = setupLogging('loggly', {
+        token: 'your-really-long-input-token',
+        subdomain: 'your-subdomain',
+        tags: ['loggly-tag1', 'loggly-tag2', 'loggly-tagn'] 
+      });
+      
+      setup.logger.log('trace', 'Log event #1');
+      return setup;
+    },
+    'there should be one message only': function (topic) {
+      //console.log('topic', topic);
+      assert.equal(topic.results.length, 1);
+    }
+  }
+
+}).export(module);

test/multiprocess-test.js

@@ -1,241 +1,311 @@
-var vows = require('vows'),
+"use strict";
-    sandbox = require('sandboxed-module'),
+var vows = require('vows')
-    assert = require('assert');
+, sandbox = require('sandboxed-module')
+, assert = require('assert')
+;
 
 function makeFakeNet() {
-    return {
+  return {
-        logEvents: [],
+    logEvents: [],
-        data: [],
+    data: [],
-        cbs: {},
+    cbs: {},
-        createConnectionCalled: 0,
+    createConnectionCalled: 0,
-        fakeAppender: function(logEvent) {
+    fakeAppender: function(logEvent) {
-            this.logEvents.push(logEvent);
+      this.logEvents.push(logEvent);
+    },
+    createConnection: function(port, host) {
+      var fakeNet = this;
+      this.port = port;
+      this.host = host;
+      this.createConnectionCalled += 1;
+      return {
+        on: function(evt, cb) {
+          fakeNet.cbs[evt] = cb;
         },
-        createConnection: function(port, host) {
+        write: function(data, encoding) {
-            var fakeNet = this;
+          fakeNet.data.push(data);
-            this.port = port;
+          fakeNet.encoding = encoding;
-            this.host = host;
-            this.createConnectionCalled += 1;
-            return {
-                on: function(evt, cb) {
-                    fakeNet.cbs[evt] = cb;
-                },
-                write: function(data, encoding) {
-                    fakeNet.data.push(data);
-                    fakeNet.encoding = encoding;
-                },
-                end: function() {
-                    fakeNet.closeCalled = true;
-                }
-            };
         },
-        createServer: function(cb) {
+        end: function() {
-          var fakeNet = this;
+          fakeNet.closeCalled = true;
-          cb({
-            remoteAddress: '1.2.3.4',
-            remotePort: '1234',
-            setEncoding: function(encoding) {
-              fakeNet.encoding = encoding;
-            },
-            on: function(event, cb) {
-              fakeNet.cbs[event] = cb;
-            }
-          });
-
-          return {
-            listen: function(port, host) {
-              fakeNet.port = port;
-              fakeNet.host = host;
-            }
-          };
         }
-    };
+      };
+    },
+    createServer: function(cb) {
+      var fakeNet = this;
+      cb({
+        remoteAddress: '1.2.3.4',
+        remotePort: '1234',
+        setEncoding: function(encoding) {
+          fakeNet.encoding = encoding;
+        },
+        on: function(event, cb) {
+          fakeNet.cbs[event] = cb;
+        }
+      });
+
+      return {
+        listen: function(port, host) {
+          fakeNet.port = port;
+          fakeNet.host = host;
+        }
+      };
+    }
+  };
 }
 
 vows.describe('Multiprocess Appender').addBatch({
-    'worker': {
+  'worker': {
-        topic: function() {
+    topic: function() {
-            var fakeNet = makeFakeNet(),
+      var fakeNet = makeFakeNet(),
-                appender = sandbox.require(
+      appender = sandbox.require(
-                    '../lib/appenders/multiprocess',
+        '../lib/appenders/multiprocess',
-                    {
+        {
-                        requires: {
+          requires: {
-                            'net': fakeNet
+            'net': fakeNet
-                        }
+          }
-                    }
-                ).appender({ mode: 'worker', loggerPort: 1234, loggerHost: 'pants' });
-
-            //don't need a proper log event for the worker tests
-            appender('before connect');
-            fakeNet.cbs['connect']();
-            appender('after connect');
-            fakeNet.cbs['close'](true);
-            appender('after error, before connect');
-            fakeNet.cbs['connect']();
-            appender('after error, after connect');
-
-            return fakeNet;
-        },
-        'should open a socket to the loggerPort and loggerHost': function(net) {
-            assert.equal(net.port, 1234);
-            assert.equal(net.host, 'pants');
-        },
-        'should buffer messages written before socket is connected': function(net) {
-            assert.equal(net.data[0], JSON.stringify('before connect'));
-        },
-        'should write log messages to socket as json strings with a terminator string': function(net) {
-            assert.equal(net.data[0], JSON.stringify('before connect'));
-            assert.equal(net.data[1], '__LOG4JS__');
-            assert.equal(net.data[2], JSON.stringify('after connect'));
-            assert.equal(net.data[3], '__LOG4JS__');
-            assert.equal(net.encoding, 'utf8');
-        },
-        'should attempt to re-open the socket on error': function(net) {
-            assert.equal(net.data[4], JSON.stringify('after error, before connect'));
-            assert.equal(net.data[5], '__LOG4JS__');
-            assert.equal(net.data[6], JSON.stringify('after error, after connect'));
-            assert.equal(net.data[7], '__LOG4JS__');
-            assert.equal(net.createConnectionCalled, 2);
         }
+      ).appender({ mode: 'worker', loggerPort: 1234, loggerHost: 'pants' });
+      
+      //don't need a proper log event for the worker tests
+      appender('before connect');
+      fakeNet.cbs.connect();
+      appender('after connect');
+      fakeNet.cbs.close(true);
+      appender('after error, before connect');
+      fakeNet.cbs.connect();
+      appender('after error, after connect');
+	  appender(new Error('Error test'));
+      
+      return fakeNet;
     },
-    'worker with timeout': {
+    'should open a socket to the loggerPort and loggerHost': function(net) {
-        topic: function() {
+      assert.equal(net.port, 1234);
-            var fakeNet = makeFakeNet(),
+      assert.equal(net.host, 'pants');
-                appender = sandbox.require(
-                    '../lib/appenders/multiprocess',
-                    {
-                        requires: {
-                            'net': fakeNet
-                        }
-                    }
-                ).appender({ mode: 'worker' });
-
-            //don't need a proper log event for the worker tests
-            appender('before connect');
-            fakeNet.cbs['connect']();
-            appender('after connect');
-            fakeNet.cbs['timeout']();
-            appender('after timeout, before close');
-            fakeNet.cbs['close']();
-            appender('after close, before connect');
-            fakeNet.cbs['connect']();
-            appender('after close, after connect');
-
-            return fakeNet;
-        },
-        'should attempt to re-open the socket': function(net) {
-            //skipping the __LOG4JS__ separators
-            assert.equal(net.data[0], JSON.stringify('before connect'));
-            assert.equal(net.data[2], JSON.stringify('after connect'));
-            assert.equal(net.data[4], JSON.stringify('after timeout, before close'));
-            assert.equal(net.data[6], JSON.stringify('after close, before connect'));
-            assert.equal(net.data[8], JSON.stringify('after close, after connect'));
-            assert.equal(net.createConnectionCalled, 2);
-        }
     },
-    'worker defaults': {
+    'should buffer messages written before socket is connected': function(net) {
-        topic: function() {
+      assert.equal(net.data[0], JSON.stringify('before connect'));
-            var fakeNet = makeFakeNet(),
-                appender = sandbox.require(
-                    '../lib/appenders/multiprocess',
-                    {
-                        requires: {
-                            'net': fakeNet
-                        }
-                    }
-                ).appender({ mode: 'worker' });
-
-            return fakeNet;
-        },
-        'should open a socket to localhost:5000': function(net) {
-            assert.equal(net.port, 5000);
-            assert.equal(net.host, 'localhost');
-        }
     },
-    'master': {
+    'should write log messages to socket as json strings with a terminator string': function(net) {
-        topic: function() {
+      assert.equal(net.data[0], JSON.stringify('before connect'));
-            var fakeNet = makeFakeNet(),
+      assert.equal(net.data[1], '__LOG4JS__');
-                appender = sandbox.require(
+      assert.equal(net.data[2], JSON.stringify('after connect'));
-                    '../lib/appenders/multiprocess',
+      assert.equal(net.data[3], '__LOG4JS__');
-                    {
+      assert.equal(net.encoding, 'utf8');
-                        requires: {
-                            'net': fakeNet
-                        }
-                    }
-                ).appender({ mode: 'master',
-                             loggerHost: 'server',
-                             loggerPort: 1234,
-                             actualAppender: fakeNet.fakeAppender.bind(fakeNet)
-                           });
-
-            appender('this should be sent to the actual appender directly');
-
-            return fakeNet;
-        },
-        'should listen for log messages on loggerPort and loggerHost': function(net) {
-            assert.equal(net.port, 1234);
-            assert.equal(net.host, 'server');
-        },
-        'should return the underlying appender': function(net) {
-            assert.equal(net.logEvents[0], 'this should be sent to the actual appender directly');
-        },
-        'when a client connects': {
-            topic: function(net) {
-              var logString = JSON.stringify({ level: { level: 10000, levelStr: 'DEBUG' }, data: ['some debug']}) + '__LOG4JS__';
-
-                net.cbs['data'](JSON.stringify({ level: { level: 40000, levelStr: 'ERROR' }, data: ['an error message'] }) + '__LOG4JS__');
-                net.cbs['data'](logString.substring(0, 10));
-                net.cbs['data'](logString.substring(10));
-                net.cbs['data'](logString + logString + logString);
-                net.cbs['end'](JSON.stringify({ level:  { level: 50000, levelStr: 'FATAL' }, data: ["that's all folks"] }) + '__LOG4JS__');
-                net.cbs['data']('bad message__LOG4JS__');
-                return net;
-            },
-            'should parse log messages into log events and send to appender': function(net) {
-                assert.equal(net.logEvents[1].level.toString(), 'ERROR');
-                assert.equal(net.logEvents[1].data[0], 'an error message');
-                assert.equal(net.logEvents[1].remoteAddress, '1.2.3.4');
-                assert.equal(net.logEvents[1].remotePort, '1234');
-            },
-            'should parse log messages split into multiple chunks': function(net) {
-                assert.equal(net.logEvents[2].level.toString(), 'DEBUG');
-                assert.equal(net.logEvents[2].data[0], 'some debug');
-                assert.equal(net.logEvents[2].remoteAddress, '1.2.3.4');
-                assert.equal(net.logEvents[2].remotePort, '1234');
-            },
-            'should parse multiple log messages in a single chunk': function(net) {
-                assert.equal(net.logEvents[3].data[0], 'some debug');
-                assert.equal(net.logEvents[4].data[0], 'some debug');
-                assert.equal(net.logEvents[5].data[0], 'some debug');
-            },
-            'should handle log messages sent as part of end event': function(net) {
-                assert.equal(net.logEvents[6].data[0], "that's all folks");
-            },
-            'should handle unparseable log messages': function(net) {
-                assert.equal(net.logEvents[7].level.toString(), 'ERROR');
-                assert.equal(net.logEvents[7].categoryName, 'log4js');
-                assert.equal(net.logEvents[7].data[0], 'Unable to parse log:');
-                assert.equal(net.logEvents[7].data[1], 'bad message');
-            }
-        }
     },
-    'master defaults': {
+    'should attempt to re-open the socket on error': function(net) {
-        topic: function() {
+      assert.equal(net.data[4], JSON.stringify('after error, before connect'));
-            var fakeNet = makeFakeNet(),
+      assert.equal(net.data[5], '__LOG4JS__');
-                appender = sandbox.require(
+      assert.equal(net.data[6], JSON.stringify('after error, after connect'));
-                    '../lib/appenders/multiprocess',
+      assert.equal(net.data[7], '__LOG4JS__');
-                    {
+      assert.equal(net.createConnectionCalled, 2);
-                        requires: {
+    },
-                            'net': fakeNet
+    'should serialize an Error correctly': function(net) {
-                        }
+      assert(JSON.parse(net.data[8]).stack, "Expected:\n\n" + net.data[8] + "\n\n to have a 'stack' property");
-                    }
+      var actual = JSON.parse(net.data[8]).stack;
-                ).appender({ mode: 'master' });
+      var expectedRegex = /^Error: Error test/;
+      assert(actual.match(expectedRegex), "Expected: \n\n " + actual + "\n\n to match " + expectedRegex);
 
-            return fakeNet;
-        },
-        'should listen for log messages on localhost:5000': function(net) {
-            assert.equal(net.port, 5000);
-            assert.equal(net.host, 'localhost');
-        }
     }
+  },
+  'worker with timeout': {
+    topic: function() {
+      var fakeNet = makeFakeNet(),
+      appender = sandbox.require(
+        '../lib/appenders/multiprocess',
+        {
+          requires: {
+            'net': fakeNet
+          }
+        }
+      ).appender({ mode: 'worker' });
+      
+      //don't need a proper log event for the worker tests
+      appender('before connect');
+      fakeNet.cbs.connect();
+      appender('after connect');
+      fakeNet.cbs.timeout();
+      appender('after timeout, before close');
+      fakeNet.cbs.close();
+      appender('after close, before connect');
+      fakeNet.cbs.connect();
+      appender('after close, after connect');
+      
+      return fakeNet;
+    },
+    'should attempt to re-open the socket': function(net) {
+      //skipping the __LOG4JS__ separators
+      assert.equal(net.data[0], JSON.stringify('before connect'));
+      assert.equal(net.data[2], JSON.stringify('after connect'));
+      assert.equal(net.data[4], JSON.stringify('after timeout, before close'));
+      assert.equal(net.data[6], JSON.stringify('after close, before connect'));
+      assert.equal(net.data[8], JSON.stringify('after close, after connect'));
+      assert.equal(net.createConnectionCalled, 2);
+    }
+  },
+  'worker defaults': {
+    topic: function() {
+      var fakeNet = makeFakeNet(),
+      appender = sandbox.require(
+        '../lib/appenders/multiprocess',
+        {
+          requires: {
+            'net': fakeNet
+          }
+        }
+      ).appender({ mode: 'worker' });
+      
+      return fakeNet;
+    },
+    'should open a socket to localhost:5000': function(net) {
+      assert.equal(net.port, 5000);
+      assert.equal(net.host, 'localhost');
+    }
+  },
+  'master': {
+    topic: function() {
+      var fakeNet = makeFakeNet(),
+      appender = sandbox.require(
+        '../lib/appenders/multiprocess',
+        {
+          requires: {
+            'net': fakeNet
+          }
+        }
+      ).appender({ mode: 'master',
+                   loggerHost: 'server',
+                   loggerPort: 1234,
+                   actualAppender: fakeNet.fakeAppender.bind(fakeNet)
+                 });
+      
+      appender('this should be sent to the actual appender directly');
+      
+      return fakeNet;
+    },
+    'should listen for log messages on loggerPort and loggerHost': function(net) {
+      assert.equal(net.port, 1234);
+      assert.equal(net.host, 'server');
+    },
+    'should return the underlying appender': function(net) {
+      assert.equal(net.logEvents[0], 'this should be sent to the actual appender directly');
+    },
+    'when a client connects': {
+      topic: function(net) {
+        var logString = JSON.stringify(
+          { level: { level: 10000, levelStr: 'DEBUG' }
+            , data: ['some debug']}
+        ) + '__LOG4JS__';
+        
+        net.cbs.data(
+          JSON.stringify(
+            { level: { level: 40000, levelStr: 'ERROR' }
+              , data: ['an error message'] }
+          ) + '__LOG4JS__'
+        );
+        net.cbs.data(logString.substring(0, 10));
+        net.cbs.data(logString.substring(10));
+        net.cbs.data(logString + logString + logString);
+        net.cbs.end(
+          JSON.stringify(
+            { level:  { level: 50000, levelStr: 'FATAL' }
+              , data: ["that's all folks"] }
+          ) + '__LOG4JS__'
+        );
+        net.cbs.data('bad message__LOG4JS__');
+        return net;
+      },
+      'should parse log messages into log events and send to appender': function(net) {
+        assert.equal(net.logEvents[1].level.toString(), 'ERROR');
+        assert.equal(net.logEvents[1].data[0], 'an error message');
+        assert.equal(net.logEvents[1].remoteAddress, '1.2.3.4');
+        assert.equal(net.logEvents[1].remotePort, '1234');
+      },
+      'should parse log messages split into multiple chunks': function(net) {
+        assert.equal(net.logEvents[2].level.toString(), 'DEBUG');
+        assert.equal(net.logEvents[2].data[0], 'some debug');
+        assert.equal(net.logEvents[2].remoteAddress, '1.2.3.4');
+        assert.equal(net.logEvents[2].remotePort, '1234');
+      },
+      'should parse multiple log messages in a single chunk': function(net) {
+        assert.equal(net.logEvents[3].data[0], 'some debug');
+        assert.equal(net.logEvents[4].data[0], 'some debug');
+        assert.equal(net.logEvents[5].data[0], 'some debug');
+      },
+      'should handle log messages sent as part of end event': function(net) {
+        assert.equal(net.logEvents[6].data[0], "that's all folks");
+      },
+      'should handle unparseable log messages': function(net) {
+        assert.equal(net.logEvents[7].level.toString(), 'ERROR');
+        assert.equal(net.logEvents[7].categoryName, 'log4js');
+        assert.equal(net.logEvents[7].data[0], 'Unable to parse log:');
+        assert.equal(net.logEvents[7].data[1], 'bad message');
+      }
+    }
+  },
+  'master defaults': {
+    topic: function() {
+      var fakeNet = makeFakeNet(),
+      appender = sandbox.require(
+        '../lib/appenders/multiprocess',
+        {
+          requires: {
+            'net': fakeNet
+          }
+        }
+      ).appender({ mode: 'master' });
+      
+      return fakeNet;
+    },
+    'should listen for log messages on localhost:5000': function(net) {
+      assert.equal(net.port, 5000);
+      assert.equal(net.host, 'localhost');
+    }
+  }
+}).addBatch({
+  'configure': {
+    topic: function() {
+      var results = {}
+      , fakeNet = makeFakeNet()
+      , appender = sandbox.require(
+        '../lib/appenders/multiprocess',
+        {
+          requires: {
+            'net': fakeNet,
+            '../log4js': {
+              loadAppender: function(app) {
+                results.appenderLoaded = app;
+              },
+              appenderMakers: {
+                'madeupappender': function(config, options) {
+                  results.config = config;
+                  results.options = options;
+                }
+              }
+            }
+          }
+        }
+      ).configure(
+        {
+          mode: 'master',
+          appender: {
+            type: 'madeupappender',
+            cheese: 'gouda'
+          }
+        },
+        { crackers: 'jacobs' }
+      );
+
+      return results;
+        
+    },
+    'should load underlying appender for master': function(results) {
+      assert.equal(results.appenderLoaded, 'madeupappender');
+    },
+    'should pass config to underlying appender': function(results) {
+      assert.equal(results.config.cheese, 'gouda');
+    },
+    'should pass options to underlying appender': function(results) {
+      assert.equal(results.options.crackers, 'jacobs');
+    }
+  }
 }).exportTo(module);

test/nolog-test.js

@@ -1,3 +1,4 @@
+"use strict";
 var vows = require('vows')
 , assert = require('assert')
 , levels = require('../lib/levels');
@@ -8,7 +9,7 @@ function MockLogger() {
   this.messages = [];
 
   this.log = function(level, message, exception) {
-	  that.messages.push({ level: level, message: message });
+    that.messages.push({ level: level, message: message });
   };
 
   this.isLevelEnabled = function(level) {
@@ -20,7 +21,7 @@ function MockLogger() {
 }
 
 function MockRequest(remoteAddr, method, originalUrl) {
-
+  
   this.socket = { remoteAddress: remoteAddr };
   this.originalUrl = originalUrl;
   this.method = method;
@@ -34,226 +35,226 @@ function MockResponse(statusCode) {
   this.statusCode = statusCode;
 
   this.end = function(chunk, encoding) {
-
+    
   };
 }
 
 vows.describe('log4js connect logger').addBatch({
   'getConnectLoggerModule': {
-      topic: function() {
+    topic: function() {
-	  var clm = require('../lib/connect-logger');
+      var clm = require('../lib/connect-logger');
-	  return clm;
+      return clm;
-      },
-
-      'should return a "connect logger" factory' : function(clm) {
-	  assert.isObject(clm);
-      },
-
-      'nolog String' : {
-	  topic: function(clm) {
-	      var ml = new MockLogger();
-	      var cl = clm.connectLogger(ml, { nolog: "\\.gif" });
-              return {cl: cl, ml: ml};
-          },
-
-          'check unmatch url request': {
-              topic: function(d){
-		  var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.png'); // not gif
-		  var res = new MockResponse(200);
-		  d.cl(req, res, function() { });
-                  res.end('chunk', 'encoding');
-                  return d.ml.messages;
-              }
-            , 'check message': function(messages){
-		  assert.isArray(messages);
-		  assert.equal(messages.length, 1);
-		  assert.ok(levels.INFO.isEqualTo(messages[0].level));
-		  assert.include(messages[0].message, 'GET');
-		  assert.include(messages[0].message, 'http://url');
-		  assert.include(messages[0].message, 'my.remote.addr');
-		  assert.include(messages[0].message, '200');
-                  messages.pop();
-	      }
-	  },
-
-          'check match url request': {
-	      topic: function(d) {
-		  var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.gif'); // gif
-		  var res = new MockResponse(200);
-		  d.cl(req, res, function() { });
-                  res.end('chunk', 'encoding');
-                  return d.ml.messages;
-	      }
-	    , 'check message': function(messages) {
-		  assert.isArray(messages);
-		  assert.equal(messages.length, 0);
-	      }
-	  }
     },
 
-      'nolog Strings' : {
+    'should return a "connect logger" factory' : function(clm) {
-	  topic: function(clm) {
+      assert.isObject(clm);
-	      var ml = new MockLogger();
+    },
-	      var cl = clm.connectLogger(ml, {nolog: "\\.gif|\\.jpe?g"});
-              return {cl: cl, ml: ml};
-          },
 
-          'check unmatch url request (png)': {
+    'nolog String' : {
-              topic: function(d){
+      topic: function(clm) {
-		  var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.png'); // not gif
+        var ml = new MockLogger();
-		  var res = new MockResponse(200);
+        var cl = clm.connectLogger(ml, { nolog: "\\.gif" });
-		  d.cl(req, res, function() { });
+        return {cl: cl, ml: ml};
-                  res.end('chunk', 'encoding');
+      },
-                  return d.ml.messages;
+
-              }
+      'check unmatch url request': {
-            , 'check message': function(messages){
+        topic: function(d){
-		  assert.isArray(messages);
+          var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.png'); // not gif
-		  assert.equal(messages.length, 1);
+          var res = new MockResponse(200);
-		  assert.ok(levels.INFO.isEqualTo(messages[0].level));
+          d.cl(req, res, function() { });
-		  assert.include(messages[0].message, 'GET');
+          res.end('chunk', 'encoding');
-		  assert.include(messages[0].message, 'http://url');
+          return d.ml.messages;
-		  assert.include(messages[0].message, 'my.remote.addr');
+        }, 
-		  assert.include(messages[0].message, '200');
+        'check message': function(messages){
-                  messages.pop();
+          assert.isArray(messages);
-	      }
+          assert.equal(messages.length, 1);
-	  },
+          assert.ok(levels.INFO.isEqualTo(messages[0].level));
+          assert.include(messages[0].message, 'GET');
+          assert.include(messages[0].message, 'http://url');
+          assert.include(messages[0].message, 'my.remote.addr');
+          assert.include(messages[0].message, '200');
+          messages.pop();
+        }
+      },
+
+      'check match url request': {
+        topic: function(d) {
+          var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.gif'); // gif
+          var res = new MockResponse(200);
+          d.cl(req, res, function() { });
+          res.end('chunk', 'encoding');
+          return d.ml.messages;
+        }, 
+        'check message': function(messages) {
+          assert.isArray(messages);
+          assert.equal(messages.length, 0);
+        }
+      }
+    },
+
+    'nolog Strings' : {
+      topic: function(clm) {
+        var ml = new MockLogger();
+        var cl = clm.connectLogger(ml, {nolog: "\\.gif|\\.jpe?g"});
+        return {cl: cl, ml: ml};
+      },
+      
+      'check unmatch url request (png)': {
+        topic: function(d){
+          var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.png'); // not gif
+          var res = new MockResponse(200);
+          d.cl(req, res, function() { });
+          res.end('chunk', 'encoding');
+          return d.ml.messages;
+        }, 
+        'check message': function(messages){
+          assert.isArray(messages);
+          assert.equal(messages.length, 1);
+          assert.ok(levels.INFO.isEqualTo(messages[0].level));
+          assert.include(messages[0].message, 'GET');
+          assert.include(messages[0].message, 'http://url');
+          assert.include(messages[0].message, 'my.remote.addr');
+          assert.include(messages[0].message, '200');
+          messages.pop();
+        }
+      },
 
       'check match url request (gif)': {
-	      topic: function(d) {
+        topic: function(d) {
-		      var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.gif'); // gif
+          var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.gif'); // gif
-		      var res = new MockResponse(200);
+          var res = new MockResponse(200);
-		      d.cl(req, res, function() { });
+          d.cl(req, res, function() { });
           res.end('chunk', 'encoding');
           return d.ml.messages;
-	      }
+        }, 
-	      , 'check message': function(messages) {
+        'check message': function(messages) {
-		      assert.isArray(messages);
+          assert.isArray(messages);
-		      assert.equal(messages.length, 0);
+          assert.equal(messages.length, 0);
-	      }
+        }
-	    },
+      },
       'check match url request (jpeg)': {
-	      topic: function(d) {
+        topic: function(d) {
-		      var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.jpeg'); // gif
+          var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.jpeg'); // gif
-		      var res = new MockResponse(200);
+          var res = new MockResponse(200);
-		      d.cl(req, res, function() { });
+          d.cl(req, res, function() { });
           res.end('chunk', 'encoding');
           return d.ml.messages;
-	      }
+        }, 
-	      , 'check message': function(messages) {
+        'check message': function(messages) {
-		      assert.isArray(messages);
+          assert.isArray(messages);
-		      assert.equal(messages.length, 0);
+          assert.equal(messages.length, 0);
-	      }
+        }
-	    }
+      }
     },
-	  'nolog Array<String>' : {
+    'nolog Array<String>' : {
-	    topic: function(clm) {
+      topic: function(clm) {
-		    var ml = new MockLogger();
+        var ml = new MockLogger();
-		    var cl = clm.connectLogger(ml, {nolog: ["\\.gif", "\\.jpe?g"]});
+        var cl = clm.connectLogger(ml, {nolog: ["\\.gif", "\\.jpe?g"]});
+        return {cl: cl, ml: ml};
+      },
+      
+      'check unmatch url request (png)': {
+        topic: function(d){
+          var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.png'); // not gif
+          var res = new MockResponse(200);
+          d.cl(req, res, function() { });
+          res.end('chunk', 'encoding');
+          return d.ml.messages;
+        }, 
+        'check message': function(messages){
+          assert.isArray(messages);
+          assert.equal(messages.length, 1);
+          assert.ok(levels.INFO.isEqualTo(messages[0].level));
+          assert.include(messages[0].message, 'GET');
+          assert.include(messages[0].message, 'http://url');
+          assert.include(messages[0].message, 'my.remote.addr');
+          assert.include(messages[0].message, '200');
+          messages.pop();
+        }
+      },
+
+      'check match url request (gif)': {
+        topic: function(d) {
+          var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.gif'); // gif
+          var res = new MockResponse(200);
+          d.cl(req, res, function() { });
+          res.end('chunk', 'encoding');
+          return d.ml.messages;
+        }, 
+        'check message': function(messages) {
+          assert.isArray(messages);
+          assert.equal(messages.length, 0);
+        }
+      },
+
+      'check match url request (jpeg)': {
+        topic: function(d) {
+          var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.jpeg'); // gif
+          var res = new MockResponse(200);
+          d.cl(req, res, function() { });
+          res.end('chunk', 'encoding');
+          return d.ml.messages;
+        }, 
+        'check message': function(messages) {
+          assert.isArray(messages);
+          assert.equal(messages.length, 0);
+        }
+      },
+    },
+    'nolog RegExp' : {
+      topic: function(clm) {
+        var ml = new MockLogger();
+        var cl = clm.connectLogger(ml, {nolog: /\.gif|\.jpe?g/});
         return {cl: cl, ml: ml};
       },
 
       'check unmatch url request (png)': {
         topic: function(d){
-		      var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.png'); // not gif
+          var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.png'); // not gif
-		      var res = new MockResponse(200);
+          var res = new MockResponse(200);
-		      d.cl(req, res, function() { });
+          d.cl(req, res, function() { });
           res.end('chunk', 'encoding');
           return d.ml.messages;
-        }
+        }, 
-        , 'check message': function(messages){
+        'check message': function(messages){
-		      assert.isArray(messages);
+          assert.isArray(messages);
-		      assert.equal(messages.length, 1);
+          assert.equal(messages.length, 1);
-		      assert.ok(levels.INFO.isEqualTo(messages[0].level));
+          assert.ok(levels.INFO.isEqualTo(messages[0].level));
-		      assert.include(messages[0].message, 'GET');
+          assert.include(messages[0].message, 'GET');
-		      assert.include(messages[0].message, 'http://url');
+          assert.include(messages[0].message, 'http://url');
-		      assert.include(messages[0].message, 'my.remote.addr');
+          assert.include(messages[0].message, 'my.remote.addr');
-		      assert.include(messages[0].message, '200');
+          assert.include(messages[0].message, '200');
           messages.pop();
-	      }
+        }
-	    },
-
-      'check match url request (gif)': {
-	      topic: function(d) {
-		      var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.gif'); // gif
-		      var res = new MockResponse(200);
-		      d.cl(req, res, function() { });
-          res.end('chunk', 'encoding');
-          return d.ml.messages;
-	      }
-	      , 'check message': function(messages) {
-		      assert.isArray(messages);
-		      assert.equal(messages.length, 0);
-	      }
-	    },
-
-      'check match url request (jpeg)': {
-	      topic: function(d) {
-		      var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.jpeg'); // gif
-		      var res = new MockResponse(200);
-		      d.cl(req, res, function() { });
-          res.end('chunk', 'encoding');
-          return d.ml.messages;
-	      }
-	      , 'check message': function(messages) {
-		      assert.isArray(messages);
-		      assert.equal(messages.length, 0);
-	      }
-	    },
-    },
-	  'nolog RegExp' : {
-	    topic: function(clm) {
-		    var ml = new MockLogger();
-		    var cl = clm.connectLogger(ml, {nolog: /\.gif|\.jpe?g/});
-        return {cl: cl, ml: ml};
       },
 
-      'check unmatch url request (png)': {
-        topic: function(d){
-		      var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.png'); // not gif
-		      var res = new MockResponse(200);
-		      d.cl(req, res, function() { });
-          res.end('chunk', 'encoding');
-          return d.ml.messages;
-        }
-        , 'check message': function(messages){
-		      assert.isArray(messages);
-		      assert.equal(messages.length, 1);
-		      assert.ok(levels.INFO.isEqualTo(messages[0].level));
-		      assert.include(messages[0].message, 'GET');
-		      assert.include(messages[0].message, 'http://url');
-		      assert.include(messages[0].message, 'my.remote.addr');
-		      assert.include(messages[0].message, '200');
-          messages.pop();
-	      }
-	    },
-
       'check match url request (gif)': {
-	      topic: function(d) {
+        topic: function(d) {
-		      var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.gif'); // gif
+          var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.gif'); // gif
-		      var res = new MockResponse(200);
+          var res = new MockResponse(200);
-		      d.cl(req, res, function() { });
+          d.cl(req, res, function() { });
           res.end('chunk', 'encoding');
           return d.ml.messages;
-	      }
+        }, 
-	      , 'check message': function(messages) {
+        'check message': function(messages) {
-		      assert.isArray(messages);
+          assert.isArray(messages);
-		      assert.equal(messages.length, 0);
+          assert.equal(messages.length, 0);
-	      }
+        }
-	    },
+      },
 
       'check match url request (jpeg)': {
-	      topic: function(d) {
+        topic: function(d) {
-		      var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.jpeg'); // gif
+          var req = new MockRequest('my.remote.addr', 'GET', 'http://url/hoge.jpeg'); // gif
-		      var res = new MockResponse(200);
+          var res = new MockResponse(200);
-		      d.cl(req, res, function() { });
+          d.cl(req, res, function() { });
           res.end('chunk', 'encoding');
           return d.ml.messages;
-	      }
+        }, 
-	      , 'check message': function(messages) {
+        'check message': function(messages) {
-		      assert.isArray(messages);
+          assert.isArray(messages);
-		      assert.equal(messages.length, 0);
+          assert.equal(messages.length, 0);
-	      }
+        }
-	    },
+      }
     }
   }
 

test/reloadConfiguration-test.js

@@ -0,0 +1,340 @@
+"use strict";
+var vows = require('vows')
+, assert = require('assert')
+, sandbox = require('sandboxed-module');
+
+function setupConsoleTest() {
+  var fakeConsole = {}
+  , logEvents = []
+  , log4js;
+  
+  ['trace','debug','log','info','warn','error'].forEach(function(fn) {
+    fakeConsole[fn] = function() {
+      throw new Error("this should not be called.");
+    };
+  });
+
+  log4js = sandbox.require(
+    '../lib/log4js', 
+    {
+      globals: {
+        console: fakeConsole
+      }
+    }
+  );
+
+  log4js.clearAppenders();
+  log4js.addAppender(function(evt) {
+    logEvents.push(evt);
+  });
+
+  return { log4js: log4js, logEvents: logEvents, fakeConsole: fakeConsole };
+}
+
+vows.describe('reload configuration').addBatch({
+  'with config file changing' : {
+    topic: function() {
+      var pathsChecked = [],
+      logEvents = [],
+      logger,
+      modulePath = 'path/to/log4js.json',
+      fakeFS = {
+        lastMtime: Date.now(),
+        config: { 
+          appenders: [ 
+            { type: 'console', layout: { type: 'messagePassThrough' } } 
+          ],
+          levels: { 'a-test' : 'INFO' } 
+        },
+        readFileSync: function (file, encoding) {
+          assert.equal(file, modulePath);
+          assert.equal(encoding, 'utf8');
+          return JSON.stringify(fakeFS.config);
+        },
+        statSync: function (path) {
+          pathsChecked.push(path);
+          if (path === modulePath) {
+            fakeFS.lastMtime += 1;
+            return { mtime: new Date(fakeFS.lastMtime) };
+          } else {
+            throw new Error("no such file");
+          }
+        }
+      },
+      fakeConsole = {
+        'name': 'console',
+        'appender': function () {
+          return function(evt) { logEvents.push(evt); };
+        },
+        'configure': function (config) {
+          return fakeConsole.appender();
+        }
+      },
+      setIntervalCallback,
+      fakeSetInterval = function(cb, timeout) {
+        setIntervalCallback = cb;
+      },
+      log4js = sandbox.require(
+        '../lib/log4js',
+        {
+          requires: {
+            'fs': fakeFS,
+            './appenders/console': fakeConsole
+          },
+          globals: {
+            'console': fakeConsole,
+            'setInterval' : fakeSetInterval,
+          }
+        }
+      );
+      
+      log4js.configure('path/to/log4js.json', { reloadSecs: 30 });
+      logger = log4js.getLogger('a-test');
+      logger.info("info1");
+      logger.debug("debug2 - should be ignored");
+      fakeFS.config.levels['a-test'] = "DEBUG";
+      setIntervalCallback();
+      logger.info("info3");
+      logger.debug("debug4");
+      
+      return logEvents;
+    },
+    'should configure log4js from first log4js.json found': function(logEvents) {
+      assert.equal(logEvents[0].data[0], 'info1');
+      assert.equal(logEvents[1].data[0], 'info3');
+      assert.equal(logEvents[2].data[0], 'debug4');
+      assert.equal(logEvents.length, 3);
+    }
+  },
+  
+  'with config file staying the same' : {
+    topic: function() {
+      var pathsChecked = [],
+      fileRead = 0,
+      logEvents = [],
+      logger,
+      modulePath = require('path').normalize(__dirname + '/../lib/log4js.json'),
+      mtime = new Date(),
+      fakeFS = {
+        config: { 
+          appenders: [ 
+            { type: 'console', layout: { type: 'messagePassThrough' } } 
+          ],
+          levels: { 'a-test' : 'INFO' } 
+        },
+        readFileSync: function (file, encoding) {
+          fileRead += 1;
+          assert.isString(file);
+          assert.equal(file, modulePath);
+          assert.equal(encoding, 'utf8');
+          return JSON.stringify(fakeFS.config);
+        },
+        statSync: function (path) {
+          pathsChecked.push(path);
+          if (path === modulePath) {
+            return { mtime: mtime };
+          } else {
+            throw new Error("no such file");
+          }
+        }
+      },
+      fakeConsole = {
+        'name': 'console',
+        'appender': function () {
+          return function(evt) { logEvents.push(evt); };
+        },
+        'configure': function (config) {
+          return fakeConsole.appender();
+        }
+      },
+      setIntervalCallback,
+      fakeSetInterval = function(cb, timeout) {
+        setIntervalCallback = cb;
+      },
+      log4js = sandbox.require(
+        '../lib/log4js',
+        {
+          requires: {
+            'fs': fakeFS,
+            './appenders/console': fakeConsole
+          },
+          globals: {
+            'console': fakeConsole,
+            'setInterval' : fakeSetInterval,
+          }
+        }
+      );
+      
+      log4js.configure(modulePath, { reloadSecs: 3 });
+      logger = log4js.getLogger('a-test');
+      logger.info("info1");
+      logger.debug("debug2 - should be ignored");
+      setIntervalCallback();
+      logger.info("info3");
+      logger.debug("debug4");
+      
+      return [ pathsChecked, logEvents, modulePath, fileRead ];
+    },
+    'should only read the configuration file once': function(args) {
+      var fileRead = args[3];
+      assert.equal(fileRead, 1);
+    },
+    'should configure log4js from first log4js.json found': function(args) {
+      var logEvents = args[1];
+      assert.equal(logEvents.length, 2);
+      assert.equal(logEvents[0].data[0], 'info1');
+      assert.equal(logEvents[1].data[0], 'info3');
+    }
+  },
+
+  'when config file is removed': {
+    topic: function() {
+      var pathsChecked = [],
+      fileRead = 0,
+      logEvents = [],
+      logger,
+      modulePath = require('path').normalize(__dirname + '/../lib/log4js.json'),
+      mtime = new Date(),
+      fakeFS = {
+        config: { 
+          appenders: [ 
+            { type: 'console', layout: { type: 'messagePassThrough' } } 
+          ],
+          levels: { 'a-test' : 'INFO' } 
+        },
+        readFileSync: function (file, encoding) {
+          fileRead += 1;
+          assert.isString(file);
+          assert.equal(file, modulePath);
+          assert.equal(encoding, 'utf8');
+          return JSON.stringify(fakeFS.config);
+        },
+        statSync: function (path) {
+          this.statSync = function() {
+            throw new Error("no such file");
+          };
+          return { mtime: new Date() };
+        }
+      },
+      fakeConsole = {
+        'name': 'console',
+        'appender': function () {
+          return function(evt) { logEvents.push(evt); };
+        },
+        'configure': function (config) {
+          return fakeConsole.appender();
+        }
+      },
+      setIntervalCallback,
+      fakeSetInterval = function(cb, timeout) {
+        setIntervalCallback = cb;
+      },
+      log4js = sandbox.require(
+        '../lib/log4js',
+        {
+          requires: {
+            'fs': fakeFS,
+            './appenders/console': fakeConsole
+          },
+          globals: {
+            'console': fakeConsole,
+            'setInterval' : fakeSetInterval,
+          }
+        }
+      );
+      
+      log4js.configure(modulePath, { reloadSecs: 3 });
+      logger = log4js.getLogger('a-test');
+      logger.info("info1");
+      logger.debug("debug2 - should be ignored");
+      setIntervalCallback();
+      logger.info("info3");
+      logger.debug("debug4");
+      
+      return [ pathsChecked, logEvents, modulePath, fileRead ];
+    },
+    'should only read the configuration file once': function(args) {
+      var fileRead = args[3];
+      assert.equal(fileRead, 1);
+    },
+    'should not clear configuration when config file not found': function(args) {
+      var logEvents = args[1];
+      assert.equal(logEvents.length, 3);
+      assert.equal(logEvents[0].data[0], 'info1');
+      assert.equal(logEvents[1].level.toString(), 'WARN');
+      assert.include(logEvents[1].data[0], 'Failed to load configuration file');
+      assert.equal(logEvents[2].data[0], 'info3');
+    }
+  },
+
+  'when passed an object': {
+    topic: function() {
+      var test = setupConsoleTest();
+      test.log4js.configure({}, { reloadSecs: 30 });
+      return test.logEvents;
+    },
+    'should log a warning': function(events) {
+      assert.equal(events[0].level.toString(), 'WARN');
+      assert.equal(
+        events[0].data[0], 
+        'Ignoring configuration reload parameter for "object" configuration.'
+      );
+    }
+  },
+
+  'when called twice with reload options': {
+    topic: function() {
+      var modulePath = require('path').normalize(__dirname + '/../lib/log4js.json'),
+      fakeFS = {
+        readFileSync: function (file, encoding) {
+          return JSON.stringify({});
+        },
+        statSync: function (path) {
+          return { mtime: new Date() };
+        }
+      },
+      fakeConsole = {
+        'name': 'console',
+        'appender': function () {
+          return function(evt) { };
+        },
+        'configure': function (config) {
+          return fakeConsole.appender();
+        }
+      },
+      setIntervalCallback,
+      intervalCleared = false,
+      clearedId,
+      fakeSetInterval = function(cb, timeout) {
+        setIntervalCallback = cb;
+        return 1234;
+      },
+      log4js = sandbox.require(
+        '../lib/log4js',
+        {
+          requires: {
+            'fs': fakeFS,
+            './appenders/console': fakeConsole
+          },
+          globals: {
+            'console': fakeConsole,
+            'setInterval' : fakeSetInterval,
+            'clearInterval': function(interval) {
+              intervalCleared = true;
+              clearedId = interval;
+            }
+          }
+        }
+      );
+      
+      log4js.configure(modulePath, { reloadSecs: 3 });
+      log4js.configure(modulePath, { reloadSecs: 15 });
+      
+      return { cleared: intervalCleared, id: clearedId };
+    },
+    'should clear the previous interval': function(result) {
+      assert.isTrue(result.cleared);
+      assert.equal(result.id, 1234);
+    }
+  }
+}).exportTo(module);

test/setLevel-asymmetry-test.js

@@ -1,5 +1,9 @@
-// This test shows an asymmetry between setLevel and isLevelEnabled (in log4js-node@0.4.3 and earlier):
+"use strict";
-// 1) setLevel("foo") works, but setLevel(log4js.levels.foo) silently does not (sets the level to TRACE).
+/* jshint loopfunc: true */
+// This test shows an asymmetry between setLevel and isLevelEnabled 
+// (in log4js-node@0.4.3 and earlier):
+// 1) setLevel("foo") works, but setLevel(log4js.levels.foo) silently 
+//    does not (sets the level to TRACE).
 // 2) isLevelEnabled("foo") works as does isLevelEnabled(log4js.levels.foo).
 //
 
@@ -19,7 +23,8 @@ var strLevels= ['Trace','Debug','Info','Warn','Error','Fatal'];
 
 var log4jsLevels =[];
 // populate an array with the log4js.levels that match the strLevels.
-// Would be nice if we could iterate over log4js.levels instead, but log4js.levels.toLevel prevents that for now.
+// Would be nice if we could iterate over log4js.levels instead, 
+// but log4js.levels.toLevel prevents that for now.
 strLevels.forEach(function(l) {
   log4jsLevels.push(log4js.levels.toLevel(l));
 });
@@ -29,18 +34,19 @@ strLevels.forEach(function(l) {
 var levelTypes = {
   'string': strLevels,
   'log4js.levels.level': log4jsLevels,
-}
+};
 
 // Set up the basic vows batch for this test
 var batch = {
   setLevel: {
   }
-}
+};
 
 showProgress('Populating batch object...');
 
 // Populating the batch object programmatically,
-// as I don't have the patience to manually populate it with the (strLevels.length x levelTypes.length) ^ 2 = 144 possible test combinations
+// as I don't have the patience to manually populate it with 
+// the (strLevels.length x levelTypes.length) ^ 2 = 144 possible test combinations
 for (var type in levelTypes) {
   var context = 'is called with a '+type;
   var levelsToTest = levelTypes[type];
@@ -58,15 +64,30 @@ for (var type in levelTypes) {
         var t = type;
         var ct = comparisonType;
         var expectedResult = log4jsLevel.isLessThanOrEqualTo(comparisonLevel);
-        var vow = 'isLevelEnabled('+comparisonLevel+') called with a '+comparisonType+' should return '+expectedResult;
+        var vow = 'isLevelEnabled(' + comparisonLevel + 
+          ') called with a ' + comparisonType + 
+          ' should return ' + expectedResult;
         showProgress('Setting up the vows vow for '+vow);
 
         batch.setLevel[context][subContext][vow] = function(levelToSet) {
           logger.setLevel(levelToSet);
-          showProgress('*** Checking setLevel( '+level+' ) of type '+t+', and isLevelEnabled( '+comparisonLevel+' ) of type '+ct+'. Expecting: '+expectedResult);
+          showProgress(
-          assert.equal(logger.isLevelEnabled(comparisonLevel), expectedResult, 'Failed: calling setLevel( '+level+' ) with type '+type+', isLevelEnabled( '+comparisonLevel+' ) of type '+comparisonType+' did not return '+expectedResult);
+            '*** Checking setLevel( ' + level + 
+              ' ) of type ' + t + 
+              ', and isLevelEnabled( ' + comparisonLevel + 
+              ' ) of type ' + ct + '. Expecting: ' + expectedResult
+          );
+          assert.equal(
+            logger.isLevelEnabled(comparisonLevel), 
+            expectedResult, 
+            'Failed: calling setLevel( ' + level + 
+              ' ) with type ' + type + 
+              ', isLevelEnabled( ' + comparisonLevel + 
+              ' ) of type ' + comparisonType + 
+              ' did not return ' + expectedResult
+          );
         };
-      })
+      });
     }
   });
 

test/smtpAppender-test.js

@@ -1,168 +1,231 @@
-var vows = require('vows'),
+"use strict";
-    assert = require('assert'),
+var vows = require('vows')
-    log4js = require('../lib/log4js'),
+, assert = require('assert')
-    sandbox = require('sandboxed-module');
+, log4js = require('../lib/log4js')
+, sandbox = require('sandboxed-module')
+;
 
 function setupLogging(category, options) {
-    var msgs = [];
+  var msgs = [];
 
-    var fakeMailer = {
+  var fakeMailer = {
 		createTransport: function (name, options) {
 			return {
 				config: options,
 				sendMail: function (msg, callback) {
-				    msgs.push(msg);
+          msgs.push(msg);
-				    callback(null, true);
+          callback(null, true);
-				}
+        },
+        close: function() {}
 			};
 		}
-    };
+  };
 
-    var smtpModule = sandbox.require('../lib/appenders/smtp', {
+  var fakeLayouts = {
+    layout: function(type, config) {
+      this.type = type;
+      this.config = config;
+      return log4js.layouts.messagePassThroughLayout;
+    },
+    basicLayout: log4js.layouts.basicLayout,
+    messagePassThroughLayout: log4js.layouts.messagePassThroughLayout
+  };
+
+  var fakeConsole = {
+    errors: [],
+    error: function(msg, value) {
+      this.errors.push({ msg: msg, value: value });
+    }
+  };
+
+  var smtpModule = sandbox.require('../lib/appenders/smtp', {
 		requires: {
-		    'nodemailer': fakeMailer
+      'nodemailer': fakeMailer,
-		}
+      '../layouts': fakeLayouts
-    });
+		},
+    globals: {
+      console: fakeConsole
+    }
+  });
 
-    log4js.addAppender(smtpModule.configure(options), category);
+  log4js.addAppender(smtpModule.configure(options), category);
 
-    return {
+  return {
 		logger: log4js.getLogger(category),
 		mailer: fakeMailer,
+    layouts: fakeLayouts,
+    console: fakeConsole,
 		results: msgs
-    };
+  };
 }
 
 function checkMessages (result, sender, subject) {
-    for (var i = 0; i < result.results.length; ++i) {
+  for (var i = 0; i < result.results.length; ++i) {
 		assert.equal(result.results[i].from, sender);
 		assert.equal(result.results[i].to, 'recipient@domain.com');
 		assert.equal(result.results[i].subject, subject ? subject : 'Log event #' + (i+1));
 		assert.ok(new RegExp('.+Log event #' + (i+1) + '\n$').test(result.results[i].text));
-    }
+  }
 }
 
 log4js.clearAppenders();
 vows.describe('log4js smtpAppender').addBatch({
-    'minimal config': {
+  'minimal config': {
 		topic: function() {
-		    var setup = setupLogging('minimal config', {
+      var setup = setupLogging('minimal config', {
-			recipients: 'recipient@domain.com',
+        recipients: 'recipient@domain.com',
-			transport: "SMTP",
+        transport: "SMTP",
-			SMTP: {
+        SMTP: {
-			    port: 25,
+          port: 25,
-			    auth: {
+          auth: {
-				    user: 'user@domain.com'
+            user: 'user@domain.com'
-			    }
+          }
-			}
+        }
-		    });
+      });
-		    setup.logger.info('Log event #1');
+      setup.logger.info('Log event #1');
-		    return setup;
+      return setup;
 		},
 		'there should be one message only': function (result) {
-		    assert.equal(result.results.length, 1);
+      assert.equal(result.results.length, 1);
 		},
 		'message should contain proper data': function (result) {
-		    checkMessages(result);
+      checkMessages(result);
 		}
+  },
+  'fancy config': {
+    topic: function() {
+      var setup = setupLogging('fancy config', {
+        recipients: 'recipient@domain.com',
+        sender: 'sender@domain.com',
+        subject: 'This is subject',
+        transport: "SMTP",
+        SMTP: {
+          port: 25,
+          auth: {
+            user: 'user@domain.com'
+          }
+        }
+      });
+      setup.logger.info('Log event #1');
+      return setup;
     },
-    'fancy config': {
+    'there should be one message only': function (result) {
-		topic: function() {
+      assert.equal(result.results.length, 1);
-		    var setup = setupLogging('fancy config', {
-			recipients: 'recipient@domain.com',
-			sender: 'sender@domain.com',
-			subject: 'This is subject',
-			transport: "SMTP",
-			SMTP: {
-			    port: 25,
-			    auth: {
-				    user: 'user@domain.com'
-			    }
-			}
-		    });
-		    setup.logger.info('Log event #1');
-		    return setup;
-		},
-		'there should be one message only': function (result) {
-		    assert.equal(result.results.length, 1);
-		},
-		'message should contain proper data': function (result) {
-		    checkMessages(result, 'sender@domain.com', 'This is subject');
-		}
     },
-    'separate email for each event': {
+    'message should contain proper data': function (result) {
-		topic: function() {
+      checkMessages(result, 'sender@domain.com', 'This is subject');
-		    var self = this;
-		    var setup = setupLogging('separate email for each event', {
-				recipients: 'recipient@domain.com',
-				transport: "SMTP",
-				SMTP: {
-				    port: 25,
-				    auth: {
-					    user: 'user@domain.com'
-				    }
-				}
-		    });
-		    setTimeout(function () {
-		    	setup.logger.info('Log event #1');
-		    }, 0);
-		    setTimeout(function () {
-		    	setup.logger.info('Log event #2');
-		    }, 500);
-		    setTimeout(function () {
-		    	setup.logger.info('Log event #3');
-		    }, 1050);
-		    setTimeout(function () {
-		    	self.callback(null, setup);
-		    }, 2100);
-		},
-		'there should be three messages': function (result) {
-		    assert.equal(result.results.length, 3);
-		},
-		'messages should contain proper data': function (result) {
-		    checkMessages(result);
-		}
-    },
-    'multiple events in one email': {
-		topic: function() {
-		    var self = this;
-		    var setup = setupLogging('multiple events in one email', {
-				recipients: 'recipient@domain.com',
-				sendInterval: 1,
-				transport: "SMTP",
-				SMTP: {
-				    port: 25,
-				    auth: {
-					    user: 'user@domain.com'
-				    }
-				}
-		    });
-		    setTimeout(function () {
-		    	setup.logger.info('Log event #1');
-		    }, 0);
-		    setTimeout(function () {
-		    	setup.logger.info('Log event #2');
-		    }, 500);
-		    setTimeout(function () {
-		    	setup.logger.info('Log event #3');
-		    }, 1050);
-		    setTimeout(function () {
-		    	self.callback(null, setup);
-		    }, 2100);
-		},
-		'there should be two messages': function (result) {
-		    assert.equal(result.results.length, 2);
-		},
-		'messages should contain proper data': function (result) {
-		    assert.equal(result.results[0].to, 'recipient@domain.com');
-		    assert.equal(result.results[0].subject, 'Log event #1');
-		    assert.equal(result.results[0].text.match(new RegExp('.+Log event #[1-2]$', 'gm')).length, 2);
-	
-		    assert.equal(result.results[1].to, 'recipient@domain.com');
-		    assert.equal(result.results[1].subject, 'Log event #3');
-		    assert.ok(new RegExp('.+Log event #3\n$').test(result.results[1].text));
-		}
     }
+  },
+  'config with layout': {
+    topic: function() {
+      var setup = setupLogging('config with layout', {
+        layout: {
+          type: "tester"
+        }
+      });
+      return setup;
+    },
+    'should configure layout': function(result) {
+      assert.equal(result.layouts.type, 'tester');
+    }
+  },
+  'separate email for each event': {
+    topic: function() {
+      var self = this;
+      var setup = setupLogging('separate email for each event', {
+        recipients: 'recipient@domain.com',
+        transport: "SMTP",
+        SMTP: {
+          port: 25,
+          auth: {
+            user: 'user@domain.com'
+          }
+        }
+      });
+      setTimeout(function () {
+        setup.logger.info('Log event #1');
+      }, 0);
+      setTimeout(function () {
+        setup.logger.info('Log event #2');
+      }, 500);
+      setTimeout(function () {
+        setup.logger.info('Log event #3');
+      }, 1100);
+      setTimeout(function () {
+        self.callback(null, setup);
+      }, 3000);
+    },
+    'there should be three messages': function (result) {
+      assert.equal(result.results.length, 3);
+    },
+    'messages should contain proper data': function (result) {
+      checkMessages(result);
+    }
+  },
+  'multiple events in one email': {
+    topic: function() {
+      var self = this;
+      var setup = setupLogging('multiple events in one email', {
+        recipients: 'recipient@domain.com',
+        sendInterval: 1,
+        transport: "SMTP",
+        SMTP: {
+          port: 25,
+          auth: {
+            user: 'user@domain.com'
+          }
+        }
+      });
+      setTimeout(function () {
+        setup.logger.info('Log event #1');
+      }, 0);
+      setTimeout(function () {
+        setup.logger.info('Log event #2');
+      }, 100);
+      setTimeout(function () {
+        setup.logger.info('Log event #3');
+      }, 1500);
+      setTimeout(function () {
+        self.callback(null, setup);
+      }, 3000);
+    },
+    'there should be two messages': function (result) {
+      assert.equal(result.results.length, 2);
+    },
+    'messages should contain proper data': function (result) {
+      assert.equal(result.results[0].to, 'recipient@domain.com');
+      assert.equal(result.results[0].subject, 'Log event #1');
+      assert.equal(result.results[0].text.match(new RegExp('.+Log event #[1-2]$', 'gm')).length, 2);
+      assert.equal(result.results[1].to, 'recipient@domain.com');
+      assert.equal(result.results[1].subject, 'Log event #3');
+      assert.ok(new RegExp('.+Log event #3\n$').test(result.results[1].text));
+    }
+  },
+  'error when sending email': {
+    topic: function() {
+      var setup = setupLogging('error when sending email', {
+        recipients: 'recipient@domain.com',
+        sendInterval: 0,
+        transport: 'SMTP',
+        SMTP: { port: 25, auth: { user: 'user@domain.com' } }
+      });
 
+      setup.mailer.createTransport = function() {
+        return {
+          sendMail: function(msg, cb) {
+            cb({ message: "oh noes" });
+          },
+          close: function() { }
+        };
+      };
+
+      setup.logger.info("This will break");
+      return setup.console;
+    },
+    'should be logged to console': function(cons) {
+      assert.equal(cons.errors.length, 1);
+      assert.equal(cons.errors[0].msg, "log4js.smtpAppender - Error happened");
+      assert.equal(cons.errors[0].value.message, 'oh noes');
+    }
+  }
 }).export(module);
-

test/streams/BaseRollingFileStream-test.js

@@ -0,0 +1,93 @@
+"use strict";
+var vows = require('vows')
+, assert = require('assert')
+, fs = require('fs')
+, sandbox = require('sandboxed-module');
+
+vows.describe('../../lib/streams/BaseRollingFileStream').addBatch({
+  'when node version < 0.10.0': {
+    topic: function() {
+      var streamLib = sandbox.load(
+        '../../lib/streams/BaseRollingFileStream',
+        {
+          globals: {
+            process: {
+              version: '0.8.11'
+            }
+          },
+          requires: {
+            'readable-stream': {
+              Writable: function() {}
+            }
+          }
+        }
+      );
+      return streamLib.required;
+    },
+    'it should use readable-stream to maintain compatibility': function(required) {
+      assert.ok(required['readable-stream']);
+      assert.ok(!required.stream);
+    }
+  },
+
+  'when node version > 0.10.0': {
+    topic: function() {
+      var streamLib = sandbox.load(
+        '../../lib/streams/BaseRollingFileStream',
+        {
+          globals: {
+            process: {
+              version: '0.10.1'
+            }
+          },
+          requires: {
+            'stream': {
+              Writable: function() {}
+            }
+          }
+        }
+      );
+      return streamLib.required;
+    },
+    'it should use the core stream module': function(required) {
+      assert.ok(required.stream);
+      assert.ok(!required['readable-stream']);
+    }
+  },
+
+  'when no filename is passed': {
+    topic: require('../../lib/streams/BaseRollingFileStream'),
+    'it should throw an error': function(BaseRollingFileStream) {
+      try {
+        new BaseRollingFileStream();
+        assert.fail('should not get here');
+      } catch (e) {
+        assert.ok(e);
+      }
+    }
+  },
+
+  'default behaviour': {
+    topic: function() {
+      var BaseRollingFileStream = require('../../lib/streams/BaseRollingFileStream')
+      , stream = new BaseRollingFileStream('basetest.log');
+      return stream;
+    },
+    teardown: function() {
+      try {
+        fs.unlink('basetest.log');
+      } catch (e) {
+        console.error("could not remove basetest.log", e);
+      }
+    },
+    'it should not want to roll': function(stream) {
+      assert.isFalse(stream.shouldRoll());
+    },
+    'it should not roll': function(stream) {
+      var cbCalled = false;
+      //just calls the callback straight away, no async calls
+      stream.roll('basetest.log', function() { cbCalled = true; });
+      assert.isTrue(cbCalled);
+    }
+  }
+}).exportTo(module);

test/streams/DateRollingFileStream-test.js

@@ -1,3 +1,4 @@
+"use strict";
 var vows = require('vows')
 , assert = require('assert')
 , fs = require('fs')
@@ -11,120 +12,216 @@ if (semver.satisfies(process.version, '>=0.10.0')) {
 } else {
   streams = require('readable-stream');
 }
-DateRollingFileStream = require('../../lib/streams').DateRollingFileStream
+DateRollingFileStream = require('../../lib/streams').DateRollingFileStream;
 
 function cleanUp(filename) {
-    return function() {
+  return function() {
-        fs.unlink(filename);
+    fs.unlink(filename);
-    };
+  };
 }
 
 function now() {
-    return testTime.getTime();
+  return testTime.getTime();
 }
 
 vows.describe('DateRollingFileStream').addBatch({
-    'arguments': {
+  'arguments': {
-        topic: new DateRollingFileStream(__dirname + '/test-date-rolling-file-stream-1', 'yyyy-mm-dd.hh'),
+    topic: new DateRollingFileStream(
-        teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-1'),
+      __dirname + '/test-date-rolling-file-stream-1', 
-
+      'yyyy-mm-dd.hh'
-        'should take a filename and a pattern and return a WritableStream': function(stream) {
+    ),
-          assert.equal(stream.filename, __dirname + '/test-date-rolling-file-stream-1');
+    teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-1'),
-          assert.equal(stream.pattern, 'yyyy-mm-dd.hh');
+    
-          assert.instanceOf(stream, streams.Writable);
+    'should take a filename and a pattern and return a WritableStream': function(stream) {
-        },
+      assert.equal(stream.filename, __dirname + '/test-date-rolling-file-stream-1');
-        'with default settings for the underlying stream': function(stream) {
+      assert.equal(stream.pattern, 'yyyy-mm-dd.hh');
-          assert.equal(stream.theStream.mode, 420);
+      assert.instanceOf(stream, streams.Writable);
-          assert.equal(stream.theStream.flags, 'a');
-	  //encoding is not available on the underlying stream
-          //assert.equal(stream.encoding, 'utf8');
-        }
     },
-
+    'with default settings for the underlying stream': function(stream) {
-    'default arguments': {
+      assert.equal(stream.theStream.mode, 420);
-        topic: new DateRollingFileStream(__dirname + '/test-date-rolling-file-stream-2'),
+      assert.equal(stream.theStream.flags, 'a');
-        teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-2'),
+      //encoding is not available on the underlying stream
-
+      //assert.equal(stream.encoding, 'utf8');
-        'pattern should be .yyyy-MM-dd': function(stream) {
-            assert.equal(stream.pattern, '.yyyy-MM-dd');
-        }
-    },
-
-    'with stream arguments': {
-        topic: new DateRollingFileStream(__dirname + '/test-date-rolling-file-stream-3', 'yyyy-MM-dd', { mode: 0666 }),
-        teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-3'),
-
-        'should pass them to the underlying stream': function(stream) {
-            assert.equal(stream.theStream.mode, 0666);
-        }
-    },
-
-    'with stream arguments but no pattern': {
-        topic: new DateRollingFileStream(__dirname + '/test-date-rolling-file-stream-4', { mode: 0666 }),
-        teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-4'),
-
-        'should pass them to the underlying stream': function(stream) {
-            assert.equal(stream.theStream.mode, 0666);
-        },
-        'should use default pattern': function(stream) {
-            assert.equal(stream.pattern, '.yyyy-MM-dd');
-        }
-    },
-
-    'with a pattern of .yyyy-MM-dd': {
-        topic: function() {
-          var that = this,
-          stream = new DateRollingFileStream(__dirname + '/test-date-rolling-file-stream-5', '.yyyy-MM-dd', null, now);
-          stream.write("First message\n", 'utf8', function() {
-	          that.callback(null, stream);
-	        });
-        },
-        teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-5'),
-
-        'should create a file with the base name': {
-            topic: function(stream) {
-                fs.readFile(__dirname + '/test-date-rolling-file-stream-5', this.callback);
-            },
-            'file should contain first message': function(result) {
-                assert.equal(result.toString(), "First message\n");
-            }
-        },
-
-        'when the day changes': {
-            topic: function(stream) {
-              testTime = new Date(2012, 8, 13, 0, 10, 12);
-              stream.write("Second message\n", 'utf8', this.callback);
-            },
-            teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-5.2012-09-12'),
-
-
-            'the number of files': {
-                topic: function() {
-                    fs.readdir(__dirname, this.callback);
-                },
-                'should be two': function(files) {
-                    assert.equal(files.filter(function(file) { return file.indexOf('test-date-rolling-file-stream-5') > -1; }).length, 2);
-                }
-            },
-
-            'the file without a date': {
-                topic: function() {
-                    fs.readFile(__dirname + '/test-date-rolling-file-stream-5', this.callback);
-                },
-                'should contain the second message': function(contents) {
-                    assert.equal(contents.toString(), "Second message\n");
-                }
-            },
-
-            'the file with the date': {
-                topic: function() {
-                    fs.readFile(__dirname + '/test-date-rolling-file-stream-5.2012-09-12', this.callback);
-                },
-                'should contain the first message': function(contents) {
-                    assert.equal(contents.toString(), "First message\n");
-                }
-            }
-        }
     }
+  },
+  
+  'default arguments': {
+    topic: new DateRollingFileStream(__dirname + '/test-date-rolling-file-stream-2'),
+    teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-2'),
+    
+    'pattern should be .yyyy-MM-dd': function(stream) {
+      assert.equal(stream.pattern, '.yyyy-MM-dd');
+    }
+  },
+
+  'with stream arguments': {
+    topic: new DateRollingFileStream(
+      __dirname + '/test-date-rolling-file-stream-3', 
+      'yyyy-MM-dd', 
+      { mode: parseInt('0666', 8) }
+    ),
+    teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-3'),
+    
+    'should pass them to the underlying stream': function(stream) {
+      assert.equal(stream.theStream.mode, parseInt('0666', 8));
+    }
+  },
+
+  'with stream arguments but no pattern': {
+    topic: new DateRollingFileStream(
+      __dirname + '/test-date-rolling-file-stream-4', 
+      { mode: parseInt('0666', 8) }
+    ),
+    teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-4'),
+    
+    'should pass them to the underlying stream': function(stream) {
+      assert.equal(stream.theStream.mode, parseInt('0666', 8));
+    },
+    'should use default pattern': function(stream) {
+      assert.equal(stream.pattern, '.yyyy-MM-dd');
+    }
+  },
+
+  'with a pattern of .yyyy-MM-dd': {
+    topic: function() {
+      var that = this,
+      stream = new DateRollingFileStream(
+        __dirname + '/test-date-rolling-file-stream-5', '.yyyy-MM-dd', 
+        null, 
+        now
+      );
+      stream.write("First message\n", 'utf8', function() {
+        that.callback(null, stream);
+      });
+    },
+    teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-5'),
+    
+    'should create a file with the base name': {
+      topic: function(stream) {
+        fs.readFile(__dirname + '/test-date-rolling-file-stream-5', this.callback);
+      },
+      'file should contain first message': function(result) {
+        assert.equal(result.toString(), "First message\n");
+      }
+    },
+
+    'when the day changes': {
+      topic: function(stream) {
+        testTime = new Date(2012, 8, 13, 0, 10, 12);
+        stream.write("Second message\n", 'utf8', this.callback);
+      },
+      teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-5.2012-09-12'),
+
+      
+      'the number of files': {
+        topic: function() {
+          fs.readdir(__dirname, this.callback);
+        },
+        'should be two': function(files) {
+          assert.equal(
+            files.filter(
+              function(file) { 
+                return file.indexOf('test-date-rolling-file-stream-5') > -1; 
+              }
+            ).length, 
+            2
+          );
+        }
+      },
+      
+      'the file without a date': {
+        topic: function() {
+          fs.readFile(__dirname + '/test-date-rolling-file-stream-5', this.callback);
+        },
+        'should contain the second message': function(contents) {
+          assert.equal(contents.toString(), "Second message\n");
+        }
+      },
+      
+      'the file with the date': {
+        topic: function() {
+          fs.readFile(__dirname + '/test-date-rolling-file-stream-5.2012-09-12', this.callback);
+        },
+        'should contain the first message': function(contents) {
+          assert.equal(contents.toString(), "First message\n");
+        }
+      }
+    }
+  },
+  
+  'with alwaysIncludePattern': {
+    topic: function() {
+      var that = this,
+      testTime = new Date(2012, 8, 12, 0, 10, 12),
+      stream = new DateRollingFileStream(
+        __dirname + '/test-date-rolling-file-stream-pattern', 
+        '.yyyy-MM-dd', 
+        {alwaysIncludePattern: true}, 
+        now
+      );
+      stream.write("First message\n", 'utf8', function() {
+        that.callback(null, stream);
+      });
+    },
+    teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-pattern.2012-09-12'),
+    
+    'should create a file with the pattern set': {
+      topic: function(stream) {
+        fs.readFile(__dirname + '/test-date-rolling-file-stream-pattern.2012-09-12', this.callback);
+      },
+      'file should contain first message': function(result) {
+        assert.equal(result.toString(), "First message\n");
+      }
+    },
+    
+    'when the day changes': {
+      topic: function(stream) {
+        testTime = new Date(2012, 8, 13, 0, 10, 12);
+        stream.write("Second message\n", 'utf8', this.callback);
+      },
+      teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-pattern.2012-09-13'),
+      
+      
+      'the number of files': {
+        topic: function() {
+          fs.readdir(__dirname, this.callback);
+        },
+        'should be two': function(files) {
+          assert.equal(
+            files.filter(
+              function(file) { 
+                return file.indexOf('test-date-rolling-file-stream-pattern') > -1; 
+              }
+            ).length, 
+            2
+          );
+        }
+      },
+      
+      'the file with the later date': {
+        topic: function() {
+          fs.readFile(
+            __dirname + '/test-date-rolling-file-stream-pattern.2012-09-13', 
+            this.callback
+          );
+        },
+        'should contain the second message': function(contents) {
+          assert.equal(contents.toString(), "Second message\n");
+        }
+      },
+      
+      'the file with the date': {
+        topic: function() {
+          fs.readFile(
+            __dirname + '/test-date-rolling-file-stream-pattern.2012-09-12', 
+            this.callback
+          );
+        },
+        'should contain the first message': function(contents) {
+          assert.equal(contents.toString(), "First message\n");
+        }
+      }
+    }
+  }
 
 }).exportTo(module);

test/streams/rollingFileStream-test.js

@@ -1,3 +1,4 @@
+"use strict";
 var vows = require('vows')
 , async = require('async')
 , assert = require('assert')
@@ -15,120 +16,195 @@ if (semver.satisfies(process.version, '>=0.10.0')) {
 RollingFileStream = require('../../lib/streams').RollingFileStream;
 
 function remove(filename) {
-    try {
+  try {
-        fs.unlinkSync(filename);
+    fs.unlinkSync(filename);
-    } catch (e) {
+  } catch (e) {
-        //doesn't really matter if it failed
+    //doesn't really matter if it failed
-    }
+  }
+}
+
+function create(filename) {
+  fs.writeFileSync(filename, "test file");
 }
 
 vows.describe('RollingFileStream').addBatch({
-    'arguments': {
+  'arguments': {
-        topic: function() {
+    topic: function() {
-            remove(__dirname + "/test-rolling-file-stream");
+      remove(__dirname + "/test-rolling-file-stream");
-            return new RollingFileStream("test-rolling-file-stream", 1024, 5);
+      return new RollingFileStream("test-rolling-file-stream", 1024, 5);
-        },
-        'should take a filename, file size in bytes, number of backups as arguments and return a Writable': function(stream) {
-          assert.instanceOf(stream, streams.Writable);
-          assert.equal(stream.filename, "test-rolling-file-stream");
-          assert.equal(stream.size, 1024);
-          assert.equal(stream.backups, 5);
-        },
-        'with default settings for the underlying stream': function(stream) {
-            assert.equal(stream.theStream.mode, 420);
-            assert.equal(stream.theStream.flags, 'a');
-	  //encoding isn't a property on the underlying stream
-          //assert.equal(stream.theStream.encoding, 'utf8');
-        }
     },
-    'with stream arguments': {
+    'should take a filename, file size (bytes), no. backups,  return Writable': function(stream) {
-        topic: function() {
+      assert.instanceOf(stream, streams.Writable);
-            remove(__dirname + '/test-rolling-file-stream');
+      assert.equal(stream.filename, "test-rolling-file-stream");
-            return new RollingFileStream('test-rolling-file-stream', 1024, 5, { mode: 0666 });
+      assert.equal(stream.size, 1024);
-        },
+      assert.equal(stream.backups, 5);
-        'should pass them to the underlying stream': function(stream) {
-            assert.equal(stream.theStream.mode, 0666);
-        }
     },
-    'without size': {
+    'with default settings for the underlying stream': function(stream) {
-        topic: function() {
+      assert.equal(stream.theStream.mode, 420);
-            try {
+      assert.equal(stream.theStream.flags, 'a');
-                new RollingFileStream(__dirname + "/test-rolling-file-stream");
+      //encoding isn't a property on the underlying stream
-            } catch (e) {
+      //assert.equal(stream.theStream.encoding, 'utf8');
-                return e;
+    }
-            }
+  },
-        },
+  'with stream arguments': {
-        'should throw an error': function(err) {
+    topic: function() {
-            assert.instanceOf(err, Error);
+      remove(__dirname + '/test-rolling-file-stream');
-        }
+      return new RollingFileStream(
+        'test-rolling-file-stream', 
+        1024, 
+        5, 
+        { mode: parseInt('0666', 8) }
+      );
     },
-    'without number of backups': {
+    'should pass them to the underlying stream': function(stream) {
-        topic: function() {
+      assert.equal(stream.theStream.mode, parseInt('0666', 8));
-            remove('test-rolling-file-stream');
+    }
-            return new RollingFileStream(__dirname + "/test-rolling-file-stream", 1024);
+  },
-        },
+  'without size': {
-        'should default to 1 backup': function(stream) {
+    topic: function() {
-            assert.equal(stream.backups, 1);
+      try {
-        }
+        new RollingFileStream(__dirname + "/test-rolling-file-stream");
-    },
+      } catch (e) {
-    'writing less than the file size': {
+        return e;
-      topic: function() {
-        remove(__dirname + "/test-rolling-file-stream-write-less");
-        var that = this, stream = new RollingFileStream(__dirname + "/test-rolling-file-stream-write-less", 100);
-        stream.write("cheese", "utf8", function() {
-          stream.end();
-          fs.readFile(__dirname + "/test-rolling-file-stream-write-less", "utf8", that.callback);
-	});
-      },
-      'should write to the file': function(contents) {
-        assert.equal(contents, "cheese");
-      },
-      'the number of files': {
-        topic: function() {
-          fs.readdir(__dirname, this.callback);
-        },
-        'should be one': function(files) {
-          assert.equal(files.filter(function(file) { return file.indexOf('test-rolling-file-stream-write-less') > -1; }).length, 1);
-        }
       }
     },
-    'writing more than the file size': {
+    'should throw an error': function(err) {
+      assert.instanceOf(err, Error);
+    }
+  },
+  'without number of backups': {
+    topic: function() {
+      remove('test-rolling-file-stream');
+      return new RollingFileStream(__dirname + "/test-rolling-file-stream", 1024);
+    },
+    'should default to 1 backup': function(stream) {
+      assert.equal(stream.backups, 1);
+    }
+  },
+  'writing less than the file size': {
+    topic: function() {
+      remove(__dirname + "/test-rolling-file-stream-write-less");
+      var that = this
+      , stream = new RollingFileStream(
+        __dirname + "/test-rolling-file-stream-write-less", 
+        100
+      );
+      stream.write("cheese", "utf8", function() {
+        stream.end();
+        fs.readFile(__dirname + "/test-rolling-file-stream-write-less", "utf8", that.callback);
+      });
+    },
+    'should write to the file': function(contents) {
+      assert.equal(contents, "cheese");
+    },
+    'the number of files': {
       topic: function() {
-        remove(__dirname + "/test-rolling-file-stream-write-more");
+        fs.readdir(__dirname, this.callback);
-        remove(__dirname + "/test-rolling-file-stream-write-more.1");
-        var that = this, stream = new RollingFileStream(__dirname + "/test-rolling-file-stream-write-more", 45);
-	async.forEach([0, 1, 2, 3, 4, 5, 6], function(i, cb) {
-	  stream.write(i +".cheese\n", "utf8", cb);
-        }, function() {
-	  stream.end();
-	  that.callback();
-	});
       },
-      'the number of files': {
+      'should be one': function(files) {
-        topic: function() {
+        assert.equal(
-          fs.readdir(__dirname, this.callback);
+          files.filter(
-        },
+            function(file) { 
-        'should be two': function(files) {
+              return file.indexOf('test-rolling-file-stream-write-less') > -1; 
-          assert.equal(files.filter(
+            }
-	    function(file) { return file.indexOf('test-rolling-file-stream-write-more') > -1; }
+          ).length, 
-	  ).length, 2);
+          1
-        }
+        );
-      },
-      'the first file': {
-        topic: function() {
-          fs.readFile(__dirname + "/test-rolling-file-stream-write-more", "utf8", this.callback);
-        },
-        'should contain the last two log messages': function(contents) {
-          assert.equal(contents, '5.cheese\n6.cheese\n');
-        }
-      },
-      'the second file': {
-        topic: function() {
-          fs.readFile(__dirname + '/test-rolling-file-stream-write-more.1', "utf8", this.callback);
-        },
-        'should contain the first five log messages': function(contents) {
-          assert.equal(contents, '0.cheese\n1.cheese\n2.cheese\n3.cheese\n4.cheese\n');
-        }
       }
     }
+  },
+  'writing more than the file size': {
+    topic: function() {
+      remove(__dirname + "/test-rolling-file-stream-write-more");
+      remove(__dirname + "/test-rolling-file-stream-write-more.1");
+      var that = this
+      , stream = new RollingFileStream(
+        __dirname + "/test-rolling-file-stream-write-more", 
+        45
+      );
+      async.forEach(
+        [0, 1, 2, 3, 4, 5, 6], 
+        function(i, cb) {
+          stream.write(i +".cheese\n", "utf8", cb);
+        }, 
+        function() {
+          stream.end();
+          that.callback();
+        }
+      );
+    },
+    'the number of files': {
+      topic: function() {
+        fs.readdir(__dirname, this.callback);
+      },
+      'should be two': function(files) {
+        assert.equal(files.filter(
+          function(file) { 
+            return file.indexOf('test-rolling-file-stream-write-more') > -1; 
+          }
+        ).length, 2);
+      }
+    },
+    'the first file': {
+      topic: function() {
+        fs.readFile(__dirname + "/test-rolling-file-stream-write-more", "utf8", this.callback);
+      },
+      'should contain the last two log messages': function(contents) {
+        assert.equal(contents, '5.cheese\n6.cheese\n');
+      }
+    },
+    'the second file': {
+      topic: function() {
+        fs.readFile(__dirname + '/test-rolling-file-stream-write-more.1', "utf8", this.callback);
+      },
+      'should contain the first five log messages': function(contents) {
+        assert.equal(contents, '0.cheese\n1.cheese\n2.cheese\n3.cheese\n4.cheese\n');
+      }
+    }
+  },
+  'when many files already exist': {
+    topic: function() {
+      remove(__dirname + '/test-rolling-stream-with-existing-files.11');
+      remove(__dirname + '/test-rolling-stream-with-existing-files.20');
+      remove(__dirname + '/test-rolling-stream-with-existing-files.-1');
+      remove(__dirname + '/test-rolling-stream-with-existing-files.1.1');
+      remove(__dirname + '/test-rolling-stream-with-existing-files.1');
+      
+
+      create(__dirname + '/test-rolling-stream-with-existing-files.11');
+      create(__dirname + '/test-rolling-stream-with-existing-files.20');
+      create(__dirname + '/test-rolling-stream-with-existing-files.-1');
+      create(__dirname + '/test-rolling-stream-with-existing-files.1.1');
+      create(__dirname + '/test-rolling-stream-with-existing-files.1');
+
+      var that = this
+      , stream = new RollingFileStream(
+        __dirname + "/test-rolling-stream-with-existing-files", 
+        45,
+        5
+      );
+      async.forEach(
+        [0, 1, 2, 3, 4, 5, 6], 
+        function(i, cb) {
+          stream.write(i +".cheese\n", "utf8", cb);
+        }, 
+        function() {
+          stream.end();
+          that.callback();
+        }
+      );
+    },
+    'the files': {
+      topic: function() {
+        fs.readdir(__dirname, this.callback);
+      },
+      'should be rolled': function(files) {
+        assert.include(files, 'test-rolling-stream-with-existing-files');
+        assert.include(files, 'test-rolling-stream-with-existing-files.1');
+        assert.include(files, 'test-rolling-stream-with-existing-files.2');
+        assert.include(files, 'test-rolling-stream-with-existing-files.11');
+        assert.include(files, 'test-rolling-stream-with-existing-files.20');
+      }
+    }
+  }  
 }).exportTo(module);

test/with-categoryFilter.json

@@ -0,0 +1,23 @@
+{
+  "appenders": [
+    { 
+      "type": "categoryFilter",
+      "exclude": "web",
+      "appender": {
+        "type": "file",
+        "filename": "test/categoryFilter-noweb.log", 
+        "layout": { 
+          "type": "messagePassThrough" 
+        } 
+      }
+    },
+    { 
+      "category": "web", 
+      "type": "file",
+      "filename": "test/categoryFilter-web.log", 
+      "layout": { 
+        "type": "messagePassThrough" 
+      } 
+    }
+  ]
+}