updated npm version number

Global log level

LICENSE.txt

@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

README.md

@@ -2,9 +2,9 @@
 
 This is a conversion of the [log4js](http://log4js.berlios.de/index.html) 
 framework to work with [node](http://nodejs.org). I've mainly stripped out the browser-specific code
-and tidied up some of the javascript. It includes a basic file logger, with log rolling based on file size.
+and tidied up some of the javascript. It includes a basic file logger, with log rolling based on file size, and also replaces node's console.log functions. 
 
-NOTE: since v0.2.0 require('log4js') returns a function, so you need to call that function in your code before you can use it. I've done this to make testing easier (allows dependency injection).
+NOTE: in v0.2.x require('log4js') returned a function, and you needed to call that function in your code before you could use it. This was to make testing easier. v0.3.x make use of [felixge's sandbox-module](https://github.com/felixge/node-sandboxed-module), so we don't need to return a function.
 
 ## installation
 
@@ -12,20 +12,23 @@ npm install log4js
 
 ## tests
 
-Tests now use [vows](http://vowsjs.org), run with `vows test/logging.js`. I am slowly porting the previous tests from jspec (run those with `node tests.js`), since jspec is no longer maintained.
+Tests now use [vows](http://vowsjs.org), run with `vows test/*.js`. 
 
 ## usage
 
 Minimalist version:
-           var log4js = require('log4js')();
+
+           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
 
 See example.js:
 
-    var log4js = require('log4js')(); //note the need to call the function
+    var log4js = require('log4js'); //note the need to call the function
     log4js.addAppender(log4js.consoleAppender());
     log4js.addAppender(log4js.fileAppender('logs/cheese.log'), 'cheese');
     
@@ -39,7 +42,8 @@ See example.js:
     logger.error('Cheese is too ripe!');
     logger.fatal('Cheese was breeding ground for listeria.');
   
-Output
+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.
 
@@ -49,12 +53,34 @@ Output
 You can either configure the appenders and log levels manually (as above), or provide a 
 configuration file (`log4js.configure('path/to/file.json')`) explicitly, or just let log4js look for a file called `log4js.json` (it looks in the current directory first, then the require paths, and finally looks for the default config included in the same directory as the `log4js.js` file). 
 An example file can be found in `test/log4js.json`. An example config file with log rolling is in `test/with-log-rolling.json`
+You can also pass an object to the configure function, which has the same properties as the json versions.
 
-## todo
+## connect/express logger
 
-patternLayout has no tests. This is mainly because I haven't found a use for it yet, 
+A connect/express logger has been added to log4js, by [danbell](https://github.com/danbell). This allows connect/express servers to log using log4js. See example-connect-logger.js. 
-and am not entirely sure what it was supposed to do. It is more-or-less intact from 
+
-the original log4js.
+    var log4js = require('./lib/log4js');
+    log4js.addAppender(log4js.consoleAppender());
+    log4js.addAppender(log4js.fileAppender('cheese.log'), 'cheese');
+      
+    var logger = log4js.getLogger('cheese');
+    
+    logger.setLevel('INFO');
+    
+    var app = require('express').createServer();
+    app.configure(function() {
+        app.use(log4js.connectLogger(logger, { level: log4js.levels.INFO }));
+    });
+    app.get('/', function(req,res) {
+        res.send('hello world');
+    });
+    app.listen(5000);
+
+The options object that is passed to log4js.connectLogger supports a format string the same as the connect/express logger. For example:
+
+    app.configure(function() {
+        app.use(log4js.connectLogger(logger, { level: log4js.levels.INFO, format: ':method :url' }));
+    });
 
 ## author (of this node version)
 

example-connect-logger.js

@@ -0,0 +1,14 @@
+var log4js = require('./lib/log4js');
+log4js.addAppender(log4js.fileAppender('cheese.log'), 'cheese');
+
+var logger = log4js.getLogger('cheese');
+logger.setLevel('INFO');
+
+var app = require('express').createServer();
+app.configure(function() {
+    app.use(log4js.connectLogger(logger, { level: log4js.levels.INFO }));
+});
+app.get('/', function(req,res) {
+    res.send('hello world');
+});
+app.listen(5000);

example.js

@@ -1,13 +1,22 @@
-var log4js = require('./lib/log4js')();
+var log4js = require('./lib/log4js');
-log4js.addAppender(log4js.consoleAppender());
+//log the cheese logger messages to a file, and the console ones as well.
-log4js.addAppender(log4js.fileAppender('cheese.log'), 'cheese');
+log4js.addAppender(log4js.fileAppender('cheese.log'), 'cheese', 'console');
-  
+
 var logger = log4js.getLogger('cheese');
+//only errors and above get logged.
 logger.setLevel('ERROR');
 
+//console logging methds have been replaced with log4js ones.
+console.error("AAArgh! Something went wrong", { some: "otherObject", useful_for: "debug purposes" });
+
+//these will not appear (logging level beneath error)
 logger.trace('Entering cheese testing');
 logger.debug('Got cheese.');
-logger.info('Cheese is Gouda.');  
+logger.info('Cheese is Gouda.');
 logger.warn('Cheese is quite smelly.');
-logger.error('Cheese is too ripe!');
+//these end up on the console and in cheese.log
+logger.error('Cheese %s is too ripe!', "gouda");
 logger.fatal('Cheese was breeding ground for listeria.');
+
+
+

lib/connect-logger.js

@@ -0,0 +1,114 @@
+var levels = require("./levels");
+/**
+ * Log requests with the given `options` or a `format` string.
+ *
+ * Options:
+ *
+ *   - `format`        Format string, see below for tokens
+ *   - `level`         A log4js levels instance.
+ *
+ * Tokens:
+ *
+ *   - `:req[header]` ex: `:req[Accept]`
+ *   - `:res[header]` ex: `:res[Content-Length]`
+ *   - `:http-version`
+ *   - `:response-time`
+ *   - `:remote-addr`
+ *   - `:date`
+ *   - `:method`
+ *   - `:url`
+ *   - `:referrer`
+ *   - `:user-agent`
+ *   - `:status`
+ *
+ * @param {String|Function|Object} format or options
+ * @return {Function}
+ * @api public
+ */
+
+function getLogger(logger4js, options) {
+    if ('object' == typeof options) {
+	options = options || {};
+    } else if (options) {
+	options = { format: options };
+    } else {
+	options = {};
+    }
+
+    var thislogger = logger4js
+  , level = levels.toLevel(options.level, levels.INFO)
+  , fmt = options.format || ':remote-addr - - ":method :url HTTP/:http-version" :status :content-length ":req[referer]" ":user-agent"';
+
+    return function (req, res, next) {
+
+	// mount safety
+	if (req._logging) return next();
+
+	if (thislogger.isLevelEnabled(level)) {
+
+	    var start = +new Date
+	  , statusCode
+	  , writeHead = res.writeHead
+	  , end = res.end
+	  , url = req.originalUrl;
+
+	    // flag as logging
+	    req._logging = true;
+
+	    // proxy for statusCode.
+	    res.writeHead = function(code, headers){
+		res.writeHead = writeHead;
+		res.writeHead(code, headers);
+		res.__statusCode = statusCode = code;
+		res.__headers = headers || {};
+	    };
+
+	    // proxy end to output a line to the provided logger.
+	    res.end = function(chunk, encoding) {
+		res.end = end;
+		res.end(chunk, encoding);
+		res.responseTime = +new Date - start;
+		if ('function' == typeof fmt) {
+		    var line = fmt(req, res, function(str){ return format(str, req, res); });
+		    if (line) thislogger.log(level, line);
+		} else {
+		    thislogger.log(level, format(fmt, req, res));
+		}
+	    };
+
+	    next();
+	}
+    };
+}
+
+/**
+ * Return formatted log line.
+ *
+ * @param  {String} str
+ * @param  {IncomingMessage} req
+ * @param  {ServerResponse} res
+ * @return {String}
+ * @api private
+ */
+
+function format(str, req, res) {
+    return str
+      .replace(':url', req.originalUrl)
+	.replace(':method', req.method)
+	  .replace(':status', res.__statusCode || res.statusCode)
+	    .replace(':response-time', res.responseTime)
+	      .replace(':date', new Date().toUTCString())
+		.replace(':referrer', req.headers['referer'] || req.headers['referrer'] || '')
+		  .replace(':http-version', req.httpVersionMajor + '.' + req.httpVersionMinor)
+		    .replace(':remote-addr', req.socket && (req.socket.remoteAddress || (req.socket.socket && req.socket.socket.remoteAddress)))
+		      .replace(':user-agent', req.headers['user-agent'] || '')
+                        .replace(':content-length', (res._headers && res._headers['content-length']) || (res.__headers && res.__headers['Content-Length']) || '-')
+		          .replace(/:req\[([^\]]+)\]/g, function(_, field){ return req.headers[field.toLowerCase()]; })
+		            .replace(/:res\[([^\]]+)\]/g, function(_, field){
+		                return res._headers
+			      ? (res._headers[field.toLowerCase()] || res.__headers[field])
+			      : (res.__headers && res.__headers[field]);
+		            });
+}
+
+exports.connectLogger = getLogger;

lib/date_format.js

@@ -0,0 +1,60 @@
+exports.ISO8601_FORMAT = "yyyy-MM-dd hh:mm:ss.SSS";
+exports.ISO8601_WITH_TZ_OFFSET_FORMAT = "yyyy-MM-ddThh:mm:ssO";
+exports.DATETIME_FORMAT = "dd MM yyyy hh:mm:ss.SSS";
+exports.ABSOLUTETIME_FORMAT = "hh:mm:ss.SSS";
+
+exports.asString = function(/*format,*/ date) {
+    var format = exports.ISO8601_FORMAT;
+    if (typeof(date) === "string") {
+        format = arguments[0];
+        date = arguments[1];
+    }
+
+    var vDay = addZero(date.getDate());
+    var vMonth = addZero(date.getMonth()+1);
+    var vYearLong = addZero(date.getFullYear());
+    var vYearShort = addZero(date.getFullYear().toString().substring(3,4));
+    var vYear = (format.indexOf("yyyy") > -1 ? vYearLong : vYearShort);
+    var vHour  = addZero(date.getHours());
+    var vMinute = addZero(date.getMinutes());
+    var vSecond = addZero(date.getSeconds());
+    var vMillisecond = padWithZeros(date.getMilliseconds(), 3);
+    var vTimeZone = offset(date);
+    var formatted = format
+                      .replace(/dd/g, vDay)
+                      .replace(/MM/g, vMonth)
+                      .replace(/y{1,4}/g, vYear)
+                      .replace(/hh/g, vHour)
+                      .replace(/mm/g, vMinute)
+                      .replace(/ss/g, vSecond)
+                      .replace(/SSS/g, vMillisecond)
+                      .replace(/O/g, vTimeZone);
+    return formatted;
+
+    function padWithZeros(vNumber, width) {
+	var numAsString = vNumber + "";
+	while (numAsString.length < width) {
+	    numAsString = "0" + numAsString;
+	}
+	return numAsString;
+    }
+
+    function addZero(vNumber) {
+	return padWithZeros(vNumber, 2);
+    }
+
+    /**
+     * Formats the TimeOffest
+     * Thanks to http://www.svendtofte.com/code/date_format/
+     * @private
+     */
+    function offset(date) {
+	// Difference to Greenwich time (GMT) in hours
+	var os = Math.abs(date.getTimezoneOffset());
+	var h = String(Math.floor(os/60));
+	var m = String(os%60);
+	h.length == 1? h = "0"+h:1;
+	m.length == 1? m = "0"+m:1;
+	return date.getTimezoneOffset() < 0 ? "+"+h+m : "-"+h+m;
+    }
+};

lib/layouts.js

@@ -0,0 +1,257 @@
+var dateFormat = require('./date_format')
+, util = require('util')
+, replacementRegExp = /%[sdj]/g
+, layoutMakers = {
+    "messagePassThrough": function() { return messagePassThroughLayout; }
+  , "basic": function() { return basicLayout; }
+  , "colored": function() { return colouredLayout; }
+  , "coloured": function() { return colouredLayout; }
+  , "pattern": function (config) {
+	var pattern = config.pattern || undefined;
+	return patternLayout(pattern);
+    }
+}
+, colours = {
+    ALL: "grey"
+  , TRACE: "blue"
+  , DEBUG: "cyan"
+  , INFO: "green"
+  , WARN: "yellow"
+  , ERROR: "red"
+  , FATAL: "magenta"
+  , OFF: "grey"
+};
+
+
+function formatLogData(logData) {
+    var output = ""
+    , data = Array.isArray(logData) ? logData.slice() : Array.prototype.slice.call(arguments)
+    , format = data.shift();
+
+    if (typeof format  === "string") {
+        output = format.replace(replacementRegExp, function(match) {
+            switch (match) {
+            case "%s": return new String(data.shift());
+            case "%d": return new Number(data.shift());
+            case "%j": return JSON.stringify(data.shift());
+            default:
+                return match;
+            };
+        });
+        if (data.length > 0) {
+            output += '\n';
+        }
+    }
+
+    data.forEach(function (item) {
+        if (item.stack) {
+            output += item.stack;
+        } else {
+            output += util.inspect(item);
+        }
+    });
+
+    return output;
+}
+
+/**
+ * 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;
+}
+
+function timestampLevelAndCategory(loggingEvent, colour) {
+    var output = colorize(
+        formatLogData(
+            '[%s] [%s] %s - '
+          , dateFormat.asString(loggingEvent.startTime)
+          , loggingEvent.level
+          , loggingEvent.categoryName
+        )
+      , colour
+    );
+    return output;
+}
+
+/**
+ * BasicLayout is a simple layout for storing the logs. The logs are stored
+ * in following format:
+ * <pre>
+ * [startTime] [logLevel] categoryName - message\n
+ * </pre>
+ *
+ * @author Stephan Strittmatter
+ */
+function basicLayout (loggingEvent) {
+    return timestampLevelAndCategory(loggingEvent) + formatLogData(loggingEvent.data);
+}
+
+/**
+ * colouredLayout - taken from masylum's fork.
+ * same as basicLayout, but with colours.
+ */
+function colouredLayout (loggingEvent) {
+    return timestampLevelAndCategory(loggingEvent, colours[loggingEvent.level.toString()]) + formatLogData(loggingEvent.data);
+}
+
+function messagePassThroughLayout (loggingEvent) {
+    return formatLogData(loggingEvent.data);
+}
+
+/**
+ * PatternLayout
+ * Format for specifiers is %[padding].[truncation][field]{[format]}
+ * e.g. %5.10p - left pad the log level by 5 characters, up to a max of 10
+ * Fields can be any of:
+ *  - %r time in toLocaleTimeString format
+ *  - %p log level
+ *  - %c log category
+ *  - %m log data
+ *  - %d date in various formats
+ *  - %% %
+ *  - %n newline
+ * 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%])(\{([^\}]+)\})?|([^%]+)/;
+
+    pattern = pattern || TTCC_CONVERSION_PATTERN;
+
+    return function(loggingEvent) {
+	var formattedString = "";
+	var result;
+	var searchString = pattern;
+
+	while ((result = regex.exec(searchString))) {
+	    var matchedString = result[0];
+	    var padding = result[1];
+	    var truncation = result[2];
+	    var conversionCharacter = result[3];
+	    var specifier = result[5];
+	    var text = result[6];
+
+	    // Check if the pattern matched was just normal text
+	    if (text) {
+		formattedString += "" + text;
+	    } else {
+		// Create a raw replacement string based on the conversion
+		// character and specifier
+		var replacement = "";
+		switch(conversionCharacter) {
+		case "c":
+		    var loggerName = loggingEvent.categoryName;
+		    if (specifier) {
+			var precision = parseInt(specifier, 10);
+			var loggerNameBits = loggingEvent.categoryName.split(".");
+			if (precision >= loggerNameBits.length) {
+			    replacement = loggerName;
+			} else {
+			    replacement = loggerNameBits.slice(loggerNameBits.length - precision).join(".");
+			}
+		    } else {
+			replacement = loggerName;
+		    }
+		    break;
+		case "d":
+		    var format = dateFormat.ISO8601_FORMAT;
+		    if (specifier) {
+			format = specifier;
+			// Pick up special cases
+			if (format == "ISO8601") {
+			    format = dateFormat.ISO8601_FORMAT;
+			} else if (format == "ABSOLUTE") {
+			    format = dateFormat.ABSOLUTETIME_FORMAT;
+			} else if (format == "DATE") {
+			    format = dateFormat.DATETIME_FORMAT;
+			}
+		    }
+		    // Format the date
+		    replacement = dateFormat.asString(format, loggingEvent.startTime);
+		    break;
+		case "m":
+		    replacement = formatLogData(loggingEvent.data);
+		    break;
+		case "n":
+		    replacement = "\n";
+		    break;
+		case "p":
+		    replacement = loggingEvent.level.toString();
+		    break;
+		case "r":
+		    replacement = "" + loggingEvent.startTime.toLocaleTimeString();
+		    break;
+		case "%":
+		    replacement = "%";
+		    break;
+		default:
+		    replacement = matchedString;
+		    break;
+		}
+		// Format the replacement according to any padding or
+		// truncation specified
+
+		var len;
+
+		// First, truncation
+		if (truncation) {
+		    len = parseInt(truncation.substr(1), 10);
+		    replacement = replacement.substring(0, len);
+		}
+		// Next, padding
+		if (padding) {
+		    if (padding.charAt(0) == "-") {
+			len = parseInt(padding.substr(1), 10);
+			// Right pad with spaces
+			while (replacement.length < len) {
+			    replacement += " ";
+			}
+		    } else {
+			len = parseInt(padding, 10);
+			// Left pad with spaces
+			while (replacement.length < len) {
+			    replacement = " " + replacement;
+			}
+		    }
+		}
+		formattedString += replacement;
+	    }
+	    searchString = searchString.substr(result.index + result[0].length);
+	}
+	return formattedString;
+    };
+
+};
+
+
+module.exports = {
+    basicLayout: basicLayout
+  , messagePassThroughLayout: messagePassThroughLayout
+  , patternLayout: patternLayout
+  , colouredLayout: colouredLayout
+  , coloredLayout: colouredLayout
+  , layout: function(name, config) {
+        return layoutMakers[name] && layoutMakers[name](config);
+    }
+};

lib/levels.js

@@ -0,0 +1,56 @@
+function Level(level, levelStr) {
+    this.level = level;
+    this.levelStr = levelStr;
+}
+
+/**
+ * converts given String to corresponding Level
+ * @param {String} sArg String value of Level
+ * @param {Log4js.Level} defaultLevel default Level, if no String representation
+ * @return Level object
+ * @type Log4js.Level
+ */
+function toLevel(sArg, defaultLevel) {
+
+    if (sArg === null) {
+	return defaultLevel;
+    }
+
+    if (typeof sArg == "string") {
+	var s = sArg.toUpperCase();
+	if (module.exports[s]) {
+	    return module.exports[s];
+	}
+    }
+    return defaultLevel;
+};
+
+Level.prototype.toString = function() {
+    return this.levelStr;
+};
+
+Level.prototype.isLessThanOrEqualTo = function(otherLevel) {
+    if (typeof otherLevel === "string") {
+        otherLevel = Level.toLevel(otherLevel);
+    }
+    return this.level <= otherLevel.level;
+};
+
+Level.prototype.isGreaterThanOrEqualTo = function(otherLevel) {
+    if (typeof otherLevel === "string") {
+        otherLevel = Level.toLevel(otherLevel);
+    }
+    return this.level >= otherLevel.level;
+};
+
+module.exports = {
+    ALL: new Level(Number.MIN_VALUE, "ALL")
+  , TRACE: new Level(5000, "TRACE")
+  , DEBUG: new Level(10000, "DEBUG")
+  , INFO: new Level(20000, "INFO")
+  , WARN: new Level(30000, "WARN")
+  , ERROR: new Level(40000, "ERROR")
+  , FATAL: new Level(50000, "FATAL")
+  , OFF: new Level(Number.MAX_VALUE, "OFF")
+  , toLevel: toLevel
+};

memory-test.js

@@ -0,0 +1,37 @@
+var log4js = require('./lib/log4js')
+, logger
+, usage
+, i;
+
+log4js.configure(
+    {
+        appenders: [
+            {
+                category: "memory-test"
+              , type: "file"
+              , filename: "memory-test.log"
+            },
+            {
+                type: "console"
+              , category: "memory-usage"
+            },
+            {
+                type: "file"
+              , filename: "memory-usage.log"
+              , category: "memory-usage"
+              , layout: {
+                  type: "messagePassThrough"
+              }
+            }
+        ]
+    }
+);
+logger = log4js.getLogger("memory-test");
+usage = log4js.getLogger("memory-usage");
+
+for (i=0; i < 1000000; i++) {
+    if ( (i % 5000) === 0) {
+        usage.info("%d %d", i, process.memoryUsage().rss);
+    }
+    logger.info("Doing something.");
+}

package.json

@@ -1,6 +1,6 @@
 {
    "name": "log4js",
-   "version": "0.2.0",
+   "version": "0.3.0",
    "description": "Port of Log4js to work with node.",
    "keywords": [
        "logging",
@@ -15,10 +15,13 @@
    },
    "engines": [ "node >=0.1.100" ],
    "scripts": {
-       "test": "vows test/logging.js" 
+       "test": "vows test/*.js" 
    },
    "directories": {
        "test": "test",
        "lib": "lib"
+   },
+   "devDependencies": {
+       "vows": ">=0.5.2"
    } 
 }

spec/lib/jspec.css

@@ -1,149 +0,0 @@
-body.jspec {
-  margin: 45px 0;
-  font: 12px "Helvetica Neue Light", "Lucida Grande", "Calibri", "Arial", sans-serif;
-  background: #efefef url(images/bg.png) top left repeat-x;
-  text-align: center;
-}
-#jspec {
-  margin: 0 auto;
-  padding-top: 30px;
-  width: 1008px;
-  background: url(images/vr.png) top left repeat-y;
-  text-align: left;
-}
-#jspec-top {
-  position: relative;
-  margin: 0 auto;
-  width: 1008px;
-  height: 40px;
-  background: url(images/sprites.bg.png) top left no-repeat;
-}
-#jspec-bottom {
-  margin: 0 auto;
-  width: 1008px;
-  height: 15px;
-  background: url(images/sprites.bg.png) bottom left no-repeat;
-}
-#jspec .loading {
-  margin-top: -45px;
-  width: 1008px;
-  height: 80px;
-  background: url(images/loading.gif) 50% 50% no-repeat;
-}
-#jspec-title {
-  position: absolute;
-  top: 15px;
-  left: 20px;
-  width: 160px;
-  font-size: 22px;
-  font-weight: normal;
-  background: url(images/sprites.png) 0 -126px no-repeat;
-  text-align: center;
-}
-#jspec-title em {
-  font-size: 10px;
-  font-style: normal;
-  color: #BCC8D1;
-}
-#jspec-report * {
-	margin: 0;
-	padding: 0;
-	background: none;
-	border: none;
-}
-#jspec-report {
-  padding: 15px 40px;
-	font: 11px "Helvetica Neue Light", "Lucida Grande", "Calibri", "Arial", sans-serif;
-	color: #7B8D9B;
-}
-#jspec-report.has-failures {
-  padding-bottom: 30px;
-}
-#jspec-report .hidden {
-  display: none;
-}
-#jspec-report .heading {
-  margin-bottom: 15px;
-}
-#jspec-report .heading span {
-  padding-right: 10px;
-}
-#jspec-report .heading .passes em {
-  color: #0ea0eb;
-}
-#jspec-report .heading .failures em {
-  color: #FA1616;
-}
-#jspec-report table {
-  font-size: 11px;
-  border-collapse: collapse;
-}
-#jspec-report td {
-  padding: 8px;
-  text-indent: 30px;
-  color: #7B8D9B;
-}
-#jspec-report tr.body {
-  display: none;
-}
-#jspec-report tr.body pre {
-  margin: 0;
-  padding: 0 0 5px 25px;
-}
-#jspec-report tr.even:hover + tr.body, 
-#jspec-report tr.odd:hover + tr.body {
-  display: block;
-}
-#jspec-report tr td:first-child em {
-	display: block;
-	clear: both;
-  font-style: normal;
-  font-weight: normal;
-  color: #7B8D9B;
-}
-#jspec-report tr.even:hover, 
-#jspec-report tr.odd:hover {
-  text-shadow: 1px 1px 1px #fff;
-  background: #F2F5F7;
-}
-#jspec-report td + td {
-  padding-right: 0;
-  width: 15px;
-}
-#jspec-report td.pass {
-  background: url(images/sprites.png) 3px -7px no-repeat;
-}
-#jspec-report td.fail {
-  background: url(images/sprites.png) 3px -158px no-repeat;
-  font-weight: bold;
-  color: #FC0D0D;
-}
-#jspec-report td.requires-implementation {
-  background: url(images/sprites.png) 3px -333px no-repeat;
-}
-#jspec-report tr.description td {
-  margin-top: 25px;
-  padding-top: 25px;
-  font-size: 12px;
-  font-weight: bold;
-  text-indent: 0;
-  color: #1a1a1a;
-}
-#jspec-report tr.description:first-child td {
-  border-top: none;  
-}
-#jspec-report .assertion {
-  display: block;
-  float: left;
-  margin: 0 0 0 1px;
-  padding: 0;
-  width: 1px;
-  height: 5px;
-  background: #7B8D9B;
-}
-#jspec-report .assertion.failed {
-  background: red;
-}
-.jspec-sandbox {
-  display: none;
-}

