hermodlog 1.0.0 → 1.1.1

package/README.md

@@ -4,6 +4,8 @@ Stupid simple logging for JS but with context for heavy log environments.
 
 This is just to only pass along a single logger instance between modules and have a hierarchical way to sort and display such modules.
 
+<img width="1365" alt="image" src="https://github.com/Alex-Werner/hermodlog/assets/5849920/347d8d00-8cb1-4838-bc5d-e7434fdd019b">
+
 
 ## Install
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermodlog",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Simple contextual logger to simplify log display in heavy load context and provide easy parsing",
   "main": "src/Logger.js",
   "type": "module",
@@ -22,6 +22,6 @@
     "chalk": "^5.3.0"
   },
   "devDependencies": {
-    "vitest": "^0.34.4"
+    "vitest": "^0.34.5"
   }
 }

package/src/LOG_LEVELS.js

@@ -0,0 +1,9 @@
+const LOG_LEVELS = {
+    trace: 0,
+    debug: 1,
+    info: 2,
+    warn: 3,
+    error: 4,
+}
+
+export default LOG_LEVELS

package/src/Logger.js

@@ -1,8 +1,22 @@
-import chalk from 'chalk';
-export default class Logger {
-    constructor(_date, level = 'info') {
-
-        this.level = level;
+import LOG_LEVELS from "./LOG_LEVELS.js";
+
+import context from "./methods/context.js";
+import debug from "./methods/debug.js";
+import error from "./methods/error.js";
+import info from "./methods/info.js";
+import listener from "./methods/listener.js";
+import log from "./methods/log.js";
+import method from "./methods/method.js";
+import module from "./methods/module.js";
+import trace from "./methods/trace.js";
+import warn from "./methods/warn.js";
+
+class Logger {
+    constructor(props = {}) {
+        this.level = props.level ?? 'info';
+        if (!LOG_LEVELS.hasOwnProperty(this.level)) {
+            throw new Error(`Unknown log level ${this.level}`)
+        }
 
         this.history = [];
 
@@ -10,137 +24,33 @@ export default class Logger {
         this.methodName = null
         this.moduleName = null
         this.listenerName = null
-        if(_date){
-            this._date = _date;
+        if (props.date) {
+            this.date = props.date;
         }
     }
 
-    context(_context) {
-        const logger = new Logger(this._date);
-        logger.contextName = _context;
-        logger.methodName = this.methodName;
-        logger.moduleName = this.moduleName;
-        logger.listenerName = this.listenerName;
-
-        logger._log = this._log.bind(logger);
-        return logger;
-    }
-    module(_module) {
-        const logger = new Logger(this._date);
-        logger.methodName = this.methodName;
-        logger.moduleName = _module;
-        logger.contextName = this.contextName;
-        logger.listenerName = this.listenerName;
-
-        logger._log = this._log.bind(logger);
-        return logger;
-    }
-    listener(_listener) {
-        const logger = new Logger(this._date);
-        logger.moduleName = this.moduleName;
-        logger.contextName = this.contextName;
-        logger.listenerName = _listener;
-        logger._log = this._log.bind(logger);
-        return logger;
-    }
-    method(_method) {
-        const logger = new Logger(this._date);
-        logger.moduleName = this.moduleName;
-        logger.contextName = this.contextName;
-        logger.listenerName = this.listenerName;
-        logger.methodName = _method;
-        logger._log = this._log.bind(logger);
-        return logger;
-    }
     _log(message) {
         console.log(message)
     }
 
-    log(...args) {
-        let _message = args[0];
-        if(args.length > 1){
-            _message = args.slice(0).join(' | ');
-        }
-        const date = this._date || new Date();
-        let message = `[${chalk.gray(date.toISOString())}]`;
-
-
-        if(this.contextName){
-            message += ` context: ${chalk.blueBright(this.contextName)} |`;
-        }
-        if(this.moduleName){
-            message += ` module:${chalk.gray(this.moduleName)} |`;
-        }
-        if(this.listenerName){
-            message += ` listener: ${chalk.red(this.listenerName)} |`;
-        }
-        if(this.methodName){
-            message += ` method: ${chalk.yellow(this.methodName)} |`;
-        }
-        if(message.endsWith(' |')){
-            message = message.slice(0, -1);
-        }
-
-        for(let i = 0; i < args.length; i++){
-            if(typeof args[i] === 'object'){
-                const constructorName = args[i].constructor.name;
-                message += ` ${chalk.yellow(`${constructorName}(`)}`
-                message += chalk.yellow(JSON.stringify(args[i], null, 2))
-                message += ` ${chalk.yellow(")")}`
-            }
-            if(typeof args[i] === 'string'){
-                message += chalk.green(args[i])
-            }
-        }
-
-
-        // // If message is an object, we put it on a new line
-        // if(typeof _message === 'object'){
-        //     message += ' Object'
-        //     message += '\n'+JSON.stringify(_message, null, 2)
-        // } else{
-        //     message += ' : '+ _message
-        // }
-
-        this.history.push(message);
-        if(this.history.length > 100){
-            this.history.shift();
-        }
-
-        this._log(message);
-    }
-    info(message) {
-        this.log(message);
-    }
-    debug(message) {
-        this.log(message);
-    }
-    trace(message) {
-        if(this.level === 'trace')
-        {
-            this.log(message);
-        }
+    clone() {
+        return new Logger({
+            level: this.level,
+            date: this.date,
+        })
     }
-    error(_message) {
-        const date = this._date || new Date();
-        let message = `[${chalk.gray(date.toISOString())}]`;
 
-        if(this.moduleName){
-            message += ` - m=${chalk.blue(this.moduleName)}`;
-        }
-        if(this.contextName){
-            message += ` - c=${chalk.green(this.contextName)}`;
-        }
-
-        message += ` : ${chalk.red(_message)}`
-
-        this.history.push(message);
-        if(this.history.length > 100){
-            this.history.shift();
-        }
-        this._log(message);
-    }
-    warn(message) {
-        this.log(message);
-    }
 };
+
+Logger.prototype.context = context;
+Logger.prototype.debug = debug;
+Logger.prototype.error = error;
+Logger.prototype.info = info;
+Logger.prototype.listener = listener;
+Logger.prototype.log = log;
+Logger.prototype.method = method;
+Logger.prototype.module = module;
+Logger.prototype.trace = trace;
+Logger.prototype.warn = warn;
+
+export default Logger;

package/src/methods/context.js

@@ -0,0 +1,12 @@
+import Logger from "../Logger.js";
+
+export default function context(_context) {
+    const logger = this.clone();
+    logger.contextName = _context;
+    logger.methodName = this.methodName;
+    logger.moduleName = this.moduleName;
+    logger.listenerName = this.listenerName;
+
+    logger._log = this._log.bind(logger);
+    return logger;
+}

package/src/methods/debug.js

@@ -0,0 +1,50 @@
+import LOG_LEVELS from "../LOG_LEVELS.js";
+import chalk from "chalk";
+
+export default function debug(...args) {
+    if(LOG_LEVELS[this.level] > LOG_LEVELS['debug']){
+        return;
+    }
+    let _message = args[0];
+    if(args.length > 1){
+        _message = args.slice(0).join(' | ');
+    }
+    const date = this.date || new Date();
+    let message = `[${chalk.gray(date.toISOString())}][${chalk.blue('D')}]`;
+
+
+    if(this.contextName){
+        message += ` context: ${chalk.blueBright(this.contextName)} |`;
+    }
+    if(this.moduleName){
+        message += ` module:${chalk.gray(this.moduleName)} |`;
+    }
+    if(this.listenerName){
+        message += ` listener: ${chalk.cyan(this.listenerName)} |`;
+    }
+    if(this.methodName){
+        message += ` method: ${chalk.yellow(this.methodName)} |`;
+    }
+    if(message.endsWith(' |')){
+        message = message.slice(0, -1);
+    }
+
+    for(let i = 0; i < args.length; i++){
+        if(typeof args[i] === 'object'){
+            const constructorName = args[i].constructor.name;
+            message += ` ${chalk.blue(`${constructorName}(`)}`
+            message += chalk.blue(JSON.stringify(args[i], null, 2))
+            message += ` ${chalk.blue(")")}`
+        }
+        if(typeof args[i] === 'string'){
+            message += chalk.blue(args[i])
+        }
+    }
+
+    this.history.push(message);
+    if(this.history.length > 100){
+        this.history.shift();
+    }
+
+    this._log(message);
+}

package/src/methods/error.js

@@ -0,0 +1,49 @@
+import LOG_LEVELS from "../LOG_LEVELS.js";
+import chalk from "chalk";
+
+export default function error(...args) {
+    if(LOG_LEVELS[this.level] > LOG_LEVELS['error']){
+        return;
+    }
+    let _message = args[0];
+    if(args.length > 1){
+        _message = args.slice(0).join(' | ');
+    }
+    const date = this.date || new Date();
+    let message = `[${chalk.gray(date.toISOString())}][${chalk.red('E')}]`;
+
+    if(this.contextName){
+        message += ` context: ${chalk.blueBright(this.contextName)} |`;
+    }
+    if(this.moduleName){
+        message += ` module:${chalk.gray(this.moduleName)} |`;
+    }
+    if(this.listenerName){
+        message += ` listener: ${chalk.cyan(this.listenerName)} |`;
+    }
+    if(this.methodName){
+        message += ` method: ${chalk.yellow(this.methodName)} |`;
+    }
+    if(message.endsWith(' |')){
+        message = message.slice(0, -1);
+    }
+
+    for(let i = 0; i < args.length; i++){
+        if(typeof args[i] === 'object'){
+            const constructorName = args[i].constructor.name;
+            message += ` ${chalk.red(`${constructorName}(`)}`
+            message += chalk.red(JSON.stringify(args[i], null, 2))
+            message += ` ${chalk.red(")")}`
+        }
+        if(typeof args[i] === 'string'){
+            message += chalk.red(args[i])
+        }
+    }
+
+    this.history.push(message);
+    if(this.history.length > 100){
+        this.history.shift();
+    }
+
+    this._log(message);
+}

package/src/methods/info.js

@@ -0,0 +1,50 @@
+import LOG_LEVELS from "../LOG_LEVELS.js";
+import chalk from "chalk";
+
+export default function info(...args) {
+    if(LOG_LEVELS[this.level] > LOG_LEVELS['info']){
+        return;
+    }
+    let _message = args[0];
+    if(args.length > 1){
+        _message = args.slice(0).join(' | ');
+    }
+    const date = this.date || new Date();
+    let message = `[${chalk.gray(date.toISOString())}][${chalk.green('I')}]`;
+
+
+    if(this.contextName){
+        message += ` context: ${chalk.blueBright(this.contextName)} |`;
+    }
+    if(this.moduleName){
+        message += ` module:${chalk.gray(this.moduleName)} |`;
+    }
+    if(this.listenerName){
+        message += ` listener: ${chalk.cyan(this.listenerName)} |`;
+    }
+    if(this.methodName){
+        message += ` method: ${chalk.yellow(this.methodName)} |`;
+    }
+    if(message.endsWith(' |')){
+        message = message.slice(0, -1);
+    }
+
+    for(let i = 0; i < args.length; i++){
+        if(typeof args[i] === 'object'){
+            const constructorName = args[i].constructor.name;
+            message += ` ${chalk.yellow(`${constructorName}(`)}`
+            message += chalk.yellow(JSON.stringify(args[i], null, 2))
+            message += ` ${chalk.yellow(")")}`
+        }
+        if(typeof args[i] === 'string'){
+            message += chalk.green(args[i])
+        }
+    }
+
+    this.history.push(message);
+    if(this.history.length > 100){
+        this.history.shift();
+    }
+
+    this._log(message);
+}

package/src/methods/listener.js

@@ -0,0 +1,10 @@
+import Logger from "../Logger.js";
+
+export default function  listener(_listener) {
+    const logger = this.clone();
+    logger.moduleName = this.moduleName;
+    logger.contextName = this.contextName;
+    logger.listenerName = _listener;
+    logger._log = this._log.bind(logger);
+    return logger;
+}

package/src/methods/log.js

@@ -0,0 +1,6 @@
+import chalk from "chalk";
+import LOG_LEVELS from "../LOG_LEVELS.js";
+
+export default function log(...args) {
+    return this.info(...args);
+}

package/src/methods/method.js

@@ -0,0 +1,11 @@
+import Logger from "../Logger.js";
+
+export default function  method(_method) {
+    const logger = this.clone();
+    logger.moduleName = this.moduleName;
+    logger.contextName = this.contextName;
+    logger.listenerName = this.listenerName;
+    logger.methodName = _method;
+    logger._log = this._log.bind(logger);
+    return logger;
+}

package/src/methods/module.js

@@ -0,0 +1,12 @@
+import Logger from "../Logger.js";
+
+export default function   module(_module) {
+    const logger = this.clone();
+    logger.methodName = this.methodName;
+    logger.moduleName = _module;
+    logger.contextName = this.contextName;
+    logger.listenerName = this.listenerName;
+
+    logger._log = this._log.bind(logger);
+    return logger;
+}

package/src/methods/trace.js

@@ -0,0 +1,50 @@
+import LOG_LEVELS from "../LOG_LEVELS.js";
+import chalk from "chalk";
+
+export default function trace(...args) {
+    if(LOG_LEVELS[this.level] > LOG_LEVELS['trace']){
+        return;
+    }
+    let _message = args[0];
+    if(args.length > 1){
+        _message = args.slice(0).join(' | ');
+    }
+    const date = this.date || new Date();
+    let message = `[${chalk.gray(date.toISOString())}][${chalk.grey('T')}]`;
+
+
+    if(this.contextName){
+        message += ` context: ${chalk.blueBright(this.contextName)} |`;
+    }
+    if(this.moduleName){
+        message += ` module:${chalk.gray(this.moduleName)} |`;
+    }
+    if(this.listenerName){
+        message += ` listener: ${chalk.cyan(this.listenerName)} |`;
+    }
+    if(this.methodName){
+        message += ` method: ${chalk.yellow(this.methodName)} |`;
+    }
+    if(message.endsWith(' |')){
+        message = message.slice(0, -1);
+    }
+
+    for(let i = 0; i < args.length; i++){
+        if(typeof args[i] === 'object'){
+            const constructorName = args[i].constructor.name;
+            message += ` ${chalk.grey(`${constructorName}(`)}`
+            message += chalk.grey(JSON.stringify(args[i], null, 2))
+            message += ` ${chalk.grey(")")}`
+        }
+        if(typeof args[i] === 'string'){
+            message += chalk.grey(args[i])
+        }
+    }
+
+    this.history.push(message);
+    if(this.history.length > 100){
+        this.history.shift();
+    }
+
+    this._log(message);
+}

package/src/methods/warn.js

@@ -0,0 +1,50 @@
+import LOG_LEVELS from "../LOG_LEVELS.js";
+import chalk from "chalk";
+
+export default function warn(...args) {
+    if(LOG_LEVELS[this.level] > LOG_LEVELS['warn']){
+        return;
+    }
+    let _message = args[0];
+    if(args.length > 1){
+        _message = args.slice(0).join(' | ');
+    }
+    const date = this.date || new Date();
+    let message = `[${chalk.gray(date.toISOString())}][${chalk.yellow('W')}]`;
+
+
+    if(this.contextName){
+        message += ` context: ${chalk.blueBright(this.contextName)} |`;
+    }
+    if(this.moduleName){
+        message += ` module:${chalk.gray(this.moduleName)} |`;
+    }
+    if(this.listenerName){
+        message += ` listener: ${chalk.cyan(this.listenerName)} |`;
+    }
+    if(this.methodName){
+        message += ` method: ${chalk.yellow(this.methodName)} |`;
+    }
+    if(message.endsWith(' |')){
+        message = message.slice(0, -1);
+    }
+
+    for(let i = 0; i < args.length; i++){
+        if(typeof args[i] === 'object'){
+            const constructorName = args[i].constructor.name;
+            message += ` ${chalk.yellow(`${constructorName}(`)}`
+            message += chalk.yellow(JSON.stringify(args[i], null, 2))
+            message += ` ${chalk.yellow(")")}`
+        }
+        if(typeof args[i] === 'string'){
+            message += chalk.yellow(args[i])
+        }
+    }
+
+    this.history.push(message);
+    if(this.history.length > 100){
+        this.history.shift();
+    }
+
+    this._log(message);
+}

package/usage.example.js

@@ -0,0 +1,43 @@
+import Logger from './src/Logger.js';
+
+
+const logger = new Logger({
+    level: 'trace',
+});
+const contextLogger = logger.context('APIContext')
+contextLogger.log('Started API');
+const moduleLogger = contextLogger.module('Websocket Server')
+moduleLogger.log('Started WSS');
+const listenerLogger = moduleLogger.listener('onConnection')
+listenerLogger.log('New connection');
+const object = {
+    x:42,
+    y: {
+        b:[1,2,3]
+    },
+    req:'getCar'
+}
+listenerLogger.method('processIncomingMessage').log('Received from ws client',object)
+
+class Car {
+    constructor(props) {
+        this.name = props.name;
+    }
+};
+
+const car = new Car({name: 'RSQ'});
+
+listenerLogger.method('processIncomingMessage').log('Responding to client object:',car)
+listenerLogger.error('Something happened while sending:',car)
+
+listenerLogger.trace('Display me');
+listenerLogger.level = 'error'
+listenerLogger.trace('Do not display me trace on error');
+listenerLogger.log('Do not display me log on error')
+listenerLogger.error('Do display me')
+listenerLogger.level = 'trace'
+listenerLogger.error('Error')
+listenerLogger.warn('Warn')
+listenerLogger.info('Info')
+listenerLogger.debug('debug')
+listenerLogger.trace('trace')