removed main function, now using felixge's sandboxed-module, split code into multiple files

lib/connect-logger.js

@@ -1,3 +1,4 @@
+var levels = require("./levels");
 /**
  * Log requests with the given `options` or a `format` string.
  *
@@ -25,115 +26,89 @@
  * @api public
  */
 
-module.exports = function(log4js_module) {
+function getLogger(logger4js, options) {
-    var log4js = log4js_module;
+    if ('object' == typeof options) {
-
+	options = options || {};
-    function getLogger(logger4js, options) {
+    } else if (options) {
-	if ('object' == typeof options) {
+	options = { format: options };
-	    options = options || {};
+    } else {
-	} else if (options) {
+	options = {};
-	    options = { format: options };
-	} else {
-	    options = {};
-	}
-	
-	var thislogger = logger4js;
-	var level = options.level || log4js.levels.TRACE;
-	var fmt = options.format;
-	
-	return function logger(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.
-		if (fmt) {
-		    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));
-			}
-		    };
-		} else {
-		    res.end = function(chunk, encoding) {
-			var contentLength = (res._headers && res._headers['content-length'])
-			    || (res.__headers && res.__headers['Content-Length'])
-			    || '-';
-
-			res.end = end;
-			res.end(chunk, encoding);
-
-			thislogger.log(level, 
-				       (req.socket && (req.socket.remoteAddress || (req.socket.socket && req.socket.socket.remoteAddress))) + 
-				       ' - - "' + req.method + ' ' + url + 
-				       ' HTTP/' + req.httpVersionMajor + '.' + req.httpVersionMinor + '" ' + 
-				       (statusCode || res.statusCode) + ' ' + contentLength + ' "' + 
-				       (req.headers['referer'] || req.headers['referrer'] || '') + '" "' + 
-				       (req.headers['user-agent'] || '') + '"');
-		    };
-		}
-
-		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(/: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]);
-		});
-	}
-
     }
 
