mirror of
https://github.com/log4js-node/log4js-node.git
synced 2025-12-08 19:26:01 +00:00
removed main function, now using felixge's sandboxed-module, split code into multiple files
This commit is contained in:
Gareth Jones
parent
8767cda15f
commit
e121ca345a
@ -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) {
|
||||
var log4js = log4js_module;
|
||||
|
||||
function getLogger(logger4js, options) {
|
||||
if ('object' == typeof options) {
|
||||
options = options || {};
|
||||
} else if (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]);
|
||||
});
|
||||
}
|
||||
|
||||
function getLogger(logger4js, options) {
|
||||
if ('object' == typeof options) {
|
||||
options = options || {};
|
||||
} else if (options) {
|
||||
options = { format: options };
|
||||
} else {
|
||||
options = {};
|
||||
}
|
||||
|
||||
return {
|
||||
connectLogger: getLogger
|
||||
};
|
||||
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;
|
||||
648
lib/log4js.js
648
lib/log4js.js
@ -15,24 +15,24 @@
|
||||
/*jsl:option explicit*/
|
||||
|
||||
/**
|
||||
* @fileoverview log4js is a library to log in JavaScript in similar manner
|
||||
* @fileoverview log4js is a library to log in JavaScript in similar manner
|
||||
* than in log4j for Java. The API should be nearly the same.
|
||||
*
|
||||
*
|
||||
* This file contains all log4js code and is the only file required for logging.
|
||||
*
|
||||
*
|
||||
* <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
|
||||
* logging.addAppender(logging.fileAppender("file.log"), "some-category");
|
||||
* //get a logger
|
||||
* var log = logging.getLogger("some-category");
|
||||
* var log = logging.getLogger("some-category");
|
||||
* log.setLevel(logging.levels.TRACE); //set the Level
|
||||
*
|
||||
*
|
||||
* ...
|
||||
*
|
||||
*
|
||||
* //call the log
|
||||
* log.trace("trace me" );
|
||||
* </pre>
|
||||
@ -44,35 +44,28 @@
|
||||
* @static
|
||||
* Website: http://log4js.berlios.de
|
||||
*/
|
||||
var events = require('events'),
|
||||
path = require('path'),
|
||||
sys = require('sys'),
|
||||
DEFAULT_CATEGORY = '[default]',
|
||||
ALL_CATEGORIES = '[all]',
|
||||
appenders = {},
|
||||
loggers = {},
|
||||
levels = {
|
||||
ALL: new Level(Number.MIN_VALUE, "ALL", "grey"),
|
||||
TRACE: new Level(5000, "TRACE", "blue"),
|
||||
DEBUG: new Level(10000, "DEBUG", "cyan"),
|
||||
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 = {
|
||||
var events = require('events')
|
||||
, fs = require('fs')
|
||||
, path = require('path')
|
||||
, sys = require('sys')
|
||||
, layouts = require('./layouts')
|
||||
, levels = require('./levels')
|
||||
, DEFAULT_CATEGORY = '[default]'
|
||||
, ALL_CATEGORIES = '[all]'
|
||||
, appenders = {}
|
||||
, loggers = {}
|
||||
, 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);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
@ -99,7 +82,7 @@ layoutMakers = {
|
||||
* @static
|
||||
*/
|
||||
function getLogger (categoryName) {
|
||||
|
||||
|
||||
// Use default logger if categoryName is not specified or invalid
|
||||
if (!(typeof categoryName == "string")) {
|
||||
categoryName = DEFAULT_CATEGORY;
|
||||
@ -122,7 +105,7 @@ function getLogger (categoryName) {
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return loggers[categoryName];
|
||||
}
|
||||
|
||||
@ -139,13 +122,13 @@ function addAppender () {
|
||||
if (Array.isArray(args[0])) {
|
||||
args = args[0];
|
||||
}
|
||||
|
||||
|
||||
args.forEach(function(category) {
|
||||
if (!appenders[category]) {
|
||||
appenders[category] = [];
|
||||
}
|
||||
appenders[category].push(appender);
|
||||
|
||||
|
||||
if (category === ALL_CATEGORIES) {
|
||||
for (var logger in loggers) {
|
||||
if (loggers.hasOwnProperty(logger)) {
|
||||
@ -156,7 +139,6 @@ function addAppender () {
|
||||
loggers[category].addListener("log", appender);
|
||||
}
|
||||
});
|
||||
appenders.count = appenders.count ? appenders.count++ : 1;
|
||||
}
|
||||
|
||||
function clearAppenders () {
|
||||
@ -174,7 +156,7 @@ function configureAppenders(appenderList, fileAppender, consoleAppender) {
|
||||
appenderList.forEach(function(appenderConfig) {
|
||||
var appender = appenderMakers[appenderConfig.type](appenderConfig, fileAppender, consoleAppender);
|
||||
if (appender) {
|
||||
addAppender(appender, appenderConfig.category);
|
||||
addAppender(appender, appenderConfig.category);
|
||||
} else {
|
||||
throw new Error("log4js configuration problem for "+sys.inspect(appenderConfig));
|
||||
}
|
||||
@ -192,48 +174,8 @@ 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,11 +233,11 @@ 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);
|
||||
};
|
||||
|
||||
|
||||
Logger.prototype[levelString.toLowerCase()] = function (message, exception) {
|
||||
if (this.isLevelEnabled(level)) {
|
||||
this.log(level, message, exception);
|
||||
@ -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);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -314,11 +256,11 @@ function setGlobalLogLevel(level) {
|
||||
* @static
|
||||
*/
|
||||
function getDefaultLogger () {
|
||||
return getLogger(DEFAULT_CATEGORY);
|
||||
return getLogger(DEFAULT_CATEGORY);
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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.
|
||||
* same as basicLayout, but with colours.
|
||||
*/
|
||||
function colouredLayout (loggingEvent) {
|
||||
var timestampLevelAndCategory = colorize('[' + loggingEvent.startTime.toFormattedString() + '] ', 'grey');
|
||||
timestampLevelAndCategory += colorize(
|
||||
'[' + loggingEvent.level.toString() + '] ', loggingEvent.level.colour
|
||||
);
|
||||
timestampLevelAndCategory += colorize(loggingEvent.categoryName + ' - ', 'grey');
|
||||
|
||||
var output = timestampLevelAndCategory + loggingEvent.message;
|
||||
|
||||
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;
|
||||
|
||||
function consoleAppender (layout) {
|
||||
layout = layout || layouts.colouredLayout;
|
||||
return function(loggingEvent) {
|
||||
var formattedString = "";
|
||||
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;
|
||||
console._preLog4js_log(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 || layouts.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);
|
||||
|
||||
|
||||
module.exports = function (fileSystem, standardOutput, configPaths) {
|
||||
var fs = fileSystem || require('fs'),
|
||||
standardOutput = standardOutput || sys.puts,
|
||||
configPaths = configPaths || require.paths;
|
||||
|
||||
|
||||
function consoleAppender (layout) {
|
||||
layout = layout || colouredLayout;
|
||||
return function(loggingEvent) {
|
||||
standardOutput(layout(loggingEvent));
|
||||
};
|
||||
if (logSize > 0) {
|
||||
setupLogRolling(logFile, file, logSize, numBackups || 5, (filePollInterval * 1000) || 30000);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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);
|
||||
return function(loggingEvent) {
|
||||
fs.write(logFile, layout(loggingEvent)+'\n', null, "utf8");
|
||||
};
|
||||
}
|
||||
|
||||
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');
|
||||
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);
|
||||
}
|
||||
}
|
||||
//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');
|
||||
}
|
||||
|
||||
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;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
|
||||
Date.ISO8601_FORMAT = "yyyy-MM-dd hh:mm:ss.SSS";
|
||||
Date.ISO8601_WITH_TZ_OFFSET_FORMAT = "yyyy-MM-ddThh:mm:ssO";
|
||||
Date.DATETIME_FORMAT = "dd MMM YYYY hh:mm:ss.SSS";
|
||||
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) {
|
||||
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;
|
||||
function replaceConsole(logger) {
|
||||
function replaceWith(fn) {
|
||||
return function() {
|
||||
fn.apply(logger, arguments);
|
||||
}
|
||||
}
|
||||
|
||||
['log','debug','info','warn','error'].forEach(function (item) {
|
||||
console['_preLog4js_'+item] = console[item];
|
||||
console[item] = replaceWith(item === 'log' ? logger.info : logger[item]);
|
||||
});
|
||||
|
||||
}
|
||||
|
||||
//set ourselves up if we can find a default log4js.json
|
||||
configure(findConfiguration());
|
||||
//replace console.log, etc with log4js versions
|
||||
replaceConsole(getLogger("console"));
|
||||
|
||||
module.exports = {
|
||||
getLogger: getLogger,
|
||||
getDefaultLogger: getDefaultLogger,
|
||||
|
||||
addAppender: addAppender,
|
||||
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];
|
||||
});
|
||||
|
||||
|
||||
386
test/logging.js
386
test/logging.js
@ -1,10 +1,11 @@
|
||||
var vows = require('vows'),
|
||||
assert = require('assert');
|
||||
var vows = require('vows')
|
||||
, 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 = [];
|
||||
@ -54,7 +55,7 @@ vows.describe('log4js').addBatch({
|
||||
assert.instanceOf(events[3].exception, Error);
|
||||
assert.equal(events[3].exception.message, "{ err: 127, cause: 'incendiary underwear' }");
|
||||
},
|
||||
|
||||
|
||||
},
|
||||
|
||||
},
|
||||
@ -79,18 +80,25 @@ 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);
|
||||
log4js.addAppender(appender, 'file-test');
|
||||
|
||||
appender = log4js.fileAppender('./tmp-tests.log', log4js.layouts.messagePassThroughLayout);
|
||||
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");
|
||||
}
|
||||
@ -98,42 +106,49 @@ vows.describe('log4js').addBatch({
|
||||
|
||||
'fileAppender - with rolling based on size and number of files to keep': {
|
||||
topic: function() {
|
||||
var watchCb,
|
||||
filesOpened = [],
|
||||
filesClosed = [],
|
||||
var watchCb,
|
||||
filesOpened = [],
|
||||
filesClosed = [],
|
||||
filesRenamed = [],
|
||||
newFilenames = [],
|
||||
existingFiles = ['tests.log'],
|
||||
log4js = require('../lib/log4js')({
|
||||
watchFile: function(file, options, callback) {
|
||||
assert.equal(file, 'tests.log');
|
||||
assert.equal(options.persistent, false);
|
||||
assert.equal(options.interval, 30000);
|
||||
assert.isFunction(callback);
|
||||
watchCb = callback;
|
||||
},
|
||||
openSync: function(file) {
|
||||
assert.equal(file, 'tests.log');
|
||||
filesOpened.push(file);
|
||||
return file;
|
||||
},
|
||||
statSync: function(file) {
|
||||
if (existingFiles.indexOf(file) < 0) {
|
||||
throw new Error("this file doesn't exist");
|
||||
} else {
|
||||
return true;
|
||||
}
|
||||
},
|
||||
renameSync: function(oldFile, newFile) {
|
||||
filesRenamed.push(oldFile);
|
||||
existingFiles.push(newFile);
|
||||
},
|
||||
closeSync: function(file) {
|
||||
//it should always be closing tests.log
|
||||
assert.equal(file, 'tests.log');
|
||||
filesClosed.push(file);
|
||||
}
|
||||
});
|
||||
log4js = sandbox.require(
|
||||
'../lib/log4js'
|
||||
, {
|
||||
requires: {
|
||||
'fs': {
|
||||
watchFile: function(file, options, callback) {
|
||||
assert.equal(file, 'tests.log');
|
||||
assert.equal(options.persistent, false);
|
||||
assert.equal(options.interval, 30000);
|
||||
assert.isFunction(callback);
|
||||
watchCb = callback;
|
||||
},
|
||||
openSync: function(file) {
|
||||
assert.equal(file, 'tests.log');
|
||||
filesOpened.push(file);
|
||||
return file;
|
||||
},
|
||||
statSync: function(file) {
|
||||
if (existingFiles.indexOf(file) < 0) {
|
||||
throw new Error("this file doesn't exist");
|
||||
} else {
|
||||
return true;
|
||||
}
|
||||
},
|
||||
renameSync: function(oldFile, newFile) {
|
||||
filesRenamed.push(oldFile);
|
||||
existingFiles.push(newFile);
|
||||
},
|
||||
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];
|
||||
},
|
||||
@ -156,7 +171,7 @@ vows.describe('log4js').addBatch({
|
||||
assert.deepEqual(existingFiles, ['tests.log', 'tests.log.1']);
|
||||
//and opened a new log file.
|
||||
assert.length(filesOpened, 2);
|
||||
|
||||
|
||||
//now tell the watchCb that we've flipped over the threshold again
|
||||
watchCb({ size: 1025 }, { size: 123 });
|
||||
//it should have closed the old file
|
||||
@ -195,7 +210,7 @@ vows.describe('log4js').addBatch({
|
||||
if (!messages.hasOwnProperty(file)) {
|
||||
messages[file] = [];
|
||||
}
|
||||
messages[file].push(message);
|
||||
messages[file].push(message);
|
||||
},
|
||||
readFileSync: function(file, encoding) {
|
||||
return require('fs').readFileSync(file, encoding);
|
||||
@ -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) {
|
||||
@ -214,7 +236,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);
|
||||
@ -244,7 +266,7 @@ vows.describe('log4js').addBatch({
|
||||
assert.equal(messages.watchedFile, 'tmp-test.log');
|
||||
},
|
||||
'should handle an object or a file name': function(args) {
|
||||
var log4js = args[0],
|
||||
var log4js = args[0],
|
||||
messages = args[1],
|
||||
config = {
|
||||
"appenders": [
|
||||
@ -265,9 +287,20 @@ vows.describe('log4js').addBatch({
|
||||
|
||||
'with no appenders defined' : {
|
||||
topic: function() {
|
||||
var logger, message, log4jsFn = require('../lib/log4js'), log4js;
|
||||
log4jsFn().clearAppenders();
|
||||
log4js = log4jsFn(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;
|
||||
@ -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;
|
||||
},
|
||||
@ -296,13 +329,13 @@ vows.describe('log4js').addBatch({
|
||||
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.message, 'This is a test');
|
||||
assert.equal(otherEvent.categoryName, 'cheese');
|
||||
|
||||
|
||||
otherEvent = undefined;
|
||||
appenderEvent = undefined;
|
||||
log4js.getLogger('pants').debug("this should not be propagated to otherEvent");
|
||||
@ -310,14 +343,14 @@ vows.describe('log4js').addBatch({
|
||||
assert.equal(appenderEvent.message, "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.message, 'this is a category test');
|
||||
|
||||
|
||||
appenderEvent = undefined;
|
||||
log4js.getLogger('some other category').debug('Cheese');
|
||||
assert.isUndefined(appenderEvent);
|
||||
@ -328,24 +361,24 @@ vows.describe('log4js').addBatch({
|
||||
'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.message, 'this is a test');
|
||||
appenderEvent = undefined;
|
||||
|
||||
|
||||
var otherLogger = log4js.getLogger('biscuits');
|
||||
otherLogger.debug("mmm... garibaldis");
|
||||
assert.equal(appenderEvent.message, "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.message, 'this is a test');
|
||||
|
||||
@ -355,7 +388,7 @@ vows.describe('log4js').addBatch({
|
||||
assert.equal(appenderEvent.message, "big pants");
|
||||
|
||||
appenderEvent = undefined;
|
||||
|
||||
|
||||
log4js.getLogger("something else").debug("pants");
|
||||
assert.isUndefined(appenderEvent);
|
||||
}
|
||||
@ -364,144 +397,70 @@ vows.describe('log4js').addBatch({
|
||||
|
||||
'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; },
|
||||
fakeRequirePath = [ '/a/b/c', '/some/other/path', '/path/to/config', '/some/later/directory' ],
|
||||
log4jsFn = require('../lib/log4js'),
|
||||
log4js, logger;
|
||||
|
||||
log4jsFn().clearAppenders();
|
||||
log4js = log4jsFn(fakeFS, fakeConsoleLog, fakeRequirePath);
|
||||
logger = log4js.getLogger('a-test');
|
||||
fakeConsole = {
|
||||
log : function (msg) { message = msg; },
|
||||
info: this.log,
|
||||
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, [
|
||||
'log4js.json',
|
||||
'/a/b/c/log4js.json',
|
||||
'/some/other/path/log4js.json',
|
||||
'/path/to/config/log4js.json',
|
||||
'/some/later/directory/log4js.json',
|
||||
require('path').normalize(__dirname + '/../lib/log4js.json')
|
||||
]);
|
||||
expectedPaths = ['log4js.json'].concat(
|
||||
require.paths.map(function(item) {
|
||||
return item + '/log4js.json';
|
||||
}),
|
||||
args[2]
|
||||
);
|
||||
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");
|
||||
}
|
||||
},
|
||||
|
||||
'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,59 +477,62 @@ 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')();
|
||||
},
|
||||
'should replace console.log methods with log4js ones': function(log4js) {
|
||||
var logEvent;
|
||||
log4js.clearAppenders();
|
||||
log4js.addAppender(function(evt) { logEvent = evt; });
|
||||
var fakeConsole = {}
|
||||
, logEvents = []
|
||||
, log4js;
|
||||
|
||||
console.log("Some debug message someone put in a module");
|
||||
assert.equal(logEvent.message, "Some debug message someone put in a module");
|
||||
assert.equal(logEvent.level.toString(), "INFO");
|
||||
logEvent = undefined;
|
||||
console.debug("Some debug");
|
||||
assert.equal(logEvent.message, "Some debug");
|
||||
assert.equal(logEvent.level.toString(), "DEBUG");
|
||||
logEvent = undefined;
|
||||
console.error("An error");
|
||||
assert.equal(logEvent.message, "An error");
|
||||
assert.equal(logEvent.level.toString(), "ERROR");
|
||||
logEvent = undefined;
|
||||
console.info("some info");
|
||||
assert.equal(logEvent.message, "some info");
|
||||
assert.equal(logEvent.level.toString(), "INFO");
|
||||
logEvent = undefined;
|
||||
console.trace("tracing");
|
||||
assert.equal(logEvent.message, "tracing");
|
||||
assert.equal(logEvent.level.toString(), "TRACE");
|
||||
['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");
|
||||
|
||||
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");
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,16 +1,6 @@
|
||||
var vows = require('vows'),
|
||||
assert = require('assert');
|
||||
|
||||
var mockLog4js = {
|
||||
levels: {
|
||||
TRACE: 0,
|
||||
DEBUG: 1,
|
||||
INFO: 2,
|
||||
WARN: 3,
|
||||
ERROR: 4,
|
||||
FATAL: 5
|
||||
}
|
||||
}
|
||||
var vows = require('vows')
|
||||
, assert = require('assert')
|
||||
, levels = require('../lib/levels');
|
||||
|
||||
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');
|
||||
return ml.messages;
|
||||
res.end('chunk', 'encoding');
|
||||
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;
|
||||
var cl = clm.connectLogger(ml, { level: mockLog4js.levels.INFO, format: ':method :url' } );
|
||||
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() { });
|
||||
@ -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');
|
||||
}
|
||||
}
|
||||
|
||||
@ -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) {
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user