spec/lib/jspec.growl.js

@@ -1,115 +0,0 @@
-
-// JSpec - Growl - Copyright TJ Holowaychuk <tj@vision-media.ca> (MIT Licensed)
-
-;(function(){
-  
-  Growl = {
-    
-    // --- Version
-    
-    version: '1.0.0',
-    
-    /**
-     * Execute the given _cmd_, returning an array of lines from stdout.
-     *
-     * Examples:
-     *
-     *   Growl.exec('growlnotify', '-m', msg)
-     *
-     * @param  {string ...} cmd
-     * @return {array}
-     * @api public
-     */
-
-    exec: function(cmd) {
-      var lines = [], line
-      with (JavaImporter(java.lang, java.io)) {
-        var proccess = Runtime.getRuntime().exec(Array.prototype.slice.call(arguments))
-        var stream = new DataInputStream(proccess.getInputStream())
-        while (line = stream.readLine())
-          lines.push(line + '')
-        stream.close()    
-      }
-      return lines
-    },
-    
-    /**
-     * Return the extension of the given _path_ or null.
-     *
-     * @param  {string} path
-     * @return {string}
-     * @api private
-     */
-    
-    extname: function(path) {
-      return path.lastIndexOf('.') != -1 ? 
-        path.slice(path.lastIndexOf('.') + 1, path.length) :
-          null
-    },
-
-    /**
-     * Version of the 'growlnotify' binary.
-     *
-     * @return {string}
-     * @api private
-     */
-
-    binVersion: function() {
-      try { return this.exec('growlnotify', '-v')[0].split(' ')[1] } catch (e) {}
-    },
-
-    /**
-     * Send growl notification _msg_ with _options_.
-     *
-     * Options:
-     *
-     *  - title   Notification title
-     *  - sticky  Make the notification stick (defaults to false)
-     *  - name    Application name (defaults to growlnotify)
-     *  - image
-     *    - path to an icon sets --iconpath
-     *    - path to an image sets --image
-     *    - capitalized word sets --appIcon
-     *    - filename uses extname as --icon
-     *    - otherwise treated as --icon
-     *
-     * Examples:
-     *
-     *   Growl.notify('New email')
-     *   Growl.notify('5 new emails', { title: 'Thunderbird' })
-     *
-     * @param {string} msg
-     * @param {options} hash
-     * @api public
-     */
-
-    notify: function(msg, options) {
-      options = options || {}
-      var args = ['growlnotify', '-m', msg]
-      if (!this.binVersion()) throw new Error('growlnotify executable is required')
-      if (image = options.image) {
-        var flag, ext = this.extname(image)
-        flag = flag || ext == 'icns' && 'iconpath'
-        flag = flag || /^[A-Z]/.test(image) && 'appIcon'
-        flag = flag || /^png|gif|jpe?g$/.test(ext) && 'image'
-        flag = flag || ext && (image = ext) && 'icon'
-        flag = flag || 'icon'
-        args.push('--' + flag, image)
-      }
-      if (options.sticky) args.push('--sticky')
-      if (options.name) args.push('--name', options.name)
-      if (options.title) args.push(options.title)
-      this.exec.apply(this, args)
-    }
-  }
-  
-  JSpec.include({
-    name: 'Growl',
-    reporting: function(options){
-      var stats = JSpec.stats
-      if (stats.failures) Growl.notify('failed ' + stats.failures + ' assertions', { title: 'JSpec'})
-      else Growl.notify('passed ' + stats.passes + ' assertions', { title: 'JSpec' })
-    }
-  })
-  
-})()

