Initial commit

.gitignore

@@ -0,0 +1,4 @@
+*.swp
+.sonar/
+coverage/
+node_modules/

.npmignore

@@ -0,0 +1,5 @@
+node_modules/
+run_sonar.hs
+sonar-runner.properties
+coverage
+.sonar

.travis.yml

@@ -0,0 +1,4 @@
+language: node_js
+node_js:
+  - 0.6
+  - 0.8

LICENSE

@@ -0,0 +1,25 @@
+Copyright 2011 Steven Looman. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are
+permitted provided that the following conditions are met:
+
+   1. Redistributions of source code must retain the above copyright notice, this list of
+      conditions and the following disclaimer.
+
+   2. Redistributions in binary form must reproduce the above copyright notice, this list
+      of conditions and the following disclaimer in the documentation and/or other materials
+      provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY STEVEN LOOMAN ''AS IS'' AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL STEVEN LOOMAN OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The views and conclusions contained in the software and documentation are those of the
+authors and should not be interpreted as representing official policies, either expressed
+or implied, of Steven Looman.

README.md

@@ -0,0 +1,3 @@
+Blammo
+======
+Blammo - the Log-ger for NodeJS!

blammo.xml

@@ -0,0 +1,33 @@
+<configuration>
+	<appender name="console" type="console_appender">
+		<encoder type="dummy_encoder"/>
+		<layout type="pattern_layout">%timestamp|%pid|%logger|%level|%message</layout>
+	</appender>
+
+	<appender name="file_pattern" type="file_appender">
+		<encoder type="dummy_encoder"/>
+		<layout type="pattern_layout">%timestamp|%pid|%logger|%level|%message</layout>
+
+		<config>
+			<filename>/tmp/blammo.log</filename>
+		</config>
+	</appender>
+
+	<appender name="file_json" type="file_appender">
+		<encoder type="dummy_encoder"/>
+		<layout type="json_layout" />
+
+		<config>
+			<filename>/tmp/blammo.json</filename>
+		</config>
+	</appender>
+
+	<logger name="logger1">
+		<appender-ref ref="console" />
+	</logger>
+
+	<root level="warn">
+		<appender-ref ref="file_pattern" />
+		<appender-ref ref="file_json" />
+	</root>
+</configuration>

example.js

@@ -0,0 +1,14 @@
+var blammo = require('./');
+
+function main() {
+    var logger1 = blammo.LoggerFactory.getLogger('logger1');
+    var logger2 = blammo.LoggerFactory.getLogger('logger2');
+
+    logger1.debug('test debug message');
+    logger2.debug('test debug message');
+
+    logger1.error('test error message');
+    logger2.error('test error message');
+}
+
+main();

index.js

@@ -0,0 +1,6 @@
+/**
+ * Export lib/
+ *
+ */
+
+module.exports = require('./lib');

lib/appender.js

@@ -0,0 +1,43 @@
+var FilterReply = require('./filter_reply');
+
+
+function Appender() {
+}
+
+
+Appender.prototype.addFilter = function(filter) {
+    this.filters.push(filter);
+};
+
+Appender.prototype.shouldAppend = function(le) {
+    var i;
+    var filter, reply;
+    for (i = 0; i < this.filters.length; ++i) {
+        filter = this.filters[i];
+        reply = filter.decide(le);
+
+        if (reply === FilterReply.ACCEPT) {
+            return true;
+        } else if (reply === FilterReply.DENY) {
+            return false;
+        }
+    }
+
+    return true;
+};
+
+Appender.prototype.doAppend = function(le) {
+    if (!this.shouldAppend(le)) {
+        return;
+    }
+
+    this.append(le);
+};
+
+
+Appender.prototype.getName = function() {
+    return this.name;
+};
+
+
+module.exports = Appender;

lib/configuration_reader.js