-    return {
+    var thislogger = logger4js
-	connectLogger: getLogger
+  , 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/log4js.js

@@ -22,7 +22,7 @@
  *
  * <h3>Example:</h3>
  * <pre>
- *  var logging = require('log4js-node')();
+ *  var logging = require('log4js');
  *  //add an appender that logs all messages to stdout.
  *  logging.addAppender(logging.consoleAppender());
  *  //add an appender that logs "some-category" to a file
@@ -44,35 +44,28 @@
  * @static
  * Website: http://log4js.berlios.de
  */
-var events = require('events'),
+var events = require('events')
-path = require('path'),
+, fs = require('fs')
-sys = require('sys'),
+, path = require('path')
-DEFAULT_CATEGORY = '[default]',
+, sys = require('sys')
-ALL_CATEGORIES = '[all]',
+, layouts = require('./layouts')
-appenders = {},
+, levels = require('./levels')
-loggers = {},
+, DEFAULT_CATEGORY = '[default]'
-levels = {
+, ALL_CATEGORIES = '[all]'
-    ALL: new Level(Number.MIN_VALUE, "ALL", "grey"),
+, appenders = {}
-    TRACE: new Level(5000, "TRACE", "blue"),
+, loggers = {}
-    DEBUG: new Level(10000, "DEBUG", "cyan"),
+, appenderMakers = {
-    INFO: new Level(20000, "INFO", "green"),
-    WARN: new Level(30000, "WARN", "yellow"),
-    ERROR: new Level(40000, "ERROR", "red"),
-    FATAL: new Level(50000, "FATAL", "magenta"),
-    OFF: new Level(Number.MAX_VALUE, "OFF", "grey")  
-},
-appenderMakers = {
     "file": function(config, fileAppender) {
 	var layout;
 	if (config.layout) {
-	    layout = layoutMakers[config.layout.type](config.layout);
+	    layout = layouts.layout(config.layout.type, config.layout);
 	}
 	return fileAppender(config.filename, layout, config.maxLogSize, config.backups, config.pollInterval);
     },
     "console": function(config, fileAppender, consoleAppender) {
 	var layout;
 	if (config.layout) {
-	    layout = layoutMakers[config.layout.type](config.layout);
+	    layout = layouts.layout(config.layout.type, config.layout);
 	}
 	return consoleAppender(layout);
     },
@@ -80,16 +73,6 @@ appenderMakers = {
 	var appender = appenderMakers[config.appender.type](config.appender, fileAppender, consoleAppender);
 	return logLevelFilter(config.level, appender);
     }
-},
-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);
-    }
 };
 
 /**
@@ -156,7 +139,6 @@ function addAppender () {
 	    loggers[category].addListener("log", appender);
 	}
     });
-    appenders.count = appenders.count ? appenders.count++ : 1;
 }
 
 function clearAppenders () {
@@ -194,46 +176,6 @@ function configureLevels(levels) {
     }
 }
 
-function Level(level, levelStr, colour) {
-    this.level = level;
-    this.levelStr = levelStr;
-    this.colour = colour;
-}
-
-/** 
- * 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
- */
-Level.toLevel = function(sArg, defaultLevel) {                  
-    
-    if (sArg === null) {
-	return defaultLevel;
-    }
-    
-    if (typeof sArg == "string") { 
-	var s = sArg.toUpperCase();
-	if (levels[s]) {
-	    return levels[s];
-	}
-    }
-    return defaultLevel;
-};
-
-Level.prototype.toString = function() {
-    return this.levelStr;	
-};
-
-Level.prototype.isLessThanOrEqualTo = function(otherLevel) {
-    return this.level <= otherLevel.level;
-};
-
-Level.prototype.isGreaterThanOrEqualTo = function(otherLevel) {
-    return this.level >= otherLevel.level;
-};
-
 /**
  * Models a logging event.
  * @constructor
@@ -273,7 +215,7 @@ function Logger (name, level) {
 sys.inherits(Logger, events.EventEmitter);
 
 Logger.prototype.setLevel = function(level) {
-    this.level = Level.toLevel(level, levels.TRACE);
+    this.level = levels.toLevel(level, levels.TRACE);
 };
 
 Logger.prototype.removeLevel = function() {
@@ -291,7 +233,7 @@ Logger.prototype.isLevelEnabled = function(otherLevel) {
 
 ['Trace','Debug','Info','Warn','Error','Fatal'].forEach(
     function(levelString) {
-	var level = Level.toLevel(levelString);
+	var level = levels.toLevel(levelString);
 	Logger.prototype['is'+levelString+'Enabled'] = function() {
 	    return this.isLevelEnabled(level);
 	};
@@ -305,7 +247,7 @@ Logger.prototype.isLevelEnabled = function(otherLevel) {
 );
 
 function setGlobalLogLevel(level) {
-    Logger.prototype.level = Level.toLevel(level, levels.TRACE);
+    Logger.prototype.level = levels.toLevel(level, levels.TRACE);
 }
 
 /**
@@ -318,7 +260,7 @@ function getDefaultLogger () {
 }
 
 function logLevelFilter (levelString, appender) {
-    var level = Level.toLevel(levelString);
+    var level = levels.toLevel(levelString);
     return function(logEvent) {
 	if (logEvent.level.isGreaterThanOrEqualTo(level)) {
 	    appender(logEvent);
@@ -326,424 +268,154 @@ function logLevelFilter (levelString, appender) {
     }
 }
 
-/**
- * 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) {
-    var timestampLevelAndCategory = '[' + loggingEvent.startTime.toFormattedString() + '] ';
-    timestampLevelAndCategory += '[' + loggingEvent.level.toString() + '] ';
-    timestampLevelAndCategory += loggingEvent.categoryName + ' - ';
 
-    var output = timestampLevelAndCategory + loggingEvent.message;
+function consoleAppender (layout) {
-    
+    layout = layout || layouts.colouredLayout;
-    if (loggingEvent.exception) {
+    return function(loggingEvent) {
-	output += '\n'
+	console._preLog4js_log(layout(loggingEvent));
-	output += timestampLevelAndCategory;
-	if (loggingEvent.exception.stack) {
-	    output += loggingEvent.exception.stack;
-	} else {
-	    output += loggingEvent.exception.name + ': '+loggingEvent.exception.message;
-	}
-    }
-    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 '\033[' + styles[style][0] + 'm' + str +
-        '\033[' + styles[style][1] + 'm';
 }
 
 /**
- * colouredLayout - taken from masylum's fork.
+ * File Appender writing the logs to a text file. Supports rolling of logs by size.
- * same as basicLayout, but with colours.
+ *
+ * @param file file log messages will be written to
+ * @param layout a function that takes a logevent and returns a string (defaults to basicLayout).
+ * @param logSize - the maximum size (in bytes) for a log file, if not provided then logs won't be rotated.
+ * @param numBackups - the number of log files to keep after logSize has been reached (default 5)
+ * @param filePollInterval - the time in seconds between file size checks (default 30s)
  */