spec/lib/jspec.jquery.js

@@ -1,71 +0,0 @@
-
-// JSpec - jQuery - Copyright TJ Holowaychuk <tj@vision-media.ca> (MIT Licensed)
-
-JSpec
-.requires('jQuery', 'when using jspec.jquery.js')
-.include({
-  name: 'jQuery',
-  
-  // --- Initialize
-  
-  init : function() {
-    jQuery.ajaxSetup({ async: false })
-  },
-  
-  // --- Utilities
-  
-  utilities : {
-    element:  jQuery,
-    elements: jQuery,
-    sandbox : function() {
-      return jQuery('<div class="sandbox"></div>')
-    }
-  },
-  
-  // --- Matchers
-  
-  matchers : {
-    have_tag      : "jQuery(expected, actual).length == 1",
-    have_one      : "alias have_tag",
-    have_tags     : "jQuery(expected, actual).length > 1",
-    have_many     : "alias have_tags",
-    have_child    : "jQuery(actual).children(expected).length == 1",
-    have_children : "jQuery(actual).children(expected).length > 1",
-    have_text     : "jQuery(actual).text() == expected",
-    have_value    : "jQuery(actual).val() == expected",
-    be_enabled    : "!jQuery(actual).attr('disabled')",
-    have_class    : "jQuery(actual).hasClass(expected)",
-    
-    be_visible : function(actual) {
-      return jQuery(actual).css('display') != 'none' &&
-             jQuery(actual).css('visibility') != 'hidden' &&
-             jQuery(actual).attr('type') != 'hidden'
-    },
-    
-    be_hidden : function(actual) {
-      return !JSpec.does(actual, 'be_visible')
-    },
-
-    have_classes : function(actual) {
-      return !JSpec.any(JSpec.toArray(arguments, 1), function(arg){
-        return !JSpec.does(actual, 'have_class', arg)
-      })
-    },
-
-    have_attr : function(actual, attr, value) {
-      return value ? jQuery(actual).attr(attr) == value:
-                     jQuery(actual).attr(attr)
-    },
-    
-    'be disabled selected checked' : function(attr) {
-      return 'jQuery(actual).attr("' + attr + '")'
-    },
-    
-    'have type id title alt href src sel rev name target' : function(attr) {
-      return function(actual, value) {
-        return JSpec.does(actual, 'have_attr', attr, value)
-      }
-    }
-  }
-})
-

spec/lib/jspec.shell.js

@@ -1,39 +0,0 @@
-
-// JSpec - Shell - Copyright TJ Holowaychuk <tj@vision-media.ca> (MIT Licensed)
-
-;(function(){
-  
-  var _quit = quit
-  
-  Shell = {
-    
-    // --- Global
-    
-    main: this,
-    
-    // --- Commands
-    
-    commands: {
-      quit: ['Terminate the shell', function(){ _quit() }],
-      exit: ['Terminate the shell', function(){ _quit() }],
-      p: ['Inspect an object', function(o){ return o.toSource() }]
-    },
-    
-    /**
-     * Start the interactive shell.
-     *
-     * @api public
-     */
-    
-    start : function() {
-      for (var name in this.commands)
-        if (this.commands.hasOwnProperty(name))
-          this.commands[name][1].length ?
-            this.main[name] = this.commands[name][1] :
-              this.main.__defineGetter__(name, this.commands[name][1])
-    }
-  }
-  
-  Shell.start()
-  
-})()

