version 0.5.2

Fixed layout stack trace test
Merge pull request #89 from ixti/master
2012-08-14 10:47:25 +10:00 · 2012-08-14 09:44:43 +10:00 · 2012-08-13 16:32:08 -07:00 · 2012-08-09 15:21:30 +02:00 · 2012-08-09 15:15:28 +02:00 · 2012-08-01 16:21:01 -07:00
31 changed files with 784 additions and 466 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,4 +1,4 @@
 language: node_js
 node_js:
  - 0.6
-  - 0.7
+  - 0.8
--- a/README.md
+++ b/README.md
@@ -17,6 +17,16 @@ Out of the box it supports the following features:
 * configurable log message layout/patterns
 * different log levels for different log categories (make some parts of your app log as DEBUG, others only ERRORS, etc.)

+NOTE: from log4js 0.5 onwards you'll need to explicitly enable replacement of node's console.log functions. Do this either by calling `log4js.replaceConsole()` or configuring with an object or json file like this:
+
+```javascript
+{
+    appenders: [
+        { type: "console" }
+    ],
+    replaceConsole: true
+}
+```

 ## installation

@@ -35,12 +45,13 @@ By default, log4js outputs to stdout with the coloured layout (thanks to [masylu

    [2010-01-17 11:43:37.987] [DEBUG] [default] - Some debug messages

-See example.js:
+See example.js for a full example, but here's a snippet (also in fromreadme.js):

    var log4js = require('log4js'); 
-    log4js.loadAppender('console');
+    //console log is loaded by default, so you won't normally need to do this
+    //log4js.loadAppender('console');
    log4js.loadAppender('file');
-    log4js.addAppender(log4js.appenders.console());
+    //log4js.addAppender(log4js.appenders.console());
    log4js.addAppender(log4js.appenders.file('logs/cheese.log'), 'cheese');

    var logger = log4js.getLogger('cheese');
@@ -114,13 +125,13 @@ If you have already defined an absolute path for one of the FileAppenders in the
      ]
    }
    
-Documentation for most of the core appenders can be found on the [wiki](wiki/Appenders), otherwise take a look at the tests and the examples.
+Documentation for most of the core appenders can be found on the [wiki](log4js-node/wiki/Appenders), otherwise take a look at the tests and the examples.

 ## Documentation
-See the [wiki](wiki). Improve the [wiki](wiki), please.
+See the [wiki](log4js-node/wiki). Improve the [wiki](log4js-node/wiki), please.

 ## Contributing
-Contributions welcome, but take a look at the [rules](wiki/Contributing) first.
+Contributions welcome, but take a look at the [rules](log4js-node/wiki/Contributing) first.

 ## License

--- a/example-socket.js
+++ b/example-socket.js
@@ -0,0 +1,45 @@
+var log4js = require('./lib/log4js')
+, cluster = require('cluster')
+, numCPUs = require('os').cpus().length
+, i = 0;
+
+if (cluster.isMaster) {
+    log4js.configure({
+        appenders: [
+            {
+                type: "multiprocess",
+                mode: "master",
+                appender: {
+                    type: "console"
+                }
+            }
+        ]
+    });
+
+    console.info("Master creating %d workers", numCPUs);
+    for (i=0; i < numCPUs; i++) {
+        cluster.fork();
+    }
+
+    cluster.on('death', function(worker) {
+        console.info("Worker %d died.", worker.pid);
+    });
+} else {
+    log4js.configure({
+        appenders: [
+            {
+                type: "multiprocess",
+                mode: "worker"
+            }
+        ]
+    });
+    var logger = log4js.getLogger('example-socket');
+
+    console.info("Worker %d started.", process.pid);
+    for (i=0; i < 1000; i++) {
+        logger.info("Worker %d - logging something %d", process.pid, i);
+    }
+}
+
+
+
--- a/example.js
+++ b/example.js
@@ -1,12 +1,39 @@
 var log4js = require('./lib/log4js');
 //log the cheese logger messages to a file, and the console ones as well.
-log4js.addAppender(log4js.fileAppender('cheese.log'), 'cheese', 'console');
+log4js.configure({
+    appenders: [
+        {
+            type: "file",
+            filename: "cheese.log",
+            category: [ 'cheese','console' ]
+        },
+        {
+            type: "console"
+        }
+    ],
+    replaceConsole: true
+});
+
+//to add an appender programmatically, and without clearing other appenders
+//loadAppender is only necessary if you haven't already configured an appender of this type
+log4js.loadAppender('file');
+log4js.addAppender(log4js.appenders.file('pants.log'), 'pants');
+//a custom logger outside of the log4js/lib/appenders directory can be accessed like so
+//log4js.loadAppender('what/you/would/put/in/require');
+//log4js.addAppender(log4js.appenders['what/you/would/put/in/require'](args));
+//or through configure as:
+//log4js.configure({
+//  appenders: [ { type: 'what/you/would/put/in/require', otherArgs: 'blah' } ]
+//});

 var logger = log4js.getLogger('cheese');
 //only errors and above get logged.
