Struts example source code file (Logger.js)

This example Struts source code file (Logger.js) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Struts tags/keywords

critical, critical, date, debug, error, error, info, info, warning, warning

The Struts Logger.js source code

/*
	Copyright (c) 2004-2006, The Dojo Foundation
	All Rights Reserved.

	Licensed under the Academic Free License version 2.1 or above OR the
	modified BSD license. For more information on Dojo licensing, see:

		http://dojotoolkit.org/community/licensing.shtml
*/



dojo.provide("dojo.logging.Logger");
dojo.provide("dojo.logging.LogFilter");
dojo.provide("dojo.logging.Record");
dojo.provide("dojo.log");
dojo.require("dojo.lang.common");
dojo.require("dojo.lang.declare");
dojo.logging.Record = function (logLevel, message) {
	this.level = logLevel;
	this.message = "";
	this.msgArgs = [];
	this.time = new Date();
	if (dojo.lang.isArray(message)) {
		if (message.length > 0 && dojo.lang.isString(message[0])) {
			this.message = message.shift();
		}
		this.msgArgs = message;
	} else {
		this.message = message;
	}
};
dojo.logging.LogFilter = function (loggerChain) {
	this.passChain = loggerChain || "";
	this.filter = function (record) {
		return true;
	};
};
dojo.logging.Logger = function () {
	this.cutOffLevel = 0;
	this.propagate = true;
	this.parent = null;
	this.data = [];
	this.filters = [];
	this.handlers = [];
};
dojo.extend(dojo.logging.Logger, {_argsToArr:function (args) {
	var ret = [];
	for (var x = 0; x < args.length; x++) {
		ret.push(args[x]);
	}
	return ret;
}, setLevel:function (lvl) {
	this.cutOffLevel = parseInt(lvl);
}, isEnabledFor:function (lvl) {
	return parseInt(lvl) >= this.cutOffLevel;
}, getEffectiveLevel:function () {
	if ((this.cutOffLevel == 0) && (this.parent)) {
		return this.parent.getEffectiveLevel();
	}
	return this.cutOffLevel;
}, addFilter:function (flt) {
	this.filters.push(flt);
	return this.filters.length - 1;
}, removeFilterByIndex:function (fltIndex) {
	if (this.filters[fltIndex]) {
		delete this.filters[fltIndex];
		return true;
	}
	return false;
}, removeFilter:function (fltRef) {
	for (var x = 0; x < this.filters.length; x++) {
		if (this.filters[x] === fltRef) {
			delete this.filters[x];
			return true;
		}
	}
	return false;
}, removeAllFilters:function () {
	this.filters = [];
}, filter:function (rec) {
	for (var x = 0; x < this.filters.length; x++) {
		if ((this.filters[x]["filter"]) && (!this.filters[x].filter(rec)) || (rec.level < this.cutOffLevel)) {
			return false;
		}
	}
	return true;
}, addHandler:function (hdlr) {
	this.handlers.push(hdlr);
	return this.handlers.length - 1;
}, handle:function (rec) {
	if ((!this.filter(rec)) || (rec.level < this.cutOffLevel)) {
		return false;
	}
	for (var x = 0; x < this.handlers.length; x++) {
		if (this.handlers[x]["handle"]) {
			this.handlers[x].handle(rec);
		}
	}
	return true;
}, log:function (lvl, msg) {
	if ((this.propagate) && (this.parent) && (this.parent.rec.level >= this.cutOffLevel)) {
		this.parent.log(lvl, msg);
		return false;
	}
	this.handle(new dojo.logging.Record(lvl, msg));
	return true;
}, debug:function (msg) {
	return this.logType("DEBUG", this._argsToArr(arguments));
}, info:function (msg) {
	return this.logType("INFO", this._argsToArr(arguments));
}, warning:function (msg) {
	return this.logType("WARNING", this._argsToArr(arguments));
}, error:function (msg) {
	return this.logType("ERROR", this._argsToArr(arguments));
}, critical:function (msg) {
	return this.logType("CRITICAL", this._argsToArr(arguments));
}, exception:function (msg, e, squelch) {
	if (e) {
		var eparts = [e.name, (e.description || e.message)];
		if (e.fileName) {
			eparts.push(e.fileName);
			eparts.push("line " + e.lineNumber);
		}
		msg += " " + eparts.join(" : ");
	}
	this.logType("ERROR", msg);
	if (!squelch) {
		throw e;
	}
}, logType:function (type, args) {
	return this.log.apply(this, [dojo.logging.log.getLevel(type), args]);
}, warn:function () {
	this.warning.apply(this, arguments);
}, err:function () {
	this.error.apply(this, arguments);
}, crit:function () {
	this.critical.apply(this, arguments);
}});
dojo.logging.LogHandler = function (level) {
	this.cutOffLevel = (level) ? level : 0;
	this.formatter = null;
	this.data = [];
	this.filters = [];
};
dojo.lang.extend(dojo.logging.LogHandler, {setFormatter:function (formatter) {
	dojo.unimplemented("setFormatter");
}, flush:function () {
}, close:function () {
}, handleError:function () {
	dojo.deprecated("dojo.logging.LogHandler.handleError", "use handle()", "0.6");
}, handle:function (record) {
	if ((this.filter(record)) && (record.level >= this.cutOffLevel)) {
		this.emit(record);
	}
}, emit:function (record) {
	dojo.unimplemented("emit");
}});
void (function () {
	var names = ["setLevel", "addFilter", "removeFilterByIndex", "removeFilter", "removeAllFilters", "filter"];
	var tgt = dojo.logging.LogHandler.prototype;
	var src = dojo.logging.Logger.prototype;
	for (var x = 0; x < names.length; x++) {
		tgt[names[x]] = src[names[x]];
	}
})();
dojo.logging.log = new dojo.logging.Logger();
dojo.logging.log.levels = [{"name":"DEBUG", "level":1}, {"name":"INFO", "level":2}, {"name":"WARNING", "level":3}, {"name":"ERROR", "level":4}, {"name":"CRITICAL", "level":5}];
dojo.logging.log.loggers = {};
dojo.logging.log.getLogger = function (name) {
	if (!this.loggers[name]) {
		this.loggers[name] = new dojo.logging.Logger();
		this.loggers[name].parent = this;
	}
	return this.loggers[name];
};
dojo.logging.log.getLevelName = function (lvl) {
	for (var x = 0; x < this.levels.length; x++) {
		if (this.levels[x].level == lvl) {
			return this.levels[x].name;
		}
	}
	return null;
};
dojo.logging.log.getLevel = function (name) {
	for (var x = 0; x < this.levels.length; x++) {
		if (this.levels[x].name.toUpperCase() == name.toUpperCase()) {
			return this.levels[x].level;
		}
	}
	return null;
};
dojo.declare("dojo.logging.MemoryLogHandler", dojo.logging.LogHandler, {initializer:function (level, recordsToKeep, postType, postInterval) {
	dojo.logging.LogHandler.call(this, level);
	this.numRecords = (typeof djConfig["loggingNumRecords"] != "undefined") ? djConfig["loggingNumRecords"] : ((recordsToKeep) ? recordsToKeep : -1);
	this.postType = (typeof djConfig["loggingPostType"] != "undefined") ? djConfig["loggingPostType"] : (postType || -1);
	this.postInterval = (typeof djConfig["loggingPostInterval"] != "undefined") ? djConfig["loggingPostInterval"] : (postType || -1);
}, emit:function (record) {
	if (!djConfig.isDebug) {
		return;
	}
	var logStr = String(dojo.log.getLevelName(record.level) + ": " + record.time.toLocaleTimeString()) + ": " + record.message;
	if (!dj_undef("println", dojo.hostenv)) {
		dojo.hostenv.println(logStr, record.msgArgs);
	}
	this.data.push(record);
	if (this.numRecords != -1) {
		while (this.data.length > this.numRecords) {
			this.data.shift();
		}
	}
}});
dojo.logging.logQueueHandler = new dojo.logging.MemoryLogHandler(0, 50, 0, 10000);
dojo.logging.log.addHandler(dojo.logging.logQueueHandler);
dojo.log = dojo.logging.log;