spec/lib/jspec.timers.js

@@ -1,90 +0,0 @@
-
-// JSpec - Mock Timers - Copyright TJ Holowaychuk <tj@vision-media.ca> (MIT Licensed)
-
-;(function(){
-  
-  /**
-   * Version.
-   */
-   
-  mockTimersVersion = '1.0.2'
-  
-  /**
-   * Localized timer stack.
-   */
-  
-  var timers = []
-  
-  /**
-   * Set mock timeout with _callback_ and timeout of _ms_.
-   *
-   * @param  {function} callback
-   * @param  {int} ms
-   * @return {int}
-   * @api public
-   */
-  
-  setTimeout = function(callback, ms) {
-    var id
-  	return id = setInterval(function(){
-  	  callback()
-  	  clearInterval(id)
-  	}, ms)
-  }
-  
-  /**
-   * Set mock interval with _callback_ and interval of _ms_.
-   *
-   * @param  {function} callback
-   * @param  {int} ms
-   * @return {int}
-   * @api public
-   */
-
-  setInterval = function(callback, ms) {
-    callback.step = ms, callback.current = callback.last = 0
-    return timers[timers.length] = callback, timers.length
-  }
-  
-  /**
-   * Destroy timer with _id_.
-   *
-   * @param  {int} id
-   * @return {bool}
-   * @api public
-   */
-
-  clearInterval = clearTimeout = function(id) {
-    return delete timers[--id]
-  }
-  
-  /**
-   * Reset timers.
-   *
-   * @return {array}
-   * @api public
-   */
-  
-  resetTimers = function() {
-    return timers = []
-  }
-  
-  /**
-   * Increment each timers internal clock by _ms_.
-   *
-   * @param  {int} ms
-   * @api public
-   */
-  
-  tick = function(ms) {
-    for (var i = 0, len = timers.length; i < len; ++i)
-      if (timers[i] && (timers[i].current += ms))
-        if (timers[i].current - timers[i].last >= timers[i].step) {
-          var times = Math.floor((timers[i].current - timers[i].last) / timers[i].step)
-          var remainder = (timers[i].current - timers[i].last) % timers[i].step
-          timers[i].last = timers[i].current - remainder
-          while (times-- && timers[i]) timers[i]()
-        }
-  }
-  
-})()

spec/lib/jspec.xhr.js

@@ -1,193 +0,0 @@
-
-// JSpec - XHR - Copyright TJ Holowaychuk <tj@vision-media.ca> (MIT Licensed)
-
-(function(){
-  
-  // --- Original XMLHttpRequest
-  
-  var OriginalXMLHttpRequest = 'XMLHttpRequest' in this ? 
-                                 XMLHttpRequest :
-                                   function(){}
-  var OriginalActiveXObject = 'ActiveXObject' in this ?
-                                 ActiveXObject :
-                                   undefined
-                                   
-  // --- MockXMLHttpRequest
-
-  var MockXMLHttpRequest = function() {
-    this.requestHeaders = {}
-  }
-  
-  MockXMLHttpRequest.prototype = {
-    status: 0,
-    async: true,
-    readyState: 0,
-    responseText: '',
-    abort: function(){},
-    onreadystatechange: function(){},
-
-   /**
-    * Return response headers hash.
-    */
-
-    getAllResponseHeaders : function(){
-      return this.responseHeaders
-    },
-    
-    /**
-     * Return case-insensitive value for header _name_.
-     */
-
-    getResponseHeader : function(name) {
-      return this.responseHeaders[name.toLowerCase()]
-    },
-    
-    /**
-     * Set case-insensitive _value_ for header _name_.
-     */
-
-    setRequestHeader : function(name, value) {
-      this.requestHeaders[name.toLowerCase()] = value
-    },
-    
-    /**
-     * Open mock request.
-     */
-
-    open : function(method, url, async, user, password) {
-      this.user = user
-      this.password = password
-      this.url = url
-      this.readyState = 1
-      this.method = method.toUpperCase()
-      if (async != undefined) this.async = async
-      if (this.async) this.onreadystatechange()
-    },
-    
-    /**
-     * Send request _data_.
-     */
-
-    send : function(data) {
-      var self = this
-      this.data = data
-      this.readyState = 4
-      if (this.method == 'HEAD') this.responseText = null
-      this.responseHeaders['content-length'] = (this.responseText || '').length
-      if(this.async) this.onreadystatechange()
-      lastRequest = function(){
-        return self
-      }
-    }
-  }
-  
-  // --- Response status codes
-  
-  JSpec.statusCodes = {
-    100: 'Continue',
-    101: 'Switching Protocols',
-    200: 'OK',
-    201: 'Created',
-    202: 'Accepted',
-    203: 'Non-Authoritative Information',
-    204: 'No Content',
-    205: 'Reset Content',
-    206: 'Partial Content',
-    300: 'Multiple Choice',
-    301: 'Moved Permanently',
-    302: 'Found',
-    303: 'See Other',
-    304: 'Not Modified',
-    305: 'Use Proxy',
-    307: 'Temporary Redirect',
-    400: 'Bad Request',
-    401: 'Unauthorized',
-    402: 'Payment Required',
-    403: 'Forbidden',
-    404: 'Not Found',
-    405: 'Method Not Allowed',
-    406: 'Not Acceptable',
-    407: 'Proxy Authentication Required',
-    408: 'Request Timeout',
-    409: 'Conflict',
-    410: 'Gone',
-    411: 'Length Required',
-    412: 'Precondition Failed',
-    413: 'Request Entity Too Large',
-    414: 'Request-URI Too Long',
-    415: 'Unsupported Media Type',
-    416: 'Requested Range Not Satisfiable',
-    417: 'Expectation Failed',
-    422: 'Unprocessable Entity',
-    500: 'Internal Server Error',
-    501: 'Not Implemented',
-    502: 'Bad Gateway',
-    503: 'Service Unavailable',
-    504: 'Gateway Timeout',
-    505: 'HTTP Version Not Supported'
-  }
-  
-  /**
-   * Mock XMLHttpRequest requests.
-   *
-   *   mockRequest().and_return('some data', 'text/plain', 200, { 'X-SomeHeader' : 'somevalue' })
-   *
-   * @return {hash}
-   * @api public
-   */
-  
-  function mockRequest() {
-    return { and_return : function(body, type, status, headers) {
-      XMLHttpRequest = MockXMLHttpRequest
-      ActiveXObject = false
-      status = status || 200
-      headers = headers || {}
-      headers['content-type'] = type
-      JSpec.extend(XMLHttpRequest.prototype, {
-        responseText: body,
-        responseHeaders: headers,
-        status: status,
-        statusText: JSpec.statusCodes[status]
-      })
-    }}
-  }
-  
-  /**
-   * Unmock XMLHttpRequest requests.
-   *
-   * @api public
-   */
-  
-  function unmockRequest() {
-    XMLHttpRequest = OriginalXMLHttpRequest
-    ActiveXObject = OriginalActiveXObject
-  }
-  
-  JSpec.include({
-    name: 'Mock XHR',
-
-    // --- Utilities
-
-    utilities : {
-      mockRequest: mockRequest,
-      unmockRequest: unmockRequest
-    },
-
-    // --- Hooks
-
-    afterSpec : function() {
-      unmockRequest()
-    },
-    
-    // --- DSLs
-    
-    DSLs : {
-      snake : {
-        mock_request: mockRequest,
-        unmock_request: unmockRequest,
-        last_request: function(){ return lastRequest() }
-      }
-    }
-
-  })
-})()

spec/spec.logging.js

@@ -1,144 +0,0 @@
-describe 'log4js'
-  before
-      extend(context, {
-          log4js : require("log4js")()
-      });
-  end
-
-  before_each 
-    log4js.clearAppenders();
-    event = '';
-    logger = log4js.getLogger('tests');
-    logger.setLevel("TRACE");
-    logger.addListener("log", function (logEvent) { event = logEvent; });    
-  end
-    
-  describe 'addAppender'
-    before_each
-      appenderEvent = undefined;
-      appender = function(logEvent) { appenderEvent = logEvent; };
-    end
-        
-    describe 'without a category'
-      it 'should register the function as a listener for all loggers'
-        log4js.addAppender(appender);
-        logger.debug("This is a test");
-        appenderEvent.should.be event
-      end
-      
-      it 'should also register as an appender for loggers if an appender for that category is defined'
-        var otherEvent;
-        log4js.addAppender(appender);
-        log4js.addAppender(function (evt) { otherEvent = evt; }, 'cheese');
-        
-        var cheeseLogger = log4js.getLogger('cheese');
-        cheeseLogger.addListener("log", function (logEvent) { event = logEvent; });    
-
-        cheeseLogger.debug('This is a test');
-        
-        appenderEvent.should.be event
-        otherEvent.should.be event
-        
-        otherEvent = undefined;
-        appenderEvent = undefined;
-        log4js.getLogger('pants').debug("this should not be propagated to otherEvent");
-        otherEvent.should.be undefined
-        appenderEvent.should.not.be undefined
-        appenderEvent.message.should.be "this should not be propagated to otherEvent"
-        
-        cheeseLogger = null;
-      end
-    end
-    
-    describe 'with a category'
-      it 'should only register the function as a listener for that category'
-        log4js.addAppender(appender, 'tests');
-        
-        logger.debug('this is a test');
-        appenderEvent.should.be event
-        
-        appenderEvent = undefined;
-        log4js.getLogger('some other category').debug('Cheese');
-        appenderEvent.should.be undefined
-      end
-    end
-    
-    describe 'with multiple categories'
-      it 'should register the function as a listener for all the categories'
-        log4js.addAppender(appender, 'tests', 'biscuits');
-        
-        logger.debug('this is a test');
-        appenderEvent.should.be event
-        appenderEvent = undefined;
-        
-        var otherLogger = log4js.getLogger('biscuits');
-        otherLogger.debug("mmm... garibaldis");
-        appenderEvent.should.not.be undefined
-        appenderEvent.message.should.be "mmm... garibaldis"
-        appenderEvent = undefined;
-        
-        otherLogger = null;
-        
-        log4js.getLogger("something else").debug("pants");
-        appenderEvent.should.be undefined
-      end
-      
-      it 'should register the function when the list of categories is an array'
-        log4js.addAppender(appender, ['tests', 'pants']);
-        
-        logger.debug('this is a test');
-        appenderEvent.should.be event
-        appenderEvent = undefined;
-        
-        var otherLogger = log4js.getLogger('pants');
-        otherLogger.debug("big pants");
-        appenderEvent.should.not.be undefined
-        appenderEvent.message.should.be "big pants"
-        appenderEvent = undefined;
-        
-        otherLogger = null;
-        
-        log4js.getLogger("something else").debug("pants");
-        appenderEvent.should.be undefined
-      end      
-    end
-  end
-  
-  describe 'basicLayout'
-    it 'should take a logevent and output a formatted string'
-      logger.debug('this is a test');
-      var output = log4js.basicLayout(event);
-      output.should.match /\[.*?\] \[DEBUG\] tests - this is a test/
-    end
-    
-    it 'should output a stacktrace, message if the event has an error attached'
-      var error = new Error("Some made-up error");
-      var stack = error.stack.split(/\n/);
-      
-      logger.debug('this is a test', error);
-
-      var output = log4js.basicLayout(event);
-      var lines = output.split(/\n/);
-      lines.length.should.be stack.length+1 
-      lines[0].should.match /\[.*?\] \[DEBUG\] tests - this is a test/
-      lines[1].should.match /\[.*?\] \[DEBUG\] tests - Error: Some made-up error/
-      for (var i = 1; i < stack.length; i++) {
-        lines[i+1].should.eql stack[i]
-      }
-    end
-    
-    it 'should output a name and message if the event has something that pretends to be an error'
-      logger.debug('this is a test', { name: 'Cheese', message: 'Gorgonzola smells.' });
-      var output = log4js.basicLayout(event);
-      var lines = output.split(/\n/);
-      lines.length.should.be 2 
-      lines[0].should.match /\[.*?\] \[DEBUG\] tests - this is a test/
-      lines[1].should.match /\[.*?\] \[DEBUG\] tests - Cheese: Gorgonzola smells./
-    end
-  end
-  
-  
-  
-  
-end
-

