Merge pull request #101 from Dignifiedquire/feature-color-pattern

[feature] Add patternColoured Layout.

README.md

@@ -73,17 +73,19 @@ The first 5 lines of the code above could also be written as:
 
     var log4js = require('log4js');
     log4js.configure({
-	    appenders: [
-		    { type: 'console' },
-		    { type: 'file', filename: 'logs/cheese.log', category: 'cheese' }
-	    ]
+            appenders: [
+                    { type: 'console' },
+                    { type: 'file', filename: 'logs/cheese.log', category: 'cheese' }
+            ]
     });
     
 
 ## configuration
 
 You can configure the appenders and log levels manually (as above), or provide a
-configuration file (`log4js.configure('path/to/file.json')`), or a configuration object.
+configuration file (`log4js.configure('path/to/file.json')`), or a configuration object. The 
+configuration file location may also be specified via the environment variable 
+LOG4JS_CONFIG (`export LOG4JS_CONFIG=path/to/file.json`). 
 An example file can be found in `test/log4js.json`. An example config file with log rolling is in `test/with-log-rolling.json`.
 By default, the configuration file is checked for changes every 60 seconds, and if changed, reloaded. This allows changes to logging levels to occur without restarting the application.
 
@@ -110,7 +112,6 @@ If you have already defined an absolute path for one of the FileAppenders in the
           "filename": "relative/path/to/log_file.log",
           "maxLogSize": 20480,
           "backups": 3,
-          "pollInterval": 15,
           "category": "relative-logger"
         },
         {
@@ -119,7 +120,6 @@ If you have already defined an absolute path for one of the FileAppenders in the
           "filename": "/absolute/path/to/log_file.log",
           "maxLogSize": 20480,
           "backups": 10,
-          "pollInterval": 15,
           "category": "absolute-logger"          
         }
       ]

lib/appenders/dateFile.js