-function colouredLayout (loggingEvent) {
+function fileAppender (file, layout, logSize, numBackups, filePollInterval) {
-    var timestampLevelAndCategory = colorize('[' + loggingEvent.startTime.toFormattedString() + '] ', 'grey');
+    layout = layout || layouts.basicLayout;
-    timestampLevelAndCategory += colorize(
+    //syncs are generally bad, but we need
-        '[' + loggingEvent.level.toString() + '] ', loggingEvent.level.colour
+    //the file to be open before we start doing any writing.
-    );
+    var logFile = fs.openSync(file, 'a', 0644);
-    timestampLevelAndCategory += colorize(loggingEvent.categoryName + ' - ', 'grey');
 
-    var output = timestampLevelAndCategory + loggingEvent.message;
+    if (logSize > 0) {
-
+        setupLogRolling(logFile, file, logSize, numBackups || 5, (filePollInterval * 1000) || 30000);
-    if (loggingEvent.exception) {
-        output += '\n'
-        output += timestampLevelAndCategory;
-        if (loggingEvent.exception.stack) {
-            output += loggingEvent.exception.stack;
-        } else {
-            output += loggingEvent.exception.name + ': '+loggingEvent.exception.message;
-        }
     }
-    return output;
-}
-
-function messagePassThroughLayout (loggingEvent) {
-    return loggingEvent.message;
-}
-
-/** 
- * PatternLayout 
- * 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 || patternLayout.TTCC_CONVERSION_PATTERN;
 
     return function(loggingEvent) {
-	var formattedString = "";
+	fs.write(logFile, layout(loggingEvent)+'\n', null, "utf8");
-	var result;
-	var searchString = this.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 dateFormat = Date.ISO8601_FORMAT;
-		    if (specifier) {
-			dateFormat = specifier;
-			// Pick up special cases
-			if (dateFormat == "ISO8601") {
-			    dateFormat = Date.ISO8601_FORMAT;
-			} else if (dateFormat == "ABSOLUTE") {
-			    dateFormat = Date.ABSOLUTETIME_FORMAT;
-			} else if (dateFormat == "DATE") {
-			    dateFormat = Date.DATETIME_FORMAT;
-			}
-		    }
-		    // Format the date
-		    replacement = loggingEvent.startTime.toFormattedString(dateFormat);
-		    break;
-		case "m":
-		    replacement = loggingEvent.message;
-		    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;
     };
+}
 
-};
+function setupLogRolling (logFile, filename, logSize, numBackups, filePollInterval) {
-
+    fs.watchFile(
-
+        filename,
-module.exports = function (fileSystem, standardOutput, configPaths) {
+        {
-    var fs = fileSystem || require('fs'),
+            persistent: false,
-    standardOutput = standardOutput || sys.puts,
+            interval: filePollInterval
-    configPaths = configPaths || require.paths;
+        },
-
+        function (curr, prev) {
-
+            if (curr.size >= logSize) {
-    function consoleAppender (layout) {
+                rollThatLog(logFile, filename, numBackups);
-	layout = layout || colouredLayout;
-	return function(loggingEvent) {
-	    standardOutput(layout(loggingEvent));
-	};  
-    }
-
-    /**
-     * File Appender writing the logs to a text file. Supports rolling of logs by size.
-     * 
-     * @param file file log messages will be written to
-     * @param layout a function that takes a logevent and returns a string (defaults to basicLayout).
-     * @param logSize - the maximum size (in bytes) for a log file, if not provided then logs won't be rotated.
-     * @param numBackups - the number of log files to keep after logSize has been reached (default 5)
-     * @param filePollInterval - the time in seconds between file size checks (default 30s)
-     */
-    function fileAppender (file, layout, logSize, numBackups, filePollInterval) {
-	layout = layout || basicLayout;	
-	//syncs are generally bad, but we need 
-	//the file to be open before we start doing any writing.
-	var logFile = fs.openSync(file, 'a', 0644);
-
-        if (logSize > 0) {
-            setupLogRolling(logFile, file, logSize, numBackups || 5, (filePollInterval * 1000) || 30000);
-        }
-	
-	return function(loggingEvent) {
-	    fs.write(logFile, layout(loggingEvent)+'\n', null, "utf8");
-	};
-    }
-
-    function setupLogRolling (logFile, filename, logSize, numBackups, filePollInterval) {
-        fs.watchFile(filename, 
-                     { 
-                         persistent: false, 
-                         interval: filePollInterval 
-                     },
-                     function (curr, prev) {
-                         if (curr.size >= logSize) {
-                             rollThatLog(logFile, filename, numBackups);
-                         }
-                     }
-                    );
-    }
-
-    function rollThatLog (logFile, filename, numBackups) {
-        //doing all of this fs stuff sync, because I don't want to lose any log events.
-        //first close the current one.
-        fs.closeSync(logFile);
-        //roll the backups (rename file.n-1 to file.n, where n <= numBackups)
-        for (var i=numBackups; i > 0; i--) {
-            if (i > 1) {
-                if (fileExists(filename + '.' + (i-1))) {
-                    fs.renameSync(filename+'.'+(i-1), filename+'.'+i);
-                }
-            } else {
-                fs.renameSync(filename, filename+'.1');
             }
         }
-        //open it up again
+    );
-        logFile = fs.openSync(filename, 'a', 0644);
+}
-    }
 