test/date_format.js

@@ -0,0 +1,23 @@
+var vows = require('vows')
+, assert = require('assert')
+, dateFormat = require('../lib/date_format');
+
+vows.describe('date_format').addBatch({
+    'Date extensions': {
+        topic: function() {
+            return new Date(2010, 0, 11, 14, 31, 30, 5);
+        },
+        'should format a date as string using a pattern': function(date) {
+            assert.equal(
+                dateFormat.asString(dateFormat.DATETIME_FORMAT, date),
+                "11 01 2010 14:31:30.005"
+            );
+        },
+        'should default to the ISO8601 format': function(date) {
+            assert.equal(
+                dateFormat.asString(date),
+                '2010-01-11 14:31:30.005'
+            );
+        }
+    }
+}).export(module);

test/layouts.js

@@ -0,0 +1,201 @@
+var vows = require('vows'),
+assert = require('assert');
+
+//used for patternLayout tests.
+function test(args, pattern, value) {
+    var layout = args[0]
+    , event = args[1];
+
+    assert.equal(layout(pattern)(event), value);
+}
+
+vows.describe('log4js layouts').addBatch({
+    'colouredLayout': {
+        topic: function() {
+            return require('../lib/layouts').colouredLayout;
+        },
+
+        'should apply level colour codes to output': function(layout) {
+            var output = layout({
+                data: ["nonsense"],
+                startTime: new Date(2010, 11, 5, 14, 18, 30, 45),
+                categoryName: "cheese",
+                level: {
+                    toString: function() { return "ERROR"; }
+                }
+            });
+            assert.equal(output, '\033[31m[2010-12-05 14:18:30.045] [ERROR] cheese - \033[39mnonsense');
+        },
+
+        'should support the console.log format for the message': function(layout) {
+            var output = layout({
+                data: ["thing %d", 2],
+                startTime: new Date(2010, 11, 5, 14, 18, 30, 45),
+                categoryName: "cheese",
+                level: {
+                    toString: function() { return "ERROR"; }
+                }
+            });
+            assert.equal(output, '\033[31m[2010-12-05 14:18:30.045] [ERROR] cheese - \033[39mthing 2');
+        }
+    },
+
+    'messagePassThroughLayout': {
+        topic: function() {
+            return require('../lib/layouts').messagePassThroughLayout;
+        },
+        'should take a logevent and output only the message' : function(layout) {
+            assert.equal(layout({
+                data: ["nonsense"],
+                startTime: new Date(2010, 11, 5, 14, 18, 30, 45),
+                categoryName: "cheese",
+                level: {
+                    colour: "green",
+                    toString: function() { return "ERROR"; }
+                }
+            }), "nonsense");
+        },
+        'should support the console.log format for the message' : function(layout) {
+              assert.equal(layout({
+                  data: ["thing %d", 1]
+                , startTime: new Date(2010, 11, 5, 14, 18, 30, 45)
+                , categoryName: "cheese"
+                , level : {
+                    colour: "green"
+                  , toString: function() { return "ERROR"; }
+                }
+              }), "thing 1");
+          }
+    },
+
+    'basicLayout': {
+        topic: function() {
+            var layout = require('../lib/layouts').basicLayout,
+            event = {
+                data: ['this is a test'],
+                startTime: new Date(2010, 11, 5, 14, 18, 30, 45),
+                categoryName: "tests",
+                level: {
+                    toString: function() { return "DEBUG"; }
+                }
+            };
+            return [layout, event];
+        },
+        'should take a logevent and output a formatted string': function(args) {
+            var layout = args[0], event = args[1];
+            assert.equal(layout(event), "[2010-12-05 14:18:30.045] [DEBUG] tests - this is a test");
+        },
+        'should output a stacktrace, message if the event has an error attached': function(args) {
+            var layout = args[0], event = args[1], output, lines,
+            error = new Error("Some made-up error"),
+            stack = error.stack.split(/\n/);
+
+            event.data = ['this is a test', error];
+            output = layout(event);
+            lines = output.split(/\n/);
+
+            assert.length(lines, stack.length+1);
+            assert.equal(lines[0], "[2010-12-05 14:18:30.045] [DEBUG] tests - this is a test");
+            assert.equal(lines[1], "Error: Some made-up error");
+            for (var i = 1; i < stack.length; i++) {
+                assert.equal(lines[i+1], stack[i]);
+            }
+        },
+        'should output any extra data in the log event as util.inspect strings': function(args) {
+            var layout = args[0], event = args[1], output, lines;
+            event.data = ['this is a test', {
+                    name: 'Cheese',
+                    message: 'Gorgonzola smells.'
+            }];
+            output = layout(event);
+            lines = output.split(/\n/);
+
+            assert.length(lines, 2);
+            assert.equal(lines[0], "[2010-12-05 14:18:30.045] [DEBUG] tests - this is a test");
+            assert.equal(lines[1], "{ name: 'Cheese', message: 'Gorgonzola smells.' }");
+        }
+    },
+
+    'patternLayout': {
+        topic: function() {
+            var event = {
+                data: ['this is a test'],
+                startTime: new Date(2010, 11, 5, 14, 18, 30, 45),
+                categoryName: "multiple.levels.of.tests",
+                level: {
+                    toString: function() { return "DEBUG"; }
+                }
+            }, layout = require('../lib/layouts').patternLayout;
+            return [layout, event];
+        },
+
+        'should default to "time logLevel loggerName - message"': function(args) {
+            test(args, null, "14:18:30 DEBUG multiple.levels.of.tests - this is a test\n");
+        },
+        '%r should output time only': function(args) {
+            test(args, '%r', '14:18:30');
+        },
+        '%p should output the log level': function(args) {
+            test(args, '%p', 'DEBUG');
+        },
+        '%c should output the log category': function(args) {
+            test(args, '%c', 'multiple.levels.of.tests');
+        },
+        '%m should output the log data': function(args) {
+            test(args, '%m', 'this is a test');
+        },
+        '%n should output a new line': function(args) {
+            test(args, '%n', '\n');
+        },
+        '%c should handle category names like java-style package names': function(args) {
+            test(args, '%c{1}', 'tests');
+            test(args, '%c{2}', 'of.tests');
+            test(args, '%c{3}', 'levels.of.tests');
+            test(args, '%c{4}', 'multiple.levels.of.tests');
+            test(args, '%c{5}', 'multiple.levels.of.tests');
+            test(args, '%c{99}', 'multiple.levels.of.tests');
+        },
+        '%d should output the date in ISO8601 format': function(args) {
+            test(args, '%d', '2010-12-05 14:18:30.045');
+        },
+        '%d should allow for format specification': function(args) {
+            test(args, '%d{ISO8601}', '2010-12-05 14:18:30.045');
+            test(args, '%d{ABSOLUTE}', '14:18:30.045');
+            test(args, '%d{DATE}', '05 12 2010 14:18:30.045');
+            test(args, '%d{yyyy MM dd}', '2010 12 05');
+            test(args, '%d{yyyy MM dd hh mm ss SSS}', '2010 12 05 14 18 30 045');
+        },
+        '%% should output %': function(args) {
+            test(args, '%%', '%');
+        },
+        'should output anything not preceded by % as literal': function(args) {
+            test(args, 'blah blah blah', 'blah blah blah');
+        },
+        'should handle complicated patterns': function(args) {
+            test(args,
+                 '%m%n %c{2} at %d{ABSOLUTE} cheese %p%n',
+                 'this is a test\n of.tests at 14:18:30.045 cheese DEBUG\n'
+                );
+        },
+        'should truncate fields if specified': function(args) {
+            test(args, '%.4m', 'this');
+            test(args, '%.7m', 'this is');
+            test(args, '%.9m', 'this is a');
+            test(args, '%.14m', 'this is a test');
+            test(args, '%.2919102m', 'this is a test');
+        },
+        'should pad fields if specified': function(args) {
+            test(args, '%10p', '     DEBUG');
+            test(args, '%8p', '   DEBUG');
+            test(args, '%6p', ' DEBUG');
+            test(args, '%4p', 'DEBUG');
+            test(args, '%-4p', 'DEBUG');
+            test(args, '%-6p', 'DEBUG ');
+            test(args, '%-8p', 'DEBUG   ');
+            test(args, '%-10p', 'DEBUG     ');
+        }
+
+    }
+
+}).export(module);
+

test/logging.js

