Fixes for version v0.10 streams, breaks log4js for older versions of node

lib/streams/BaseRollingFileStream.js

@@ -1,5 +1,6 @@
 var fs = require('fs'),
-    util = require('util');
+stream = require('stream'),
+util = require('util');
 
 function debug(message) {
 //    console.log(message);
@@ -8,85 +9,64 @@ function debug(message) {
 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");
-    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 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");
-        }
+  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);
+  throwErrorIfArgumentsAreNotValid();
+  debug("Calling BaseRollingFileStream.super");
+  BaseRollingFileStream.super_.call(this);
+  this.openTheStream();
+  this.currentSize = currentFileSize(this.filename);
 }
-util.inherits(BaseRollingFileStream, fs.FileWriteStream);
+util.inherits(BaseRollingFileStream, stream.Writable);
 
-BaseRollingFileStream.prototype.initRolling = function() {
-    var that = this;
+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);
+  }
 
-    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;
-    }
+  debug("in _write");
 
-    this.rolling = true;
-    this.roll(this.filename, function() {
-        that.currentSize = 0;
-        that.rolling = emptyRollingQueue();
-        if (that.rolling) {
-            process.nextTick(function() { that.initRolling(); });
-        }
-    });
+  if (this.shouldRoll()) {
+    this.currentSize = 0;
+    this.roll(this.filename, writeTheChunk);
+  } else {
+    writeTheChunk();
+  }
 };
 
-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);
+BaseRollingFileStream.prototype.openTheStream = function(cb) {
+  debug("opening the underlying stream");
+  this.theStream = fs.createWriteStream(this.filename, this.options);
+  if (cb) {
+    this.theStream.on("open", cb);
+  }
+};
 
-            if (!this.rollBeforeWrite && this.shouldRoll()) {
-                this.initRolling();
-            }
-        }
-    }
-    return canWrite;
+BaseRollingFileStream.prototype.closeTheStream = function(cb) {
+  debug("closing the underlying stream");
+  this.theStream.end(null, null, cb);
 };
 
 BaseRollingFileStream.prototype.shouldRoll = function() {