updated readme with node 0.10 info

Fixes for version v0.10 streams, breaks log4js for older versions of node
bumped version
2013-03-20 09:16:42 +11:00 · 2013-03-20 09:14:27 +11:00 · 2013-02-25 16:33:48 +11:00 · 2013-02-24 21:30:42 -08:00 · 2013-02-21 00:06:59 +09:00 · 2013-02-14 16:32:03 -08:00
26 changed files with 406 additions and 590 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,4 +1,3 @@
 language: node_js
 node_js:
-  - 0.6
-  - 0.8
+  - 0.10
--- a/README.md
+++ b/README.md
@@ -17,14 +17,16 @@ Out of the box it supports the following features:
 * configurable log message layout/patterns
 * different log levels for different log categories (make some parts of your app log as DEBUG, others only ERRORS, etc.)

+NOTE: 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
 {
-    appenders: [
-        { type: "console" }
-    ],
-    replaceConsole: true
+  appenders: [
+    { type: "console" }
+  ],
+  replaceConsole: true
 }
 ```

@@ -36,49 +38,49 @@ npm install log4js
 ## usage

 Minimalist version:
-
-           var log4js = require('log4js');
-           var logger = log4js.getLogger();
-           logger.debug("Some debug messages");
-
+```javascript
+var log4js = require('log4js');
+var logger = log4js.getLogger();
+logger.debug("Some debug messages");
+```
 By default, log4js outputs to stdout with the coloured layout (thanks to [masylum](http://github.com/masylum)), so for the above you would see:
-
-    [2010-01-17 11:43:37.987] [DEBUG] [default] - Some debug messages
-
+```bash
+[2010-01-17 11:43:37.987] [DEBUG] [default] - Some debug messages
+```
 See example.js for a full example, but here's a snippet (also in fromreadme.js):
+```javascript
+var log4js = require('log4js'); 
+//console log is loaded by default, so you won't normally need to do this
+//log4js.loadAppender('console');
+log4js.loadAppender('file');
+//log4js.addAppender(log4js.appenders.console());
+log4js.addAppender(log4js.appenders.file('logs/cheese.log'), 'cheese');

-    var log4js = require('log4js'); 
-    //console log is loaded by default, so you won't normally need to do this
-    //log4js.loadAppender('console');
-    log4js.loadAppender('file');
-    //log4js.addAppender(log4js.appenders.console());
-    log4js.addAppender(log4js.appenders.file('logs/cheese.log'), 'cheese');
-
-    var logger = log4js.getLogger('cheese');
-    logger.setLevel('ERROR');
-
-    logger.trace('Entering cheese testing');
-    logger.debug('Got cheese.');
-    logger.info('Cheese is Gouda.');
-    logger.warn('Cheese is quite smelly.');
-    logger.error('Cheese is too ripe!');
-    logger.fatal('Cheese was breeding ground for listeria.');
+var logger = log4js.getLogger('cheese');
+logger.setLevel('ERROR');