@@ -0,0 +1,49 @@
+var streams = require('../streams'),
+    layouts = require('../layouts'),
+    path = require('path'),
+    os = require('os'),
+    eol = os.EOL || '\n',
+    openFiles = [];
+
+//close open files on process exit.
+process.on('exit', function() {
+    openFiles.forEach(function (file) {
+        file.end();
+    });
+});
+
+/**
+ * File appender that rolls files according to a date pattern.
+ * @filename base filename.
+ * @pattern the format that will be added to the end of filename when rolling,
+ *          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, layout) {
+    layout = layout || layouts.basicLayout;
+
+    var logFile = new streams.BufferedWriteStream(new streams.DateRollingFileStream(filename, pattern));
+    openFiles.push(logFile);
+
+    return function(logEvent) {
+        logFile.write(layout(logEvent) + eol, "utf8");
+    };
+
+}
+
+function configure(config, options) {
+    var layout;
+
+    if (config.layout) {
+	layout = layouts.layout(config.layout.type, config.layout);
+    }
+
+    if (options && options.cwd && !config.absolute) {
+        config.filename = path.join(options.cwd, config.filename);
+    }
+
+    return appender(config.filename, config.pattern, layout);
+}
+
+exports.appender = appender;
+exports.configure = configure;

lib/appenders/file.js

@@ -1,12 +1,17 @@
 var layouts = require('../layouts')
-, path = require('path')
-, fs = require('fs')
-, streams = require('../streams')
-, os = require('os')
-, eol = os.EOL || '\n';
+  , path = require('path')
+  , fs = require('fs')
+  , streams = require('../streams')
+  , os = require('os')
+  , eol = os.EOL || '\n'
+  , openFiles = [];
 
-var openFiles = [];
-var listenerAtttached = false;
+//close open files on process exit.
+process.on('exit', function() {
+    openFiles.forEach(function (file) {
+        file.end();
+    });
+});
 
 /**
  * File Appender writing the logs to a text file. Supports rolling of logs by size.
@@ -48,16 +53,6 @@ function fileAppender (file, layout, logSize, numBackups) {
     // push file to the stack of open handlers
     openFiles.push(logFile);
 
-    //close the file on process exit.
-    if (!listenerAtttached) {
-        listenerAtttached = true;
-        process.on('exit', function() {
-            openFiles.forEach(function (file) {
-                file.end();
-            });
-        });
-    }
-
     return function(loggingEvent) {
         logFile.write(layout(loggingEvent) + eol, "utf8");
     };

lib/appenders/multiprocess.js

@@ -16,20 +16,15 @@ function logServer(config) {
     function deserializeLoggingEvent(clientSocket, msg) {
         var loggingEvent;
         try {
-            loggingEvent = JSON.parse(msg);
-            loggingEvent.startTime = new Date(loggingEvent.startTime);
-            loggingEvent.level.toString = function levelToString() {
-                return loggingEvent.level.levelStr;
-            };
+          loggingEvent = JSON.parse(msg);
+          loggingEvent.startTime = new Date(loggingEvent.startTime);
+	        loggingEvent.level = log4js.levels.toLevel(loggingEvent.level.levelStr);
         } catch (e) {
             // JSON.parse failed, just log the contents probably a naughty.
             loggingEvent = {
                 startTime: new Date(),
                 categoryName: 'log4js',
-                level: { toString: function () {
-                             return 'ERROR';
-                         }
-                       },
+                level: log4js.levels.ERROR,
                 data: [ 'Unable to parse log:', msg ]
             };
         }

lib/layouts.js

@@ -24,7 +24,6 @@ var dateFormat = require('./date_format')
     , OFF: "grey"
   };
 
-
 function formatLogData(logData) {
     var output = ""
       , data = Array.isArray(logData) ? logData.slice() : Array.prototype.slice.call(arguments)
@@ -58,30 +57,36 @@ function formatLogData(logData) {
     return output;
 }
 
+var styles = {
+    //styles
+    'bold'      : [1,  22],
+    'italic'    : [3,  23],
+    'underline' : [4,  24],
+    'inverse'   : [7,  27],
+    //grayscale
+    'white'     : [37, 39],
+    'grey'      : [90, 39],
+    'black'     : [90, 39],
+    //colors
+    'blue'      : [34, 39],
+    'cyan'      : [36, 39],
+    'green'     : [32, 39],
+    'magenta'   : [35, 39],
+    'red'       : [31, 39],
+    'yellow'    : [33, 39]
+};
+
+function colorizeStart(style) {
+  return style ? '\033[' + styles[style][0] + 'm' : '';
+}
+function colorizeEnd(style) {
+  return style ? '\033[' + styles[style][1] + 'm' : '';
+}
 /**
  * Taken from masylum's fork (https://github.com/masylum/log4js-node)
  */
 function colorize (str, style) {
-    var styles = {
-        //styles
-        'bold'      : [1,  22],
-        'italic'    : [3,  23],
-        'underline' : [4,  24],
-        'inverse'   : [7,  27],
-        //grayscale
-        'white'     : [37, 39],
-        'grey'      : [90, 39],
-        'black'     : [90, 39],
-        //colors
-        'blue'      : [34, 39],
-        'cyan'      : [36, 39],
-        'green'     : [32, 39],
-        'magenta'   : [35, 39],
-        'red'       : [31, 39],
-        'yellow'    : [33, 39]
-    };
-    return style ? '\033[' + styles[style][0] + 'm' + str +
-        '\033[' + styles[style][1] + 'm' : str;
+    return colorizeStart(style) + str + colorizeEnd(style);
 }
 
 function timestampLevelAndCategory(loggingEvent, colour) {
@@ -134,12 +139,13 @@ function messagePassThroughLayout (loggingEvent) {
  *  - %d date in various formats
  *  - %% %
  *  - %n newline
+ * You can use %[ and %] to define a colored block.
  * Takes a pattern string and returns a layout function.
  * @author Stephan Strittmatter
  */
 function patternLayout (pattern) {
     var TTCC_CONVERSION_PATTERN  = "%r %p %c - %m%n";
-    var regex = /%(-?[0-9]+)?(\.?[0-9]+)?([cdmnpr%])(\{([^\}]+)\})?|([^%]+)/;
+    var regex = /%(-?[0-9]+)?(\.?[0-9]+)?([\[\]cdmnpr%])(\{([^\}]+)\})?|([^%]+)/;
 
     pattern = pattern || TTCC_CONVERSION_PATTERN;
 
@@ -206,6 +212,12 @@ function patternLayout (pattern) {
 		case "r":
 		    replacement = "" + loggingEvent.startTime.toLocaleTimeString();
 		    break;
+		case "[":
+		    replacement = colorizeStart(colours[loggingEvent.level.toString()]);
+		    break;
+		case "]":
+		    replacement = colorizeEnd(colours[loggingEvent.level.toString()]);
+		    break;
 		case "%":
 		    replacement = "%";
 		    break;
@@ -248,7 +260,6 @@ function patternLayout (pattern) {
 
 };
 
-
 module.exports = {
     basicLayout: basicLayout
   , messagePassThroughLayout: messagePassThroughLayout

lib/log4js.js

@@ -240,8 +240,9 @@ function initReloadConfiguration(filename, options) {
 
 function configure(configurationFileOrObject, options) {
     var config = configurationFileOrObject;
+    config = config || process.env.LOG4JS_CONFIG;
     options = options || {};
-
+  
     if (config === undefined || config === null || typeof(config) === 'string') {
         if (options.reloadSecs) {
             initReloadConfiguration(config, options);

lib/streams.js

@@ -1,268 +0,0 @@
-var util = require('util'),
-fs = require('fs'),
-path = require('path'),
-events = require('events'),
-async = require('async');
-
-function debug(message) {
-//    util.debug(message);
-//    console.log(message);
-}
-
-function BufferedWriteStream(stream) {
-    var that = this;
-    this.stream = stream;
-    this.buffer = [];
-    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());
-    }
-};
-
-function BaseRollingFileStream(filename, options) {
-    this.filename = filename;
-    this.options = options || { encoding: 'utf8', mode: 0644, flags: 'a' };
-    this.rolling = false;
-    this.writesWhileRolling = [];
-    this.currentSize = 0;
-
-    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();
-
-    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) {
-    if (this.rolling) {
-        this.writesWhileRolling.push({ data: data, encoding: encoding });
-        return false;
-    } else {
-        var canWrite = BaseRollingFileStream.super_.prototype.write.call(this, data, encoding);
-        this.currentSize += data.length;
-        debug('current size = ' + this.currentSize);
-        if (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
-};
-
-
-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);
-
-};
-
-
-exports.BaseRollingFileStream = BaseRollingFileStream;
-exports.RollingFileStream = RollingFileStream;
-exports.BufferedWriteStream = BufferedWriteStream;

lib/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/streams/BufferedWriteStream.js

@@ -0,0 +1,77 @@
+var events = require('events'),
+    util = require('util');
+
+module.exports = BufferedWriteStream;
+
+function BufferedWriteStream(stream) {
+    var that = this;
+    this.stream = stream;
+    this.buffer = [];
+    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

@@ -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/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/streams/index.js

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

package.json

@@ -1,6 +1,6 @@
 {
    "name": "log4js",
-   "version": "0.5.2",
+   "version": "0.5.5",
    "description": "Port of Log4js to work with node.",
    "keywords": [
        "logging",

test/configuration-test.js

@@ -84,6 +84,48 @@ vows.describe('log4js configure').addBatch({
             'should add appender configure function to appenderMakers': function(log4js) {
                 assert.isFunction(log4js.appenderMakers['some/other/external']);
             }
+        },
+        'when configuration file loaded via LOG4JS_CONFIG environment variable': {
+          topic: function() {
+            process.env.LOG4JS_CONFIG = 'some/path/to/mylog4js.json';
+            var fileRead = 0,
+            modulePath = 'some/path/to/mylog4js.json',
+            pathsChecked = [],
+            mtime = new Date(),
+            fakeFS = {
+                config: { appenders: [ { type: 'console', layout: { type: 'messagePassThrough' } } ],
+                          levels: { 'a-test' : 'INFO' } },
+                readdirSync: function(dir) {
+                    return require('fs').readdirSync(dir);
+                },
+                readFileSync: function (file, encoding) {
+                    fileRead += 1;
+                    assert.isString(file);
+                    assert.equal(file, modulePath);
+                    assert.equal(encoding, 'utf8');
+                    return JSON.stringify(fakeFS.config);
+                },
+                statSync: function (path) {
+                    pathsChecked.push(path);
+                    if (path === modulePath) {
+                        return { mtime: mtime };
+                    } else {
+                        throw new Error("no such file");
+                    }
+                }
+            },
+            log4js = sandbox.require('../lib/log4js',
+                                     {
+                                       requires: {
+                                         'fs': fakeFS,
+                                       }
+                                     });
+            delete process.env.LOG4JS_CONFIG;
+            return fileRead;
+          },
+          'should load the specified local configuration file' : function(fileRead) {
+            assert.equal(fileRead, 1);
+          }
         }
     }
 }).exportTo(module);

test/dateFileAppender-test.js

@@ -0,0 +1,98 @@
+var vows = require('vows'),
+    assert = require('assert'),
+    path = require('path'),
+    fs = require('fs'),
+    log4js = require('../lib/log4js');
+
+function removeFile(filename) {
+    return function() {
+        fs.unlink(path.join(__dirname, filename), function(err) {
+            if (err) {
+                console.log("Could not delete ", filename, err);
+            }
+        });
+    };
+}
+
+vows.describe('../lib/appenders/dateFile').addBatch({
+    'appender': {
+        'adding multiple dateFileAppenders': {
+            topic: function () {
+                var listenersCount = process.listeners('exit').length,
+                    dateFileAppender = require('../lib/appenders/dateFile'),
+                    count = 5,
+                    logfile;
+
+                while (count--) {
+                    logfile = path.join(__dirname, 'datefa-default-test' + count + '.log');
+                    log4js.addAppender(dateFileAppender.appender(logfile));
+                }
+
+                return listenersCount;
+            },
+            teardown: function() {
+                removeFile('datefa-default-test0.log')();
+                removeFile('datefa-default-test1.log')();
+                removeFile('datefa-default-test2.log')();
+                removeFile('datefa-default-test3.log')();
+                removeFile('datefa-default-test4.log')();
+            },
+
+            'should only add one `exit` listener': function (initialCount) {
+                assert.equal(process.listeners('exit').length, initialCount + 1);
+            }
+        },
+
+        'with default settings': {
+            topic: function() {
+                var that = this,
+                    testFile = path.join(__dirname, 'date-appender-default.log'),
+                    appender = require('../lib/appenders/dateFile').appender(testFile),
+                    logger = log4js.getLogger('default-settings');
+                log4js.clearAppenders();
+                log4js.addAppender(appender, 'default-settings');
+
+                logger.info("This should be in the file.");
+
+                setTimeout(function() {
+                    fs.readFile(testFile, "utf8", that.callback);
+                }, 100);
+
+            },
+            teardown: removeFile('date-appender-default.log'),
+
+            'should write to the file': function(contents) {
+                assert.include(contents, 'This should be in the file');
+            },
+
+            'should use the basic layout': function(contents) {
+                assert.match(contents, /\[\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}\.\d{3}\] \[INFO\] default-settings - /);
+            }
+        }
+
+    }
+}).addBatch({
+    'configure': {
+        'with dateFileAppender': {
+	    topic: function() {
+	        var log4js = require('../lib/log4js')
+                  , logger;
+	        //this config file defines one file appender (to ./date-file-test.log)
+	        //and sets the log level for "tests" to WARN
+                log4js.configure('test/with-dateFile.json');
+                logger = log4js.getLogger('tests');
+	        logger.info('this should not be written to the file');
+	        logger.warn('this should be written to the file');
+
+                fs.readFile(path.join(__dirname, 'date-file-test.log'), 'utf8', this.callback);
+	    },
+            teardown: removeFile('date-file-test.log'),
+
+	    'should load appender configuration from a json file': function(err, contents) {
+	        assert.include(contents, 'this should be written to the file\n');
+                assert.equal(contents.indexOf('this should not be written to the file'), -1);
+	    }
+        }
+
+    }
+}).exportTo(module);

test/layouts-test.js

@@ -243,9 +243,9 @@ vows.describe('log4js layouts').addBatch({
             test(args, '%-6p', 'DEBUG ');
             test(args, '%-8p', 'DEBUG   ');
             test(args, '%-10p', 'DEBUG     ');
+        },
+        '%[%r%] should output colored time': function(args) {
+            test(args, '%[%r%]', '\033[36m14:18:30\033[39m');
         }
-
     }
-
 }).export(module);
-

test/logging-test.js

@@ -115,8 +115,7 @@ vows.describe('log4js').addBatch({
                         "type" : "file",
                         "filename" : "cheesy-wotsits.log",
                         "maxLogSize" : 1024,
-                        "backups" : 3,
-                        "pollInterval" : 15
+                        "backups" : 3
                     }
                 ]
             };

test/multiprocess-test.js

@@ -181,14 +181,14 @@ vows.describe('Multiprocess Appender').addBatch({
         },
         'when a client connects': {
             topic: function(net) {
-                var logString = JSON.stringify({ level: 'DEBUG', data: ['some debug']}) + '__LOG4JS__';
+              var logString = JSON.stringify({ level: { level: 10000, levelStr: 'DEBUG' }, data: ['some debug']}) + '__LOG4JS__';
 
                 net.cbs['connect']();
-                net.cbs['data'](JSON.stringify({ level: 'ERROR', data: ['an error message'] }) + '__LOG4JS__');
+                net.cbs['data'](JSON.stringify({ level: { level: 40000, levelStr: 'ERROR' }, data: ['an error message'] }) + '__LOG4JS__');
                 net.cbs['data'](logString.substring(0, 10));
                 net.cbs['data'](logString.substring(10));
                 net.cbs['data'](logString + logString + logString);
-                net.cbs['end'](JSON.stringify({ level: 'FATAL', data: ["that's all folks"] }) + '__LOG4JS__');
+                net.cbs['end'](JSON.stringify({ level:  { level: 50000, levelStr: 'FATAL' }, data: ["that's all folks"] }) + '__LOG4JS__');
                 net.cbs['data']('bad message__LOG4JS__');
                 return net;
             },

test/streams/DateRollingFileStream-test.js

@@ -0,0 +1,123 @@
+var vows = require('vows'),
+    assert = require('assert'),
+    fs = require('fs'),
+    DateRollingFileStream = require('../../lib/streams').DateRollingFileStream,
+    testTime = new Date(2012, 8, 12, 10, 37, 11);
+
+function cleanUp(filename) {
+    return function() {
+        fs.unlink(filename);
+    };
+}
+
+function now() {
+    return testTime.getTime();
+}
+
+vows.describe('DateRollingFileStream').addBatch({
+    'arguments': {
+        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) {
+            assert.equal(stream.filename, __dirname + '/test-date-rolling-file-stream-1');
+            assert.equal(stream.pattern, 'yyyy-mm-dd.hh');
+            assert.instanceOf(stream, fs.FileWriteStream);
+        },
+        'with default settings for the underlying stream': function(stream) {
+            assert.equal(stream.mode, 420);
+            assert.equal(stream.flags, 'a');
+            assert.equal(stream.encoding, 'utf8');
+        }
+    },
+
+    'default arguments': {
+        topic: new DateRollingFileStream(__dirname + '/test-date-rolling-file-stream-2'),
+        teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-2'),
+
+        'pattern should be .yyyy-MM-dd': function(stream) {
+            assert.equal(stream.pattern, '.yyyy-MM-dd');
+        }
+    },
+
+    'with stream arguments': {
+        topic: new DateRollingFileStream(__dirname + '/test-date-rolling-file-stream-3', 'yyyy-MM-dd', { mode: 0666 }),
+        teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-3'),
+
+        'should pass them to the underlying stream': function(stream) {
+            assert.equal(stream.mode, 0666);
+        }
+    },
+
+    'with stream arguments but no pattern': {
+        topic: new DateRollingFileStream(__dirname + '/test-date-rolling-file-stream-4', { mode: 0666 }),
+        teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-4'),
+
+        'should pass them to the underlying stream': function(stream) {
+            assert.equal(stream.mode, 0666);
+        },
+        'should use default pattern': function(stream) {
+            assert.equal(stream.pattern, '.yyyy-MM-dd');
+        }
+    },
+
+    'with a pattern of .yyyy-MM-dd': {
+        topic: function() {
+            var that = this,
+                stream = new DateRollingFileStream(__dirname + '/test-date-rolling-file-stream-5', '.yyyy-MM-dd', null, now);
+            stream.on("open", function() {
+                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'),
+
+        '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");
+                }
+            }
+        }
+    }
+
+}).exportTo(module);

test/streams/bufferedStream-test.js

@@ -1,7 +1,7 @@
 var vows = require('vows')
 , assert = require('assert')
 , events = require('events')
-, BufferedWriteStream = require('../lib/streams').BufferedWriteStream;
+, BufferedWriteStream = require('../../lib/streams').BufferedWriteStream;
 
 function FakeStream() {
     this.writes = [];
@@ -127,4 +127,4 @@ vows.describe('BufferedWriteStream').addBatch({
         }
     }
 
-}).exportTo(module);
+}).exportTo(module);