-    function fileExists (filename) {
+function rollThatLog (logFile, filename, numBackups) {
+    //doing all of this fs stuff sync, because I don't want to lose any log events.
+    //first close the current one.
+    fs.closeSync(logFile);
+    //roll the backups (rename file.n-1 to file.n, where n <= numBackups)
+    for (var i=numBackups; i > 0; i--) {
+        if (i > 1) {
+            if (fileExists(filename + '.' + (i-1))) {
+                fs.renameSync(filename+'.'+(i-1), filename+'.'+i);
+            }
+        } else {
+            fs.renameSync(filename, filename+'.1');
+        }
+    }
+    //open it up again
+    logFile = fs.openSync(filename, 'a', 0644);
+}
+
+function fileExists (filename) {
+    try {
+        fs.statSync(filename);
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+
+function configure (configurationFileOrObject) {
+    var config = configurationFileOrObject;
+    if (typeof(config) === "string") {
+	config = JSON.parse(fs.readFileSync(config, "utf8"));
+    }
+    if (config) {
+	try {
+	    configureAppenders(config.appenders, fileAppender, consoleAppender);
+	    configureLevels(config.levels);
+        } catch (e) {
+	    throw new Error("Problem reading log4js config " + sys.inspect(config) + ". Error was \"" + e.message + "\" ("+e.stack+")");
+        }
+    }
+}
+
+function findConfiguration() {
+    //add current directory onto the list of configPaths
+    var paths = ['.'].concat(require.paths);
+    //add this module's directory to the end of the list, so that we pick up the default config
+    paths.push(__dirname);
+    var pathsWithConfig = paths.filter( function (pathToCheck) {
         try {
-            fs.statSync(filename);
+            fs.statSync(path.join(pathToCheck, "log4js.json"));
             return true;
         } catch (e) {
             return false;
         }
+    });
+    if (pathsWithConfig.length > 0) {
+        return path.join(pathsWithConfig[0], 'log4js.json');
     }
-
+    return undefined;
-    function configure (configurationFileOrObject) {
-	var config = configurationFileOrObject;
-	if (typeof(config) === "string") {
-	    config = JSON.parse(fs.readFileSync(config, "utf8"));
-        }
-	if (config) {
-	    try {
-		configureAppenders(config.appenders, fileAppender, consoleAppender);
-		configureLevels(config.levels);
-            } catch (e) {
-		throw new Error("Problem reading log4js config " + sys.inspect(config) + ". Error was \"" + e.message + "\" ("+e.stack+")");
-            }
-	}
-    }
-
-    function findConfiguration() {
-        //add current directory onto the list of configPaths
-        var paths = ['.'].concat(configPaths);
-        //add this module's directory to the end of the list, so that we pick up the default config
-        paths.push(__dirname);
-        var pathsWithConfig = paths.filter( function (pathToCheck) {
-            try {
-                fs.statSync(path.join(pathToCheck, "log4js.json"));
-                return true;
-            } catch (e) {
-                return false;
-            }
-        });
-        if (pathsWithConfig.length > 0) {
-            return path.join(pathsWithConfig[0], 'log4js.json');
-        }
-        return undefined;
-    }
-
-    function replaceConsole(logger) {
-        function replaceWith (fn) {
-            return function() {
-                fn.apply(logger, arguments);
-            }
-        }
- 
-        console.log = replaceWith(logger.info);
-        console.debug = replaceWith(logger.debug);
-        console.trace = replaceWith(logger.trace);
-        console.info = replaceWith(logger.info);
-        console.warn = replaceWith(logger.warn);
-        console.error = replaceWith(logger.error);
-
-    }
-
-    //do we already have appenders?
-    if (!appenders.count) {
-	//set ourselves up if we can find a default log4js.json
-	configure(findConfiguration());
-	//replace console.log, etc with log4js versions
-	//disabling this (17/04/11 - GJ), as console.log does fancy formatting that this breaks
-	//replaceConsole(getLogger("console"));
-    }
-
-    var thismodule = {
-	getLogger: getLogger,
-	getDefaultLogger: getDefaultLogger,
-
-	addAppender: addAppender,
-	clearAppenders: clearAppenders,
-	configure: configure,
-	
-	levels: levels,
-	setGlobalLogLevel: setGlobalLogLevel,
-
-	consoleAppender: consoleAppender,
-	fileAppender: fileAppender,
-	logLevelFilter: logLevelFilter,
-	
-	basicLayout: basicLayout,
-	messagePassThroughLayout: messagePassThroughLayout,
-	patternLayout: patternLayout,
-        colouredLayout: colouredLayout,
-        coloredLayout: colouredLayout,
-    };
-    thismodule.connectLogger = require('./connect-logger')(thismodule).connectLogger;
-	
-    return thismodule;
 }
 
-
+function replaceConsole(logger) {
-Date.ISO8601_FORMAT = "yyyy-MM-dd hh:mm:ss.SSS";
+    function replaceWith(fn) {
-Date.ISO8601_WITH_TZ_OFFSET_FORMAT = "yyyy-MM-ddThh:mm:ssO";
+        return function() {
-Date.DATETIME_FORMAT = "dd MMM YYYY hh:mm:ss.SSS";
+            fn.apply(logger, arguments);
-Date.ABSOLUTETIME_FORMAT = "hh:mm:ss.SSS";
+        }
-
-Date.prototype.toFormattedString = function(format) {
-    format = format || Date.ISO8601_FORMAT;
-
-    var vDay = addZero(this.getDate());
-    var vMonth = addZero(this.getMonth()+1);
-    var vYearLong = addZero(this.getFullYear());
-    var vYearShort = addZero(this.getFullYear().toString().substring(3,4));
-    var vYear = (format.indexOf("yyyy") > -1 ? vYearLong : vYearShort);
-    var vHour  = addZero(this.getHours());
-    var vMinute = addZero(this.getMinutes());
-    var vSecond = addZero(this.getSeconds());
-    var vMillisecond = padWithZeros(this.getMilliseconds(), 3);
-    var vTimeZone = offset(this);
-    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) {
+    ['log','debug','info','warn','error'].forEach(function (item) {
-	return padWithZeros(vNumber, 2);
+        console['_preLog4js_'+item] = console[item];
-    }
+        console[item] = replaceWith(item === 'log' ? logger.info : logger[item]);
+    });
 
-    /**
+}
-     * Formats the TimeOffest
+
-     * Thanks to http://www.svendtofte.com/code/date_format/
+//set ourselves up if we can find a default log4js.json
-     * @private
+configure(findConfiguration());
-     */
+//replace console.log, etc with log4js versions
-    function offset(date) {
+replaceConsole(getLogger("console"));
-	// Difference to Greenwich time (GMT) in hours
+
-	var os = Math.abs(date.getTimezoneOffset());
+module.exports = {
-	var h = String(Math.floor(os/60));
+    getLogger: getLogger,
-	var m = String(os%60);
+    getDefaultLogger: getDefaultLogger,
-	h.length == 1? h = "0"+h:1;
+
-	m.length == 1? m = "0"+m:1;
+    addAppender: addAppender,
-	return date.getTimezoneOffset() < 0 ? "+"+h+m : "-"+h+m;
+    clearAppenders: clearAppenders,
-    }
+    configure: configure,
+
+    levels: levels,
+    setGlobalLogLevel: setGlobalLogLevel,
+
+    consoleAppender: consoleAppender,
+    fileAppender: fileAppender,
+    logLevelFilter: logLevelFilter,
+
+    layouts: layouts,
+    connectLogger: require('./connect-logger').connectLogger(this)
 };
 
+//keep the old-style layouts
+['basicLayout','messagePassThroughLayout','colouredLayout','coloredLayout'].forEach(function(item) {
+    module.exports[item] = layouts[item];
+});
+

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");
@@ -79,10 +80,17 @@ vows.describe('log4js').addBatch({
                     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');
 
 	    var logger = log4js.getLogger('file-test');
@@ -104,36 +112,43 @@ vows.describe('log4js').addBatch({
             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;
+                          },
-                },
+                          openSync: 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 file;
-                    } else {
+                          },
-                        return true;
+                          statSync: function(file) {
-                    }
+                              if (existingFiles.indexOf(file) < 0) {
-                },
+                                  throw new Error("this file doesn't exist");
-                renameSync: function(oldFile, newFile) {
+                              } else {
-                    filesRenamed.push(oldFile);
+                                  return true;
-                    existingFiles.push(newFile);
+                              }
-                },
+                          },
-                closeSync: function(file) {
+                          renameSync: function(oldFile, newFile) {
-                    //it should always be closing tests.log
+                              filesRenamed.push(oldFile);
-                    assert.equal(file, 'tests.log');
+                              existingFiles.push(newFile);
-                    filesClosed.push(file);
+                          },
-                }
+                          closeSync: function(file) {
-            });
+                              //it should always be closing tests.log
+                              assert.equal(file, 'tests.log');
+                              filesClosed.push(file);
+                          }
+                      }
+                  }
+              }
+            );
             var appender = log4js.fileAppender('tests.log', log4js.messagePassThroughLayout, 1024, 2, 30);
             return [watchCb, filesOpened, filesClosed, filesRenamed, existingFiles];
         },