@@ -0,0 +1,213 @@
+var fs = require('fs');
+var DOMParser = require('xmldom').DOMParser;
+
+var LoggerFactory = require('./logger_factory');
+var Logger = require('./logger');
+var Levels = require('./levels');
+
+
+var knownAppenders = {
+    'console_appender'     : require('./console_appender'),
+    'file_appender'        : require('./file_appender'),
+    'rolling_file_appender': require('./rolling_file_appender')
+};
+
+var knownEncoders = {
+    'dummy_encoder': require('./dummy_encoder')
+};
+
+var knownLayouts = {
+    'pattern_layout': require('./pattern_layout'),
+    'json_layout'   : require('./json_layout')
+};
+
+var knownFilters = {
+    'level_filter'    : require('./level_filter'),
+    'threshold_filter': require('./threshold_filter')
+};
+
+
+/**
+ * Read the confugration file and construct the Appenders/Loggers
+ */
+function readConfiguration(filename) {
+    var xml = fs.readFileSync(filename).toString();
+    var doc = new DOMParser().parseFromString(xml);
+    var root = doc.firstChild;
+
+    return parseConfiguration(root);
+}
+
+
+function getChildrenByTagName(node, name) {
+    var children = [];
+
+    var i;
+    var child;
+    for (i = 0; i < node.childNodes.length; ++i) {
+        child = node.childNodes.item(i);
+        if (child.tagName === name) {
+            children.push(child);
+        }
+    }
+
+    return children;
+}
+
+function getChildByTagName(node, name) {
+    var i;
+    var child;
+    for (i = 0; i < node.childNodes.length; ++i) {
+        child = node.childNodes.item(i);
+        if (child.tagName === name) {
+            return child;
+        }
+    }
+}
+
+
+function parseConfiguration(node) {
+    var appenderNodes = getChildrenByTagName(node, 'appender');
+    var appenders = parseAppenders(appenderNodes);
+
+    var loggerNodes = getChildrenByTagName(node, 'logger');
+    var loggers = parseLoggers(loggerNodes, appenders);
+
+    var rootNode = getChildByTagName(node, 'root');
+    var root = parseRoot(rootNode, appenders);
+
+    return root;
+}
+
+
+function parseAppenders(appenderNodes) {
+    var appenders = {};
+
+    appenderNodes.forEach(function(appenderNode) {
+        appender = parseAppender(appenderNode);
+        appenders[appender.name] = appender;
+    });
+
+    return appenders;
+}
+
+function parseAppender(node) {
+    var name = node.getAttribute('name');
+    var type = node.getAttribute('type');
+
+    var encoderNode = getChildByTagName(node, 'encoder');
+    var encoder = parseEncoder(encoderNode);
+
+    var layoutNode = getChildByTagName(node, 'layout');
+    var layout = parseLayout(layoutNode);
+
+    var filtersNode = getChildByTagName(node, 'filters');
+    var filters = parseFilters(filtersNode);
+
+    var configNode = getChildByTagName(node, 'config');
+    var config = {};
+    if (configNode) {
+        config = parseAppenderConfig(configNode);
+    }
+
+    return new knownAppenders[type](name, encoder, layout, config);
+}
+
+function parseEncoder(node) {
+    var type = node.getAttribute('type');
+
+    return new knownEncoders[type]();
+}
+
+function parseLayout(node) {
+    var type = node.getAttribute('type');
+    var pattern = node.textContent;
+
+    return new knownLayouts[type](pattern);
+}
+
+function parseFilters(node) {
+    if (!node) {
+        return [];
+    }
+
+    var filterNodes = getChildrenByTagName(node, 'filter');
+
+    var filters = [];
+    filterNodes.forEach(function(filterNode) {
+        var filter = parseFilter(filterNode);
+        filters.append(filter);
+    });
+
+    return filters;
+}
+
+function parseFilter(node) {
+    var type = node.getAttribute('type');
+    var param = node.textContent;
+
+    return new knownFilters[type](param);
+}
+
+function parseAppenderConfig(node) {
+    var config = {};
+
+    var i, child, key, value;
+    for (i = 0; i < node.childNodes.length; ++i) {
+        child = node.childNodes.item(i);
+
+        key = child.tagName;
+        value = child.textContent;
+
+        if (key) {
+            config[key] = value;
+        }
+    }
+
+    return config;
+}
+
+
+function parseLoggers(loggerNodes, appenders) {
+    loggerNodes.forEach(function(loggerNode) {
+        parseLogger(loggerNode, appenders);
+    });
+}
+
+function parseLogger(node, appenders) {
+    var name = node.getAttribute('name');
+    var logger = LoggerFactory.getLogger(name);
+
+    return parseLogger2(logger, node, appenders);
+}
+
+function parseRoot(node, appenders) {
+    var root = LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
+
+    return parseLogger2(root, node, appenders);
+}
+
+function parseLogger2(logger, node, appenders) {
+    var levelString = (node.getAttribute('level') || 'debug').toUpperCase();
+    var level = Levels[levelString];
+    logger.setLevel(level);
+
+    var appenderRefs = getChildrenByTagName(node, 'appender-ref');
+    appenderRefs.forEach(function(appenderRefNode) {
+        var ref = appenderRefNode.getAttribute('ref');
+        var appender = appenders[ref];
+        logger.addAppender(appender);
+    });
+
+    return logger;
+}
+
+
+function doRead() {
+    var configFile = process.env.BLAMMO_CONFIG || 'blammo.xml';
+    if (fs.existsSync(configFile)) {
+        readConfiguration(configFile);
+    }
+}
+
+doRead();

lib/console_appender.js

@@ -0,0 +1,31 @@
+var util = require('util');
+
+var Appender = require('./appender');
+
+
+/**
+ * Build a ConsoleAppender
+ *
+ * Appends to the console
+ */
+function ConsoleAppender(name, encoder, layout) {
+    this.name = name;
+    this.encoder = encoder;
+    this.layout = layout;
+
+    this.filters = [];
+}
+
+
+util.inherits(ConsoleAppender, Appender);
+
+
+ConsoleAppender.prototype.append = function(e) {
+    var str = this.layout.doLayout(e);
+    var encodedStr = this.encoder.doEncode(str);
+
+    console.log(encodedStr);
+};
+
+
+module.exports = ConsoleAppender;