test/streams/rollingFileStream-test.js

@@ -2,7 +2,7 @@ var vows = require('vows')
 , assert = require('assert')
 , events = require('events')
 , fs = require('fs')
-, RollingFileStream = require('../lib/streams').RollingFileStream;
+, RollingFileStream = require('../../lib/streams').RollingFileStream;
 
 function remove(filename) {
     try {
@@ -19,11 +19,11 @@ vows.describe('RollingFileStream').addBatch({
             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) {
-                                                                              assert.instanceOf(stream, fs.FileWriteStream);
-                                                                              assert.equal(stream.filename, "test-rolling-file-stream");
-                                                                              assert.equal(stream.size, 1024);
-                                                                              assert.equal(stream.backups, 5);
-                                                                          },
+            assert.instanceOf(stream, fs.FileWriteStream);
+            assert.equal(stream.filename, "test-rolling-file-stream");
+            assert.equal(stream.size, 1024);
+            assert.equal(stream.backups, 5);
+        },
         'with default settings for the underlying stream': function(stream) {
             assert.equal(stream.mode, 420);
             assert.equal(stream.flags, 'a');

test/with-dateFile.json

@@ -0,0 +1,17 @@
+{
+  "appenders": [
+    { 
+      "category": "tests", 
+      "type": "dateFile", 
+      "filename": "test/date-file-test.log",
+      "pattern": "-from-MM-dd", 
+      "layout": { 
+        "type": "messagePassThrough" 
+      } 
+    }
+  ],
+  
+  "levels": {
+    "tests":  "WARN"
+  }
+}

test/with-log-rolling.json

@@ -4,8 +4,7 @@
       "type": "file",
       "filename": "tmp-test.log",
       "maxLogSize": 1024,
-      "backups": 3,
-      "pollInterval": 15
+      "backups": 3
     }
   ]
-}
+}