nope-js-node
Version:
NoPE Runtime for Nodejs. For Browser-Support please use nope-browser
340 lines (339 loc) • 10.4 kB
JavaScript
;
/**
* @author Martin Karkowski
* @email m.karkowski@zema.de
* @create date 2021-11-11 11:27:44
* @modify date 2021-11-11 11:27:44
* @desc [description]
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.NopeLogger = exports.shouldLog = exports.enableFor = exports.enabledFor = exports.LoggerLevels = exports.formatMsgForConsole = void 0;
const Logger = require("js-logger");
const objectMethods_1 = require("../helpers/objectMethods");
const runtimeMethods_1 = require("../helpers/runtimeMethods");
const colors = {
Reset: "\x1b[0m",
Bright: "\x1b[1m",
Dim: "\x1b[2m",
Underscore: "\x1b[4m",
Blink: "\x1b[5m",
Reverse: "\x1b[7m",
Hidden: "\x1b[8m",
FgBlack: "\x1b[30m",
FgRed: "\x1b[31m",
FgGreen: "\x1b[32m",
FgYellow: "\x1b[33m",
FgBlue: "\x1b[34m",
FgMagenta: "\x1b[35m",
FgCyan: "\x1b[36m",
FgWhite: "\x1b[37m",
BgBlack: "\x1b[40m",
BgRed: "\x1b[41m",
BgGreen: "\x1b[42m",
BgYellow: "\x1b[43m",
BgBlue: "\x1b[44m",
BgMagenta: "\x1b[45m",
BgCyan: "\x1b[46m",
BgWhite: "\x1b[47m",
};
const colorMatching = {
ERROR: colors.FgRed,
WARN: colors.FgYellow,
INFO: colors.FgWhite,
DEBUG: colors.FgGreen,
TRACE: colors.FgCyan,
};
const spacer = {
ERROR: "",
WARN: " ",
INFO: " ",
DEBUG: "",
TRACE: "",
};
exports.formatMsgForConsole = runtimeMethods_1.RUNNINGINNODE
? function (message, context) {
return [
colors.FgBlue,
new Date().toISOString(),
colors.Reset,
"-",
colorMatching[context.level.name],
context.level.name + spacer[context.level.name],
colors.Reset,
"-",
colors.BgWhite + colors.FgBlack,
context.name,
colorMatching[context.level.name],
":",
...message,
colors.Reset,
];
}
: function (message, context) {
return [
new Date().toISOString(),
"-",
context.level.name + spacer[context.level.name],
"-",
context.name,
":",
...message,
];
};
Logger.useDefaults({
defaultLevel: Logger.DEBUG,
formatter: runtimeMethods_1.RUNNINGINNODE
? function (messages, context) {
messages.unshift(colors.FgBlue, new Date().toISOString(), colors.Reset, "-", colorMatching[context.level.name], context.level.name + spacer[context.level.name], colors.Reset, "-", colors.BgWhite + colors.FgBlack, context.name, colors.Reset, colorMatching[context.level.name], ":");
messages.push(colors.Reset);
}
: function (messages, context) {
messages.unshift(context.level.name + spacer[context.level.name], "-", context.name, ":");
},
});
/**
* Array containg the Valid Types of the Loger. see {@link LoggerLevel}
*/
exports.LoggerLevels = ["error", "warn", "info", "debug", "trace"];
const order = {
error: 8,
warn: 5,
info: 3,
debug: 2,
trace: 1,
};
const mapping = {
error: Logger.ERROR,
warn: Logger.WARN,
info: Logger.INFO,
debug: Logger.DEBUG,
trace: Logger.TRACE,
};
const reverseOrder = {};
Object.getOwnPropertyNames(order).map((key) => {
reverseOrder[order[key]] = key;
});
const reverseMapping = {};
Object.getOwnPropertyNames(mapping).map((key) => {
reverseMapping[mapping[key]] = key;
});
function _selectLevel(master, slave) {
const masterLevel = order[master];
const slaveLevel = order[slave];
return reverseOrder[Math.max(masterLevel, slaveLevel)];
}
/**
* Helper Function, to create a Logger.
* Therefore it uses a specific Level and a Lable of the
* Logger
*
* @export
* @param {LoggerLevel} level The Level, which should be rendered
* @param {string} [label=''] An Lable for the Logger. Every Message beginns with that lable.
* @return {*} Returns a Logger.
*/
function _getLogger(level, label = "") {
const logger = Logger.get(label);
logger.setLevel(mapping[level]);
return logger;
}
/**
* Tests if the Logger is enabled for the level, or extracts the level.
*
* @param {ILogger} logger The logger
* @param {LoggerLevel} [lvl] if provided tests if the lvl matches the logger. otherwise returns the current level
* @return {(boolean | LoggerLevel)}
*/
function enabledFor(logger, lvl) {
if (lvl) {
return logger.enabledFor(mapping[lvl]);
}
return logger.getLevel().name;
}
exports.enabledFor = enabledFor;
/**
* Enables the Logger for the desired Level.
*
* @param {ILogger} logger The logger
* @param {LoggerLevel} lvl The level to use
* @return {void}
*/
function enableFor(logger, lvl) {
return logger.setLevel(mapping[lvl]);
}
exports.enableFor = enableFor;
/**
* Helper to test if the message would be logged.
* @param loggerLevel The Level of the logger
* @param messageLevel The Level of the Message
* @returns
*/
function shouldLog(loggerLevel, messageLevel) {
return order[messageLevel] >= order[loggerLevel];
}
exports.shouldLog = shouldLog;
/**
* The Nope-Logger. It consits o
*/
class NopeLogger {
/**
* Sets the Level of the logger. Sets all logger to the defined value.
*
* @author M.Karkowski
* @memberof NopeLogger
*/
set level(value) {
if (!this.isLocked) {
this._level = value;
this.setLoglevel("core" + objectMethods_1.SPLITCHAR, value);
}
}
/**
* Returns the general logger-level.
*
* @author M.Karkowski
* @type {LoggerLevel}
* @memberof NopeLogger
*/
get level() {
return this._level;
}
/**
* Creates a sublogger with the given name and the
* level.
*
* @author M.Karkowski
* @param {string} [name=""] The name of the logger
* @param {LoggerLevel} [level=this.level] The level of the logger.
* @return {ILogger} The Logger
* @memberof NopeLogger
*/
getLogger(name = "", level = this.level) {
if (!this._loggers.has(name)) {
this._loggers.set(name, _getLogger(_selectLevel(this.level, level), name));
}
return this._loggers.get(name);
}
/**
* Helper function, to update the Logger Defaults. Therefore you should checkout the [description](https://www.npmjs.com/package/js-logger)
*
* @param {ILoggerOpts} defaults
* @memberof NopeLogger
*/
setDefaults(defaults) {
Logger.useDefaults(defaults);
}
/**
* Rewrites the Stream of the Logger to the
* given handler. Watch out, only one handler
* is active.
*
* @param {(msg, context) => void} handler
* @memberof NopeLogger
*/
setHandler(handler) {
Logger.setHandler(handler);
}
/**
* Function to determine the Logger Level
* @param loggerGroup The specified group, which should be addressed
* @param level The Level to Set
*/
setLoglevel(loggerGroup, level) {
if (!loggerGroup.startsWith("core" + objectMethods_1.SPLITCHAR)) {
loggerGroup = "core" + objectMethods_1.SPLITCHAR + loggerGroup;
}
if (!loggerGroup.endsWith(objectMethods_1.SPLITCHAR)) {
loggerGroup += objectMethods_1.SPLITCHAR;
}
/** Iterate over all Loggers and close the unused Loggers */
for (let [name, logger] of this._loggers.entries()) {
if (!name.startsWith("core" + objectMethods_1.SPLITCHAR)) {
name = "core" + objectMethods_1.SPLITCHAR + name;
}
if (!name.endsWith(objectMethods_1.SPLITCHAR)) {
name += objectMethods_1.SPLITCHAR;
}
if (name == loggerGroup || name.startsWith(loggerGroup)) {
/** Update the Level */
logger.setLevel(mapping[level]);
}
}
}
/**
* Function, to check, whether a specific logger is enabled for logging the given log level
*
* @author M.Karkowski
* @param {string} loggerName Name of the Logger
* @param {LoggerLevel} level The Log-Level to Test
* @return {boolean} Result of the Test.
* @memberof NopeLogger
*/
isLogging(loggerName, level) {
return (order[reverseMapping[this.getLogger(loggerName).getLevel().name]] >=
order[level]);
}
/**
* Creates an instance of NopeLogger.
* @author M.Karkowski
* @memberof NopeLogger
*/
constructor() {
/**
* Helper to readout the level
*
* @author M.Karkowski
* @type {LoggerLevel}
* @memberof NopeLogger
*/
this._level = "debug";
this._pw = "";
this._loggers = new Map();
this._logger = _getLogger("debug", "root");
this._loggers.set("", this._logger);
}
/**
* Lock the Logger Level with a password. This prevents chaning the
* log level to other log-levels. you must {@link NopeLogger.unlock} to
* update the Level again.
*
* @param {string} pw The Password to Lock the Logger
* @memberof NopeLogger
*/
lock(pw) {
if (this._pw !== "") {
this._loggers.get("").error("Please unlock before");
}
else {
this._pw = pw;
}
}
/**
* Unlock the Logger, therefore the password used for locking is
* required. After unlocking, the log-level can be adapted.
*
* @author M.Karkowski
* @param {string} pw The password to unlock the logger
* @memberof NopeLogger
*/
unlock(pw) {
if (this._pw === pw) {
this._pw = "";
}
else {
this._loggers.get("").error("Unlocking wasnt successfull");
}
}
/**
* Flag indicating, whether the logger is locked or not.
*
* @author M.Karkowski
* @readonly
* @type {boolean}
* @memberof NopeLogger
*/
get isLocked() {
return this._pw !== "";
}
}
exports.NopeLogger = NopeLogger;