API Name: global.GSLog
var GSLog = Class.create();
GSLog.prototype = {
/* GSLog(traceProperty,caller): Instanciates a logging instance
*
* traceProperty: The name of the property containing the logging level for the targeted script/object
* caller: The name of the script, object etc. calling the logger
*
* To use Log4J style logging:
* [this]._log = (new GSLog(traceProperty,caller))).setLog4J();
*/
initialize : function(traceProperty,caller) {
this.whoami = '';
if (caller !== null)
this.whoami = caller;
this._logLevel = (typeof gs.logWarning == 'function');
this._devel = true; // Look up the dev instance property?
// support properties
if (traceProperty)
this.setLevel(gs.getProperty(traceProperty, ''));
else
this.setLevel(this._getCallerThreshold(caller));
// Want to use log4j style logging?
this._log4j = false;
//Default logging to gs.log and not gs.print
this._printLog = false;
//Option to prefix each log message with a milliseconds value
this._timestampPrefix = false;
// gs.print('GSLog.initialize: [' + this.whoami + '] level=' + this.logLevel + ' [' + this._levelOrder[this.logLevel] + ']');
},
// System Log has Debug, Error, Information, Warning
logDebug: function(msg) {
this.log('debug', msg);
},
logInfo: function(msg) {
this.log('info', msg);
},
logNotice: function(msg) {
this.log('notice', msg);
},
logWarning: function(msg) {
this.log('warning', msg);
},
logErr: function(msg) {
this.log('err', msg);
},
logError: function(msg) {
this.log('err', msg);
},
logCrit: function(msg) {
this.log('crit', msg);
},
logAlert: function(msg) {
this.log('alert', msg);
},
logEmerg: function(msg) {
this.log('emerg', msg);
},
// Log4j style logging
trace: function(msg) {
this.log('trace', msg);
}, // If you're logging trace, you're probably logging too much.
debug: function(msg) {
this.log('debug', msg);
},
info: function(msg){
this.log('info', msg);
},
warn: function(msg){
this.log('warning', msg);
},
error: function(msg){
this.log('err', msg);
},
fatal: function(msg){
this.log('fatal', msg);
},
/* log(level,msg): Log a message at the specified level
*
* level: The level at which to log
* msg: The message
*/
log: function(level, msg) {
// (always log a message at an invalid log level)
if (typeof this._levelOrder[level] !== undefined && this._levelOrder[level] > this._levelOrder[this.logLevel] )
return;
var whomsg='';
var scriptPrefix='*** Script';
if (!this._logLevel && this._devel)
scriptPrefix = '*** Script [' + this._logPrefix[level] + ']';
else if (this.whoami) {
whomsg = '[' + this.whoami + '] ';
scriptPrefix = '*** Script [' + this.whoami + ']';
}
// override 'Script: ' prefix in log, and log at the given level if the right function exists
if (this._printLog)
//Removal of '*** Script' as gs.print prefixes this on.
gs.print(scriptPrefix.replace('*** Script','') + ': [' + this._logPrefix[level] + '] ' + msg);
else {
var logFunction = gs.log;
switch (level) {
case 'debug':
msg = '[' + this._logPrefix[level] + '] ' + msg;
break;
case 'warning':
if (typeof gs.logWarning == 'function')
logFunction = gs.logWarning;
break;
case 'err':
case 'error':
if (typeof gs.logError == 'function')
logFunction = gs.logError;
break;
// case 'info':
default:
if (typeof gs.log == 'function')
logFunction = gs.log;
}
if (this._timestampPrefix) {
var gdt = new GlideDateTime();
var gdtMs = gdt.getNumericValue().toString();
msg = gdt.getDisplayValueInternal() + "." + gdtMs.substr(gdtMs.length - 3) + " " + msg;
}
logFunction(msg, scriptPrefix);
}
},
setLevel: function(level) {
if (level.toString() == 'true')
level = 'debug'; // compatibility with true|false logging properties
else if (!level || level.toString() == 'false')
level = 'notice'; // default
else if (!this._levelOrder[level]) {
level = 'notice'; // invalid, so set to default
}
/* If you want to use log4j style logging we have to cut down some of the error states.
* Everything higher than an error -> FATAL, NOTICE -> INFO
* We also have to disallow FATAL and TRACE for BSD style logging. FATAL -> EMERG, TRACE->DEBUG
*/
if (this._log4j) { //Only allow Log4J log levels
switch (level) {
case GSLog.EMERG:
case GSLog.ALERT:
case GSLog.CRIT:
level=GSLog.FATAL;
break;
case GSLog.NOTICE:
level = GSLog.INFO;
break;
default:
break;
}
} else { //Only allow BSD log levels
switch (level) {
case GSLog.FATAL:
level=GSLog.EMERG;
break;
case GSLog.TRACE:
level=GSLog.DEBUG;
break;
default:
break;
}
}
// gs.print('GSLog.setLevel: ' + level);
this.logLevel = level;
},
/* getLevel(): Returns the current logging level */
getLevel: function(level) {
return this.logLevel;
},
/* debugOn(): sets the log level to GSLog.DEBUG */
debugOn: function() {
return (this.logLevel == 'debug');
},
/* atLevel(logLevel) : Returns true if the logging level of the logger is the same as or above minLogLevel
*
* minLogLevel: The minimum logging level to compare against.
*/
atLevel: function(minLogLevel) {
if (!this._levelOrder[minLogLevel]) {
return false;
}
if (this._levelOrder[minLogLevel]<=this._levelOrder[this.logLevel]) {
return true;
}
return false;
},
/* setLog4J(): Switches the logging class into Log4J mode */
setLog4J: function() {
this._log4J = true;
this.setLevel(this.logLevel); //Checking that the log levels are OK for Log4J style logging
return this; // allows type to be set at instanciation without a sepperate parameter in the constructor. Easier to understand.
},
/* disableDatabaseLogs(): Switches the output of the GSLog to use gs.print instead of gs.log */
disableDatabaseLogs: function() {
this._printLog = true;
return this; // allows type to be set at instanciation without a separate parameter in the constructor. Easier to understand.
},
includeTimestamp: function() {
this._timestampPrefix = true;
},
///
// logging levels
_levelOrder: {
fatal: 0,
emerg: 1,
alert: 2,
crit: 3,
err: 4,
warning: 5,
notice: 6,
info: 7,
debug: 8,
trace: 9
},
// logging prefixes
_logPrefix: {
fatal: 'FATAL',
emerg: 'EMERG',
alert: 'ALERT',
crit: 'CRIT ',
err: 'ERROR',
warning: 'WARN ',
notice: 'NOTIC',
info: 'INFO ',
debug: 'DEBUG',
trace: 'TRACE'
},
_getCallerThreshold: function(caller) {
// TODO: consider performing a record lookup, on the caller name, to pick a log level
return 'notice';
},
type: 'GSLog'
};
// BSD style log level constants
GSLog.EMERG = "emerg";
GSLog.ALERT = "alert";
GSLog.CRIT = "crit";
GSLog.ERR = "err";
GSLog.WARNING= "warning";
GSLog.NOTICE = "notice";
GSLog.INFO = "info";
GSLog.DEBUG = "debug";
// Additions for Log4j style logging
GSLog.FATAL = "fatal";
GSLog.TRACE = "trace";
GSLog.ERROR = GSLog.ERR;
GSLog.WARN = GSLog.WARNING;