@@ -204,7 +219,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) {
@@ -265,9 +287,20 @@ vows.describe('log4js').addBatch({
 
     'with no appenders defined' : {
         topic: function() {
-            var logger, message, log4jsFn = require('../lib/log4js'), log4js;
+            var logger
-	    log4jsFn().clearAppenders();
+          , message
-	    log4js = log4jsFn(null, function (msg) { message = msg; } );
+          , 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;
@@ -279,7 +312,7 @@ vows.describe('log4js').addBatch({
 
     'addAppender' : {
         topic: function() {
-            var log4js = require('../lib/log4js')();
+            var log4js = require('../lib/log4js');
             log4js.clearAppenders();
             return log4js;
         },
@@ -367,45 +400,56 @@ vows.describe('log4js').addBatch({
             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; },
-	    log4jsFn = require('../lib/log4js'),
+                info: this.log,
-            log4js, logger;
+                warn: this.log,
+                debug: this.log,
+                error: this.log
+            },
+	    log4js = sandbox.require(
+                '../lib/log4js',
+                {
+                    requires: {
+                        'fs': fakeFS
+                    },
+                    globals: {
+                        'console': fakeConsole
+                    }
+                }
+            );
 
-	    log4jsFn().clearAppenders();
+	    logger = log4js.getLogger('a-test');
-	    log4js  = log4jsFn(fakeFS, fakeConsoleLog, fakeRequirePath);
-            logger = log4js.getLogger('a-test');
             logger.debug("this is a test");
 
-
+            return [ pathsChecked, message, modulePath ];
-            return [ pathsChecked, message ];
         },
 
         '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) {
@@ -414,94 +458,9 @@ vows.describe('log4js').addBatch({
         }
     },
 
-    '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");
-        }
-    },
-
-    'basicLayout': {
-        topic: function() {
-            var layout = require('../lib/log4js')().basicLayout,
-            event = { 
-                message: 'this is a test', 
-                startTime: new Date(2010, 11, 5, 14, 18, 30, 45), 
-                categoryName: "tests", 
-                level: { 
-                    colour: "green", 
-                    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.exception = 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], "[2010-12-05 14:18:30.045] [DEBUG] tests - Error: Some made-up error");
-            for (var i = 1; i < stack.length; i++) {
-                assert.equal(lines[i+1], stack[i]);
-            }
-        },    
-        'should output a name and message if the event has something that pretends to be an error': function(args) {
-            var layout = args[0], event = args[1], output, lines;
-            event.exception = { 
-                    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], "[2010-12-05 14:18:30.045] [DEBUG] tests - Cheese: Gorgonzola smells.");
-        }
-    },
-
     '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); }), "logLevelTest");
             logger = log4js.getLogger("logLevelTest");
@@ -518,57 +477,60 @@ vows.describe('log4js').addBatch({
         }
     },
 
-    'Date extensions': {
-        topic: function() {
-            require('../lib/log4js')();
-            return new Date(2010, 0, 11, 14, 31, 30, 5);
-        },
-        'should add a toFormattedString method to Date': function(date) {
-            assert.isFunction(date.toFormattedString);
-        },
-        'should default to a format': function(date) {
-            assert.equal(date.toFormattedString(), '2010-01-11 14:31:30.005');
-        }
-    },
-/** Disabling the console.log replacement ****
     'console' : {
         topic: function() {
-            return require('../lib/log4js')();
+            var fakeConsole = {}
-        },
+          , logEvents = []
-        'should replace console.log methods with log4js ones': function(log4js) {
+          , log4js;
-            var logEvent;
-            log4js.clearAppenders();
-            log4js.addAppender(function(evt) { logEvent = evt; });
 
-            console.log("Some debug message someone put in a module");
+            ['trace','debug','log','info','warn','error'].forEach(function(fn) {
-            assert.equal(logEvent.message, "Some debug message someone put in a module");
+                fakeConsole[fn] = function() {
-            assert.equal(logEvent.level.toString(), "INFO");
+                    throw new Error("this should not be called.");
-            logEvent = undefined;
+                };
-            console.debug("Some debug");
+            });
-            assert.equal(logEvent.message, "Some debug");
+
-            assert.equal(logEvent.level.toString(), "DEBUG");
+            log4js = sandbox.require(
-            logEvent = undefined;
+                '../lib/log4js'
-            console.error("An error");
+              , {
-            assert.equal(logEvent.message, "An error");
+                  globals: {
-            assert.equal(logEvent.level.toString(), "ERROR");
+                      console: fakeConsole
-            logEvent = undefined;
+                  }
-            console.info("some info");
+              }
-            assert.equal(logEvent.message, "some info");
+            );
-            assert.equal(logEvent.level.toString(), "INFO");
+
-            logEvent = undefined;
+            log4js.clearAppenders();
-            console.trace("tracing");
+            log4js.addAppender(function(evt) {
-            assert.equal(logEvent.message, "tracing");
+                logEvents.push(evt);
-            assert.equal(logEvent.level.toString(), "TRACE");
+            });
+
+            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");
+
+            return logEvents;
+        },
+        'should replace console.log methods with log4js ones': function(logEvents) {
+            assert.equal(logEvents[0].message, "Some debug message someone put in a module");
+            assert.equal(logEvents[0].level.toString(), "INFO");
+            assert.equal(logEvents[1].message, "Some debug");
+            assert.equal(logEvents[1].level.toString(), "DEBUG");
+            assert.equal(logEvents[2].message, "An error");
+            assert.equal(logEvents[2].level.toString(), "ERROR");
+            assert.equal(logEvents[3].message, "some info");
+            assert.equal(logEvents[3].level.toString(), "INFO");
+            assert.equal(logEvents[4].message, "a warning");
+            assert.equal(logEvents[4].level.toString(), "WARN");
         }
     },
-*/
     'configuration persistence' : {
 	'should maintain appenders between requires': function () {
-	    var logEvent, firstLog4js = require('../lib/log4js')(), secondLog4js;
+	    var logEvent, firstLog4js = require('../lib/log4js'), secondLog4js;
 	    firstLog4js.clearAppenders();
 	    firstLog4js.addAppender(function(evt) { logEvent = evt; });
 
-	    secondLog4js = require('../lib/log4js')();
+	    secondLog4js = require('../lib/log4js');
 	    secondLog4js.getLogger().info("This should go to the appender defined in firstLog4js");
 
 	    assert.equal(logEvent.message, "This should go to the appender defined in firstLog4js");

test/test-connect-logger.js

@@ -1,16 +1,6 @@
-var vows = require('vows'), 
+var vows = require('vows')
-assert = require('assert');
+, assert = require('assert')
-
+, levels = require('../lib/levels');
-var mockLog4js = {
-    levels: {
-	TRACE: 0,
-	DEBUG: 1,
-	INFO: 2,
-	WARN: 3,
-	ERROR: 4,
-	FATAL: 5
-    }
-}
 
 function MockLogger() {
 
@@ -22,10 +12,10 @@ function MockLogger() {
     };
 
     this.isLevelEnabled = function(level) {
-	return (level >= that.level);
+        return level.isGreaterThanOrEqualTo(that.level);
     };
 
-    this.level = mockLog4js.levels.TRACE;
+    this.level = levels.TRACE;
 
 }
 
@@ -53,7 +43,7 @@ function MockResponse(statusCode) {
 vows.describe('log4js connect logger').addBatch({
     'getConnectLoggerModule': {
 	topic: function() {
-	    var clm = require('../lib/connect-logger')(mockLog4js);
+	    var clm = require('../lib/connect-logger');
 	    return clm;
 	},
 
@@ -80,14 +70,14 @@ vows.describe('log4js connect logger').addBatch({
 		var req = new MockRequest('my.remote.addr', 'GET', 'http://url');
 		var res = new MockResponse(200);
 		cl(req, res, function() { });
-		res.end('chunk', 'encoding');
+        	res.end('chunk', 'encoding');
-		return ml.messages;
+        	return ml.messages;
 	    },
 
 	    'check message': function(messages) {
 		assert.isArray(messages);
 		assert.length(messages, 1);
-		assert.equal(messages[0].level, mockLog4js.levels.TRACE);
+		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');
@@ -98,7 +88,7 @@ vows.describe('log4js connect logger').addBatch({
 	'log events with level below logging level' : {
 	    topic: function(clm) {
 		var ml = new MockLogger();
-		ml.level = mockLog4js.levels.FATAL;
+		ml.level = levels.FATAL;
 		var cl = clm.connectLogger(ml);
 		var req = new MockRequest('my.remote.addr', 'GET', 'http://url');
 		var res = new MockResponse(200);
@@ -116,8 +106,8 @@ vows.describe('log4js connect logger').addBatch({
 	'log events with non-default level and custom format' : {
 	    topic: function(clm) {
 		var ml = new MockLogger();
-		ml.level = mockLog4js.levels.INFO;
+		ml.level = levels.INFO;
-		var cl = clm.connectLogger(ml, { level: mockLog4js.levels.INFO, format: ':method :url' } );
+		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() { });
@@ -128,7 +118,7 @@ vows.describe('log4js connect logger').addBatch({
 	    'check message': function(messages) {
 		assert.isArray(messages);
 		assert.length(messages, 1);
-		assert.equal(messages[0].level, mockLog4js.levels.INFO);
+		assert.equal(messages[0].level, levels.INFO);
 		assert.equal(messages[0].message, 'GET http://url');
 	    }
 	}

test/test-global-log-level.js

@@ -4,7 +4,7 @@ assert = require('assert');
 vows.describe('log4js global loglevel').addBatch({
     'global loglevel' : {
         topic: function() {
-            var log4js = require('../lib/log4js')();
+            var log4js = require('../lib/log4js');
             return log4js;
         },
 
@@ -59,7 +59,7 @@ vows.describe('log4js global loglevel').addBatch({
             assert.equal(log2.level.toString(), oldLevel);
         },
 
-        'preload loglevevl': function(log4js) {
+        'preload loglevel': function(log4js) {
             var log1 = log4js.getLogger('log1');
             var level = 'OFF';
             if (log1.level.toString() == level) {