@@ -1,10 +1,11 @@
-var vows = require('vows'), 
+var vows = require('vows')
-assert = require('assert');
+, assert = require('assert')
+, sandbox = require('sandboxed-module');
 
 vows.describe('log4js').addBatch({
     'getLogger': {
 	topic: function() {
-	    var log4js = require('../lib/log4js')();
+	    var log4js = require('../lib/log4js');
 	    log4js.clearAppenders();
 	    var logger = log4js.getLogger('tests');
 	    logger.setLevel("DEBUG");
@@ -20,7 +21,7 @@ vows.describe('log4js').addBatch({
 	    assert.isFunction(logger.error);
 	    assert.isFunction(logger.fatal);
 	},
-	
+
 	'log events' : {
 	    topic: function(logger) {
 		var events = [];
@@ -29,55 +30,74 @@ vows.describe('log4js').addBatch({
 		logger.trace("Trace event 1");
 		logger.trace("Trace event 2");
 		logger.warn("Warning event");
+                logger.error("Aargh!", new Error("Pants are on fire!"));
+                logger.error("Simulated CouchDB problem", { err: 127, cause: "incendiary underwear" });
 		return events;
 	    },
 
 	    'should emit log events': function(events) {
 		assert.equal(events[0].level.toString(), 'DEBUG');
-		assert.equal(events[0].message, 'Debug event');
+		assert.equal(events[0].data[0], 'Debug event');
 		assert.instanceOf(events[0].startTime, Date);
 	    },
 
 	    'should not emit events of a lower level': function(events) {
-		assert.length(events, 2);
+		assert.length(events, 4);
 		assert.equal(events[1].level.toString(), 'WARN');
-	    }
+	    },
+
+            'should include the error if passed in': function (events) {
+                assert.instanceOf(events[2].data[1], Error);
+                assert.equal(events[2].data[1].message, 'Pants are on fire!');
+            }
+
 	},
 
     },
 
     'fileAppender': {
 	topic: function() {
-	    var appender, logmessages = [], thing = "thing", fakeFS = {
+	    var appender
-		openSync: function() {
+          , logmessages = []
+          , thing = "thing"
+          , fakeFS = {
+		createWriteStream: function() {
 		    assert.equal(arguments[0], './tmp-tests.log');
-		    assert.equal(arguments[1], 'a');
+		    assert.isObject(arguments[1]);
-		    assert.equal(arguments[2], 0644);
+		    assert.equal(arguments[1].flags, 'a');
-		    return thing;
+                    assert.equal(arguments[1].mode, 0644);
-		},
+                    assert.equal(arguments[1].encoding, 'utf8');
-		write: function() {
+		    return {
-		    assert.equal(arguments[0], thing);
+                        write: function(message) {
-		    assert.isString(arguments[1]);
+                            logmessages.push(message);
-		    assert.isNull(arguments[2]);
+                        }
-		    assert.equal(arguments[3], "utf8");
+                      , end: function() {}
-		    logmessages.push(arguments[1]);
+                      , destroySoon: function() {}
+                    };
 		},
                 watchFile: function() {
                     throw new Error("watchFile should not be called if logSize is not defined");
                 }
 	    },
-	    log4js = require('../lib/log4js')(fakeFS);
+	    log4js = sandbox.require(
+                '../lib/log4js',
+                {
+                    requires: {
+                        'fs': fakeFS
+                    }
+                }
+            );
 	    log4js.clearAppenders();
-	    
+
-	    appender = log4js.fileAppender('./tmp-tests.log', log4js.messagePassThroughLayout);
+	    appender = log4js.fileAppender('./tmp-tests.log', log4js.layouts.messagePassThroughLayout);
-	    log4js.addAppender(appender, 'file-test');	    
+	    log4js.addAppender(appender, 'file-test');
 
 	    var logger = log4js.getLogger('file-test');
 	    logger.debug("this is a test");
 
 	    return logmessages;
 	},
-	'should write log messages to file': function(logmessages) {	    
+	'should write log messages to file': function(logmessages) {
 	    assert.length(logmessages, 1);
 	    assert.equal(logmessages, "this is a test\n");
 	}
@@ -85,104 +105,125 @@ vows.describe('log4js').addBatch({
 
     'fileAppender - with rolling based on size and number of files to keep': {
         topic: function() {
-            var watchCb, 
+            var watchCb,
-            filesOpened = [], 
+            filesOpened = [],
-            filesClosed = [], 
+            filesEnded = [],
+            filesDestroyedSoon = [],
             filesRenamed = [],
             newFilenames = [],
             existingFiles = ['tests.log'],
-            log4js = require('../lib/log4js')({
+            log4js = sandbox.require(
-                watchFile: function(file, options, callback) {
+                '../lib/log4js'
-                    assert.equal(file, 'tests.log');
+              , {
-                    assert.equal(options.persistent, false);
+                  requires: {
-                    assert.equal(options.interval, 30000);
+                      'fs': {
-                    assert.isFunction(callback);
+                          watchFile: function(file, options, callback) {
-                    watchCb = callback;
+                              assert.equal(file, 'tests.log');
-                },
+                              assert.equal(options.persistent, false);
-                openSync: function(file) {
+                              assert.equal(options.interval, 30000);
-                    assert.equal(file, 'tests.log');
+                              assert.isFunction(callback);
-                    filesOpened.push(file);
+                              watchCb = callback;
-                    return file;
+                          },
-                },
+                          createWriteStream: function(file) {
-                statSync: function(file) {
+                              assert.equal(file, 'tests.log');
-                    if (existingFiles.indexOf(file) < 0) {
+                              filesOpened.push(file);
-                        throw new Error("this file doesn't exist");
+                              return {
-                    } else {
+                                  end: function() {
-                        return true;
+                                      filesEnded.push(file);
-                    }
+                                  },
-                },
+                                  destroySoon: function() {
-                renameSync: function(oldFile, newFile) {
+                                      filesDestroyedSoon.push(file);
-                    filesRenamed.push(oldFile);
+                                  }
-                    existingFiles.push(newFile);
+                              };
-                },
+                          },
-                closeSync: function(file) {
+                          statSync: function(file) {
-                    //it should always be closing tests.log
+                              if (existingFiles.indexOf(file) < 0) {
-                    assert.equal(file, 'tests.log');
+                                  throw new Error("this file doesn't exist");
-                    filesClosed.push(file);
+                              } else {
-                }
+                                  return true;
-            });
+                              }
+                          },
+                          renameSync: function(oldFile, newFile) {
+                              filesRenamed.push(oldFile);
+                              existingFiles.push(newFile);
+                          }
+                      }
+                  }
+              }
+            );
             var appender = log4js.fileAppender('tests.log', log4js.messagePassThroughLayout, 1024, 2, 30);
-            return [watchCb, filesOpened, filesClosed, filesRenamed, existingFiles];
+            return [watchCb, filesOpened, filesEnded, filesDestroyedSoon, filesRenamed, existingFiles];
         },
 
         'should close current log file, rename all old ones, open new one on rollover': function(args) {
-            var watchCb = args[0], filesOpened = args[1], filesClosed = args[2], filesRenamed = args[3], existingFiles = args[4];
+              var watchCb = args[0]
-            assert.isFunction(watchCb);
+            , filesOpened = args[1]
-            //tell the watchCb that the file is below the threshold
+            , filesEnded = args[2]
-            watchCb({ size: 891 }, { size: 0 });
+            , filesDestroyedSoon = args[3]
-            //filesOpened should still be the first one.
+            , filesRenamed = args[4]
-            assert.length(filesOpened, 1);
+            , existingFiles = args[5];
-            //tell the watchCb that the file is now over the threshold
+              assert.isFunction(watchCb);
-            watchCb({ size: 1053 }, { size: 891 });
+              //tell the watchCb that the file is below the threshold
-            //it should have closed the first log file.
+              watchCb({ size: 891 }, { size: 0 });
-            assert.length(filesClosed, 1);
+              //filesOpened should still be the first one.
-            //it should have renamed the previous log file
+              assert.length(filesOpened, 1);
-            assert.length(filesRenamed, 1);
+              //tell the watchCb that the file is now over the threshold
-            //and we should have two files now
+              watchCb({ size: 1053 }, { size: 891 });
-            assert.length(existingFiles, 2);
+              //it should have closed the first log file.
-            assert.deepEqual(existingFiles, ['tests.log', 'tests.log.1']);
+              assert.length(filesEnded, 1);
-            //and opened a new log file.
+              assert.length(filesDestroyedSoon, 1);
-            assert.length(filesOpened, 2);
+              //it should have renamed the previous log file
-            
+              assert.length(filesRenamed, 1);
-            //now tell the watchCb that we've flipped over the threshold again
+              //and we should have two files now
-            watchCb({ size: 1025 }, { size: 123 });
+              assert.length(existingFiles, 2);
-            //it should have closed the old file
+              assert.deepEqual(existingFiles, ['tests.log', 'tests.log.1']);
-            assert.length(filesClosed, 2);
+              //and opened a new log file.
-            //it should have renamed both the old log file, and the previous '.1' file
+              assert.length(filesOpened, 2);
-            assert.length(filesRenamed, 3);
-            assert.deepEqual(filesRenamed, ['tests.log', 'tests.log.1', 'tests.log' ]);
-            //it should have renamed 2 more file
-            assert.length(existingFiles, 4);
-            assert.deepEqual(existingFiles, ['tests.log', 'tests.log.1', 'tests.log.2', 'tests.log.1']);
-            //and opened a new log file
-            assert.length(filesOpened, 3);
 
-            //tell the watchCb we've flipped again.
+              //now tell the watchCb that we've flipped over the threshold again
-            watchCb({ size: 1024 }, { size: 234 });
+              watchCb({ size: 1025 }, { size: 123 });
-            //close the old one again.
+              //it should have closed the old file
-            assert.length(filesClosed, 3);
+              assert.length(filesEnded, 2);
-            //it should have renamed the old log file and the 2 backups, with the last one being overwritten.
+              assert.length(filesDestroyedSoon, 2);
-            assert.length(filesRenamed, 5);
+              //it should have renamed both the old log file, and the previous '.1' file
-            assert.deepEqual(filesRenamed, ['tests.log', 'tests.log.1', 'tests.log', 'tests.log.1', 'tests.log' ]);
+              assert.length(filesRenamed, 3);
-            //it should have renamed 2 more files
+              assert.deepEqual(filesRenamed, ['tests.log', 'tests.log.1', 'tests.log' ]);
-            assert.length(existingFiles, 6);
+              //it should have renamed 2 more file
-            assert.deepEqual(existingFiles, ['tests.log', 'tests.log.1', 'tests.log.2', 'tests.log.1', 'tests.log.2', 'tests.log.1']);
+              assert.length(existingFiles, 4);
-            //and opened a new log file
+              assert.deepEqual(existingFiles, ['tests.log', 'tests.log.1', 'tests.log.2', 'tests.log.1']);
-            assert.length(filesOpened, 4);
+              //and opened a new log file
-        }
+              assert.length(filesOpened, 3);
+
+              //tell the watchCb we've flipped again.
+              watchCb({ size: 1024 }, { size: 234 });
+              //close the old one again.
+              assert.length(filesEnded, 3);
+              assert.length(filesDestroyedSoon, 3);
+              //it should have renamed the old log file and the 2 backups, with the last one being overwritten.
+              assert.length(filesRenamed, 5);
+              assert.deepEqual(filesRenamed, ['tests.log', 'tests.log.1', 'tests.log', 'tests.log.1', 'tests.log' ]);
+              //it should have renamed 2 more files
+              assert.length(existingFiles, 6);
+              assert.deepEqual(existingFiles, ['tests.log', 'tests.log.1', 'tests.log.2', 'tests.log.1', 'tests.log.2', 'tests.log.1']);
+              //and opened a new log file
+              assert.length(filesOpened, 4);
+          }
     },
 
     'configure' : {
 	topic: function() {
 	    var messages = {}, fakeFS = {
-		openSync: function(file) {
+		createWriteStream: function(file) {
-		    return file;
+		    return {
-		},
+                        write: function(message) {
-		write: function(file, message) {
+                            if (!messages.hasOwnProperty(file)) {
-		    if (!messages.hasOwnProperty(file)) {
+			        messages[file] = [];
-			messages[file] = [];
+		            }
-		    }
+		            messages[file].push(message);
-		    messages[file].push(message); 
+                        }
+                      , end: function() {}
+                      , destroySoon: function() {}
+                    };
 		},
 		readFileSync: function(file, encoding) {
 		    return require('fs').readFileSync(file, encoding);
@@ -191,7 +232,14 @@ vows.describe('log4js').addBatch({
                     messages.watchedFile = file;
                 }
 	    },
-	    log4js = require('../lib/log4js')(fakeFS);
+	    log4js = sandbox.require(
+                '../lib/log4js'
+              , {
+                  requires: {
+                      'fs': fakeFS
+                  }
+              }
+            );
 	    return [ log4js, messages ];
 	},
 	'should load appender configuration from a json file': function(args) {
@@ -201,7 +249,7 @@ vows.describe('log4js').addBatch({
 	    //this config file defines one file appender (to ./tmp-tests.log)
 	    //and sets the log level for "tests" to WARN
 	    log4js.configure('test/log4js.json');
-	    var logger = log4js.getLogger("tests");	    
+	    var logger = log4js.getLogger("tests");
 	    logger.info('this should not be written to the file');
 	    logger.warn('this should be written to the file');
 	    assert.length(messages['tmp-tests.log'], 1);
@@ -229,12 +277,43 @@ vows.describe('log4js').addBatch({
             delete messages['tmp-test.log'];
             log4js.configure('test/with-log-rolling.json');
             assert.equal(messages.watchedFile, 'tmp-test.log');
-        }            
+        },
+        'should handle an object or a file name': function(args) {
+	    var log4js = args[0],
+	    messages = args[1],
+	    config = {
+		"appenders": [
+		    {
+			"type" : "file",
+			"filename" : "cheesy-wotsits.log",
+			"maxLogSize" : 1024,
+			"backups" : 3,
+			"pollInterval" : 15
+		    }
+		]
+	    };
+	    delete messages['cheesy-wotsits.log'];
+	    log4js.configure(config);
+	    assert.equal(messages.watchedFile, 'cheesy-wotsits.log');
+	}
     },
 
     'with no appenders defined' : {
         topic: function() {
-            var logger, message, log4js = require('../lib/log4js')(null, function (msg) { message = msg; } );
+            var logger
+          , message
+          , log4js = sandbox.require(
+              '../lib/log4js'
+            , {
+                globals: {
+                  console: {
+                      log: function(msg) {
+                          message = msg;
+                      }
+                  }
+              }
+            }
+          );
 	    logger = log4js.getLogger("some-logger");
             logger.debug("This is a test");
             return message;
@@ -244,95 +323,160 @@ vows.describe('log4js').addBatch({
         }
     },
 
+    'addAppender' : {
+        topic: function() {
+            var log4js = require('../lib/log4js');
+            log4js.clearAppenders();
+            return log4js;
+        },
+        'without a category': {
+            'should register the function as a listener for all loggers': function (log4js) {
+                var appenderEvent, appender = function(evt) { appenderEvent = evt; }, logger = log4js.getLogger("tests");
+                log4js.addAppender(appender);
+                logger.debug("This is a test");
+                assert.equal(appenderEvent.data[0], "This is a test");
+                assert.equal(appenderEvent.categoryName, "tests");
+                assert.equal(appenderEvent.level.toString(), "DEBUG");
+            },
+            'should also register as an appender for loggers if an appender for that category is defined': function (log4js) {
+                var otherEvent, appenderEvent, cheeseLogger;
+                log4js.addAppender(function (evt) { appenderEvent = evt; });
+                log4js.addAppender(function (evt) { otherEvent = evt; }, 'cheese');
+
+                cheeseLogger = log4js.getLogger('cheese');
+                cheeseLogger.debug('This is a test');
+                assert.deepEqual(appenderEvent, otherEvent);
+                assert.equal(otherEvent.data[0], 'This is a test');
+                assert.equal(otherEvent.categoryName, 'cheese');
+
+                otherEvent = undefined;
+                appenderEvent = undefined;
+                log4js.getLogger('pants').debug("this should not be propagated to otherEvent");
+                assert.isUndefined(otherEvent);
+                assert.equal(appenderEvent.data[0], "this should not be propagated to otherEvent");
+            }
+        },
+
+        'with a category': {
+            'should only register the function as a listener for that category': function(log4js) {
+                var appenderEvent, appender = function(evt) { appenderEvent = evt; }, logger = log4js.getLogger("tests");
+                log4js.addAppender(appender, 'tests');
+                logger.debug('this is a category test');
+                assert.equal(appenderEvent.data[0], 'this is a category test');
+
+                appenderEvent = undefined;
+                log4js.getLogger('some other category').debug('Cheese');
+                assert.isUndefined(appenderEvent);
+            }
+        },
+
+        'with multiple categories': {
+            'should register the function as a listener for all the categories': function(log4js) {
+                var appenderEvent, appender = function(evt) { appenderEvent = evt; }, logger = log4js.getLogger('tests');
+                log4js.addAppender(appender, 'tests', 'biscuits');
+
+                logger.debug('this is a test');
+                assert.equal(appenderEvent.data[0], 'this is a test');
+                appenderEvent = undefined;
+
+                var otherLogger = log4js.getLogger('biscuits');
+                otherLogger.debug("mmm... garibaldis");
+                assert.equal(appenderEvent.data[0], "mmm... garibaldis");
+
+                appenderEvent = undefined;
+
+                log4js.getLogger("something else").debug("pants");
+                assert.isUndefined(appenderEvent);
+            },
+            'should register the function when the list of categories is an array': function(log4js) {
+                var appenderEvent, appender = function(evt) { appenderEvent = evt; };
+                log4js.addAppender(appender, ['tests', 'pants']);
+
+                log4js.getLogger('tests').debug('this is a test');
+                assert.equal(appenderEvent.data[0], 'this is a test');
+
+                appenderEvent = undefined;
+
+                log4js.getLogger('pants').debug("big pants");
+                assert.equal(appenderEvent.data[0], "big pants");
+
+                appenderEvent = undefined;
+
+                log4js.getLogger("something else").debug("pants");
+                assert.isUndefined(appenderEvent);
+            }
+        }
+    },
+
     'default setup': {
         topic: function() {
-            var pathsChecked = [], 
+            var pathsChecked = [],
             message,
             logger,
+            modulePath = require('path').normalize(__dirname + '/../lib/log4js.json'),
             fakeFS = {
                 readFileSync: function (file, encoding) {
-                    assert.equal(file, '/path/to/config/log4js.json');
+                    assert.equal(file, modulePath);
                     assert.equal(encoding, 'utf8');
                     return '{ "appenders" : [ { "type": "console", "layout": { "type": "messagePassThrough" }} ] }';
                 },
                 statSync: function (path) {
                     pathsChecked.push(path);
-                    if (path === '/path/to/config/log4js.json') {
+                    if (path === modulePath) {
                         return true;
                     } else {
                         throw new Error("no such file");
                     }
                 }
             },
-            fakeConsoleLog = function (msg) { message = msg; }, 
+            fakeConsole = {
-            fakeRequirePath = [ '/a/b/c', '/some/other/path', '/path/to/config', '/some/later/directory' ],
+                log : function (msg) { message = msg; },
-            log4js = require('../lib/log4js')(fakeFS, fakeConsoleLog, fakeRequirePath),
+                info: this.log,
-            logger = log4js.getLogger('a-test');
+                warn: this.log,
+                debug: this.log,
+                error: this.log
+            },
+	    log4js = sandbox.require(
+                '../lib/log4js',
+                {
+                    requires: {
+                        'fs': fakeFS
+                    },
+                    globals: {
+                        'console': fakeConsole
+                    }
+                }
+            );
+
+	    logger = log4js.getLogger('a-test');
             logger.debug("this is a test");
 
-            return [ pathsChecked, message ];
+            return [ pathsChecked, message, modulePath ];
         },
-        
+
         'should check current directory, require paths, and finally the module dir for log4js.json': function(args) {
             var pathsChecked = args[0];
-            assert.deepEqual(pathsChecked, [
+              expectedPaths = ['log4js.json'].concat(
-                'log4js.json',
+                  require.paths.map(function(item) {
-                '/a/b/c/log4js.json', 
+                      return item + '/log4js.json';
-                '/some/other/path/log4js.json', 
+                  }),
-                '/path/to/config/log4js.json', 
+                  args[2]
-                '/some/later/directory/log4js.json',
+              );
-                require('path').normalize(__dirname + '/../lib/log4js.json')
+            assert.deepEqual(pathsChecked, expectedPaths);
-            ]);
         },
-        
+
         'should configure log4js from first log4js.json found': function(args) {
             var message = args[1];
             assert.equal(message, 'this is a test');
         }
     },
-    
-    'colouredLayout': {
-        topic: function() {
-            return require('../lib/log4js')().colouredLayout;
-        },
-
-        'should apply level colour codes to output': function(layout) {
-            var output = layout({ 
-                message: "nonsense", 
-                startTime: new Date(2010, 11, 5, 14, 18, 30, 45), 
-                categoryName: "cheese", 
-                level: { 
-                    colour: "green", 
-                    toString: function() { return "ERROR"; } 
-                }
-            });
-            assert.equal(output, '\033[90m[2010-12-05 14:18:30.045] \033[39m\033[32m[ERROR] \033[39m\033[90mcheese - \033[39mnonsense');
-        }
-    },
-
-    'messagePassThroughLayout': {
-        topic: function() {
-            return require('../lib/log4js')().messagePassThroughLayout;
-        },
-        'should take a logevent and output only the message' : function(layout) {
-            assert.equal(layout({ 
-                message: "nonsense", 
-                startTime: new Date(2010, 11, 5, 14, 18, 30, 45), 
-                categoryName: "cheese", 
-                level: { 
-                    colour: "green", 
-                    toString: function() { return "ERROR"; } 
-                }
-            }), "nonsense");
-        }
-    },
 
     'logLevelFilter': {
         topic: function() {
-            var log4js = require('../lib/log4js')(), logEvents = [], logger;
+            var log4js = require('../lib/log4js'), logEvents = [], logger;
             log4js.clearAppenders();
-            log4js.addAppender(log4js.logLevelFilter('ERROR', function(evt) { logEvents.push(evt); }));
+            log4js.addAppender(log4js.logLevelFilter('ERROR', function(evt) { logEvents.push(evt); }), "logLevelTest");
-            logger = log4js.getLogger();
+            logger = log4js.getLogger("logLevelTest");
             logger.debug('this should not trigger an event');
             logger.warn('neither should this');
             logger.error('this should, though');
@@ -341,22 +485,74 @@ vows.describe('log4js').addBatch({
         },
         'should only pass log events greater than or equal to its own level' : function(logEvents) {
             assert.length(logEvents, 2);
-            assert.equal(logEvents[0].message, 'this should, though');
+            assert.equal(logEvents[0].data[0], 'this should, though');
-            assert.equal(logEvents[1].message, 'so should this');
+            assert.equal(logEvents[1].data[0], 'so should this');
         }
     },
 
-    'Date extensions': {
+    'console' : {
         topic: function() {
-            require('../lib/log4js');
+            var fakeConsole = {}
-            return new Date(2010, 0, 11, 14, 31, 30, 5);
+          , logEvents = []
+          , log4js;
+
+            ['trace','debug','log','info','warn','error'].forEach(function(fn) {
+                fakeConsole[fn] = function() {
+                    throw new Error("this should not be called.");
+                };
+            });
+
+            log4js = sandbox.require(
+                '../lib/log4js'
+              , {
+                  globals: {
+                      console: fakeConsole
+                  }
+              }
+            );
+
+            log4js.clearAppenders();
+            log4js.addAppender(function(evt) {
+                logEvents.push(evt);
+            });
+
+            fakeConsole.log("Some debug message someone put in a module");
+            fakeConsole.debug("Some debug");
+            fakeConsole.error("An error");
+            fakeConsole.info("some info");
+            fakeConsole.warn("a warning");
+
+            fakeConsole.log("cheese (%s) and biscuits (%s)", "gouda", "garibaldis");
+            fakeConsole.log({ lumpy: "tapioca" });
+            fakeConsole.log("count %d", 123);
+            fakeConsole.log("stringify %j", { lumpy: "tapioca" });
+
+            return logEvents;
         },
-        'should add a toFormattedString method to Date': function(date) {
+        'should replace console.log methods with log4js ones': function(logEvents) {
-            assert.isFunction(date.toFormattedString);
+            assert.equal(logEvents[0].data[0], "Some debug message someone put in a module");
-        },
+            assert.equal(logEvents[0].level.toString(), "INFO");
-        'should default to a format': function(date) {
+            assert.equal(logEvents[1].data[0], "Some debug");
-            assert.equal(date.toFormattedString(), '2010-01-11 14:31:30.005');
+            assert.equal(logEvents[1].level.toString(), "DEBUG");
+            assert.equal(logEvents[2].data[0], "An error");
+            assert.equal(logEvents[2].level.toString(), "ERROR");
+            assert.equal(logEvents[3].data[0], "some info");
+            assert.equal(logEvents[3].level.toString(), "INFO");
+            assert.equal(logEvents[4].data[0], "a warning");
+            assert.equal(logEvents[4].level.toString(), "WARN");
         }
+    },
+    'configuration persistence' : {
+	'should maintain appenders between requires': function () {
+	    var logEvent, firstLog4js = require('../lib/log4js'), secondLog4js;
+	    firstLog4js.clearAppenders();
+	    firstLog4js.addAppender(function(evt) { logEvent = evt; });
+
+	    secondLog4js = require('../lib/log4js');
+	    secondLog4js.getLogger().info("This should go to the appender defined in firstLog4js");
+
+	    assert.equal(logEvent.data[0], "This should go to the appender defined in firstLog4js");
+	}
     }
 
 }).export(module);

test/test-connect-logger.js

@@ -0,0 +1,128 @@
+var vows = require('vows')
+, assert = require('assert')
+, levels = require('../lib/levels');
+
+function MockLogger() {
+
+    var that = this;
+    this.messages = [];
+
+    this.log = function(level, message, exception) {
+	that.messages.push({ level: level, message: message });
+    };
+
+    this.isLevelEnabled = function(level) {
+        return level.isGreaterThanOrEqualTo(that.level);
+    };
+
+    this.level = levels.TRACE;
+
+}
+
+function MockRequest(remoteAddr, method, originalUrl) {
+
+    this.socket = { remoteAddress: remoteAddr };
+    this.originalUrl = originalUrl;
+    this.method = method;
+    this.httpVersionMajor = '5';
+    this.httpVersionMinor = '0';
+    this.headers = {}
+
+}
+
+function MockResponse(statusCode) {
+
+    this.statusCode = statusCode;
+
+    this.end = function(chunk, encoding) {
+
+    }
+
+}
+
+vows.describe('log4js connect logger').addBatch({
+    'getConnectLoggerModule': {
+	topic: function() {
+	    var clm = require('../lib/connect-logger');
+	    return clm;
+	},
+
+	'should return a "connect logger" factory' : function(clm) {
+	    assert.isObject(clm);
+	},
+
+	'take a log4js logger and return a "connect logger"' : {
+	    topic: function(clm) {
+		var ml = new MockLogger();
+		var cl = clm.connectLogger(ml);
+		return cl;
+	    },
+
+	    'should return a "connect logger"': function(cl) {
+		assert.isFunction(cl);
+	    }
+	},
+
+	'log events' : {
+	    topic: function(clm) {
+		var ml = new MockLogger();
+		var cl = clm.connectLogger(ml);
+		var req = new MockRequest('my.remote.addr', 'GET', 'http://url');
+		var res = new MockResponse(200);
+		cl(req, res, function() { });
+        	res.end('chunk', 'encoding');
+        	return ml.messages;
+	    },
+
+	    'check message': function(messages) {
+		assert.isArray(messages);
+		assert.length(messages, 1);
+		assert.equal(messages[0].level, levels.INFO);
+		assert.include(messages[0].message, 'GET');
+		assert.include(messages[0].message, 'http://url');
+		assert.include(messages[0].message, 'my.remote.addr');
+		assert.include(messages[0].message, '200');
+	    }
+	},
+
+	'log events with level below logging level' : {
+	    topic: function(clm) {
+		var ml = new MockLogger();
+		ml.level = levels.FATAL;
+		var cl = clm.connectLogger(ml);
+		var req = new MockRequest('my.remote.addr', 'GET', 'http://url');
+		var res = new MockResponse(200);
+		cl(req, res, function() { });
+		res.end('chunk', 'encoding');
+		return ml.messages;
+	    },
+
+	    'check message': function(messages) {
+		assert.isArray(messages);
+		assert.isEmpty(messages);
+	    }
+	},
+
+	'log events with non-default level and custom format' : {
+	    topic: function(clm) {
+		var ml = new MockLogger();
+		ml.level = levels.INFO;
+		var cl = clm.connectLogger(ml, { level: levels.INFO, format: ':method :url' } );
+		var req = new MockRequest('my.remote.addr', 'GET', 'http://url');
+		var res = new MockResponse(200);
+		cl(req, res, function() { });
+		res.end('chunk', 'encoding');
+		return ml.messages;
+	    },
+
+	    'check message': function(messages) {
+		assert.isArray(messages);
+		assert.length(messages, 1);
+		assert.equal(messages[0].level, levels.INFO);
+		assert.equal(messages[0].message, 'GET http://url');
+	    }
+	}
+
+    }
+
+}).export(module);

test/test-global-log-level.js

@@ -0,0 +1,85 @@
+var vows = require('vows'),
+assert = require('assert');
+
+vows.describe('log4js global loglevel').addBatch({
+    'global loglevel' : {
+        topic: function() {
+            var log4js = require('../lib/log4js');
+            return log4js;
+        },
+
+        'set global loglevel on creation': function(log4js) {
+            var log1 = log4js.getLogger('log1');
+            var level = 'OFF';
+            if (log1.level.toString() == level) {
+                level = 'TRACE';
+            }
+            assert.notEqual(log1.level.toString(), level);
+
+            log4js.setGlobalLogLevel(level);
+            assert.equal(log1.level.toString(), level);
+
+            var log2 = log4js.getLogger('log2');
+            assert.equal(log2.level.toString(), level);
+        },
+
+        'global change loglevel': function(log4js) {
+            var log1 = log4js.getLogger('log1');
+            var log2 = log4js.getLogger('log2');
+            var level = 'OFF';
+            if (log1.level.toString() == level) {
+                level = 'TRACE';
+            }
+            assert.notEqual(log1.level.toString(), level);
+
+            log4js.setGlobalLogLevel(level);
+            assert.equal(log1.level.toString(), level);
+            assert.equal(log2.level.toString(), level);
+        },
+
+        'override loglevel': function(log4js) {
+            var log1 = log4js.getLogger('log1');
+            var log2 = log4js.getLogger('log2');
+            var level = 'OFF';
+            if (log1.level.toString() == level) {
+                level = 'TRACE';
+            }
+            assert.notEqual(log1.level.toString(), level);
+
+            var oldLevel = log1.level.toString();
+            assert.equal(log2.level.toString(), oldLevel);
+
+            log2.setLevel(level);
+            assert.equal(log1.level.toString(), oldLevel);
+            assert.equal(log2.level.toString(), level);
+            assert.notEqual(oldLevel, level);
+
+            log2.removeLevel();
+            assert.equal(log1.level.toString(), oldLevel);
+            assert.equal(log2.level.toString(), oldLevel);
+        },
+
+        'preload loglevel': function(log4js) {
+            var log1 = log4js.getLogger('log1');
+            var level = 'OFF';
+            if (log1.level.toString() == level) {
+                level = 'TRACE';
+            }
+            assert.notEqual(log1.level.toString(), level);
+
+            var oldLevel = log1.level.toString();
+            log4js.getLogger('log2').setLevel(level);
+
+            assert.equal(log1.level.toString(), oldLevel);
+
+            // get again same logger but as different variable
+            var log2 = log4js.getLogger('log2');
+            assert.equal(log2.level.toString(), level);
+            assert.notEqual(oldLevel, level);
+
+            log2.removeLevel();
+            assert.equal(log1.level.toString(), oldLevel);
+            assert.equal(log2.level.toString(), oldLevel);
+        }
+    }
+}).export(module);

tests.js

@@ -1,43 +0,0 @@
-require.paths.unshift("./spec/lib", "./lib");
-require("jspec");
-
-var sys = require("sys"), fs = require("fs");
-
-quit = process.exit
-print = sys.puts
-
-readFile = function(path) {
-  var result;
-  try {
-    result = fs.readFileSync(path, "utf8");
-  } catch (e) {
-    throw e;
-  }
-  return result;
-}
-
-var specsFound = false;
-
-if (process.ARGV[2]) {
-  specsFound = true;
-  JSpec.exec('spec/spec.' + process.ARGV[2] + '.js');
-} else {
-  var files = fs.readdirSync('spec/');  
-  files.filter(
-    function (file) { 
-      return file.indexOf('spec.') === 0; 
-    }
-  ).forEach(
-    function(file) {
-        specsFound = true;
-        JSpec.exec('spec/'+file);
-      }
-  );
-}
-if (specsFound) {
-  JSpec.run({ reporter: JSpec.reporters.Terminal, failuresOnly: false });
-  JSpec.report();
-} else {
-  print("No tests to run. This makes me sad.");
-}
-