Adds subcategories to the appenders and loggers. Adds property "level" at the file appender to limit the levels that a file appender accepts.

Creates a MARK category that always write to the log. That's useful to write things like '---- STARTED ----'.

lib/appenders/file.js

@@ -6,7 +6,8 @@ var layouts = require('../layouts')
 , streams = require('../streams')
 , os = require('os')
 , eol = os.EOL || '\n'
-, openFiles = [];
+, openFiles = []
+, levels = require('../levels');
 
 //close open files on process exit.
 process.on('exit', function() {
@@ -26,7 +27,7 @@ process.on('exit', function() {
  * @param numBackups - the number of log files to keep after logSize 
  *   has been reached (default 5)
  */
-function fileAppender (file, layout, logSize, numBackups) {
+function fileAppender (file, layout, logSize, numBackups, level) {
   var bytesWritten = 0;
   file = path.normalize(file);
   layout = layout || layouts.basicLayout;
@@ -61,9 +62,22 @@ function fileAppender (file, layout, logSize, numBackups) {
   // push file to the stack of open handlers
   openFiles.push(logFile);
 
-  return function(loggingEvent) {
+  if (level) {
-    logFile.write(layout(loggingEvent) + eol, "utf8");
+
-  };
+    var obj = levels.toLevel(level, levels.TRACE);
+    return function(loggingEvent) {
+      if (obj.isLessThanOrEqualTo(loggingEvent.level)) 
+        logFile.write(layout(loggingEvent) + eol, "utf8");
+    };
+
+  } else {
+
+    return function(loggingEvent) {
+      logFile.write(layout(loggingEvent) + eol, "utf8");
+    };
+
+  }
+
 }
 
 function configure(config, options) {
@@ -76,7 +90,7 @@ function configure(config, options) {
     config.filename = path.join(options.cwd, config.filename);
   }
 
-  return fileAppender(config.filename, layout, config.maxLogSize, config.backups);
+  return fileAppender(config.filename, layout, config.maxLogSize, config.backups, config.level);
 }
 
 function shutdown(cb) {

lib/levels.js

@@ -63,6 +63,7 @@ module.exports = {
   WARN: new Level(30000, "WARN"), 
   ERROR: new Level(40000, "ERROR"), 
   FATAL: new Level(50000, "FATAL"), 
+  MARK: new Level(Number.MAX_VALUE-1, "MARK"), 
   OFF: new Level(Number.MAX_VALUE, "OFF"), 
   toLevel: toLevel
 };

lib/log4js.js

@@ -92,6 +92,22 @@ function getBufferedLogger(categoryName) {
     return logger;
 }
 
+function normalizeCategory (category) {
+  return  category + '.';
+}
+
+function doesLevelEntryContainsLogger (levelCategory, loggerCategory) {  
+  var normalizedLevelCategory = normalizeCategory(levelCategory);
+  var normalizedLoggerCategory = normalizeCategory(loggerCategory);
+  return normalizedLoggerCategory.substring(0, normalizedLevelCategory.length) == normalizedLevelCategory;
+}
+
+function doesAppenderContainsLogger (appenderCategory, loggerCategory) {
+  var normalizedAppenderCategory = normalizeCategory(appenderCategory);
+  var normalizedLoggerCategory = normalizeCategory(loggerCategory);
+  return normalizedLoggerCategory.substring(0, normalizedAppenderCategory.length) == normalizedAppenderCategory;
+}
+
 
 /**
  * Get a logger instance. Instance is cached on categoryName level.
@@ -99,32 +115,51 @@ function getBufferedLogger(categoryName) {
  * @return {Logger} instance of logger for the category
  * @static
  */
-function getLogger (categoryName) {
+function getLogger (loggerCategoryName) {
 
   // Use default logger if categoryName is not specified or invalid
-  if (typeof categoryName !== "string") {
+  if (typeof loggerCategoryName !== "string") {
-    categoryName = Logger.DEFAULT_CATEGORY;
+    loggerCategoryName = Logger.DEFAULT_CATEGORY;
   }
 
-  var appenderList;
+  if (!hasLogger(loggerCategoryName)) {
-  if (!hasLogger(categoryName)) {
+
+    var level = undefined;
+
+    // If there's a "levels" entry in the configuration
+    if (levels.config) {
+      // Goes through the categories in the levels configuration entry, starting by the "higher" ones.
+      var keys = Object.keys(levels.config).sort();
+      for (var idx = 0; idx < keys.length; idx++) {
+        var levelCategory = keys[idx];
+        if (doesLevelEntryContainsLogger(levelCategory, loggerCategoryName)) {
+          // level for the logger
+          level = levels.config[levelCategory];
+        }
+      }
+    }
+  
     // Create the logger for this name if it doesn't already exist
-    loggers[categoryName] = new Logger(categoryName);
+    loggers[loggerCategoryName] = new Logger(loggerCategoryName, level);
-    if (appenders[categoryName]) {
+
-      appenderList = appenders[categoryName];
+    var appenderList;
-      appenderList.forEach(function(appender) {
+    for(var appenderCategory in appenders) {
-        loggers[categoryName].addListener("log", appender);
+      if (doesAppenderContainsLogger(appenderCategory, loggerCategoryName)) {
-      });
+        appenderList = appenders[appenderCategory];
+        appenderList.forEach(function(appender) {
+          loggers[loggerCategoryName].addListener("log", appender);
+        });
+      }
     }
     if (appenders[ALL_CATEGORIES]) {
       appenderList = appenders[ALL_CATEGORIES];
       appenderList.forEach(function(appender) {
-        loggers[categoryName].addListener("log", appender);
+        loggers[loggerCategoryName].addListener("log", appender);
       });
     }
   }
   
-  return loggers[categoryName];
+  return loggers[loggerCategoryName];
 }
 
 /**
@@ -141,13 +176,19 @@ function addAppender () {
     args = args[0];
   }
   
-  args.forEach(function(category) {
+  args.forEach(function(appenderCategory) {
-    addAppenderToCategory(appender, category);
+    addAppenderToCategory(appender, appenderCategory);
     
-    if (category === ALL_CATEGORIES) {
+    if (appenderCategory === ALL_CATEGORIES) {
       addAppenderToAllLoggers(appender);
-    } else if (hasLogger(category)) {
+    } else {
-      loggers[category].addListener("log", appender);
+
+      for(var loggerCategory in loggers) {
+        if (doesAppenderContainsLogger(appenderCategory,loggerCategory)) {
+          loggers[loggerCategory].addListener("log", appender);
+        }
+      }
+      
     }
   });
 }
@@ -193,14 +234,19 @@ function configureAppenders(appenderList, options) {
   }
 }
 
-function configureLevels(levels) {
+function configureLevels(_levels) {
-  if (levels) {
+  levels.config = _levels; // Keep it so we can create loggers later using this cfg
-    for (var category in levels) {
+  if (_levels) {
-      if (levels.hasOwnProperty(category)) {
+    var keys = Object.keys(levels.config).sort();
+    for (var idx in keys) {
+      var category = keys[idx];
+      for(var loggerCategory in loggers) {
+        if (doesLevelEntryContainsLogger(category, loggerCategory)) {
+          loggers[loggerCategory].setLevel(_levels[category]);
+        }
         if(category === ALL_CATEGORIES) {
           setGlobalLogLevel(levels[category]);
         }        
-        getLogger(category).setLevel(levels[category]);
       }
     }
   }
@@ -231,8 +277,8 @@ function loadConfigurationFile(filename) {
 function configureOnceOff(config, options) {
   if (config) {
     try {
-      configureAppenders(config.appenders, options);
       configureLevels(config.levels);
+      configureAppenders(config.appenders, options);
       
       if (config.replaceConsole) {
         replaceConsole();

lib/logger.js

@@ -63,7 +63,7 @@ Logger.prototype.isLevelEnabled = function(otherLevel) {
   return this.level.isLessThanOrEqualTo(otherLevel);
 };
 
-['Trace','Debug','Info','Warn','Error','Fatal'].forEach(
+['Trace','Debug','Info','Warn','Error','Fatal', 'Mark'].forEach(
   function(levelString) {
     var level = levels.toLevel(levelString);
     Logger.prototype['is'+levelString+'Enabled'] = function() {