+//you can also set this log level in the config object
+//via the levels field.
 logger.setLevel('ERROR');

-//console logging methds have been replaced with log4js ones.
+//console logging methods have been replaced with log4js ones.
+//so this will get coloured output on console, and appear in cheese.log
 console.error("AAArgh! Something went wrong", { some: "otherObject", useful_for: "debug purposes" });

 //these will not appear (logging level beneath error)
@@ -18,5 +45,14 @@ logger.warn('Cheese is quite smelly.');
 logger.error('Cheese %s is too ripe!', "gouda");
 logger.fatal('Cheese was breeding ground for listeria.');

+//these don't end up in cheese.log, but will appear on the console
+var anotherLogger = log4js.getLogger('another');
+anotherLogger.debug("Just checking");
+
+//one for pants.log
+//will also go to console, since that's configured for all categories
+var pantsLog = log4js.getLogger('pants');
+pantsLog.debug("Something for pants");
+


--- a/fromreadme.js
+++ b/fromreadme.js
@@ -0,0 +1,19 @@
+//remember to change the require to just 'log4js' if you've npm install'ed it
+var log4js = require('./lib/log4js');
+//by default the console appender is loaded
+//log4js.loadAppender('console');
+//you'd only need to add the console appender if you
+//had previously called log4js.clearAppenders();
+//log4js.addAppender(log4js.appenders.console());
+log4js.loadAppender('file');
+log4js.addAppender(log4js.appenders.file('cheese.log'), 'cheese');
+
+var logger = log4js.getLogger('cheese');
+logger.setLevel('ERROR');
+
+logger.trace('Entering cheese testing');
+logger.debug('Got cheese.');
+logger.info('Cheese is Gouda.');
+logger.warn('Cheese is quite smelly.');
+logger.error('Cheese is too ripe!');
+logger.fatal('Cheese was breeding ground for listeria.');
--- a/lib/appenders/file.js
+++ b/lib/appenders/file.js
@@ -1,7 +1,12 @@
 var layouts = require('../layouts')
 , path = require('path')
 , fs = require('fs')
-, streams = require('../streams');
+, streams = require('../streams')
+, os = require('os')
+, eol = os.EOL || '\n';
+
+var openFiles = [];
+var listenerAtttached = false;

 /**
 * File Appender writing the logs to a text file. Supports rolling of logs by size.
@@ -40,13 +45,21 @@ function fileAppender (file, layout, logSize, numBackups) {

    var logFile = openTheStream(file, logSize, numBackups);

+    // push file to the stack of open handlers
+    openFiles.push(logFile);
+
    //close the file on process exit.
-    process.on('exit', function() {
-        logFile.end();
-    });
+    if (!listenerAtttached) {
+        listenerAtttached = true;
+        process.on('exit', function() {
+            openFiles.forEach(function (file) {
+                file.end();
+            });
+        });
+    }

    return function(loggingEvent) {
-        logFile.write(layout(loggingEvent)+'\n', "utf8");
+        logFile.write(layout(loggingEvent) + eol, "utf8");
    };
 }

--- a/lib/appenders/multiprocess.js
+++ b/lib/appenders/multiprocess.js
@@ -1,75 +1,133 @@
-var log4js = require('../log4js');
-var layouts = require('../layouts');
-var net = require('net');
-var util = require('util');
+var log4js = require('../log4js'),
+    net = require('net'),
+    END_MSG = '__LOG4JS__';

-var LogServer = function createLogServer(config) {
-  var actualAppender = config.actualAppender;
-  var server = net.createServer(function serverCreated(clientSocket) {
-    clientSocket.on('connect', function clientConnected() {
-      var logMessage = '';
-      clientSocket.on('data', function chunkReceived(chunk) {
-        logMessage += chunk;
-      });
-      clientSocket.on('end', function gotChunks() {
+/**
+ * Creates a server, listening on config.loggerPort, config.loggerHost.
+ * Output goes to config.actualAppender (config.appender is used to
+ * set up that appender).
+ */
+function logServer(config) {
+
+    /**
+     * Takes a utf-8 string, returns an object with
+     * the correct log properties.
+     */
+    function deserializeLoggingEvent(clientSocket, msg) {
+        var loggingEvent;
        try {
-          var loggingEvent = JSON.parse(logMessage);
-          deserializeLoggingEvent(loggingEvent);
-          actualAppender(loggingEvent);
+            loggingEvent = JSON.parse(msg);
+            loggingEvent.startTime = new Date(loggingEvent.startTime);
+            loggingEvent.level.toString = function levelToString() {
+                return loggingEvent.level.levelStr;
+            };
        } catch (e) {
-          // JSON.parse failed, just log the contents probably a naughty.
-          actualAppender(createLoggingEvent('ERROR', 'Unable to parse log: ' + logMessage));
+            // JSON.parse failed, just log the contents probably a naughty.
+            loggingEvent = {
+                startTime: new Date(),
+                categoryName: 'log4js',
+                level: { toString: function () {
+                             return 'ERROR';
+                         }
+                       },
+                data: [ 'Unable to parse log:', msg ]
+            };
        }
-      });
-    });
-  });
-  server.listen(config.loggerPort || 5000, config.loggerHost || 'localhost');
-}

