Added node0.8 back into travis builds

Fix node engine in package.json

.travis.yml

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

README.md

@@ -17,6 +17,8 @@ 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: version 0.6.0 onwards will only work with node v0.10.x upwards, since it makes use of the new streams API. If you're using node 0.8 or lower, use log4js@0.5.7.
+
 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
@@ -128,13 +130,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](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](https://github.com/nomiddlename/log4js-node/wiki/Appenders), otherwise take a look at the tests and the examples.
 
 ## Documentation
-See the [wiki](log4js-node/wiki). Improve the [wiki](log4js-node/wiki), please.
+See the [wiki](https://github.com/nomiddlename/log4js-node/wiki). Improve the [wiki](https://github.com/nomiddlename/log4js-node/wiki), please.
 
 ## Contributing
-Contributions welcome, but take a look at the [rules](log4js-node/wiki/Contributing) first.
+Contributions welcome, but take a look at the [rules](https://github.com/nomiddlename/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

@@ -1,9 +1,10 @@
-var streams = require('../streams'),
+var semver = require('semver')
-    layouts = require('../layouts'),
+, layouts = require('../layouts')
-    path = require('path'),
+, path = require('path')
-    os = require('os'),
+, os = require('os')
-    eol = os.EOL || '\n',
+, eol = os.EOL || '\n'
-    openFiles = [];
+, openFiles = []
+, streams;
 
 //close open files on process exit.
 process.on('exit', function() {
@@ -20,29 +21,36 @@ process.on('exit', function() {
  * @layout layout function for log messages - defaults to basicLayout
  */
 function appender(filename, pattern, layout) {
-    layout = layout || layouts.basicLayout;
+  layout = layout || layouts.basicLayout;
+  var logFile;
 
-    var logFile = new streams.BufferedWriteStream(new streams.DateRollingFileStream(filename, pattern));
+  if (semver.satisfies(process.version, '>=0.10.0')) {
-    openFiles.push(logFile);
+    streams = require('../streams');
+    logFile = new streams.DateRollingFileStream(filename, pattern);
+  } else {
+    streams = require('../old-streams');
+    logFile = new streams.BufferedWriteStream(new streams.DateRollingFileStream(filename, pattern));
+  }
+  openFiles.push(logFile);
   
-    return function(logEvent) {
+  return function(logEvent) {
-        logFile.write(layout(logEvent) + eol, "utf8");
+    logFile.write(layout(logEvent) + eol, "utf8");
-    };
+  };
 
 }
 
 function configure(config, options) {
-    var layout;
+  var layout;
   
-    if (config.layout) {
+  if (config.layout) {
-	layout = layouts.layout(config.layout.type, config.layout);
+	  layout = layouts.layout(config.layout.type, config.layout);
-    }
+  }
 
-    if (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 appender(config.filename, config.pattern, layout);
+  return appender(config.filename, config.pattern, layout);
 }
 
 exports.appender = appender;

lib/appenders/file.js

@@ -1,10 +1,10 @@
 var layouts = require('../layouts')
-  , path = require('path')
+, path = require('path')
-  , fs = require('fs')
+, fs = require('fs')
-  , streams = require('../streams')
+, semver = require('semver')
-  , os = require('os')
+, os = require('os')
-  , eol = os.EOL || '\n'
+, eol = os.EOL || '\n'
-  , openFiles = [];
+, openFiles = [];
 
 //close open files on process exit.
 process.on('exit', function() {
@@ -22,53 +22,77 @@ 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 logFile;
-    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) {
+    , streams = require('../streams');
-            stream = new streams.BufferedWriteStream(
+
-                new streams.RollingFileStream(
+    if (fileSize) {
-                    file,
+      stream = new streams.RollingFileStream(
-                    fileSize,
+        file,
-                    numFiles
+        fileSize,
-                )
+        numFiles
-            );
+      );
-        } else {
+    } else {
-            stream = new streams.BufferedWriteStream(fs.createWriteStream(file, { encoding: "utf8", mode: 0644, flags: 'a' }));
+      stream = 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);
+  function openTheOldStyleStream(file, fileSize, numFiles) {
+    var stream
+    , streams = require('../old-streams');
+    if (fileSize) {
+      stream = new streams.BufferedWriteStream(
+        new streams.RollingFileStream(
+          file,
+          fileSize,
+          numFiles
+        )
+      );
+    } 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;
+  }
 
-    // push file to the stack of open handlers
+  if (semver.satisfies(process.version, '>=0.10.0')) {
-    openFiles.push(logFile);
+    logFile = openTheStream(file, logSize, numBackups);
+  } else {
+    logFile = openTheOldStyleStream(file, logSize, numBackups);
+  }
   
-    return function(loggingEvent) {
+  // push file to the stack of open handlers
-        logFile.write(layout(loggingEvent) + eol, "utf8");
+  openFiles.push(logFile);
-    };
+  
+  return function(loggingEvent) {
+    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,31 +38,30 @@ function logServer(config) {
     var actualAppender = config.actualAppender,
         server = net.createServer(function serverCreated(clientSocket) {
             clientSocket.setEncoding('utf8');
-            clientSocket.on('connect', function clientConnected() {
+            var logMessage = '';
-                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/old-streams/BaseRollingFileStream.js

@@ -0,0 +1,99 @@
+var fs = require('fs'),
+    util = require('util');
+
+function debug(message) {
+//    console.log(message);
+}
+
+module.exports = BaseRollingFileStream;
+
+function BaseRollingFileStream(filename, options) {
+
+debug("In BaseRollingFileStream");
+    this.filename = filename;
+    this.options = options || { encoding: 'utf8', mode: 0644, flags: 'a' };
+    this.rolling = false;
+    this.writesWhileRolling = [];
+    this.currentSize = 0;
+    this.rollBeforeWrite = false;
+
+    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.write = function(data, encoding) {
+    var canWrite = false;
+    if (this.rolling) {
+        this.writesWhileRolling.push({ data: data, encoding: encoding });
+    } 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);
+
+            if (!this.rollBeforeWrite && this.shouldRoll()) {
+                this.initRolling();
+            }
+        }
+    }
+    return canWrite;
+};
+
+BaseRollingFileStream.prototype.shouldRoll = function() {
+    return false; // default behaviour is never to roll
+};
+
+BaseRollingFileStream.prototype.roll = function(filename, callback) {
+    callback(); // default behaviour is not to do anything
+};
+

lib/old-streams/DateRollingFileStream.js

@@ -0,0 +1,89 @@
+var BaseRollingFileStream = require('./BaseRollingFileStream'),
+    format = require('../date_format'),
+    async = require('async'),
+    fs = require('fs'),
+    util = require('util');
+
+module.exports = DateRollingFileStream;
+
+function debug(message) {
+//    console.log(message);
+}
+
+function DateRollingFileStream(filename, pattern, options, now) {
+    debug("Now is " + now);
+    if (pattern && typeof(pattern) === 'object') {
+        now = options;
+        options = pattern;
+        pattern = null;
+    }
+    this.pattern = pattern || '.yyyy-MM-dd';
+    this.now = now || Date.now;
+    this.lastTimeWeWroteSomething = format.asString(this.pattern, new Date(this.now()));
+    debug("this.now is " + this.now + ", now is " + now);
+
+    DateRollingFileStream.super_.call(this, filename, options);
+    this.rollBeforeWrite = true;
+}
+
+util.inherits(DateRollingFileStream, BaseRollingFileStream);
+
+DateRollingFileStream.prototype.shouldRoll = function() {
+    var lastTime = this.lastTimeWeWroteSomething,
+        thisTime = format.asString(this.pattern, new Date(this.now()));
+
+    debug("DateRollingFileStream.shouldRoll with now = " + this.now() + ", thisTime = " + thisTime + ", lastTime = " + lastTime);
+
+    this.lastTimeWeWroteSomething = thisTime;
+    this.previousTime = lastTime;
+
+    return thisTime !== lastTime;
+};
+
+DateRollingFileStream.prototype.roll = function(filename, callback) {
+    var that = this,
+        newFilename = filename + this.previousTime;
+
+    debug("Starting roll");
+    debug("Queueing up data until we've finished rolling");
+    debug("Flushing underlying stream");
+    this.flush();
+
+    async.series([
+        deleteAnyExistingFile,
+        renameTheCurrentFile,
+        openANewFile
+    ], callback);
+
+    function deleteAnyExistingFile(cb) {
+        //on windows, you can get a EEXIST error if you rename a file to an existing file
+        //so, we'll try to delete the file we're renaming to first
+        fs.unlink(newFilename, function (err) {
+            //ignore err: if we could not delete, it's most likely that it doesn't exist
+            cb();
+        });
+    }
+
+    function renameTheCurrentFile(cb) {
+        debug("Renaming the " + filename + " -> " + newFilename);
+        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/old-streams/README.md

@@ -0,0 +1 @@
+These are for pre-0.10.x versions of node and are here just for backwards compatibility. No bug fixes or enhancements will be made to these files.

lib/old-streams/RollingFileStream.js

@@ -0,0 +1,110 @@
+var BaseRollingFileStream = require('./BaseRollingFileStream'),
+    util = require('util'),
+    path = require('path'),
+    fs = require('fs'),
+    async = require('async');
+
+function debug(message) {
+//    util.debug(message);
+//    console.log(message);
+}
+
+module.exports = RollingFileStream;
+
+function RollingFileStream (filename, size, backups, options) {
+    this.size = size;
+    this.backups = backups || 1;
+
+    function throwErrorIfArgumentsAreNotValid() {
+        if (!filename || !size || size <= 0) {
+            throw new Error("You must specify a filename and file size");
+        }
+    }
+
+    throwErrorIfArgumentsAreNotValid();
+
+    RollingFileStream.super_.call(this, filename, options);
+}
+util.inherits(RollingFileStream, BaseRollingFileStream);
+
+RollingFileStream.prototype.shouldRoll = function() {
+    return this.currentSize >= this.size;
+};
+
+RollingFileStream.prototype.roll = function(filename, callback) {
+    var that = this,
+        nameMatcher = new RegExp('^' + path.basename(filename));
+
+    function justTheseFiles (item) {
+        return nameMatcher.test(item);
+    }
+
+    function index(filename_) {
+        return parseInt(filename_.substring((path.basename(filename) + '.').length), 10) || 0;
+    }
+
+    function byIndex(a, b) {
+        if (index(a) > index(b)) {
+            return 1;
+        } else if (index(a) < index(b) ) {
+            return -1;
+        } else {
+            return 0;
+        }
+    }
+
+    function increaseFileIndex (fileToRename, cb) {
+        var idx = index(fileToRename);
+        debug('Index of ' + fileToRename + ' is ' + idx);
+        if (idx < that.backups) {
+            //on windows, you can get a EEXIST error if you rename a file to an existing file
+            //so, we'll try to delete the file we're renaming to first
+            fs.unlink(filename + '.' + (idx+1), function (err) {
+                //ignore err: if we could not delete, it's most likely that it doesn't exist
+                debug('Renaming ' + fileToRename + ' -> ' + filename + '.' + (idx+1));
+                fs.rename(path.join(path.dirname(filename), fileToRename), filename + '.' + (idx + 1), cb);
+            });
+        } else {
+            cb();
+        }
+    }
+
+    function renameTheFiles(cb) {
+        //roll the backups (rename file.n to file.n+1, where n <= numBackups)
+        debug("Renaming the old files");
+        fs.readdir(path.dirname(filename), function (err, files) {
+            async.forEachSeries(
+                files.filter(justTheseFiles).sort(byIndex).reverse(),
+                increaseFileIndex,
+                cb
+            );
+        });
+    }
+
+    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);
+            }
+        );
+    }
+
+    debug("Starting roll");
+    debug("Queueing up data until we've finished rolling");
+    debug("Flushing underlying stream");
+    this.flush();
+
+    async.series([
+        renameTheFiles,
+        openANewFile
+    ], callback);
+
+};

lib/old-streams/index.js

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

lib/streams/BaseRollingFileStream.js

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

lib/streams/DateRollingFileStream.js

@@ -6,8 +6,11 @@ var BaseRollingFileStream = require('./BaseRollingFileStream'),
 
 module.exports = DateRollingFileStream;
 
-function debug(message) {
+var debug;
-//    console.log(message);
+if (process.env.NODE_DEBUG && /\blog4js\b/.test(process.env.NODE_DEBUG)) {
+    debug = function(message) { console.error('LOG4JS: (DateRollingFileStream) %s', message); };
+} else {
+    debug = function() { };
 }
 
 function DateRollingFileStream(filename, pattern, options, now) {
@@ -23,9 +26,7 @@ function DateRollingFileStream(filename, pattern, options, now) {
     debug("this.now is " + this.now + ", now is " + now);
 
     DateRollingFileStream.super_.call(this, filename, options);
-    this.rollBeforeWrite = true;
 }
-
 util.inherits(DateRollingFileStream, BaseRollingFileStream);
 
 DateRollingFileStream.prototype.shouldRoll = function() {
@@ -45,14 +46,12 @@ DateRollingFileStream.prototype.roll = function(filename, callback) {
         newFilename = filename + this.previousTime;
 
     debug("Starting roll");
-    debug("Queueing up data until we've finished rolling");
-    debug("Flushing underlying stream");
-    this.flush();
 
     async.series([
-        deleteAnyExistingFile,
+      this.closeTheStream.bind(this),
-        renameTheCurrentFile,
+      deleteAnyExistingFile,
-        openANewFile
+      renameTheCurrentFile,
+      this.openTheStream.bind(this)
     ], callback);
 
     function deleteAnyExistingFile(cb) {
@@ -69,21 +68,4 @@ 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,9 +4,11 @@ var BaseRollingFileStream = require('./BaseRollingFileStream'),
     fs = require('fs'),
     async = require('async');
 
-function debug(message) {
+var debug;
-//    util.debug(message);
+if (process.env.NODE_DEBUG && /\blog4js\b/.test(process.env.NODE_DEBUG)) {
-//    console.log(message);
+    debug = function(message) { console.error('LOG4JS: (RollingFileStream) %s', message); };
+} else {
+    debug = function() { };
 }
 
 module.exports = RollingFileStream;
@@ -28,6 +30,7 @@ function RollingFileStream (filename, size, backups, options) {
 util.inherits(RollingFileStream, BaseRollingFileStream);
 
 RollingFileStream.prototype.shouldRoll = function() {
+  debug("should roll with current size %d, and max size %d", this.currentSize, this.size);
     return this.currentSize >= this.size;
 };
 
@@ -81,30 +84,11 @@ RollingFileStream.prototype.roll = function(filename, callback) {
         });
     }
 
-    function openANewFile(cb) {
+  debug("Rolling, rolling, rolling");
-        debug("Opening a new file");
+  async.series([
-        fs.open(
+    this.closeTheStream.bind(this),
-            filename,
+    renameTheFiles,
-            that.options.flags,
+    this.openTheStream.bind(this)
-            that.options.mode,
+  ], callback);
-            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,3 +1,2 @@
-exports.BufferedWriteStream = require('./BufferedWriteStream');
 exports.RollingFileStream = require('./RollingFileStream');
 exports.DateRollingFileStream = require('./DateRollingFileStream');

package.json

@@ -1,38 +1,41 @@
 {
-   "name": "log4js",
+  "name": "log4js",
-   "version": "0.5.6",
+  "version": "0.6.2",
-   "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": [ "node >=0.6" ],
+  "engines": {
-   "scripts": {
+    "node": ">=0.6.0"
-       "test": "vows"
+  },
-   },
+  "scripts": {
-   "directories": {
+    "test": "vows"
-       "test": "test",
+  },
-       "lib": "lib"
+  "directories": {
-   },
+    "test": "test",
-   "dependencies": {
+    "lib": "lib"
-       "async": "0.1.15",
+  },
-       "dequeue": "1.0.3"
+  "dependencies": {
-   },
+    "async": "0.1.15",
-   "devDependencies": {
+    "dequeue": "1.0.3",
-       "vows": "0.6.2",
+    "semver": "~1.1.4"
-       "sandboxed-module": "0.1.3",
+  },
-       "hook.io": "0.8.10",
+  "devDependencies": {
-       "underscore": "1.2.1"
+    "vows": "0.7.0",
-   }
+    "sandboxed-module": "0.1.3",
+    "hook.io": "0.8.10",
+    "underscore": "1.2.1"
+  }
 }

test/dateFileAppender-test.js

@@ -1,17 +1,18 @@
 var vows = require('vows'),
-    assert = require('assert'),
+assert = require('assert'),
-    path = require('path'),
+path = require('path'),
-    fs = require('fs'),
+fs = require('fs'),
-    log4js = require('../lib/log4js');
+sandbox = require('sandboxed-module'),
+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({
@@ -95,4 +96,65 @@ vows.describe('../lib/appenders/dateFile').addBatch({
         }
 
     }
+}).addBatch({
+  'with node version less than 0.10': {
+    topic: function() {
+      var oldStyleStreamCreated = false
+      , appender = sandbox.require(
+        '../lib/appenders/dateFile',
+        { 
+          globals: {
+            process: {
+              version: "v0.8.1",
+              on: function() {}
+            }
+          },
+          requires: {
+            '../old-streams': {
+              BufferedWriteStream: function() {
+                oldStyleStreamCreated = true;
+                this.on =  function() {};
+              },
+              DateRollingFileStream: function() {
+                this.on =  function() {};
+              }
+            }
+          }
+        }
+      ).appender('cheese.log', null, 1000, 1);
+      
+      return oldStyleStreamCreated;
+    },
+    'should load the old-style streams': function(loaded) {
+      assert.isTrue(loaded);
+    }
+  },
+  'with node version greater than or equal to 0.10': {
+    topic: function() {
+      var oldStyleStreamCreated = false
+      , appender = sandbox.require(
+        '../lib/appenders/dateFile',
+        { 
+          globals: {
+            process: {
+              version: "v0.10.1",
+              on: function() {}
+            }
+          },
+          requires: {
+            '../streams': {
+              DateRollingFileStream: function() {
+                this.on =  function() {};
+              }
+            }
+          }
+        }
+      ).appender('cheese.log', null, 1000, 1);
+      
+      return oldStyleStreamCreated;
+    },
+    'should load the new streams': function(loaded) {
+      assert.isFalse(loaded);
+    }
+  }
 }).exportTo(module);

test/fileAppender-test.js

@@ -2,6 +2,8 @@ var vows = require('vows')
 , fs = require('fs')
 , path = require('path')
 , log4js = require('../lib/log4js')
+, sandbox = require('sandboxed-module')
+, semver = require('semver')
 , assert = require('assert');
 
 log4js.clearAppenders();
@@ -17,9 +19,10 @@ function remove(filename) {
 vows.describe('log4js fileAppender').addBatch({
     'adding multiple fileAppenders': {
       topic: function () {
-          var listenersCount = process.listeners('exit').length
+        var listenersCount = process.listeners('exit').length
-            , logger = log4js.getLogger('default-settings')
+        , logger = log4js.getLogger('default-settings')
-            , count = 5, logfile;
+        , count = 5
+        , logfile;
 
           while (count--) {
               logfile = path.join(__dirname, '/fa-default-test' + count + '.log');
@@ -108,7 +111,13 @@ vows.describe('log4js fileAppender').addBatch({
             var that = this;
             //give the system a chance to open the stream
             setTimeout(function() {
-                fs.readdir(__dirname, that.callback);
+              fs.readdir(__dirname, function(err, files) { 
+		            if (files) { 
+		              that.callback(null, files.sort()); 
+		            } else { 
+		              that.callback(err, files); 
+		            }
+	            });
             }, 200);
         },
         'the log files': {
@@ -120,54 +129,135 @@ vows.describe('log4js fileAppender').addBatch({
                 assert.equal(files.length, 3);
             },
             'should be named in sequence': function (files) {
-                assert.deepEqual(files.sort(), ['fa-maxFileSize-with-backups-test.log', 'fa-maxFileSize-with-backups-test.log.1', 'fa-maxFileSize-with-backups-test.log.2']);
+                assert.deepEqual(files, ['fa-maxFileSize-with-backups-test.log', 'fa-maxFileSize-with-backups-test.log.1', 'fa-maxFileSize-with-backups-test.log.2']);
             },
             'and the contents of the first file': {
                 topic: function(logFiles) {
-                    fs.readFile(path.join(__dirname, logFiles[0]), "utf8", this.callback);
+                  fs.readFile(path.join(__dirname, logFiles[0]), "utf8", this.callback);
                 },
-                'should be empty because the last log message triggers rolling': function(contents) {
+                'should be the last log message': function(contents) {
+                  //there's a difference in behaviour between
+                  //old-style streams and new ones (the new ones are
+                  //correct)
+                  if (semver.satisfies(process.version, ">=0.10.0")) {
+                    assert.include(contents, 'This is the fourth log message.');
+                  } else {
                     assert.isEmpty(contents);
+                  }
                 }
             },
             'and the contents of the second file': {
                 topic: function(logFiles) {
-                    fs.readFile(path.join(__dirname, logFiles[1]), "utf8", this.callback);
+                  fs.readFile(path.join(__dirname, logFiles[1]), "utf8", this.callback);
                 },
-                'should be the last log message': function(contents) {
+                'should be the third log message': function(contents) {
+                  //there's a difference in behaviour between
+                  //old-style streams and new ones (the new ones are
+                  //correct)
+                  if (semver.satisfies(process.version, ">=0.10.0")) {
+                    assert.include(contents, 'This is the third log message.');
+                  } else {
                     assert.include(contents, 'This is the fourth log message.');
+                  } 
                 }
             },
             'and the contents of the third file': {
                 topic: function(logFiles) {
-                    fs.readFile(path.join(__dirname, logFiles[2]), "utf8", this.callback);
+                  fs.readFile(path.join(__dirname, logFiles[2]), "utf8", this.callback);
                 },
-                'should be the third log message': function(contents) {
+                'should be the second log message': function(contents) {
+                  //there's a difference in behaviour between
+                  //old-style streams and new ones (the new ones are
+                  //correct)
+                  if (semver.satisfies(process.version, ">=0.10.0")) {
+                    assert.include(contents, 'This is the second log message.');
+                  } else {
                     assert.include(contents, 'This is the third log message.');
+                  }
                 }
             }
         }
     }
 }).addBatch({
-    'configure' : {
+  'configure' : {
-        'with fileAppender': {
+    'with fileAppender': {
 	    topic: function() {
-	        var log4js = require('../lib/log4js')
+	      var log4js = require('../lib/log4js')
-              , logger;
+        , logger;
-	        //this config file defines one file appender (to ./tmp-tests.log)
+	      //this config file defines one file appender (to ./tmp-tests.log)
-	        //and sets the log level for "tests" to WARN
+	      //and sets the log level for "tests" to WARN
-                log4js.configure('test/log4js.json');
+        log4js.configure('test/log4js.json');
-                logger = log4js.getLogger('tests');
+        logger = log4js.getLogger('tests');
-	        logger.info('this should not be written to the file');
+	      logger.info('this should not be written to the file');
-	        logger.warn('this should be written to the file');
+	      logger.warn('this should be written to the file');
 
-                fs.readFile('tmp-tests.log', 'utf8', this.callback);
+        fs.readFile('tmp-tests.log', 'utf8', this.callback);
 	    },
 	    'should load appender configuration from a json file': function(err, contents) {
-	        assert.include(contents, 'this should be written to the file\n');
+	      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);
 	    }
-        }
     }
+  }
+}).addBatch({
+  'with node version less than 0.10': {
+    topic: function() {
+      var oldStyleStreamCreated = false
+      , appender = sandbox.require(
+        '../lib/appenders/file',
+        { 
+          globals: {
+            process: {
+              version: "v0.8.1",
+              on: function() {}
+            }
+          },
+          requires: {
+            '../old-streams': {
+              BufferedWriteStream: function() {
+                oldStyleStreamCreated = true;
+                this.on =  function() {};
+              },
+              RollingFileStream: function() {
+                this.on =  function() {};
+              }
+            }
+          }
+        }
+      ).appender('cheese.log', null, 1000, 1);
       
+      return oldStyleStreamCreated;
+    },
+    'should load the old-style streams': function(loaded) {
+      assert.isTrue(loaded);
+    }
+  },
+  'with node version greater than or equal to 0.10': {
+    topic: function() {
+      var oldStyleStreamCreated = false
+      , appender = sandbox.require(
+        '../lib/appenders/file',
+        { 
+          globals: {
+            process: {
+              version: "v0.10.1",
+              on: function() {}
+            }
+          },
+          requires: {
+            '../streams': {
+              RollingFileStream: function() {
+                this.on =  function() {};
+              }
+            }
+          }
+        }
+      ).appender('cheese.log', null, 1000, 1);
+      
+      return oldStyleStreamCreated;
+    },
+    'should load the new streams': function(loaded) {
+      assert.isFalse(loaded);
+    }
+  }
 }).export(module);

test/log-abspath-test.js

@@ -50,11 +50,18 @@ vows.describe('log4js-abspath').addBatch({
                         {
                             RollingFileStream: function(file) {
                                 fileOpened = file;
-                            },
+			      return {
-                            BufferedWriteStream: function(other) {
+				on: function() {},
-                                return { on: function() { }, end: function() {} }
+				end: function() {}
+			      };
                             }
                         }
+                      },
+                      globals: {
+                        process: {
+                          version: "v0.10.1",
+                          on: 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,7 +183,6 @@ 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,8 +1,10 @@
-var vows = require('vows'),
+var vows = require('vows')
-    assert = require('assert'),
+, assert = require('assert')
-    fs = require('fs'),
+, streams = require('stream')
-    DateRollingFileStream = require('../../lib/streams').DateRollingFileStream,
+, fs = require('fs')
-    testTime = new Date(2012, 8, 12, 10, 37, 11);
+, semver = require('semver')
+, DateRollingFileStream
+, testTime = new Date(2012, 8, 12, 10, 37, 11);
 
 function cleanUp(filename) {
     return function() {
@@ -14,110 +16,112 @@ function now() {
     return testTime.getTime();
 }
 
-vows.describe('DateRollingFileStream').addBatch({
+if (semver.satisfies(process.version, '>=0.10.0')) {
-    'arguments': {
+  DateRollingFileStream = require('../../lib/streams').DateRollingFileStream;
-        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 FileWriteStream': function(stream) {
+  vows.describe('DateRollingFileStream').addBatch({
-            assert.equal(stream.filename, __dirname + '/test-date-rolling-file-stream-1');
+    'arguments': {
-            assert.equal(stream.pattern, 'yyyy-mm-dd.hh');
+      topic: new DateRollingFileStream(__dirname + '/test-date-rolling-file-stream-1', 'yyyy-mm-dd.hh'),
-            assert.instanceOf(stream, fs.FileWriteStream);
+      teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-1'),
-        },
+      
-        'with default settings for the underlying stream': function(stream) {
+      'should take a filename and a pattern and return a WritableStream': function(stream) {
-            assert.equal(stream.mode, 420);
+        assert.equal(stream.filename, __dirname + '/test-date-rolling-file-stream-1');
-            assert.equal(stream.flags, 'a');
+        assert.equal(stream.pattern, 'yyyy-mm-dd.hh');
-            assert.equal(stream.encoding, 'utf8');
+        assert.instanceOf(stream, streams.Writable);
-        }
+      },
+      'with default settings for the underlying stream': function(stream) {
+        assert.equal(stream.theStream.mode, 420);
+        assert.equal(stream.theStream.flags, 'a');
+	      //encoding is not available on the underlying stream
+        //assert.equal(stream.encoding, 'utf8');
+      }
     },
     
     'default arguments': {
-        topic: new DateRollingFileStream(__dirname + '/test-date-rolling-file-stream-2'),
+      topic: new DateRollingFileStream(__dirname + '/test-date-rolling-file-stream-2'),
-        teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-2'),
+      teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-2'),
       
-        'pattern should be .yyyy-MM-dd': function(stream) {
+      'pattern should be .yyyy-MM-dd': function(stream) {
-            assert.equal(stream.pattern, '.yyyy-MM-dd');
+        assert.equal(stream.pattern, '.yyyy-MM-dd');
-        }
+      }
     },
     
     'with stream arguments': {
-        topic: new DateRollingFileStream(__dirname + '/test-date-rolling-file-stream-3', 'yyyy-MM-dd', { mode: 0666 }),
+      topic: new DateRollingFileStream(__dirname + '/test-date-rolling-file-stream-3', 'yyyy-MM-dd', { mode: 0666 }),
-        teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-3'),
+      teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-3'),
       
-        'should pass them to the underlying stream': function(stream) {
+      'should pass them to the underlying stream': function(stream) {
-            assert.equal(stream.mode, 0666);
+        assert.equal(stream.theStream.mode, 0666);
-        }
+      }
     },
     
     'with stream arguments but no pattern': {
-        topic: new DateRollingFileStream(__dirname + '/test-date-rolling-file-stream-4', { mode: 0666 }),
+      topic: new DateRollingFileStream(__dirname + '/test-date-rolling-file-stream-4', { mode: 0666 }),
-        teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-4'),
+      teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-4'),
       
-        'should pass them to the underlying stream': function(stream) {
+      'should pass them to the underlying stream': function(stream) {
-            assert.equal(stream.mode, 0666);
+        assert.equal(stream.theStream.mode, 0666);
-        },
+      },
-        'should use default pattern': function(stream) {
+      'should use default pattern': function(stream) {
-            assert.equal(stream.pattern, '.yyyy-MM-dd');
+        assert.equal(stream.pattern, '.yyyy-MM-dd');
-        }
+      }
     },
 
     'with a pattern of .yyyy-MM-dd': {
-        topic: function() {
+      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.on("open", function() {
+        stream.write("First message\n", 'utf8', function() {
-                stream.write("First message\n");
+	        that.callback(null, stream);
-                //wait for the file system to catch up with us
+	      });
-                that.callback(null, stream);
+      },
-            });
+      teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-5'),
+      
+      'should create a file with the base name': {
+        topic: function(stream) {
+          fs.readFile(__dirname + '/test-date-rolling-file-stream-5', this.callback);
         },
-        teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-5'),
+        'file should contain first message': function(result) {
-
+          assert.equal(result.toString(), "First message\n");
-        'should create a file with the base name': {
-            topic: function(stream) {
-                fs.readFile(__dirname + '/test-date-rolling-file-stream-5', this.callback);
-            },
-            'file should contain first message': function(result) {
-                assert.equal(result.toString(), "First message\n");
-            }
-        },
-
-        'when the day changes': {
-            topic: function(stream) {
-                testTime = new Date(2012, 8, 13, 0, 10, 12);
-                stream.write("Second message\n");
-                setTimeout(this.callback, 100);
-            },
-            teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-5.2012-09-12'),
-
-
-            'the number of files': {
-                topic: function() {
-                    fs.readdir(__dirname, this.callback);
-                },
-                'should be two': function(files) {
-                    assert.equal(files.filter(function(file) { return file.indexOf('test-date-rolling-file-stream-5') > -1; }).length, 2);
-                }
-            },
-
-            'the file without a date': {
-                topic: function() {
-                    fs.readFile(__dirname + '/test-date-rolling-file-stream-5', this.callback);
-                },
-                'should contain the second message': function(contents) {
-                    assert.equal(contents.toString(), "Second message\n");
-                }
-            },
-
-            'the file with the date': {
-                topic: function() {
-                    fs.readFile(__dirname + '/test-date-rolling-file-stream-5.2012-09-12', this.callback);
-                },
-                'should contain the first message': function(contents) {
-                    assert.equal(contents.toString(), "First message\n");
-                }
-            }
         }
+      },
+      
+      'when the day changes': {
+        topic: function(stream) {
+          testTime = new Date(2012, 8, 13, 0, 10, 12);
+          stream.write("Second message\n", 'utf8', this.callback);
+        },
+        teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-5.2012-09-12'),
+        
+        
+        'the number of files': {
+          topic: function() {
+            fs.readdir(__dirname, this.callback);
+          },
+          'should be two': function(files) {
+            assert.equal(files.filter(function(file) { return file.indexOf('test-date-rolling-file-stream-5') > -1; }).length, 2);
+          }
+        },
+        
+        'the file without a date': {
+          topic: function() {
+            fs.readFile(__dirname + '/test-date-rolling-file-stream-5', this.callback);
+          },
+          'should contain the second message': function(contents) {
+            assert.equal(contents.toString(), "Second message\n");
+          }
+        },
+        
+        'the file with the date': {
+          topic: function() {
+            fs.readFile(__dirname + '/test-date-rolling-file-stream-5.2012-09-12', this.callback);
+          },
+          'should contain the first message': function(contents) {
+            assert.equal(contents.toString(), "First message\n");
+          }
+        }
+      }
     }
     
-}).exportTo(module);
+  }).exportTo(module);
+}

test/streams/bufferedStream-test.js

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