working fileappender, with tests, broken everything else

lib/appenders/console.js

@@ -0,0 +1,20 @@
+var layouts = require('../layouts');
+
+function consoleAppender (layout) {
+    layout = layout || layouts.colouredLayout;
+    return function(loggingEvent) {
+	console._preLog4js_log(layout(loggingEvent));
+    };
+}
+
+function configure(config) {
+    var layout;
+    if (config.layout) {
+	layout = layouts.layout(config.layout.type, config.layout);
+    }
+    return consoleAppender(layout);
+}
+
+exports.name = "console";
+exports.appender = consoleAppender;
+exports.configure = configure;

lib/appenders/file.js

@@ -0,0 +1,124 @@
+var layouts = require('../layouts')
+, fs = require('fs');
+
+/**
+ * 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;
+    numBackups = numBackups === undefined ? 5 : numBackups;
+    filePollInterval = filePollInterval * 1000 || 30000;
+
+    function setupLogRolling () {
+        fs.watchFile(
+            file,
+            {
+                persistent: false,
+                interval: filePollInterval
+            },
+            function (curr, prev) {
+                if (curr.size >= logSize) {
+                    rollThatLog();
+                }
+            }
+        );
+    }
+
+    function rollThatLog () {
+        if (numBackups > 0) {
+            //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(file + '.' + (i-1))) {
+                        fs.renameSync(file+'.'+(i-1), file+'.'+i);
+                    }
+                } else {
+                    fs.renameSync(file, file+'.1');
+                }
+            }
+            //let's make a new file
+            var newLogFileFD = fs.openSync(file, 'a', 0644)
+          , oldLogFileFD = logFile.fd;
+            logFile.fd = newLogFileFD;
+            fs.close(oldLogFileFD);
+        } else {
+            fs.truncate(logFile.fd, logSize);
+        }
+    }
+
+    function fileExists (filename) {
+        try {
+            fs.statSync(filename);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    function openTheStream() {
+        var stream = fs.createWriteStream(file, { flags: 'a', mode: 0644, encoding: 'utf8' });
+        stream.on("open", function() {
+            canWrite = true;
+            while (logEventBuffer.length > 0 && canWrite) {
+                canWrite = writeToLog(logEventBuffer.shift());
+            }
+        });
+        stream.on("error", function (err) {
+            console.error("log4js.fileAppender - Error happened ", err);
+        });
+        stream.on("drain", function() {
+            canWrite = true;
+            while (logEventBuffer.length > 0 && canWrite) {
+                canWrite = writeToLog(logEventBuffer.shift());
+            }
+        });
+        return stream;
+    }
+
+
+    var logEventBuffer = []
+  , canWrite = false
+  , logFile = openTheStream();
+
+    if (logSize > 0) {
+        setupLogRolling();
+    }
+
+    //close the file on process exit.
+    process.on('exit', function() {
+        logFile.end();
+        logFile.destroy();
+    });
+
+    function writeToLog(loggingEvent) {
+	return logFile.write(layout(loggingEvent)+'\n', "utf8");
+    }
+
+    return function(loggingEvent) {
+        //because the log stream is opened asynchronously, we don't want to write
+        //until it is ready.
+        if (canWrite) {
+            canWrite = writeToLog(loggingEvent);
+        } else {
+            logEventBuffer.push(loggingEvent);
+        }
+    };
+}
+
+function configure(config) {
+    var layout;
+    if (config.layout) {
+	layout = layouts.layout(config.layout.type, config.layout);
+    }
+    return fileAppender(config.filename, layout, config.maxLogSize, config.backups, config.pollInterval);
+}
+
+exports.name = "file";
+exports.appender = fileAppender;
+exports.configure = configure;

lib/appenders/logLevelFilter.js

@@ -0,0 +1,19 @@
+var levels = require('../levels');
+
+function logLevelFilter (levelString, appender) {
+    var level = levels.toLevel(levelString);
+    return function(logEvent) {
+	if (logEvent.level.isGreaterThanOrEqualTo(level)) {
+	    appender(logEvent);
+	}
+    }
+}
+
+function configure(config) {
+    var appender = config.makers[config.appender.type](config.appender);
+    return logLevelFilter(config.level, appender);
+}
+
+exports.name = "logLevelFilter";
+exports.appender = logLevelFilter;
+exports.configure = configure;