typescript-logging
Version:
Library for logging, written in typescript, can be used by normal es5+ javascript as well.
268 lines • 9.96 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var LoggerOptions_1 = require("../LoggerOptions");
var DataStructures_1 = require("../../utils/DataStructures");
var MessageUtils_1 = require("../../utils/MessageUtils");
var LogMessageInternalImpl = (function () {
function LogMessageInternalImpl(loggerName, message, errorAsStack, error, logGroupRule, date, level, ready) {
this._errorAsStack = null;
this._error = null;
this._loggerName = loggerName;
this._message = message;
this._errorAsStack = errorAsStack;
this._error = error;
this._logGroupRule = logGroupRule;
this._date = date;
this._level = level;
this._ready = ready;
}
Object.defineProperty(LogMessageInternalImpl.prototype, "loggerName", {
get: function () {
return this._loggerName;
},
enumerable: true,
configurable: true
});
Object.defineProperty(LogMessageInternalImpl.prototype, "message", {
get: function () {
return this._message;
},
set: function (value) {
this._message = value;
},
enumerable: true,
configurable: true
});
Object.defineProperty(LogMessageInternalImpl.prototype, "errorAsStack", {
get: function () {
return this._errorAsStack;
},
set: function (value) {
this._errorAsStack = value;
},
enumerable: true,
configurable: true
});
Object.defineProperty(LogMessageInternalImpl.prototype, "error", {
get: function () {
return this._error;
},
set: function (value) {
this._error = value;
},
enumerable: true,
configurable: true
});
Object.defineProperty(LogMessageInternalImpl.prototype, "logGroupRule", {
get: function () {
return this._logGroupRule;
},
set: function (value) {
this._logGroupRule = value;
},
enumerable: true,
configurable: true
});
Object.defineProperty(LogMessageInternalImpl.prototype, "date", {
get: function () {
return this._date;
},
set: function (value) {
this._date = value;
},
enumerable: true,
configurable: true
});
Object.defineProperty(LogMessageInternalImpl.prototype, "level", {
get: function () {
return this._level;
},
set: function (value) {
this._level = value;
},
enumerable: true,
configurable: true
});
Object.defineProperty(LogMessageInternalImpl.prototype, "isMessageLogData", {
get: function () {
return typeof (this._message) !== "string";
},
enumerable: true,
configurable: true
});
Object.defineProperty(LogMessageInternalImpl.prototype, "ready", {
get: function () {
return this._ready;
},
set: function (value) {
this._ready = value;
},
enumerable: true,
configurable: true
});
Object.defineProperty(LogMessageInternalImpl.prototype, "messageAsString", {
get: function () {
if (typeof (this._message) === "string") {
return this._message;
}
return this._message.msg;
},
enumerable: true,
configurable: true
});
Object.defineProperty(LogMessageInternalImpl.prototype, "logData", {
get: function () {
var result = null;
if (typeof (this._message) !== "string") {
result = this.message;
}
return result;
},
enumerable: true,
configurable: true
});
return LogMessageInternalImpl;
}());
/**
* Abstract base logger, extend to easily implement a custom logger that
* logs wherever you want. You only need to implement doLog(msg: LogMessage) and
* log that somewhere (it will contain format and everything else).
*/
var AbstractLogger = (function () {
function AbstractLogger(name, logGroupRuntimeSettings) {
this._allMessages = new DataStructures_1.LinkedList();
this._open = true;
this._name = name;
this._logGroupRuntimeSettings = logGroupRuntimeSettings;
}
Object.defineProperty(AbstractLogger.prototype, "name", {
get: function () {
return this._name;
},
enumerable: true,
configurable: true
});
AbstractLogger.prototype.trace = function (msg, error) {
if (error === void 0) { error = null; }
this._log(LoggerOptions_1.LogLevel.Trace, msg, error);
};
AbstractLogger.prototype.debug = function (msg, error) {
if (error === void 0) { error = null; }
this._log(LoggerOptions_1.LogLevel.Debug, msg, error);
};
AbstractLogger.prototype.info = function (msg, error) {
if (error === void 0) { error = null; }
this._log(LoggerOptions_1.LogLevel.Info, msg, error);
};
AbstractLogger.prototype.warn = function (msg, error) {
if (error === void 0) { error = null; }
this._log(LoggerOptions_1.LogLevel.Warn, msg, error);
};
AbstractLogger.prototype.error = function (msg, error) {
if (error === void 0) { error = null; }
this._log(LoggerOptions_1.LogLevel.Error, msg, error);
};
AbstractLogger.prototype.fatal = function (msg, error) {
if (error === void 0) { error = null; }
this._log(LoggerOptions_1.LogLevel.Fatal, msg, error);
};
AbstractLogger.prototype.isTraceEnabled = function () {
return this._logGroupRuntimeSettings.level === LoggerOptions_1.LogLevel.Trace;
};
AbstractLogger.prototype.isDebugEnabled = function () {
return this._logGroupRuntimeSettings.level <= LoggerOptions_1.LogLevel.Debug;
};
AbstractLogger.prototype.isInfoEnabled = function () {
return this._logGroupRuntimeSettings.level <= LoggerOptions_1.LogLevel.Info;
};
AbstractLogger.prototype.isWarnEnabled = function () {
return this._logGroupRuntimeSettings.level <= LoggerOptions_1.LogLevel.Warn;
};
AbstractLogger.prototype.isErrorEnabled = function () {
return this._logGroupRuntimeSettings.level <= LoggerOptions_1.LogLevel.Error;
};
AbstractLogger.prototype.isFatalEnabled = function () {
return this._logGroupRuntimeSettings.level <= LoggerOptions_1.LogLevel.Fatal;
};
AbstractLogger.prototype.getLogLevel = function () {
return this._logGroupRuntimeSettings.level;
};
AbstractLogger.prototype.isOpen = function () {
return this._open;
};
AbstractLogger.prototype.close = function () {
this._open = false;
this._allMessages.clear();
};
AbstractLogger.prototype.createDefaultLogMessage = function (msg) {
return MessageUtils_1.MessageFormatUtils.renderDefaultLog4jMessage(msg, true);
};
/**
* Return optional message formatter. All LoggerTypes (except custom) will see if
* they have this, and if so use it to log.
* @returns {((message:LogMessage)=>string)|null}
*/
AbstractLogger.prototype._getMessageFormatter = function () {
return this._logGroupRuntimeSettings.formatterLogMessage;
};
AbstractLogger.prototype._log = function (level, msg, error) {
if (error === void 0) { error = null; }
if (this._open && this._logGroupRuntimeSettings.level <= level) {
var functionMessage = function () {
if (typeof msg === "function") {
return msg();
}
return msg;
};
var functionError = function () {
if (typeof error === "function") {
return error();
}
return error;
};
this._allMessages.addTail(this.createMessage(level, functionMessage, functionError, new Date()));
this.processMessages();
}
};
AbstractLogger.prototype.createMessage = function (level, msg, error, date) {
var _this = this;
var errorResult = error();
if (errorResult !== null) {
var message_1 = new LogMessageInternalImpl(this._name, msg(), null, errorResult, this._logGroupRuntimeSettings.logGroupRule, date, level, false);
MessageUtils_1.MessageFormatUtils.renderError(errorResult).then(function (stack) {
message_1.errorAsStack = stack;
message_1.ready = true;
_this.processMessages();
}).catch(function () {
message_1.errorAsStack = "<UNKNOWN> unable to get stack.";
message_1.ready = true;
_this.processMessages();
});
return message_1;
}
return new LogMessageInternalImpl(this._name, msg(), null, errorResult, this._logGroupRuntimeSettings.logGroupRule, date, level, true);
};
AbstractLogger.prototype.processMessages = function () {
// Basically we wait until errors are resolved (those messages
// may not be ready).
var msgs = this._allMessages;
if (msgs.getSize() > 0) {
do {
var msg = msgs.getHead();
if (msg != null) {
if (!msg.ready) {
break;
}
msgs.removeHead();
// This can never be null normally, but strict null checking ...
if (msg.message !== null) {
this.doLog(msg);
}
}
} while (msgs.getSize() > 0);
}
};
return AbstractLogger;
}());
exports.AbstractLogger = AbstractLogger;
//# sourceMappingURL=AbstractLogger.js.map