-function createLoggingEvent(level, message) {
-  return {
-    startTime: new Date(),
-    categoryName: 'log4js',
-    level: { toString: function () {
-      return level;
-    }},
-    data: [ message ]
-  };
-}
+        loggingEvent.remoteAddress = clientSocket.remoteAddress;
+        loggingEvent.remotePort = clientSocket.remotePort;

-function deserializeLoggingEvent(loggingEvent) {
-  loggingEvent.startTime = new Date(loggingEvent.startTime);
-  loggingEvent.level.toString = function levelToString() {
-    return loggingEvent.level.levelStr;
-  };
+        return loggingEvent;
+    }
+
+    var actualAppender = config.actualAppender,
+        server = net.createServer(function serverCreated(clientSocket) {
+            clientSocket.setEncoding('utf8');
+            clientSocket.on('connect', function clientConnected() {
+                var logMessage = '';
+
+                function logTheMessage(msg) {
+                    if (logMessage.length > 0) {
+                        actualAppender(deserializeLoggingEvent(clientSocket, msg));
+                    }
+                }
+
+                function chunkReceived(chunk) {
+                    var event;
+                    logMessage += chunk || '';
+                    if (logMessage.indexOf(END_MSG) > -1) {
+                        event = logMessage.substring(0, logMessage.indexOf(END_MSG));
+                        logTheMessage(event);
+                        logMessage = logMessage.substring(event.length + END_MSG.length) || '';
+                        //check for more, maybe it was a big chunk
+                        chunkReceived();
+                    }
+                }
+
+                clientSocket.on('data', chunkReceived);
+                clientSocket.on('end', chunkReceived);
+            });
+        });
+    server.listen(config.loggerPort || 5000, config.loggerHost || 'localhost');
+
+    return actualAppender;
 }

 function workerAppender(config) {
-  return function log(loggingEvent) {
-    var socket = net.createConnection(config.loggerPort || 5000, config.loggerHost || 'localhost');
-    socket.on('connect', function socketConnected() {
-      socket.end(JSON.stringify(loggingEvent), 'utf8');
-    });
-  };
+    var canWrite = false,
+        buffer = [],
+        socket;
+
+    createSocket();
+
+    function createSocket() {
+        socket = net.createConnection(config.loggerPort || 5000, config.loggerHost || 'localhost');
+        socket.on('connect', function() {
+            emptyBuffer();
+            canWrite = true;
+        });
+        socket.on('timeout', socket.end.bind(socket));
+        //don't bother listening for 'error', 'close' gets called after that anyway
+        socket.on('close', createSocket);
+    }
+
+    function emptyBuffer() {
+        var evt;
+        while ((evt = buffer.shift())) {
+            write(evt);
+        }
+    }
+
+    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') {
-    var server = new LogServer(config);
-    return config.actualAppender;
-  } else {
-    return workerAppender(config);
-  }
+    if (config.mode === 'master') {
+        return logServer(config);
+    } else {
+        return workerAppender(config);
+    }
 }

 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);
+    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;
--- a/lib/appenders/smtp.js
+++ b/lib/appenders/smtp.js
@@ -1,59 +1,57 @@
 var layouts = require("../layouts"),
-	mailer = require("nodemailer");
+	mailer = require("nodemailer"),
+	os = require('os');

 /**
-* SMTP Appender. Sends logging events using SMTP protocol.
+* 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.
 *
-* @param recipients comma separated list of email recipients
-* @param sender sender of all emails (defaults to SMTP user)
-* @param subject subject of all email messages (defaults to first event's message)
+* @param config appender configuration data
 * @param layout a function that takes a logevent and returns a string (defaults to basicLayout).
-* @param smtpConfig SMTP configuration for 'nodemailer'
-* @param sendInterval the time in seconds between sending attempts (defaults to 0);
 * all events are buffered and sent in one email during this time; if 0 than every event sends an email
 */