+logger.trace('Entering cheese testing');
+logger.debug('Got cheese.');
+logger.info('Cheese is Gouda.');
+logger.warn('Cheese is quite smelly.');
+logger.error('Cheese is too ripe!');
+logger.fatal('Cheese was breeding ground for listeria.');
+```
 Output:
-
-    [2010-01-17 11:43:37.987] [ERROR] cheese - Cheese is too ripe!
-    [2010-01-17 11:43:37.990] [FATAL] cheese - Cheese was breeding ground for listeria.
-    
+```bash
+[2010-01-17 11:43:37.987] [ERROR] cheese - Cheese is too ripe!
+[2010-01-17 11:43:37.990] [FATAL] cheese - Cheese was breeding ground for listeria.
+```    
 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' }
-            ]
-    });
-    
+```javascript
+var log4js = require('log4js');
+log4js.configure({
+  appenders: [
+    { type: 'console' },
+    { type: 'file', filename: 'logs/cheese.log', category: 'cheese' }
+  ]
+});
+```

 ## configuration

@@ -91,40 +93,43 @@ By default, the configuration file is checked for changes every 60 seconds, and

 To turn off configuration file change checking, configure with:

-    var log4js = require('log4js');
-    log4js.configure('my_log4js_configuration.json', {});
-
+```javascript
+var log4js = require('log4js');
+log4js.configure('my_log4js_configuration.json', {});
+```
 To specify a different period:

-    log4js.configure('file.json', { reloadSecs: 300 });
-
+```javascript
+log4js.configure('file.json', { reloadSecs: 300 });
+```
 For FileAppender you can also pass the path to the log directory as an option where all your log files would be stored.

-    log4js.configure('my_log4js_configuration.json', { cwd: '/absolute/path/to/log/dir' });
-
+```javascript
+log4js.configure('my_log4js_configuration.json', { cwd: '/absolute/path/to/log/dir' });
+```
 If you have already defined an absolute path for one of the FileAppenders in the configuration file, you could add a "absolute": true to the particular FileAppender to override the cwd option passed. Here is an example configuration file:
-
-    #### my_log4js_configuration.json ####
+```json
+#### my_log4js_configuration.json ####
+{
+  "appenders": [
    {
-      "appenders": [
-        {
-          "type": "file",
-          "filename": "relative/path/to/log_file.log",
-          "maxLogSize": 20480,
-          "backups": 3,
-          "category": "relative-logger"
-        },
-        {
-          "type": "file",
-          "absolute": true,
-          "filename": "/absolute/path/to/log_file.log",
-          "maxLogSize": 20480,
-          "backups": 10,
-          "category": "absolute-logger"          
-        }
-      ]
+      "type": "file",
+      "filename": "relative/path/to/log_file.log",
+      "maxLogSize": 20480,
+      "backups": 3,
+      "category": "relative-logger"
+    },
+    {
+      "type": "file",
+      "absolute": true,
+      "filename": "/absolute/path/to/log_file.log",
+      "maxLogSize": 20480,
+      "backups": 10,
+      "category": "absolute-logger"          
    }
-    
+  ]
+}
+```    
 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
--- a/examples/example-connect-logger.js
+++ b/examples/example-connect-logger.js
--- a/examples/example-socket.js
+++ b/examples/example-socket.js
--- a/examples/example.js
+++ b/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: [
--- a/examples/fromreadme.js
+++ b/examples/fromreadme.js
--- a/examples/log-rolling.js
+++ b/examples/log-rolling.js
@@ -1,4 +1,4 @@
-var log4js = require('./lib/log4js')
+var log4js = require('../lib/log4js')
 , log
 , i = 0;
 log4js.configure({
--- a/examples/memory-test.js
+++ b/examples/memory-test.js
--- a/examples/patternLayout-tokens.js
+++ b/examples/patternLayout-tokens.js
@@ -0,0 +1,21 @@
+var log4js = require('./lib/log4js');
+
+var config = {
+    "appenders": [
+      {
+        "type": "console",
+        "layout": {
+          "type": "pattern",
+          "pattern": "%[%r (%x{pid}) %p %c -%] %m%n",
+          "tokens": {
+            "pid" : function() { return process.pid; }
+          }
+        }
+      }
+    ]
+  };
+
+log4js.configure(config, {});
+
+var logger = log4js.getLogger("app");
+logger.info("Test log message");
--- a/lib/appenders/dateFile.js
+++ b/lib/appenders/dateFile.js
@@ -22,7 +22,7 @@ process.on('exit', function() {
 function appender(filename, pattern, layout) {
    layout = layout || layouts.basicLayout;

-    var logFile = new streams.BufferedWriteStream(new streams.DateRollingFileStream(filename, pattern));
+    var logFile = new streams.DateRollingFileStream(filename, pattern);
    openFiles.push(logFile);

    return function(logEvent) {
--- a/lib/appenders/file.js
+++ b/lib/appenders/file.js
@@ -22,53 +22,51 @@ 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;
-    file = path.normalize(file);
-    layout = layout || layouts.basicLayout;
-    numBackups = numBackups === undefined ? 5 : numBackups;
-    //there has to be at least one backup if logSize has been specified
-    numBackups = numBackups === 0 ? 1 : numBackups;
+  var bytesWritten = 0;
+  file = path.normalize(file);
+  layout = layout || layouts.basicLayout;
+  numBackups = numBackups === undefined ? 5 : numBackups;
+  //there has to be at least one backup if logSize has been specified
+  numBackups = numBackups === 0 ? 1 : numBackups;

-    function openTheStream(file, fileSize, numFiles) {
-        var stream;
-        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;
+  function openTheStream(file, fileSize, numFiles) {
+    var stream;
+    if (fileSize) {
+      stream = new streams.RollingFileStream(
+        file,
+        fileSize,
+        numFiles
+      );
+    } else {
+      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;
+  }

-    var logFile = openTheStream(file, logSize, numBackups);
-
-    // push file to the stack of open handlers
-    openFiles.push(logFile);
-
-    return function(loggingEvent) {
-        logFile.write(layout(loggingEvent) + eol, "utf8");
-    };
+  var logFile = openTheStream(file, logSize, numBackups);
+  
+  // push file to the stack of open handlers
+  openFiles.push(logFile);
+  
+  return function(loggingEvent) {
+    logFile.write(layout(loggingEvent) + eol, "utf8");
+  };
 }

 function configure(config, options) {
-    var layout;
-    if (config.layout) {
-	layout = layouts.layout(config.layout.type, config.layout);
-    }
+  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);
-    }
+  if (options && options.cwd && !config.absolute) {
+    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;
--- a/lib/appenders/multiprocess.js
+++ b/lib/appenders/multiprocess.js
@@ -115,11 +115,11 @@ function createAppender(config) {
    }
 }

-function configure(config) {
+function configure(config, options) {
    var actualAppender;
    if (config.appender && config.mode === 'master') {
        log4js.loadAppender(config.appender.type);
-        actualAppender = log4js.appenderMakers[config.appender.type](config.appender);
+        actualAppender = log4js.appenderMakers[config.appender.type](config.appender, options);
        config.actualAppender = actualAppender;
    }
    return createAppender(config);
--- a/lib/layouts.js
+++ b/lib/layouts.js
@@ -10,8 +10,9 @@ var dateFormat = require('./date_format')
    , "coloured": function() { return colouredLayout; }
    , "pattern": function (config) {
 	  var pattern = config.pattern || undefined;
-	  return patternLayout(pattern);
-      }
+	  var tokens = config.tokens || undefined;
+	  return patternLayout(pattern, tokens);
+	}
  }
  , colours = {
      ALL: "grey"
@@ -24,7 +25,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 +58,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 +140,26 @@ function messagePassThroughLayout (loggingEvent) {
 *  - %d date in various formats
 *  - %% %
 *  - %n newline
- * Takes a pattern string and returns a layout function.
+ *  - %x{<tokenname>} add dynamic tokens to your log. Tokens are specified in the tokens parameter
+ * You can use %[ and %] to define a colored block.
+ *
+ * Tokens are specified as simple key:value objects. 
+ * The key represents the token name whereas the value can be a string or function
+ * which is called to extract the value to put in the log message. If token is not
+ * found, it doesn't replace the field.
+ *
+ * A sample token would be: { "pid" : function() { return process.pid; } }
+ *
+ * Takes a pattern string, array of tokens and returns a layout function.
+ * @param {String} Log format pattern String
+ * @param {object} map object of different tokens
+ * @return {Function}
 * @author Stephan Strittmatter
+ * @author Jan Schmidle
 */
-function patternLayout (pattern) {
+function patternLayout (pattern, tokens) {
    var TTCC_CONVERSION_PATTERN  = "%r %p %c - %m%n";
-    var regex = /%(-?[0-9]+)?(\.?[0-9]+)?([cdmnpr%])(\{([^\}]+)\})?|([^%]+)/;
+    var regex = /%(-?[0-9]+)?(\.?[0-9]+)?([\[\]cdmnprx%])(\{([^\}]+)\})?|([^%]+)/;

    pattern = pattern || TTCC_CONVERSION_PATTERN;

@@ -206,9 +226,26 @@ 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;
+		case "x":
+			if(typeof(tokens[specifier]) !== 'undefined') {
+				if(typeof(tokens[specifier]) === 'function') {
+					replacement = tokens[specifier]();
+				} else {
+					replacement = tokens[specifier];
+				}
+			} else {
+				replacement = matchedString;
+			}
+			break;
 		default:
 		    replacement = matchedString;
 		    break;
@@ -248,7 +285,6 @@ function patternLayout (pattern) {

 };

-
 module.exports = {
    basicLayout: basicLayout
  , messagePassThroughLayout: messagePassThroughLayout
--- a/lib/streams/BaseRollingFileStream.js
+++ b/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() {
--- a/lib/streams/BufferedWriteStream.js
+++ b/lib/streams/BufferedWriteStream.js
@@ -1,77 +0,0 @@
-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());
-    }
-};
--- a/lib/streams/DateRollingFileStream.js
+++ b/lib/streams/DateRollingFileStream.js
@@ -23,9 +23,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 +43,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,
-        renameTheCurrentFile,
-        openANewFile
+      this.closeTheStream.bind(this),
+      deleteAnyExistingFile,
+      renameTheCurrentFile,
+      this.openTheStream.bind(this)
    ], callback);

    function deleteAnyExistingFile(cb) {
@@ -69,21 +65,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);
-            }
-        );
-    }
-
-
 };
--- a/lib/streams/RollingFileStream.js
+++ b/lib/streams/RollingFileStream.js
@@ -4,9 +4,9 @@ var BaseRollingFileStream = require('./BaseRollingFileStream'),
    fs = require('fs'),
    async = require('async');

-function debug(message) {
+function debug() {
 //    util.debug(message);
-//    console.log(message);
+//  console.log.apply(console, arguments);
 }

 module.exports = RollingFileStream;
@@ -28,6 +28,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 +82,11 @@ RollingFileStream.prototype.roll = function(filename, callback) {
        });
    }

-    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);
+  debug("Rolling, rolling, rolling");
+  async.series([
+    this.closeTheStream.bind(this),
+    renameTheFiles,
+    this.openTheStream.bind(this)
+  ], callback);

 };
--- a/lib/streams/index.js
+++ b/lib/streams/index.js
@@ -1,3 +1,2 @@
-exports.BufferedWriteStream = require('./BufferedWriteStream');
 exports.RollingFileStream = require('./RollingFileStream');
 exports.DateRollingFileStream = require('./DateRollingFileStream');
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "log4js",
-   "version": "0.5.5",
+   "version": "0.6.0",
   "description": "Port of Log4js to work with node.",
   "keywords": [
       "logging",
@@ -17,7 +17,7 @@
   "bugs": {
       "url": "http://github.com/nomiddlename/log4js-node/issues"
   },
-   "engines": [ "node >=0.6" ],
+   "engines": [ "node >=0.10" ],
   "scripts": {
       "test": "vows"
   },
@@ -26,10 +26,11 @@
       "lib": "lib"
   },
   "dependencies": {
-       "async": "0.1.15"
+       "async": "0.1.15",
+       "dequeue": "1.0.3"
   },
   "devDependencies": {
-       "vows": "0.6.2",
+       "vows": "0.7.0",
       "sandboxed-module": "0.1.3",
       "hook.io": "0.8.10",
       "underscore": "1.2.1"
--- a/test/dateFileAppender-test.js
+++ b/test/dateFileAppender-test.js
@@ -5,13 +5,13 @@ var vows = require('vows'),
    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);
-            }
-        });
-    };
+  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({
--- a/test/fileAppender-test.js
+++ b/test/fileAppender-test.js
@@ -108,7 +108,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,31 +126,31 @@ 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);
-                },
-                'should be empty because the last log message triggers rolling': function(contents) {
-                    assert.isEmpty(contents);
-                }
-            },
-            'and the contents of the second file': {
-                topic: function(logFiles) {
-                    fs.readFile(path.join(__dirname, logFiles[1]), "utf8", this.callback);
+                  fs.readFile(path.join(__dirname, logFiles[0]), "utf8", this.callback);
                },
                'should be the last log message': function(contents) {
                    assert.include(contents, 'This is the fourth log message.');
                }
            },
-            'and the contents of the third file': {
+            'and the contents of the second file': {
                topic: function(logFiles) {
-                    fs.readFile(path.join(__dirname, logFiles[2]), "utf8", this.callback);
+                  fs.readFile(path.join(__dirname, logFiles[1]), "utf8", this.callback);
                },
                'should be the third log message': function(contents) {
                    assert.include(contents, 'This is the third log message.');
                }
+            },
+            'and the contents of the third file': {
+                topic: function(logFiles) {
+                  fs.readFile(path.join(__dirname, logFiles[2]), "utf8", this.callback);
+                },
+                'should be the second log message': function(contents) {
+                    assert.include(contents, 'This is the second log message.');
+                }
            }
        }
    }
--- a/test/layouts-test.js
+++ b/test/layouts-test.js
@@ -4,9 +4,10 @@ assert = require('assert');
 //used for patternLayout tests.
 function test(args, pattern, value) {
    var layout = args[0]
-    , event = args[1];
+    , event = args[1]
+    , tokens = args[2];

-    assert.equal(layout(pattern)(event), value);
+    assert.equal(layout(pattern, tokens)(event), value);
 }

 vows.describe('log4js layouts').addBatch({
@@ -175,8 +176,12 @@ vows.describe('log4js layouts').addBatch({
                level: {
                    toString: function() { return "DEBUG"; }
                }
-            }, layout = require('../lib/layouts').patternLayout;
-            return [layout, event];
+            }, layout = require('../lib/layouts').patternLayout
+            , tokens = {
+                testString: 'testStringToken',
+                testFunction: function() { return 'testFunctionToken'; }
+            };
+            return [layout, event, tokens];
        },

        'should default to "time logLevel loggerName - message"': function(args) {
@@ -243,9 +248,21 @@ 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');
+        },
+        '%x{testString} should output the string stored in tokens': function(args) {
+            test(args, '%x{testString}', 'testStringToken');
+        },
+        '%x{testFunction} should output the result of the function stored in tokens': function(args) {
+            test(args, '%x{testFunction}', 'testFunctionToken');
+        },
+        '%x{doesNotExist} should output the string stored in tokens': function(args) {
+            test(args, '%x{doesNotExist}', '%x{doesNotExist}');
+        },
+        '%x should output the string stored in tokens': function(args) {
+            test(args, '%x', '%x');
+        },
    }
-
 }).export(module);
-
--- a/test/log-abspath-test.js
+++ b/test/log-abspath-test.js
@@ -50,9 +50,10 @@ vows.describe('log4js-abspath').addBatch({
                        {
                            RollingFileStream: function(file) {
                                fileOpened = file;
-                            },
-                            BufferedWriteStream: function(other) {
-                                return { on: function() { }, end: function() {} }
+			      return {
+				on: function() {},
+				end: function() {}
+			      };
                            }
                        }
                      }
--- a/test/streams/DateRollingFileStream-test.js
+++ b/test/streams/DateRollingFileStream-test.js
@@ -1,8 +1,9 @@
-var vows = require('vows'),
-    assert = require('assert'),
-    fs = require('fs'),
-    DateRollingFileStream = require('../../lib/streams').DateRollingFileStream,
-    testTime = new Date(2012, 8, 12, 10, 37, 11);
+var vows = require('vows')
+, assert = require('assert')
+, streams = require('stream')
+, fs = require('fs')
+, DateRollingFileStream = require('../../lib/streams').DateRollingFileStream
+, testTime = new Date(2012, 8, 12, 10, 37, 11);

 function cleanUp(filename) {
    return function() {
@@ -19,15 +20,16 @@ vows.describe('DateRollingFileStream').addBatch({
        topic: new DateRollingFileStream(__dirname + '/test-date-rolling-file-stream-1', 'yyyy-mm-dd.hh'),
        teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-1'),

-        'should take a filename and a pattern and return a 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);
+        'should take a filename and a pattern and return a WritableStream': function(stream) {
+          assert.equal(stream.filename, __dirname + '/test-date-rolling-file-stream-1');
+          assert.equal(stream.pattern, 'yyyy-mm-dd.hh');
+          assert.instanceOf(stream, streams.Writable);
        },
        'with default settings for the underlying stream': function(stream) {
-            assert.equal(stream.mode, 420);
-            assert.equal(stream.flags, 'a');
-            assert.equal(stream.encoding, 'utf8');
+          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');
        }
    },

@@ -45,7 +47,7 @@ vows.describe('DateRollingFileStream').addBatch({
        teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-3'),

        'should pass them to the underlying stream': function(stream) {
-            assert.equal(stream.mode, 0666);
+            assert.equal(stream.theStream.mode, 0666);
        }
    },

@@ -54,7 +56,7 @@ vows.describe('DateRollingFileStream').addBatch({
        teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-4'),

        'should pass them to the underlying stream': function(stream) {
-            assert.equal(stream.mode, 0666);
+            assert.equal(stream.theStream.mode, 0666);
        },
        'should use default pattern': function(stream) {
            assert.equal(stream.pattern, '.yyyy-MM-dd');
@@ -63,13 +65,11 @@ vows.describe('DateRollingFileStream').addBatch({

    '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);
-            });
+          var that = this,
+          stream = new DateRollingFileStream(__dirname + '/test-date-rolling-file-stream-5', '.yyyy-MM-dd', null, now);
+          stream.write("First message\n", 'utf8', function() {
+	    that.callback(null, stream);
+	  });
        },
        teardown: cleanUp(__dirname + '/test-date-rolling-file-stream-5'),

@@ -84,9 +84,8 @@ vows.describe('DateRollingFileStream').addBatch({

        '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);
+              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'),

--- a/test/streams/bufferedStream-test.js
+++ b/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);
--- a/test/streams/rollingFileStream-test.js
+++ b/test/streams/rollingFileStream-test.js
@@ -1,7 +1,9 @@
 var vows = require('vows')
+, async = require('async')
 , assert = require('assert')
 , events = require('events')
 , fs = require('fs')
+, streams = require('stream')
 , RollingFileStream = require('../../lib/streams').RollingFileStream;

 function remove(filename) {
@@ -18,16 +20,17 @@ vows.describe('RollingFileStream').addBatch({
            remove(__dirname + "/test-rolling-file-stream");
            return new RollingFileStream("test-rolling-file-stream", 1024, 5);
        },
-        'should take a filename, file size in bytes, number of backups as arguments and return a 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);
+        'should take a filename, file size in bytes, number of backups as arguments and return a Writable': function(stream) {
+          assert.instanceOf(stream, streams.Writable);
+          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');
-            assert.equal(stream.encoding, 'utf8');
+            assert.equal(stream.theStream.mode, 420);
+            assert.equal(stream.theStream.flags, 'a');
+	  //encoding isn't a property on the underlying stream
+          //assert.equal(stream.theStream.encoding, 'utf8');
        }
    },
    'with stream arguments': {
@@ -36,7 +39,7 @@ vows.describe('RollingFileStream').addBatch({
            return new RollingFileStream('test-rolling-file-stream', 1024, 5, { mode: 0666 });
        },
        'should pass them to the underlying stream': function(stream) {
-            assert.equal(stream.mode, 0666);
+            assert.equal(stream.theStream.mode, 0666);
        }
    },
    'without size': {
@@ -61,66 +64,63 @@ vows.describe('RollingFileStream').addBatch({
        }
    },
    'writing less than the file size': {
+      topic: function() {
+        remove(__dirname + "/test-rolling-file-stream-write-less");
+        var that = this, stream = new RollingFileStream(__dirname + "/test-rolling-file-stream-write-less", 100);
+        stream.write("cheese", "utf8", function() {
+          stream.end();
+          fs.readFile(__dirname + "/test-rolling-file-stream-write-less", "utf8", that.callback);
+	});
+      },
+      'should write to the file': function(contents) {
+        assert.equal(contents, "cheese");
+      },
+      'the number of files': {
        topic: function() {
-            remove(__dirname + "/test-rolling-file-stream-write-less");
-            var that = this, stream = new RollingFileStream(__dirname + "/test-rolling-file-stream-write-less", 100);
-            stream.on("open", function() { that.callback(null, stream); });
+          fs.readdir(__dirname, this.callback);
        },
-        '(when open)': {
-            topic: function(stream) {
-                stream.write("cheese", "utf8");
-                stream.end();
-                fs.readFile(__dirname + "/test-rolling-file-stream-write-less", "utf8", this.callback);
-            },
-            'should write to the file': function(contents) {
-                assert.equal(contents, "cheese");
-            },
-            'the number of files': {
-                topic: function() {
-                    fs.readdir(__dirname, this.callback);
-                },
-                'should be one': function(files) {
-                    assert.equal(files.filter(function(file) { return file.indexOf('test-rolling-file-stream-write-less') > -1; }).length, 1);
-                }
-            }
+        '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");
-            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);
-            });
+          fs.readdir(__dirname, this.callback);
        },
-        '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-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');
-            }
+        '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');
+        }
+      }
    }
 }).exportTo(module);
Author	SHA1	Message	Date
Gareth Jones	ecbf41bc83	updated readme with node 0.10 info	2013-03-20 09:16:42 +11:00
Gareth Jones	65e490cbd2	Fixes for version v0.10 streams, breaks log4js for older versions of node	2013-03-20 09:14:27 +11:00
Gareth Jones	5e242c9dc9	bumped version	2013-02-25 16:33:48 +11:00
Gareth Jones	50eefcc701	Merge pull request #116 from imkira/master Pass options from multiprocess appender to inner appender	2013-02-24 21:30:42 -08:00
Mário Freitas	8e53c6213e	fix: pass options from multiprocess appender to inner appender	2013-02-21 00:06:59 +09:00
Gareth Jones	a15a628311	Merge pull request #115 from NicolasPelletier/master Speed up file logging for high rate of logging.	2013-02-14 16:32:03 -08:00
Nicolas Pelletier	b75e3660f4	Speed up file logging for high rate of logging. During an evaluation of multiple loggers, I saw a slow down when trying to quickly log more than 100,000 messages to a file: ```javascript counter = 150000; while (counter) { logger.info('Message[' + counter + ']'); counter -= 1; } ``` My detailed test can be found here: - https://gist.github.com/NicolasPelletier/4773843 The test demonstrate that writing 150,000 lines straight in a FileStream takes about 22 seconds until the file content stabilizes. When calling logger.debug() 150,000 times, the file stabilizes to its final content after 229s ( almost 4 minutes ! ). After investigation, it turns out that the problem is using an Array() to accumulate the data. Pushing the data in the Array with Array.push() is quick, but the code flushing the buffer uses Array.shift(), which forces re-indexing of all 149,999 elements remaining in the Array. This is exponentially slower as the buffer grows. The solution is to use something else than an Array to accumulate the messages. The fix was made using a package called Dequeue ( https://github.com/lleo/node-dequeue ). By replacing the Array with a Dequeue object, it brought the logging of 150,000 messages back down to 31s. Seven times faster than the previous 229s. There is a caveat that each log event is slightly longer due to the need to create an object to put in the double-ended queue inside the Dequeue object. According to a quick test, it takes about 4% more time per call to logger.debug().	2013-02-13 09:35:02 -05:00
Gareth Jones	22da6226e5	Merge pull request #113 from bitcloud/patternLayout_tokens add your own tokens to the patternLayout	2013-02-11 13:45:18 -08:00
Jan Schmidle	a3bdac8e14	updated require in example to match other examles	2013-02-08 16:22:29 +01:00
Jan Schmidle	af428c5669	added example on pattern tokens usage	2013-02-08 16:18:27 +01:00
Jan Schmidle	5c75ba9468	fixed small issue that could occur with wrong evaluated parameters	2013-02-08 16:17:24 +01:00
Jan Schmidle	bec0d05847	added some documentation to the function header	2013-02-08 16:15:51 +01:00
Jan Schmidle	e4bf405f20	add your own tokens to the patternLayout	2013-02-08 14:54:18 +01:00
Gareth Jones	95568f352b	Merge pull request #110 from Dignifiedquire/fix-2 Move examples into their own directory.	2013-01-20 16:15:53 -08:00
Gareth Jones	6da6f3c90e	Merge pull request #109 from Dignifiedquire/fix-1 Misc code highlighting fixes in readme.md	2013-01-20 14:16:04 -08:00
Friedel Ziegelmayer	7f57d14e70	Move examples into their own directory.	2013-01-19 22:14:14 +01:00
Friedel Ziegelmayer	f478793da3	Misc code highlighting fixes in readme.md	2013-01-19 22:09:31 +01:00
Gareth Jones	ec2f8fec3b	Merge pull request #105 from ulikoehler/readme-syntax-highlighting Added syntax highlighting to JS code in README.md	2013-01-06 13:33:52 -08:00
Uli Köhler	0167c84ea5	Added syntax highlighting to JS code in README.md	2013-01-06 01:09:55 +01:00
Gareth Jones	3e1a27e522	New version, with colours in pattern layout	2012-12-03 09:59:36 +11:00
Gareth Jones	8b42e46071	Merge pull request #101 from Dignifiedquire/feature-color-pattern [feature] Add patternColoured Layout.	2012-12-02 14:51:27 -08:00
Friedel Ziegelmayer	4a7a90ed53	[feature] Add color option to pattern layout. Based on #90 this implements the possibillity to add the color codes according to the log level via %[ and %].	2012-12-02 23:41:59 +01:00