changed supported node versions to 0.6 and 0.8

.travis.yml

@@ -1,5 +1,4 @@
 language: node_js
 node_js:
-  - "0.10"
+  - 0.6
-  - "0.8"
+  - 0.8
-

README.md

@@ -128,13 +128,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](https://github.com/nomiddlename/log4js-node/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](https://github.com/nomiddlename/log4js-node/wiki). Improve the [wiki](https://github.com/nomiddlename/log4js-node/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](https://github.com/nomiddlename/log4js-node/wiki/Contributing) first.
+Contributions welcome, but take a look at the [rules](log4js-node/wiki/Contributing) first.
 
 ## License
 

examples/example.js

@@ -1,4 +1,4 @@
-var log4js = require('../lib/log4js');
+var log4js = require('./lib/log4js');
 //log the cheese logger messages to a file, and the console ones as well.
 log4js.configure({
     appenders: [

examples/log-rolling.js

@@ -1,4 +1,4 @@
-var log4js = require('../lib/log4js')
+var log4js = require('./lib/log4js')
 , log
 , i = 0;
 log4js.configure({

lib/appenders/dateFile.js

@@ -19,10 +19,10 @@ process.on('exit', function() {
  *          also used to check when to roll files - defaults to '.yyyy-MM-dd'
  * @layout layout function for log messages - defaults to basicLayout
  */
-function appender(filename, pattern, alwaysIncludePattern, layout) {
+function appender(filename, pattern, layout) {
     layout = layout || layouts.basicLayout;
 
-    var logFile = new streams.DateRollingFileStream(filename, pattern, { alwaysIncludePattern: alwaysIncludePattern });
+    var logFile = new streams.BufferedWriteStream(new streams.DateRollingFileStream(filename, pattern));
     openFiles.push(logFile);
 
     return function(logEvent) {
@@ -35,18 +35,14 @@ function configure(config, options) {
     var 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) {
         config.filename = path.join(options.cwd, config.filename);
     }
 
-    return appender(config.filename, config.pattern, config.alwaysIncludePattern, layout);
+    return appender(config.filename, config.pattern, layout);
 }
 
 exports.appender = appender;

lib/appenders/file.js

@@ -22,51 +22,53 @@ process.on('exit', function() {
  * @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;
+    var bytesWritten = 0;
-  file = path.normalize(file);
+    file = path.normalize(file);
-  layout = layout || layouts.basicLayout;
+    layout = layout || layouts.basicLayout;
-  numBackups = numBackups === undefined ? 5 : numBackups;
+    numBackups = numBackups === undefined ? 5 : numBackups;
-  //there has to be at least one backup if logSize has been specified
+    //there has to be at least one backup if logSize has been specified
-  numBackups = numBackups === 0 ? 1 : numBackups;
+    numBackups = numBackups === 0 ? 1 : numBackups;
 
-  function openTheStream(file, fileSize, numFiles) {
+    function openTheStream(file, fileSize, numFiles) {
-    var stream;
+        var stream;
-    if (fileSize) {
+        if (fileSize) {
-      stream = new streams.RollingFileStream(
+            stream = new streams.BufferedWriteStream(
-        file,
+                new streams.RollingFileStream(
-        fileSize,
+                    file,
-        numFiles
+                    fileSize,
-      );
+                    numFiles
-    } else {
+                )
-      stream = fs.createWriteStream(file, { encoding: "utf8", mode: 0644, flags: 'a' });
+            );
+        } else {
+            stream = new streams.BufferedWriteStream(fs.createWriteStream(file, { encoding: "utf8", mode: 0644, flags: 'a' }));
+        }
+        stream.on("error", function (err) {
+            console.error("log4js.fileAppender - Writing to file %s, error happened ", file, err);
+        });
+        return stream;
     }
-    stream.on("error", function (err) {
-      console.error("log4js.fileAppender - Writing to file %s, error happened ", file, err);
-    });
-    return stream;
-  }
 
-  var logFile = openTheStream(file, logSize, numBackups);
+    var logFile = openTheStream(file, logSize, numBackups);
-  
+
-  // push file to the stack of open handlers
+    // push file to the stack of open handlers
-  openFiles.push(logFile);
+    openFiles.push(logFile);
-  
+
-  return function(loggingEvent) {
+    return function(loggingEvent) {
-    logFile.write(layout(loggingEvent) + eol, "utf8");
+        logFile.write(layout(loggingEvent) + 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 (options && options.cwd && !config.absolute) {
+    if (options && options.cwd && !config.absolute) {
-    config.filename = path.join(options.cwd, config.filename);
+        config.filename = path.join(options.cwd, config.filename);
-  }
+    }
 
-  return fileAppender(config.filename, layout, config.maxLogSize, config.backups);
+    return fileAppender(config.filename, layout, config.maxLogSize, config.backups);
 }
 
 exports.appender = fileAppender;

lib/appenders/multiprocess.js

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

lib/streams/BaseRollingFileStream.js

@@ -1,82 +1,92 @@
 var fs = require('fs'),
-stream,
+    util = require('util');
-util = require('util'),
-semver = require('semver');
 
-if (semver.satisfies(process.version, '>=0.10.0')) {
+function debug(message) {
-  stream = require('stream');
+//    console.log(message);
-} else {
-  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.currentSize = 0;
 
-  function currentFileSize(file) {
+debug("In BaseRollingFileStream");
-    var fileSize = 0;
+    this.filename = filename;
-    try {
+    this.options = options || { encoding: 'utf8', mode: 0644, flags: 'a' };
-      fileSize = fs.statSync(file).size;
+    this.rolling = false;
-    } catch (e) {
+    this.writesWhileRolling = [];
-      // file does not exist
-    }
-    return fileSize;
-  }
-
-  function throwErrorIfArgumentsAreNotValid() {
-    if (!filename) {
-      throw new Error("You must specify a filename");
-    }
-  }
-
-  throwErrorIfArgumentsAreNotValid();
-  debug("Calling BaseRollingFileStream.super");
-  BaseRollingFileStream.super_.call(this);
-  this.openTheStream();
-  this.currentSize = currentFileSize(this.filename);
-}
-util.inherits(BaseRollingFileStream, stream.Writable);
-
-BaseRollingFileStream.prototype._write = function(chunk, encoding, callback) {
-  var that = this;
-  function writeTheChunk() {
-    debug("writing the chunk to the underlying stream");
-    that.currentSize += chunk.length;
-    that.theStream.write(chunk, encoding, callback);
-  }
-
-  debug("in _write");
-
-  if (this.shouldRoll()) {
     this.currentSize = 0;
-    this.roll(this.filename, writeTheChunk);
+    this.rollBeforeWrite = false;
-  } else {
+
-    writeTheChunk();
+    function currentFileSize(file) {
-  }
+        var fileSize = 0;
+        try {
+            fileSize = fs.statSync(file).size;
+        } catch (e) {
+            // file does not exist
+        }
+        return fileSize;
+    }
+
+    function throwErrorIfArgumentsAreNotValid() {
+        if (!filename) {
+            throw new Error("You must specify a filename");
+        }
+    }
+
+    throwErrorIfArgumentsAreNotValid();
+debug("Calling BaseRollingFileStream.super");
+    BaseRollingFileStream.super_.call(this, this.filename, this.options);
+    this.currentSize = currentFileSize(this.filename);
+}
+util.inherits(BaseRollingFileStream, fs.FileWriteStream);
+
+BaseRollingFileStream.prototype.initRolling = function() {
+    var that = this;
+
+    function emptyRollingQueue() {
+        debug("emptying the rolling queue");
+        var toWrite;
+        while ((toWrite = that.writesWhileRolling.shift())) {
+            BaseRollingFileStream.super_.prototype.write.call(that, toWrite.data, toWrite.encoding);
+            that.currentSize += toWrite.data.length;
+            if (that.shouldRoll()) {
+                that.flush();
+                return true;
+            }
+        }
+        that.flush();
+        return false;
+    }
+
+    this.rolling = true;
+    this.roll(this.filename, function() {
+        that.currentSize = 0;
+        that.rolling = emptyRollingQueue();
+        if (that.rolling) {
+            process.nextTick(function() { that.initRolling(); });
+        }
+    });
 };
 
-BaseRollingFileStream.prototype.openTheStream = function(cb) {
+BaseRollingFileStream.prototype.write = function(data, encoding) {
-  debug("opening the underlying stream");
+    var canWrite = false;
-  this.theStream = fs.createWriteStream(this.filename, this.options);
+    if (this.rolling) {
-  if (cb) {
+        this.writesWhileRolling.push({ data: data, encoding: encoding });
-    this.theStream.on("open", cb);
+    } else {
-  }
+        if (this.rollBeforeWrite && this.shouldRoll()) {
-};
+            this.writesWhileRolling.push({ data: data, encoding: encoding });
+            this.initRolling();
+        } else {
+            canWrite = BaseRollingFileStream.super_.prototype.write.call(this, data, encoding);
+            this.currentSize += data.length;
+            debug('current size = ' + this.currentSize);
 
-BaseRollingFileStream.prototype.closeTheStream = function(cb) {
+            if (!this.rollBeforeWrite && this.shouldRoll()) {
-  debug("closing the underlying stream");
+                this.initRolling();
-  this.theStream.end(cb);
+            }
+        }
+    }
+    return canWrite;
 };
 
 BaseRollingFileStream.prototype.shouldRoll = function() {

lib/streams/BufferedWriteStream.js

@@ -0,0 +1,78 @@
+var events = require('events'),
+    Dequeue = require('dequeue'),
+    util = require('util');
+
+module.exports = BufferedWriteStream;
+
+function BufferedWriteStream(stream) {
+    var that = this;
+    this.stream = stream;
+    this.buffer = new Dequeue();
+    this.canWrite = false;
+    this.bytes = 0;
+
+    this.stream.on("open", function() {
+        that.canWrite = true;
+        that.flushBuffer();
+    });
+
+    this.stream.on("error", function (err) {
+        that.emit("error", err);
+    });
+
+    this.stream.on("drain", function() {
+        that.canWrite = true;
+        that.flushBuffer();
+    });
+}
+
+util.inherits(BufferedWriteStream, events.EventEmitter);
+
+Object.defineProperty(
+    BufferedWriteStream.prototype,
+    "fd",
+    {
+        get: function() { return this.stream.fd; },
+        set: function(newFd) {
+            this.stream.fd = newFd;
+            this.bytes = 0;
+        }
+    }
+);
+
+Object.defineProperty(
+    BufferedWriteStream.prototype,
+    "bytesWritten",
+    {
+        get: function() { return this.bytes; }
+    }
+);
+
+BufferedWriteStream.prototype.write = function(data, encoding) {
+    this.buffer.push({ data: data, encoding: encoding });
+    this.flushBuffer();
+};
+
+BufferedWriteStream.prototype.end = function(data, encoding) {
+    if (data) {
+        this.buffer.push({ data: data, encoding: encoding });
+    }
+    this.flushBufferEvenIfCannotWrite();
+};
+
+BufferedWriteStream.prototype.writeToStream = function(toWrite) {
+    this.bytes += toWrite.data.length;
+    this.canWrite = this.stream.write(toWrite.data, toWrite.encoding);
+};
+
+BufferedWriteStream.prototype.flushBufferEvenIfCannotWrite = function() {
+    while (this.buffer.length > 0) {
+        this.writeToStream(this.buffer.shift());
+    }
+};
+
+BufferedWriteStream.prototype.flushBuffer = function() {
+    while (this.buffer.length > 0 && this.canWrite) {
+        this.writeToStream(this.buffer.shift());
+    }
+};

lib/streams/DateRollingFileStream.js

@@ -6,38 +6,26 @@ var BaseRollingFileStream = require('./BaseRollingFileStream'),
 
 module.exports = DateRollingFileStream;
 
-var debug;
+function debug(message) {
-if (process.env.NODE_DEBUG && /\blog4js\b/.test(process.env.NODE_DEBUG)) {
+//    console.log(message);
-    debug = function(message) { console.error('LOG4JS: (DateRollingFileStream) %s', message); };
-} else {
-    debug = function() { };
 }
 
 function DateRollingFileStream(filename, pattern, options, now) {
-  debug("Now is " + now);
+    debug("Now is " + now);
-  if (pattern && typeof(pattern) === 'object') {
+    if (pattern && typeof(pattern) === 'object') {
-    now = options;
+        now = options;
-    options = pattern;
+        options = pattern;
-    pattern = null;
+        pattern = null;
-  }
-  this.pattern = pattern || '.yyyy-MM-dd';
-  this.now = now || Date.now;
-  this.lastTimeWeWroteSomething = format.asString(this.pattern, new Date(this.now()));
-  this.baseFilename = filename;
-    
-  if (options) {
-    if (options.alwaysIncludePattern) {
-      filename = filename + this.lastTimeWeWroteSomething;
     }
-    delete options.alwaysIncludePattern;
+    this.pattern = pattern || '.yyyy-MM-dd';
-    if (options === {}) { 
+    this.now = now || Date.now;
-      options = null; 
+    this.lastTimeWeWroteSomething = format.asString(this.pattern, new Date(this.now()));
-    }
+    debug("this.now is " + this.now + ", now is " + now);
-  }
-  debug("this.now is " + this.now + ", now is " + now);
 
-  DateRollingFileStream.super_.call(this, filename, options);
+    DateRollingFileStream.super_.call(this, filename, options);
+    this.rollBeforeWrite = true;
 }
+
 util.inherits(DateRollingFileStream, BaseRollingFileStream);
 
 DateRollingFileStream.prototype.shouldRoll = function() {
@@ -54,15 +42,17 @@ DateRollingFileStream.prototype.shouldRoll = function() {
 
 DateRollingFileStream.prototype.roll = function(filename, callback) {
     var that = this,
-        newFilename = this.baseFilename + this.previousTime;
+        newFilename = filename + this.previousTime;
 
     debug("Starting roll");
+    debug("Queueing up data until we've finished rolling");
+    debug("Flushing underlying stream");
+    this.flush();
 
     async.series([
-      this.closeTheStream.bind(this),
+        deleteAnyExistingFile,
-      deleteAnyExistingFile,
+        renameTheCurrentFile,
-      renameTheCurrentFile,
+        openANewFile
-      this.openTheStream.bind(this)
     ], callback);
 
     function deleteAnyExistingFile(cb) {
@@ -79,4 +69,21 @@ DateRollingFileStream.prototype.roll = function(filename, callback) {
         fs.rename(filename, newFilename, cb);
     }
 
+    function openANewFile(cb) {
+        debug("Opening a new file");
+        fs.open(
+            filename,
+            that.options.flags,
+            that.options.mode,
+            function (err, fd) {
+                debug("opened new file");
+                var oldLogFileFD = that.fd;
+                that.fd = fd;
+                that.writable = true;
+                fs.close(oldLogFileFD, cb);
+            }
+        );
+    }
+
+
 };

lib/streams/RollingFileStream.js

@@ -4,11 +4,9 @@ var BaseRollingFileStream = require('./BaseRollingFileStream'),
     fs = require('fs'),
     async = require('async');
 
-var debug;
+function debug(message) {
-if (process.env.NODE_DEBUG && /\blog4js\b/.test(process.env.NODE_DEBUG)) {
+//    util.debug(message);
-    debug = function(message) { console.error('LOG4JS: (RollingFileStream) %s', message); };
+//    console.log(message);
-} else {
-    debug = function() { };
 }
 
 module.exports = RollingFileStream;
@@ -30,7 +28,6 @@ function RollingFileStream (filename, size, backups, options) {
 util.inherits(RollingFileStream, BaseRollingFileStream);
 
 RollingFileStream.prototype.shouldRoll = function() {
-  debug("should roll with current size %d, and max size %d", this.currentSize, this.size);
     return this.currentSize >= this.size;
 };
 
@@ -84,11 +81,30 @@ RollingFileStream.prototype.roll = function(filename, callback) {
         });
     }
 
-  debug("Rolling, rolling, rolling");
+    function openANewFile(cb) {
-  async.series([
+        debug("Opening a new file");
-    this.closeTheStream.bind(this),
+        fs.open(
-    renameTheFiles,
+            filename,
-    this.openTheStream.bind(this)
+            that.options.flags,
-  ], callback);
+            that.options.mode,
+            function (err, fd) {
+                debug("opened new file");
+                var oldLogFileFD = that.fd;
+                that.fd = fd;
+                that.writable = true;
+                fs.close(oldLogFileFD, cb);
+            }
+        );
+    }
+
+    debug("Starting roll");
+    debug("Queueing up data until we've finished rolling");
+    debug("Flushing underlying stream");
+    this.flush();
+
+    async.series([
+        renameTheFiles,
+        openANewFile
+    ], callback);
 
 };

lib/streams/index.js

@@ -1,2 +1,3 @@
+exports.BufferedWriteStream = require('./BufferedWriteStream');
 exports.RollingFileStream = require('./RollingFileStream');
 exports.DateRollingFileStream = require('./DateRollingFileStream');

package.json

@@ -1,42 +1,40 @@
 {
-  "name": "log4js",
+   "name": "log4js",
-  "version": "0.6.3",
+   "version": "0.5.8",
-  "description": "Port of Log4js to work with node.",
+   "description": "Port of Log4js to work with node.",
-  "keywords": [
+   "keywords": [
-    "logging",
+       "logging",
-    "log",
+       "log",
-    "log4j",
+       "log4j",
-    "node"
+       "node"
-  ],
+   ],
-  "main": "./lib/log4js",
+   "main": "./lib/log4js",
-  "author": "Gareth Jones <gareth.jones@sensis.com.au>",
+   "author": "Gareth Jones <gareth.jones@sensis.com.au>",
-  "repository": {
+   "repository": {
-    "type": "git",
+       "type": "git",
-    "url": "https://github.com/nomiddlename/log4js-node.git"
+       "url": "https://github.com/nomiddlename/log4js-node.git"
-  },
+   },
-  "bugs": {
+   "bugs": {
-    "url": "http://github.com/nomiddlename/log4js-node/issues"
+       "url": "http://github.com/nomiddlename/log4js-node/issues"
-  },
+   },
-  "engines": {
+   "engines": {
-    "node": ">=0.8"
+     "node":  "~0.6||~0.8" 
-  },
+   },
-  "scripts": {
+   "scripts": {
-    "test": "vows"
+       "test": "vows"
-  },
+   },
-  "directories": {
+   "directories": {
-    "test": "test",
+       "test": "test",
-    "lib": "lib"
+       "lib": "lib"
-  },
+   },
-  "dependencies": {
+   "dependencies": {
-    "async": "0.1.15",
+       "async": "0.1.15",
-    "dequeue": "1.0.3",
+       "dequeue": "1.0.3"
-    "semver": "~1.1.4",
+   },
-    "readable-stream": "~1.0.2"
+   "devDependencies": {
-  },
+       "vows": "0.6.2",
-  "devDependencies": {
+       "sandboxed-module": "0.1.3",
-    "vows": "0.7.0",
+       "hook.io": "0.8.10",
-    "sandboxed-module": "0.1.3",
+       "underscore": "1.2.1"
-    "hook.io": "0.8.10",
+   }
-    "underscore": "1.2.1"
-  }
 }

test/dateFileAppender-test.js

@@ -5,13 +5,13 @@ var vows = require('vows'),
     log4js = require('../lib/log4js');
 
 function removeFile(filename) {
-  return function() {
+    return function() {
-    fs.unlink(path.join(__dirname, filename), function(err) {
+        fs.unlink(path.join(__dirname, filename), function(err) {
-      if (err) {
+            if (err) {
-        console.log("Could not delete ", filename, err);
+                console.log("Could not delete ", filename, err);
-      }
+            }
-    });
+        });
-  };
+    };
 }
 
 vows.describe('../lib/appenders/dateFile').addBatch({
@@ -72,58 +72,27 @@ vows.describe('../lib/appenders/dateFile').addBatch({
 
     }
 }).addBatch({
-  'configure': {
+    'configure': {
-    'with dateFileAppender': {
+        'with dateFileAppender': {
 	    topic: function() {
-	      var log4js = require('../lib/log4js')
+	        var log4js = require('../lib/log4js')
-        , logger;
+                  , 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');
+                log4js.configure('test/with-dateFile.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(path.join(__dirname, 'date-file-test.log'), 'utf8', this.callback);
+                fs.readFile(path.join(__dirname, 'date-file-test.log'), 'utf8', this.callback);
 	    },
-      teardown: removeFile('date-file-test.log'),
+            teardown: removeFile('date-file-test.log'),
-      
+
 	    'should load appender configuration from a json file': function(err, contents) {
-	      assert.include(contents, 'this should be written to the file' + require('os').EOL);
+	        assert.include(contents, 'this should be written to the file\n');
-        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);
 	    }
-    },
+        }
-	  'with options.alwaysIncludePattern': {
+
-	    topic: function() {
+    }
-	      var log4js = require('../lib/log4js')
-	      , format = require('../lib/date_format')
-	      , logger
-	      , options = {
-		      "appenders": [
-		        {
-		          "category": "tests", 
-		          "type": "dateFile", 
-		          "filename": "test/date-file-test",
-		          "pattern": "-from-MM-dd.log",
-		          "alwaysIncludePattern": true,
-		          "layout": { 
-			          "type": "messagePassThrough" 
-		          }
-		        }
-		      ]
-		    }
-	      , thisTime = format.asString(options.appenders[0].pattern, new Date());
-	      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);
-	    },
-	    'should create file with the correct pattern': function(contents) {
-	      assert.include(contents, 'this should be written to the file with the appended date');
-	    }
-	  }
-      
-  }
 }).exportTo(module);

test/fileAppender-test.js

@@ -108,13 +108,7 @@ vows.describe('log4js fileAppender').addBatch({
             var that = this;
             //give the system a chance to open the stream
             setTimeout(function() {
-              fs.readdir(__dirname, function(err, files) { 
+                fs.readdir(__dirname, that.callback);
-		if (files) { 
-		  that.callback(null, files.sort()); 
-		} else { 
-		  that.callback(err, files); 
-		}
-	      });
             }, 200);
         },
         'the log files': {
@@ -126,31 +120,31 @@ vows.describe('log4js fileAppender').addBatch({
                 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']);
+                assert.deepEqual(files.sort(), ['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);
+                    fs.readFile(path.join(__dirname, logFiles[0]), "utf8", this.callback);
+                },
+                'should be empty because the last log message triggers rolling': function(contents) {
+                    assert.isEmpty(contents);
+                }
+            },
+            'and the contents of the second file': {
+                topic: function(logFiles) {
+                    fs.readFile(path.join(__dirname, logFiles[1]), "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': {
+            'and the contents of the third file': {
                 topic: function(logFiles) {
-                  fs.readFile(path.join(__dirname, logFiles[1]), "utf8", this.callback);
+                    fs.readFile(path.join(__dirname, logFiles[2]), "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.');
-                }
             }
         }
     }

test/log-abspath-test.js

@@ -50,10 +50,9 @@ vows.describe('log4js-abspath').addBatch({
                         {
                             RollingFileStream: function(file) {
                                 fileOpened = file;
-			      return {
+                            },
-				on: function() {},
+                            BufferedWriteStream: function(other) {
-				end: function() {}
+                                return { on: function() { }, end: function() {} }
-			      };
                             }
                         }
                       }

test/multiprocess-test.js

@@ -30,24 +30,24 @@ function makeFakeNet() {
             };
         },
         createServer: function(cb) {
-          var fakeNet = this;
+            var fakeNet = this;
-          cb({
+            cb({
-            remoteAddress: '1.2.3.4',
+                remoteAddress: '1.2.3.4',
-            remotePort: '1234',
+                remotePort: '1234',
-            setEncoding: function(encoding) {
+                setEncoding: function(encoding) {
-              fakeNet.encoding = encoding;
+                    fakeNet.encoding = encoding;
-            },
+                },
-            on: function(event, cb) {
+                on: function(event, cb) {
-              fakeNet.cbs[event] = cb;
+                    fakeNet.cbs[event] = cb;
-            }
+                }
-          });
+            });
 
-          return {
+            return {
-            listen: function(port, host) {
+                listen: function(port, host) {
-              fakeNet.port = port;
+                    fakeNet.port = port;
-              fakeNet.host = host;
+                    fakeNet.host = host;
-            }
+                }
-          };
+            };
         }
     };
 }
@@ -183,6 +183,7 @@ vows.describe('Multiprocess Appender').addBatch({
             topic: function(net) {
               var logString = JSON.stringify({ level: { level: 10000, levelStr: 'DEBUG' }, data: ['some debug']}) + '__LOG4JS__';
 
+                net.cbs['connect']();
                 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));

test/streams/DateRollingFileStream-test.js

@@ -1,17 +1,8 @@
-var vows = require('vows')
+var vows = require('vows'),
-, assert = require('assert')
+    assert = require('assert'),
-, fs = require('fs')
+    fs = require('fs'),
-, semver = require('semver')
+    DateRollingFileStream = require('../../lib/streams').DateRollingFileStream,
-, streams
+    testTime = new Date(2012, 8, 12, 10, 37, 11);
-, DateRollingFileStream
-, testTime = new Date(2012, 8, 12, 10, 37, 11);
-
-if (semver.satisfies(process.version, '>=0.10.0')) {
-  streams = require('stream');
-} else {
-  streams = require('readable-stream');
-}
-DateRollingFileStream = require('../../lib/streams').DateRollingFileStream
 
 function cleanUp(filename) {
     return function() {
@@ -28,16 +19,15 @@ vows.describe('DateRollingFileStream').addBatch({
         topic: new DateRollingFileStream(__dirname + '/test-date-rolling-file-stream-1', 'yyyy-mm-dd.hh'),
         teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-1'),
 
-        'should take a filename and a pattern and return a WritableStream': function(stream) {
+        'should take a filename and a pattern and return a FileWriteStream': function(stream) {
-          assert.equal(stream.filename, __dirname + '/test-date-rolling-file-stream-1');
+            assert.equal(stream.filename, __dirname + '/test-date-rolling-file-stream-1');
-          assert.equal(stream.pattern, 'yyyy-mm-dd.hh');
+            assert.equal(stream.pattern, 'yyyy-mm-dd.hh');
-          assert.instanceOf(stream, streams.Writable);
+            assert.instanceOf(stream, fs.FileWriteStream);
         },
         'with default settings for the underlying stream': function(stream) {
-          assert.equal(stream.theStream.mode, 420);
+            assert.equal(stream.mode, 420);
-          assert.equal(stream.theStream.flags, 'a');
+            assert.equal(stream.flags, 'a');
-	  //encoding is not available on the underlying stream
+            assert.equal(stream.encoding, 'utf8');
-          //assert.equal(stream.encoding, 'utf8');
         }
     },
 
@@ -55,7 +45,7 @@ vows.describe('DateRollingFileStream').addBatch({
         teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-3'),
 
         'should pass them to the underlying stream': function(stream) {
-            assert.equal(stream.theStream.mode, 0666);
+            assert.equal(stream.mode, 0666);
         }
     },
 
@@ -64,7 +54,7 @@ vows.describe('DateRollingFileStream').addBatch({
         teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-4'),
 
         'should pass them to the underlying stream': function(stream) {
-            assert.equal(stream.theStream.mode, 0666);
+            assert.equal(stream.mode, 0666);
         },
         'should use default pattern': function(stream) {
             assert.equal(stream.pattern, '.yyyy-MM-dd');
@@ -73,11 +63,13 @@ vows.describe('DateRollingFileStream').addBatch({
 
     'with a pattern of .yyyy-MM-dd': {
         topic: function() {
-          var that = this,
+            var that = this,
-          stream = new DateRollingFileStream(__dirname + '/test-date-rolling-file-stream-5', '.yyyy-MM-dd', null, now);
+                stream = new DateRollingFileStream(__dirname + '/test-date-rolling-file-stream-5', '.yyyy-MM-dd', null, now);
-          stream.write("First message\n", 'utf8', function() {
+            stream.on("open", function() {
-	          that.callback(null, stream);
+                stream.write("First message\n");
-	        });
+                //wait for the file system to catch up with us
+                that.callback(null, stream);
+            });
         },
         teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-5'),
 
@@ -92,8 +84,9 @@ vows.describe('DateRollingFileStream').addBatch({
 
         'when the day changes': {
             topic: function(stream) {
-              testTime = new Date(2012, 8, 13, 0, 10, 12);
+                testTime = new Date(2012, 8, 13, 0, 10, 12);
-              stream.write("Second message\n", 'utf8', this.callback);
+                stream.write("Second message\n");
+                setTimeout(this.callback, 100);
             },
             teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-5.2012-09-12'),
 

test/streams/bufferedStream-test.js

@@ -0,0 +1,130 @@
+var vows = require('vows')
+, assert = require('assert')
+, events = require('events')
+, BufferedWriteStream = require('../../lib/streams').BufferedWriteStream;
+
+function FakeStream() {
+    this.writes = [];
+    this.canWrite = false;
+    this.callbacks = {};
+}
+
+FakeStream.prototype.on = function(event, callback) {
+    this.callbacks[event] = callback;
+}
+
+FakeStream.prototype.write = function(data, encoding) {
+    assert.equal("utf8", encoding);
+    this.writes.push(data);
+    return this.canWrite;
+}
+
+FakeStream.prototype.emit = function(event, payload) {
+    this.callbacks[event](payload);
+}
+
+FakeStream.prototype.block = function() {
+    this.canWrite = false;
+}
+
+FakeStream.prototype.unblock = function() {
+    this.canWrite = true;
+    this.emit("drain");
+}
+
+vows.describe('BufferedWriteStream').addBatch({
+    'stream': {
+        topic: new BufferedWriteStream(new FakeStream()),
+        'should take a stream as an argument and return a stream': function(stream) {
+            assert.instanceOf(stream, events.EventEmitter);
+        }
+    },
+    'before stream is open': {
+        topic: function() {
+            var fakeStream = new FakeStream(),
+            stream = new BufferedWriteStream(fakeStream);
+            stream.write("Some data", "utf8");
+            stream.write("Some more data", "utf8");
+            return fakeStream.writes;
+        },
+        'should buffer writes': function(writes) {
+            assert.equal(writes.length, 0);
+        }
+    },
+    'when stream is open': {
+        topic: function() {
+            var fakeStream = new FakeStream(),
+            stream = new BufferedWriteStream(fakeStream);
+            stream.write("Some data", "utf8");
+            fakeStream.canWrite = true;
+            fakeStream.emit("open");
+            stream.write("Some more data", "utf8");
+            return fakeStream.writes;
+        },
+        'should write data to stream from before stream was open': function (writes) {
+            assert.equal(writes[0], "Some data");
+        },
+        'should write data to stream from after stream was open': function (writes) {
+            assert.equal(writes[1], "Some more data");
+        }
+    },
+    'when stream is blocked': {
+        topic: function() {
+            var fakeStream = new FakeStream(),
+            stream = new BufferedWriteStream(fakeStream);
+            fakeStream.emit("open");
+            fakeStream.block();
+            stream.write("will not know it is blocked until first write", "utf8");
+            stream.write("so this one will be buffered, but not the previous one", "utf8");
+            return fakeStream.writes;
+        },
+        'should buffer writes': function (writes) {
+            assert.equal(writes.length, 1);
+            assert.equal(writes[0], "will not know it is blocked until first write");
+        }
+    },
+    'when stream is unblocked': {
+        topic: function() {
+            var fakeStream = new FakeStream(),
+            stream = new BufferedWriteStream(fakeStream);
+            fakeStream.emit("open");
+            fakeStream.block();
+            stream.write("will not know it is blocked until first write", "utf8");
+            stream.write("so this one will be buffered, but not the previous one", "utf8");
+            fakeStream.unblock();
+            return fakeStream.writes;
+        },
+        'should send buffered data': function (writes) {
+            assert.equal(writes.length, 2);
+            assert.equal(writes[1], "so this one will be buffered, but not the previous one");
+        }
+    },
+    'when stream is closed': {
+        topic: function() {
+            var fakeStream = new FakeStream(),
+            stream = new BufferedWriteStream(fakeStream);
+            fakeStream.emit("open");
+            fakeStream.block();
+            stream.write("first write to notice stream is blocked", "utf8");
+            stream.write("data while blocked", "utf8");
+            stream.end();
+            return fakeStream.writes;
+        },
+        'should send any buffered writes to the stream': function (writes) {
+            assert.equal(writes.length, 2);
+            assert.equal(writes[1], "data while blocked");
+        }
+    },
+    'when stream errors': {
+        topic: function() {
+            var fakeStream = new FakeStream(),
+            stream = new BufferedWriteStream(fakeStream);
+            stream.on("error", this.callback);
+            fakeStream.emit("error", "oh noes!");
+        },
+        'should emit error': function(err, value) {
+            assert.equal(err, "oh noes!");
+        }
+    }
+
+}).exportTo(module);

test/streams/rollingFileStream-test.js

@@ -1,18 +1,8 @@
 var vows = require('vows')
-, async = require('async')
 , assert = require('assert')
 , events = require('events')
 , fs = require('fs')
-, semver = require('semver')
+, RollingFileStream = require('../../lib/streams').RollingFileStream;
-, streams
-, RollingFileStream;
-
-if (semver.satisfies(process.version, '>=0.10.0')) {
-  streams = require('stream');
-} else {
-  streams = require('readable-stream');
-}
-RollingFileStream = require('../../lib/streams').RollingFileStream;
 
 function remove(filename) {
     try {
@@ -28,17 +18,16 @@ vows.describe('RollingFileStream').addBatch({
             remove(__dirname + "/test-rolling-file-stream");
             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) {
+        'should take a filename, file size in bytes, number of backups as arguments and return a FileWriteStream': function(stream) {
-          assert.instanceOf(stream, streams.Writable);
+            assert.instanceOf(stream, fs.FileWriteStream);
-          assert.equal(stream.filename, "test-rolling-file-stream");
+            assert.equal(stream.filename, "test-rolling-file-stream");
-          assert.equal(stream.size, 1024);
+            assert.equal(stream.size, 1024);
-          assert.equal(stream.backups, 5);
+            assert.equal(stream.backups, 5);
         },
         'with default settings for the underlying stream': function(stream) {
-            assert.equal(stream.theStream.mode, 420);
+            assert.equal(stream.mode, 420);
-            assert.equal(stream.theStream.flags, 'a');
+            assert.equal(stream.flags, 'a');
-	  //encoding isn't a property on the underlying stream
+            assert.equal(stream.encoding, 'utf8');
-          //assert.equal(stream.theStream.encoding, 'utf8');
         }
     },
     'with stream arguments': {
@@ -47,7 +36,7 @@ vows.describe('RollingFileStream').addBatch({
             return new RollingFileStream('test-rolling-file-stream', 1024, 5, { mode: 0666 });
         },
         'should pass them to the underlying stream': function(stream) {
-            assert.equal(stream.theStream.mode, 0666);
+            assert.equal(stream.mode, 0666);
         }
     },
     'without size': {
@@ -72,63 +61,66 @@ vows.describe('RollingFileStream').addBatch({
         }
     },
     '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() {
-          fs.readdir(__dirname, this.callback);
+            remove(__dirname + "/test-rolling-file-stream-write-less");
+            var that = this, stream = new RollingFileStream(__dirname + "/test-rolling-file-stream-write-less", 100);
+            stream.on("open", function() { that.callback(null, stream); });
         },
-        'should be one': function(files) {
+        '(when open)': {
-          assert.equal(files.filter(function(file) { return file.indexOf('test-rolling-file-stream-write-less') > -1; }).length, 1);
+            topic: function(stream) {
+                stream.write("cheese", "utf8");
+                stream.end();
+                fs.readFile(__dirname + "/test-rolling-file-stream-write-less", "utf8", this.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': {
-      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);
+            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);
+            stream.on("open", function() {
+                for (var i=0; i < 7; i++) {
+                    stream.write(i +".cheese\n", "utf8");
+                }
+                //wait for the file system to catch up with us
+                setTimeout(that.callback, 100);
+            });
         },
-        'should be two': function(files) {
+        'the number of files': {
-          assert.equal(files.filter(
+            topic: function() {
-	    function(file) { return file.indexOf('test-rolling-file-stream-write-more') > -1; }
+                fs.readdir(__dirname, this.callback);
-	  ).length, 2);
+            },
-        }
+            '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) {
+        'the first file': {
-          assert.equal(contents, '5.cheese\n6.cheese\n');
+            topic: function() {
-        }
+                fs.readFile(__dirname + "/test-rolling-file-stream-write-more", "utf8", this.callback);
-      },
+            },
-      'the second file': {
+            'should contain the last two log messages': function(contents) {
-        topic: function() {
+                assert.equal(contents, '5.cheese\n6.cheese\n');
-          fs.readFile(__dirname + '/test-rolling-file-stream-write-more.1', "utf8", this.callback);
+            }
         },
-        'should contain the first five log messages': function(contents) {
+        'the second file': {
-          assert.equal(contents, '0.cheese\n1.cheese\n2.cheese\n3.cheese\n4.cheese\n');
+            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');
+            }
         }
-      }
     }
 }).exportTo(module);