-function smtpAppender(recipients, sender, subject, layout, smtpConfig, sendInterval) {
-	sender = sender || smtpConfig.user;
+function smtpAppender(config, layout) {
 	layout = layout || layouts.basicLayout;
-	subjectLayout = layouts.messagePassThroughLayout;
-	mailer.SMTP = smtpConfig;
-	sendInterval = sendInterval*1000 || 0;
-
+	var subjectLayout = layouts.messagePassThroughLayout;
+	var sendInterval = config.sendInterval*1000 || 0;
+	
 	var logEventBuffer = [];
 	var sendTimer;
-
+	var transport = mailer.createTransport(config.transport, config[config.transport]);
+	
 	function sendBuffer() {
 		if (logEventBuffer.length == 0)
 			return;
-
+		
 		var firstEvent = logEventBuffer[0];
 		var body = "";
 		while (logEventBuffer.length > 0) {
 			body += layout(logEventBuffer.shift()) + "\n";
 		}
-
+		
 		var msg = {
-				sender: sender,
-				to: recipients,
-				subject: subject || subjectLayout(firstEvent),
-				body: body
+				to: config.recipients,
+				subject: config.subject || subjectLayout(firstEvent),
+				text: body,
+				headers: {"Hostname": os.hostname()}
 			};
-		mailer.send_mail(msg, function(error, success) {
+		if (config.sender)
+			msg.from = config.sender;
+		transport.sendMail(msg, function(error, success) {
 			if (error) {
 				console.error("log4js.smtpAppender - Error happened ", error);
 			}
 		});
 	}
-
+	
 	function scheduleSend() {
 		if (!sendTimer)
 			sendTimer = setTimeout(function() {
-				sendTimer = null;
+				sendTimer = null; 
 				sendBuffer();
 			}, sendInterval);
 	}
-
+	
 	return function(loggingEvent) {
 		logEventBuffer.push(loggingEvent);
 		if (sendInterval > 0)
@@ -68,8 +66,10 @@ function configure(config) {
 	if (config.layout) {
 		layout = layouts.layout(config.layout.type, config.layout);
 	}
-	return smtpAppender(config.recipients, config.sender, config.subject, layout, config.smtp, config.sendInterval);
+	return smtpAppender(config, layout);
 }

+exports.name = "smtp";
 exports.appender = smtpAppender;
 exports.configure = configure;
+
--- a/lib/layouts.js
+++ b/lib/layouts.js
@@ -1,32 +1,34 @@
 var dateFormat = require('./date_format')
-, util = require('util')
-, replacementRegExp = /%[sdj]/g
-, layoutMakers = {
-    "messagePassThrough": function() { return messagePassThroughLayout; }
-  , "basic": function() { return basicLayout; }
-  , "colored": function() { return colouredLayout; }
-  , "coloured": function() { return colouredLayout; }
-  , "pattern": function (config) {
-	var pattern = config.pattern || undefined;
-	return patternLayout(pattern);
-    }
-}
-, colours = {
-    ALL: "grey"
-  , TRACE: "blue"
-  , DEBUG: "cyan"
-  , INFO: "green"
-  , WARN: "yellow"
-  , ERROR: "red"
-  , FATAL: "magenta"
-  , OFF: "grey"
-};
+  , os = require('os')
+  , eol = os.EOL || '\n'
+  , util = require('util')
+  , replacementRegExp = /%[sdj]/g
+  , layoutMakers = {
+      "messagePassThrough": function() { return messagePassThroughLayout; }
+    , "basic": function() { return basicLayout; }
+    , "colored": function() { return colouredLayout; }
+    , "coloured": function() { return colouredLayout; }
+    , "pattern": function (config) {
+	  var pattern = config.pattern || undefined;
+	  return patternLayout(pattern);
+      }
+  }
+  , colours = {
+      ALL: "grey"
+    , TRACE: "blue"
+    , DEBUG: "cyan"
+    , INFO: "green"
+    , WARN: "yellow"
+    , ERROR: "red"
+    , FATAL: "magenta"
+    , OFF: "grey"
+  };


 function formatLogData(logData) {
    var output = ""
-    , data = Array.isArray(logData) ? logData.slice() : Array.prototype.slice.call(arguments)
-    , format = data.shift();
+      , data = Array.isArray(logData) ? logData.slice() : Array.prototype.slice.call(arguments)
+      , format = data.shift();

    if (typeof format  === "string") {
        output = format.replace(replacementRegExp, function(match) {
@@ -47,10 +49,9 @@ function formatLogData(logData) {
        if (output) {
            output += ' ';
        }
+        output += util.inspect(item);
        if (item && item.stack) {
-            output += item.stack;
-        } else {
-            output += util.inspect(item);
+            output += "\n" + item.stack;
        }
    });

@@ -197,7 +198,7 @@ function patternLayout (pattern) {
 		    replacement = formatLogData(loggingEvent.data);
 		    break;
 		case "n":
-		    replacement = "\n";
+		    replacement = eol;
 		    break;
 		case "p":
 		    replacement = loggingEvent.level.toString();
@@ -257,4 +258,4 @@ module.exports = {
  , layout: function(name, config) {
        return layoutMakers[name] && layoutMakers[name](config);
    }
-};
+};
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "log4js",
-   "version": "0.5.0",
+   "version": "0.5.2",
   "description": "Port of Log4js to work with node.",
   "keywords": [
       "logging",
@@ -19,7 +19,7 @@
   },
   "engines": [ "node >=0.6" ],
   "scripts": {
-       "test": "vows test/*.js"
+       "test": "vows"
   },
   "directories": {
       "test": "test",
--- a/test/bufferedStream-test.js
+++ b/test/bufferedStream-test.js
--- a/test/configuration-test.js
+++ b/test/configuration-test.js
--- a/test/configureNoLevels-test.js
+++ b/test/configureNoLevels-test.js
--- a/test/connect-logger-test.js
+++ b/test/connect-logger-test.js
--- a/test/date_format-test.js
+++ b/test/date_format-test.js
--- a/test/fileAppender-test.js
+++ b/test/fileAppender-test.js
@@ -15,6 +15,24 @@ function remove(filename) {
 }

 vows.describe('log4js fileAppender').addBatch({
+    'adding multiple fileAppenders': {
+      topic: function () {
+          var listenersCount = process.listeners('exit').length
+            , logger = log4js.getLogger('default-settings')
+            , count = 5, logfile;
+
+          while (count--) {
+              logfile = path.join(__dirname, '/fa-default-test' + count + '.log');
+              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);
+      }
+    },

    'with default fileAppender settings': {
        topic: function() {
--- a/test/gelfAppender-test.js
+++ b/test/gelfAppender-test.js
--- a/test/global-log-level-test.js
+++ b/test/global-log-level-test.js
--- a/test/hookioAppender-test.js
+++ b/test/hookioAppender-test.js
--- a/test/layouts-test.js
+++ b/test/layouts-test.js
@@ -76,8 +76,50 @@ vows.describe('log4js layouts').addBatch({
                , 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': {
@@ -106,10 +148,11 @@ vows.describe('log4js layouts').addBatch({
            output = layout(event);
            lines = output.split(/\n/);

-            assert.equal(lines.length, stack.length);
-            assert.equal(lines[0], "[2010-12-05 14:18:30.045] [DEBUG] tests - this is a test Error: Some made-up error");
+            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+1], stack[i+1]);
+                assert.equal(lines[i+2], stack[i+1]);
            }
        },
        'should output any extra data in the log event as util.inspect strings': function(args) {
--- a/test/levels-test.js
+++ b/test/levels-test.js
--- a/test/log-abspath-test.js
+++ b/test/log-abspath-test.js
--- a/test/logLevelFilter-test.js
+++ b/test/logLevelFilter-test.js
--- a/test/logging-test.js
+++ b/test/logging-test.js
@@ -576,5 +576,4 @@ vows.describe('log4js').addBatch({
            assert.equal(logEvents[1].data[0], 'info3');
        }
    }
-
 }).export(module);
--- a/test/multiprocess-test.js
+++ b/test/multiprocess-test.js
@@ -0,0 +1,242 @@
+var vows = require('vows'),
+    sandbox = require('sandboxed-module'),
+    assert = require('assert');
+
+function makeFakeNet() {
+    return {
+        logEvents: [],
+        data: [],
+        cbs: {},
+        createConnectionCalled: 0,
+        fakeAppender: function(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;
+                },
+                write: function(data, encoding) {
+                    fakeNet.data.push(data);
+                    fakeNet.encoding = encoding;
+                },
+                end: function() {
+                    fakeNet.closeCalled = true;
+                }
+            };
+        },
+        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': {
+        topic: function() {
+            var fakeNet = makeFakeNet(),
+                appender = sandbox.require(
+                    '../lib/appenders/multiprocess',
+                    {
+                        requires: {
+                            '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);
+        }
+    },
+    '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: 'DEBUG', data: ['some debug']}) + '__LOG4JS__';
+
+                net.cbs['connect']();
+                net.cbs['data'](JSON.stringify({ level: '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: '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');
+        }
+    }
+}).exportTo(module);
--- a/test/multiprocessAppender.js
+++ b/test/multiprocessAppender.js
@@ -1,173 +0,0 @@
-var vows = require('vows');
-var assert = require('assert');
-var sandbox = require('sandboxed-module');
-var _ = require('underscore');
-
-function fancyResultingMultiprocessAppender(opts) {
-  var result = { clientOns: {}, serverOns: {}, logged: [], ended: [] };
-
-  var fakeSocket = {
-    on: function (event, fn)  {
-      result.clientOns[event] = fn;
-      if (event === 'connect') {
-        fn();
-      }
-    },
-    end: function (data, encoding) {
-      result.ended.push({ data: data, encoding: encoding });
-    }
-  }
-
-  var fakeServerSocket = {
-    on: function (event, fn)  {
-      result.serverOns[event] = fn;
-      if (event === 'connect') {
-        fn();
-      }
-    }
-  }
-
-  var fakeServer = {
-    listen: function (port, host) {
-      result.listenPort = port;
-      result.listenHost = host;
-    }
-  }
-
-  var fakeNet = {
-    createServer: function (fn) {
-      fn(fakeServerSocket);
-      return fakeServer;
-    },
-    createConnection: function (port, host) {
-      result.connectPort = port;
-      result.connectHost = host;
-      return fakeSocket;
-    }
-  }
-
-  var fakeLog4Js = {
-    appenderMakers: {}
-  };
-  fakeLog4Js.loadAppender = function (appender) {
-    fakeLog4Js.appenderMakers[appender] = function (config) {
-      result.actualLoggerConfig = config;
-      return function log(logEvent) {
-        result.logged.push(logEvent);
-      }
-    };
-  };
-
-  return { theResult: result,
-    theModule: sandbox.require('../lib/appenders/multiprocess', {
-      requires: {
-        '../log4js': fakeLog4Js,
-        'net': fakeNet
-      }
-    })
-  };
-}
-
-function logMessages(result, logs, raw) {
-  logs.forEach(function log(item) {
-    var logItem = { startTime: "Wed, 02 Nov 2011 21:46:39 GMT", level: { levelStr: 'DEBUG' }, data: [ item ] };
-    result.serverOns.data(JSON.stringify(logItem));
-    result.serverOns.end();
-    result.serverOns.connect();
-  });
-  if (raw) {
-    raw.forEach(function log(rawItem) {
-      result.serverOns.data(rawItem);
-      result.serverOns.end();
-      result.serverOns.connect();
-    });
-  }
-}
-
-
-vows.describe('log4js multiprocessAppender').addBatch({
-  'master': {
-    topic: function() {
-      var fancy = fancyResultingMultiprocessAppender();
-      var logger = fancy.theModule.configure({ mode: 'master', 'loggerPort': 5001, 'loggerHost': 'abba', appender: { type: 'file' } });
-      logMessages(fancy.theResult, [ 'ALRIGHTY THEN', 'OH WOW' ]);
-      return fancy.theResult;
-    },
-
-    'should write to the actual appender': function (result) {
-      assert.equal(result.listenPort, 5001);
-      assert.equal(result.listenHost, 'abba');
-      assert.equal(result.logged.length, 2);
-      assert.equal(result.logged[0].data[0], 'ALRIGHTY THEN');
-      assert.equal(result.logged[1].data[0], 'OH WOW');
-    },
-
-    'data written should be formatted correctly': function (result) {
-      assert.equal(result.logged[0].level.toString(), 'DEBUG');
-      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');
-    },
-
-    'client should not be called': function (result) {
-      assert.equal(_.keys(result.clientOns).length, 0);
-    }
-  },
-  'master with bad request': {
-    topic: function() {
-      var fancy = fancyResultingMultiprocessAppender();
-      var logger = fancy.theModule.configure({ mode: 'master', 'loggerPort': 5001, 'loggerHost': 'abba', appender: { type: 'file' } });
-      logMessages(fancy.theResult, [], [ 'ALRIGHTY THEN', 'OH WOW' ]);
-      return fancy.theResult;
-    },
-
-    'should write to the actual appender': function (result) {
-      assert.equal(result.listenPort, 5001);
-      assert.equal(result.listenHost, 'abba');
-      assert.equal(result.logged.length, 2);
-      assert.equal(result.logged[0].data[0], 'Unable to parse log: ALRIGHTY THEN');
-      assert.equal(result.logged[1].data[0], 'Unable to parse log: OH WOW');
-    },
-
-    'data written should be formatted correctly': function (result) {
-      assert.equal(result.logged[0].level.toString(), 'ERROR');
-      assert.equal(result.logged[0].data, 'Unable to parse log: ALRIGHTY THEN');
-      assert.isTrue(typeof(result.logged[0].startTime) === 'object');
-      assert.equal(result.logged[1].level.toString(), 'ERROR');
-      assert.equal(result.logged[1].data, 'Unable to parse log: OH WOW');
-      assert.isTrue(typeof(result.logged[1].startTime) === 'object');
-    }
-  },
-  'worker': {
-    'should emit logging events to the master': {
-      topic: function() {
-        var fancy = fancyResultingMultiprocessAppender();
-        var logger = fancy.theModule.configure({ loggerHost: 'baba', loggerPort: 1232, 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;
-      },
-
-      'client configuration should be correct': function (result) {
-        assert.equal(result.connectHost, 'baba');
-        assert.equal(result.connectPort, 1232);
-      },
-
-      'should not write to the actual appender': function (result) {
-        assert.equal(result.logged.length, 0);
-        assert.equal(result.ended.length, 2);
-        assert.equal(result.ended[0].data, JSON.stringify({ level: { levelStr: 'INFO' }, data: "ALRIGHTY THEN", startTime: '2011-10-27T03:53:16.031Z' }));
-        assert.equal(result.ended[0].encoding, 'utf8');
-        assert.equal(result.ended[1].data, JSON.stringify({ level: { levelStr: 'DEBUG' }, data: "OH WOW", startTime: '2011-10-27T04:53:16.031Z'}));
-        assert.equal(result.ended[1].encoding, 'utf8');
-        assert.equal(_.keys(result.serverOns).length, 0);
-      }
-    }
-  }
-}).exportTo(module);
--- a/test/nolog-test.js
+++ b/test/nolog-test.js
--- a/test/rollingFileStream-test.js
+++ b/test/rollingFileStream-test.js
--- a/test/setLevel-asymmetry-test.js
+++ b/test/setLevel-asymmetry-test.js
--- a/test/smtpAppender-test.js
+++ b/test/smtpAppender-test.js
@@ -0,0 +1,168 @@
+var vows = require('vows'),
+    assert = require('assert'),
+    log4js = require('../lib/log4js'),
+    sandbox = require('sandboxed-module');
+
+function setupLogging(category, options) {
+    var msgs = [];
+
+    var fakeMailer = {
+		createTransport: function (name, options) {
+			return {
+				config: options,
+				sendMail: function (msg, callback) {
+				    msgs.push(msg);
+				    callback(null, true);
+				}
+			};
+		}
+    };
+
+    var smtpModule = sandbox.require('../lib/appenders/smtp', {
+		requires: {
+		    'nodemailer': fakeMailer
+		}
+    });
+
+    log4js.addAppender(smtpModule.configure(options), category);
+
+    return {
+		logger: log4js.getLogger(category),
+		mailer: fakeMailer,
+		results: msgs
+    };
+}
+
+function checkMessages (result, sender, subject) {
+    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': {
+		topic: function() {
+		    var setup = setupLogging('minimal config', {
+			recipients: 'recipient@domain.com',
+			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);
+		}
+    },
+    '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;
+		},
+		'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': {
+		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');
+		    }, 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));
+		}
+    }
+
+}).export(module);
+
--- a/test/smtpAppender.js
+++ b/test/smtpAppender.js
@@ -1,162 +0,0 @@
-var vows = require('vows'),
-    assert = require('assert'),
-    log4js = require('../lib/log4js'),
-    sandbox = require('sandboxed-module');
-
-function setupLogging(category, options) {
-    var msgs = [];
-
-    var fakeMailer = {
-	send_mail: function (msg, callback) {
-	    msgs.push(msg);
-	    callback(null, true);
-	}
-    };
-
-    var smtpModule = sandbox.require('../lib/appenders/smtp', {
-	requires: {
-	    'nodemailer': fakeMailer
-	}
-    });
-
-    log4js.addAppender(smtpModule.configure(options), category);
-
-    return {
-	logger: log4js.getLogger(category),
-	mailer: fakeMailer,
-	results: msgs
-    };
-}
-
-function checkMessages (result, sender, subject) {
-    for (var i = 0; i < result.results.length; ++i) {
-	assert.equal(result.results[i].sender, sender ? sender : result.mailer.SMTP.user);
-	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].body));
-    }
-}
-
-log4js.clearAppenders();
-vows.describe('log4js smtpAppender').addBatch({
-    'minimal config': {
-	topic: function() {
-	    var setup = setupLogging('minimal config', {
-		recipients: 'recipient@domain.com',
-		smtp: {
-		    port: 25,
-		    user: 'user@domain.com'
-		}
-	    });
-	    setup.logger.info('Log event #1');
-	    return setup;
-	},
-	'mailer should be configured properly': function (result) {
-	    assert.ok(result.mailer.SMTP);
-	    assert.equal(result.mailer.SMTP.port, 25);
-	    assert.equal(result.mailer.SMTP.user, 'user@domain.com');
-	},
-	'there should be one message only': function (result) {
-	    assert.equal(result.results.length, 1);
-	},
-	'message should contain proper data': function (result) {
-	    checkMessages(result);
-	}
-    },
-    'fancy config': {
-	topic: function() {
-	    var setup = setupLogging('fancy config', {
-		recipients: 'recipient@domain.com',
-		sender: 'sender@domain.com',
-		subject: 'This is subject',
-		smtp: {
-		    port: 25,
-		    user: 'user@domain.com'
-		}
-	    });
-	    setup.logger.info('Log event #1');
-	    return setup;
-	},
-	'mailer should be configured properly': function (result) {
-	    assert.ok(result.mailer.SMTP);
-	    assert.equal(result.mailer.SMTP.port, 25);
-	    assert.equal(result.mailer.SMTP.user, 'user@domain.com');
-	},
-	'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': {
-	topic: function() {
-	    var self = this;
-	    var setup = setupLogging('separate email for each event', {
-		recipients: 'recipient@domain.com',
-		smtp: {
-		    port: 25,
-		    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,
-		smtp: {
-		    port: 25,
-		    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].sender, result.mailer.SMTP.user);
-	    assert.equal(result.results[0].to, 'recipient@domain.com');
-	    assert.equal(result.results[0].subject, 'Log event #1');
-	    assert.equal(result.results[0].body.match(new RegExp('.+Log event #[1-2]$', 'gm')).length, 2);
-
-	    assert.equal(result.results[1].sender, result.mailer.SMTP.user);
-	    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].body));
-	}
-    }
-
-}).export(module);
Author	SHA1	Message	Date
Gareth Jones	012b0d5ed7	version 0.5.2	2012-08-14 10:47:25 +10:00
Gareth Jones	de72005e7e	Fixed layout stack trace test	2012-08-14 09:44:43 +10:00
Gareth Jones	c6a0e58409	Merge pull request #89 from ixti/master Fix possible memleak with `exit` event handlers	2012-08-13 16:32:08 -07:00
Aleksey V Zapparov	f832a2ba79	Do not assign multiple `exit` handlers for FA	2012-08-09 15:21:30 +02:00
Aleksey V Zapparov	3f10b68c30	Add test for amount of exit listeners in FA	2012-08-09 15:15:28 +02:00
Gareth Jones	54c311842c	Merge pull request #86 from osher/patch-3 Update lib/layouts.js	2012-08-01 16:21:01 -07:00
osher	f948b5f5cd	Add unit tests - layouts-test.js	2012-08-01 10:11:37 +03:00
osher	54e420eb58	Update lib/layouts.js Errors sometimes carry additional attributes on them as part of the passed error data. A utility that utilizes it, for example - is called 'errs', which is in use for instance 'nano' - the couch-db driver. when only the stack is printed - all the additional information that is augmented on the error object does not sink to the log and is lost. consider the following code: ``` //the oups throwing utility function oups(){ e = new Error(); extend( { message : "Oups error" , description: "huston, we got a problem" , status : "MESS" , errorCode : 991 , arr :[1,2,3,4,{}] , data: { c:{} , d:{e:{}} } } throw e; } var log = require('log4js') try{ oups() } catch( e ) { log.error("error on oups", e ); } ``` output before the fix ``` error on oups Error: Oups error at repl:1:11 at REPLServer.eval (repl.js:80:21) at Interface.<anonymous> (repl.js:182:12) at Interface.emit (events.js:67:17) at Interface._onLine (readline.js:162:10) at Interface._line (readline.js:426:8) at Interface._ttyWrite (readline.js:603:14) at ReadStream.<anonymous> (readline.js:82:12) at ReadStream.emit (events.js:88:20) ``` output after the fix would be ``` error on oups { [Error: My error message] name: 'Error', description: 'huston, we got a problem', status: 'MESS', errorCode: 991, arr: [ 1, 2, 3, 4, {} ], data: { c: {}, d: { e: {} } } } Error: Oups error at repl:1:11 at REPLServer.eval (repl.js:80:21) at Interface.<anonymous> (repl.js:182:12) at Interface.emit (events.js:67:17) at Interface._onLine (readline.js:162:10) at Interface._line (readline.js:426:8) at Interface._ttyWrite (readline.js:603:14) at ReadStream.<anonymous> (readline.js:82:12) at ReadStream.emit (events.js:88:20) ```	2012-07-31 14:32:03 +03:00
Gareth Jones	40ba24a55d	Renamed tests so that vows will pick them up automatically	2012-07-31 14:52:36 +10:00
Gareth Jones	e3a20a1746	bumped npm version	2012-07-04 09:28:56 +10:00
Gareth Jones	7a02f39921	Fallback to \n if os.EOL is not defined	2012-07-04 09:25:08 +10:00
Gareth Jones	b6ba3bce00	Merge branch 'master' of https://github.com/nomiddlename/log4js-node	2012-07-04 09:11:07 +10:00
Gareth Jones	638ce187bb	use os.EOL instead of \n	2012-07-04 08:53:09 +10:00
Gareth Jones	3cbae96a97	Changed multiprocess appender to use a single socket per client	2012-07-04 08:45:20 +10:00
Gareth Jones	a33e48cb07	Changed multiprocess appender to use a single socket per client	2012-07-04 08:44:50 +10:00
Gareth Jones	df491c0b14	Changed multiprocess appender to use a single socket per client	2012-07-04 08:44:16 +10:00
Gareth Jones	6ff1a2499f	removed 0.7 added 0.8	2012-07-04 08:33:06 +10:00
Gareth Jones	ce2d7df8df	Merge pull request #78 from druciak/smtp SMTP appender migrated to nodemailer 0.3.x	2012-06-28 18:09:04 -07:00
Gareth Jones	1b12265800	Merge branch 'master' of https://github.com/nomiddlename/log4js-node	2012-06-29 10:53:38 +10:00
Gareth Jones	32e9045334	added explanation of console appender	2012-06-29 09:38:23 +10:00
Gareth Jones	1aed671137	added fromreadme.js example, updated README	2012-06-29 09:37:41 +10:00
Gareth Jones	68b47dd51c	expanded example to include loading appender programmatically	2012-06-29 09:19:20 +10:00
Gareth Jones	8f9b4444f6	made sure example works with categories	2012-06-29 09:05:18 +10:00
Gareth Jones	e49f7107fb	example now works	2012-06-29 09:01:42 +10:00
druciak	077302c772	SMTP appender migrated to nodemailer 0.3.x	2012-06-27 18:00:32 +02:00
Gareth Jones	6f0dfa0c5f	Added note about console.log replacement.	2012-06-04 09:18:58 +10:00
Gareth Jones	82a6bee331	Fixed the wiki links.	2012-06-01 18:15:55 +10:00