hermodlog 1.2.0 → 1.3.0

package/README.md

@@ -6,7 +6,7 @@ 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">
+<img width="1065" alt="image" src="https://github.com/Alex-Werner/hermodlog/assets/5849920/1df7e7dd-cf25-4ce3-872b-dab1288966e4">
 
 
 ## Install
@@ -20,13 +20,14 @@ npm i hermodlog
 ```js
 import Logger from 'hermodlog';
 
-logger = new Logger();
-logger.log("Stuff");
-
-
-contextLogger = logger.context('Node#4');
-
-moduleLogger = contextLogger.module('myModule');
+const logger = new Logger({
+    level: 'debug', // Optional, default: 'info'
+});
+const contextLogger = logger.context('Node#42');
+const moduleLogger = logger.module('WSServer');
+moduleLogger.method('init').log("Initializing server...");
+const listenerLogger = moduleLogger.listener('onMessage');
+listenerLogger.debug("Message received!");
 ```
 
 ## API
@@ -37,10 +38,18 @@ moduleLogger = contextLogger.module('myModule');
 Create a new logger instance.
 
 ##### `context(name)`
-Create a new context logger with the given name.
+Create a new context logger with the given context name.
 
 ##### `module(name)`
-Create a new module logger with the given name.
+Create a new module logger with the given module name.
+
+##### `listener(name)`
+Create a new listener sublogger with the given listener name.
+
+##### `method(name)`
+Create a new method sublogger with the given method name.
+
+#### Level methods
 
 ##### `log(message, level)`
 Log a message with the given level.
@@ -54,6 +63,9 @@ Log a message with the info level.
 ##### `warn(message)`
 Log a message with the warn level.
 
+##### `fatal(message)`
+Log a message with the fatal level.
+
 ##### `error(message)`
 Log a message with the error level.
 
@@ -61,6 +73,33 @@ Log a message with the error level.
 Log a message with the fatal level.
 
 
+#### constructor options
+The `options` object can have the following properties:  
+
+level: The default log level. Can be one of 'fatal', 'error', 'warn', 'info', 'debug', 'trace'.
+colors: An object where each key is a log level and the value is an array of colors for different parts of the log message. The array should have the following order: [date color, type color, context color, module color, listener color, method color, object color, string color, function color, number/default color].
+date: A date-compatible format
+
+```js
+{
+    const options = {
+        date: new Date('2024-01-01T00:01:01.001Z')},
+        level: 'info', // Set the default log level
+        colors: { // Set the colors for different parts of the log message
+            fatal: [chalk.gray, chalk.red, chalk.blueBright, chalk.gray, chalk.cyan, chalk.yellow, chalk.magenta, chalk.white, chalk.blue, chalk.cyan],
+            error: [chalk.gray, chalk.red, chalk.blueBright, chalk.gray, chalk.cyan, chalk.yellow, chalk.red, chalk.yellow, chalk.green, chalk.blue],
+            warn: [chalk.gray, chalk.red, chalk.blueBright, chalk.gray, chalk.cyan, chalk.yellow, chalk.yellow, chalk.blue, chalk.magenta, chalk.red],
+            info: [chalk.gray, chalk.red, chalk.blueBright, chalk.gray, chalk.cyan, chalk.yellow, chalk.blue, chalk.green, chalk.red, chalk.yellow],
+            debug: [chalk.gray, chalk.red, chalk.blueBright, chalk.gray, chalk.cyan, chalk.yellow, chalk.green, chalk.red, chalk.yellow, chalk.blue],
+            trace: [chalk.gray, chalk.red, chalk.blueBright, chalk.gray, chalk.cyan, chalk.yellow, chalk.magenta, chalk.yellow, chalk.blue, chalk.green],
+        }
+    };
+    const logger = new Logger(options);
+    
+    logger.log('Hello World');
+}
+```
+
 ### License
 
 MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermodlog",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Simple contextual logger to simplify log display in heavy load context and provide easy parsing",
   "main": "src/Logger.js",
   "type": "module",

package/src/LOG_COLORS.js

@@ -0,0 +1,13 @@
+import chalk from "chalk";
+
+const LOG_COLORS = {
+    // [date color, type color, context color, module color, listener color, method color, object color, string color, function color, number/default color]
+    debug: [chalk.gray, chalk.blue, chalk.blueBright, chalk.gray, chalk.cyan, chalk.yellow, chalk.blue, chalk.blue, chalk.blue, chalk.blue],
+    error: [chalk.gray, chalk.red, chalk.blueBright, chalk.gray, chalk.cyan, chalk.yellow, chalk.red, chalk.red, chalk.red, chalk.red],
+    fatal: [chalk.gray, chalk.magenta, chalk.blueBright, chalk.gray, chalk.cyan, chalk.yellow, chalk.magenta, chalk.magenta, chalk.magenta, chalk.magenta],
+    info: [chalk.gray, chalk.green, chalk.blueBright, chalk.gray, chalk.cyan, chalk.yellow, chalk.green, chalk.green, chalk.green, chalk.green],
+    trace: [chalk.gray, chalk.gray, chalk.blueBright, chalk.gray, chalk.cyan, chalk.yellow, chalk.gray, chalk.gray, chalk.gray, chalk.gray],
+    warn: [chalk.gray, chalk.yellow, chalk.blueBright, chalk.gray, chalk.cyan, chalk.yellow, chalk.yellow, chalk.yellow, chalk.yellow, chalk.yellow],
+}
+
+export default LOG_COLORS;

package/src/LOG_LEVELS.js

@@ -4,6 +4,7 @@ const LOG_LEVELS = {
     info: 2,
     warn: 3,
     error: 4,
+    fatal: 5
 }
 
 export default LOG_LEVELS

package/src/Logger.js

@@ -10,7 +10,10 @@ import method from "./methods/method.js";
 import module from "./methods/module.js";
 import trace from "./methods/trace.js";
 import warn from "./methods/warn.js";
+import fatal from "./methods/fatal.js";
+import child from "./methods/child.js";
 
+import LOG_COLORS from "./LOG_COLORS.js";
 class Logger {
     constructor(props = {}) {
         this.level = props.level ?? 'info';
@@ -27,6 +30,8 @@ class Logger {
         if (props.date) {
             this.date = props.date;
         }
+
+        this.LOG_COLORS = (props.colors) ?? LOG_COLORS;
     }
 
     _log(message) {
@@ -45,6 +50,7 @@ class Logger {
 Logger.prototype.context = context;
 Logger.prototype.debug = debug;
 Logger.prototype.error = error;
+Logger.prototype.fatal = fatal;
 Logger.prototype.info = info;
 Logger.prototype.listener = listener;
 Logger.prototype.log = log;
@@ -52,5 +58,6 @@ Logger.prototype.method = method;
 Logger.prototype.module = module;
 Logger.prototype.trace = trace;
 Logger.prototype.warn = warn;
+Logger.prototype.child = child;
 
 export default Logger;

package/src/Logger.spec.js

@@ -5,7 +5,7 @@ describe('Logger', () => {
     let silentLogger
     let silentModuleLogger
     it('should create an logger', () => {
-        silentLogger = new Logger(new Date('2023-07-29T01:38:00.482Z'));
+        silentLogger = new Logger({date:new Date('2023-07-29T01:38:00.482Z')});
         silentLogger._log = () => {}
         assert.equal(silentLogger.history.length, 0)
         silentLogger.log('Hello');
@@ -28,7 +28,7 @@ describe('Logger', () => {
         const silentListenerLogger = silentModuleLogger.listener('onTest')
         silentListenerLogger.log('Hello');
         assert.equal(silentListenerLogger.history.length, 1)
-        assert.equal(silentListenerLogger.history[0], "[\u001b[90m2023-07-29T01:38:00.482Z\u001b[39m] module:\u001b[90mtest-module\u001b[39m | listener: \u001b[31monTest\u001b[39m \u001b[32mHello\u001b[39m")
+        assert.equal(silentListenerLogger.history[0], "[\u001b[90m2023-07-29T01:38:00.482Z\u001b[39m] module:\u001b[90mtest-module\u001b[39m | listener: \u001b[36monTest\u001b[39m \u001b[32mHello\u001b[39m")
     })
     it('should create an logger with method', () => {
         const silentMethodLogger = silentModuleLogger.method('test-method')
@@ -48,4 +48,28 @@ describe('Logger', () => {
         levelLogger.trace('Hello');
         assert.equal(levelLogger.history.length, 1)
     });
+
+    it('should automatically beautify instead of [Object Object]', () => {
+        const object = {
+            x: 42,
+            y: {
+                b: [1, 2, 3]
+            },
+            req: 'getCar'
+        }
+        silentModuleLogger.log('Received from ws client', object)
+        assert.equal(silentModuleLogger.history.length, 2)
+        // If you change the styling of below it will assume spaces are part of the string
+        assert.equal(silentModuleLogger.history[1], `[\u001b[90m2023-07-29T01:38:00.482Z\u001b[39m] module:\u001b[90mtest-module\u001b[39m \u001b[32mReceived from ws client\u001b[39m \u001b[32mObject(\u001b[39m\u001b[32m{\u001b[39m
+\u001b[32m  "x": 42,\u001b[39m
+\u001b[32m  "y": {\u001b[39m
+\u001b[32m    "b": [\u001b[39m
+\u001b[32m      1,\u001b[39m
+\u001b[32m      2,\u001b[39m
+\u001b[32m      3\u001b[39m
+\u001b[32m    ]\u001b[39m
+\u001b[32m  },\u001b[39m
+\u001b[32m  "req": "getCar"\u001b[39m
+\u001b[32m}\u001b[39m \u001b[32m)\u001b[39m`)
+    });
 })

package/src/methods/child.js

@@ -0,0 +1,6 @@
+export default function child(_child) {
+    const logger = this.clone();
+    logger.childName = _child;
+    logger._log = this._log.bind(logger);
+    return logger;
+}

package/src/methods/debug.js

@@ -1,66 +1,8 @@
 import LOG_LEVELS from "../LOG_LEVELS.js";
-import chalk from "chalk";
-
+import log from "../utils/log.js";
 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++){
-
-        const typeOfArg = typeof args[i];
-
-        switch (typeOfArg){
-            case 'object':
-                const constructorName = args[i].constructor.name;
-                message += ` ${chalk.blue(`${constructorName}(`)}`
-                if(constructorName === 'Error'){
-                    message += chalk.blue(JSON.stringify(args[i].message, null, 2))
-                }
-                message += chalk.blue(JSON.stringify(args[i], null, 2))
-                message += ` ${chalk.blue(")")}`
-                break;
-            case 'string':
-                message += chalk.blue(args[i])
-                break;
-            case "function":
-                message += chalk.blue(args[i].toString())
-                break;
-            case "number":
-            default:
-                message += chalk.blue(args[i])
-                break;
-        }
-
-    }
-
-    this.history.push(message);
-    if(this.history.length > 100){
-        this.history.shift();
-    }
-
-    this._log(message);
+    log('debug', args, this);
 }

package/src/methods/error.js

@@ -1,64 +1,8 @@
 import LOG_LEVELS from "../LOG_LEVELS.js";
-import chalk from "chalk";
-
-export default function error(...args) {
+import log from "../utils/log.js";
+export default function info(...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++){
-
-        const typeOfArg = typeof args[i];
-
-        switch (typeOfArg){
-            case 'object':
-                const constructorName = args[i].constructor.name;
-                message += ` ${chalk.red(`${constructorName}(`)}`
-                if(constructorName === 'Error'){
-                    message += chalk.red(JSON.stringify(args[i].message, null, 2))
-                }
-                message += chalk.red(JSON.stringify(args[i], null, 2))
-                message += ` ${chalk.red(")")}`
-                break;
-            case 'string':
-                message += chalk.red(args[i])
-                break;
-            case "function":
-                message += chalk.red(args[i].toString())
-                break;
-            case "number":
-            default:
-                message += chalk.red(args[i])
-                break;
-        }
-    }
-
-    this.history.push(message);
-    if(this.history.length > 100){
-        this.history.shift();
-    }
-
-    this._log(message);
+    log('error', args, this);
 }

package/src/methods/fatal.js

@@ -0,0 +1,8 @@
+import LOG_LEVELS from "../LOG_LEVELS.js";
+import log from "../utils/log.js";
+export default function fatal(...args) {
+    if(LOG_LEVELS[this.level] > LOG_LEVELS['fatal']){
+        return;
+    }
+    log('fatal', args, this);
+}

package/src/methods/info.js

@@ -1,66 +1,8 @@
 import LOG_LEVELS from "../LOG_LEVELS.js";
-import chalk from "chalk";
-
+import log from "../utils/log.js";
 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++){
-
-        const typeOfArg = typeof args[i];
-
-        switch (typeOfArg){
-            case 'object':
-                const constructorName = args[i].constructor.name;
-                message += ` ${chalk.green(`${constructorName}(`)}`
-                if(constructorName === 'Error'){
-                    message += chalk.green(JSON.stringify(args[i].message, null, 2))
-                }
-                message += chalk.green(JSON.stringify(args[i], null, 2))
-                message += ` ${chalk.green(")")}`
-                break;
-            case 'string':
-                message += chalk.green(args[i])
-                break;
-            case "function":
-                message += chalk.green(args[i].toString())
-                break;
-            case "number":
-            default:
-                message += chalk.green(args[i])
-                break;
-        }
-
-    }
-
-    this.history.push(message);
-    if(this.history.length > 100){
-        this.history.shift();
-    }
-
-    this._log(message);
+    log('info', args, this);
 }

package/src/methods/log.js

@@ -1,6 +1,8 @@
-import chalk from "chalk";
 import LOG_LEVELS from "../LOG_LEVELS.js";
-
+import _log from "../utils/log.js";
 export default function log(...args) {
-    return this.info(...args);
+    if(LOG_LEVELS[this.level] > LOG_LEVELS['info']){
+        return;
+    }
+    _log('log', args, this);
 }

package/src/methods/trace.js

@@ -1,64 +1,8 @@
 import LOG_LEVELS from "../LOG_LEVELS.js";
-import chalk from "chalk";
-
+import log from "../utils/log.js";
 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++){
-        const typeOfArg = typeof args[i];
-
-        switch (typeOfArg){
-            case 'object':
-                const constructorName = args[i].constructor.name;
-                message += ` ${chalk.grey(`${constructorName}(`)}`
-                if(constructorName === 'Error'){
-                    message += chalk.grey(JSON.stringify(args[i].message, null, 2))
-                }
-                message += chalk.grey(JSON.stringify(args[i], null, 2))
-                message += ` ${chalk.grey(")")}`
-                break;
-            case 'string':
-                message += chalk.grey(args[i])
-                break;
-            case "function":
-                message += chalk.grey(args[i].toString())
-                break;
-            case "number":
-            default:
-                message += chalk.grey(args[i])
-                break;
-        }
-    }
-
-    this.history.push(message);
-    if(this.history.length > 100){
-        this.history.shift();
-    }
-
-    this._log(message);
+    log('trace', args, this);
 }

package/src/methods/warn.js

@@ -1,65 +1,8 @@
 import LOG_LEVELS from "../LOG_LEVELS.js";
-import chalk from "chalk";
-
+import log from "../utils/log.js";
 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++){
-
-        const typeOfArg = typeof args[i];
-
-        switch (typeOfArg){
-            case 'object':
-                const constructorName = args[i].constructor.name;
-                message += ` ${chalk.yellow(`${constructorName}(`)}`
-                if(constructorName === 'Error'){
-                    message += chalk.yellow(JSON.stringify(args[i].message, null, 2))
-                }
-                message += chalk.yellow(JSON.stringify(args[i], null, 2))
-                message += ` ${chalk.yellow(")")}`
-                break;
-            case 'string':
-                message += chalk.yellow(args[i])
-                break;
-            case "function":
-                message += chalk.yellow(args[i].toString())
-                break;
-            case "number":
-            default:
-                message += chalk.yellow(args[i])
-                break;
-        }
-    }
-
-    this.history.push(message);
-    if(this.history.length > 100){
-        this.history.shift();
-    }
-
-    this._log(message);
+    log('warn', args, this);
 }

package/src/utils/log.js

@@ -0,0 +1,65 @@
+// src/utils/log.js
+export default function log(level, args, context) {
+    const LOG_COLORS = context.LOG_COLORS;
+    const colors = LOG_COLORS[level] || LOG_COLORS['info'];
+    const date = context.date || new Date();
+    let type = level.toUpperCase()[0];
+    let message = `[${colors[0](date.toISOString())}][${colors[1](type)}]`;
+
+    if(level === 'log'){
+        message = `[${colors[0](date.toISOString())}]`;
+    }
+
+    if(context.contextName){
+        message += ` context: ${colors[2](context.contextName)} |`;
+    }
+    if(context.moduleName){
+        message += ` module:${colors[3](context.moduleName)} |`;
+    }
+    if(context.listenerName){
+        message += ` listener: ${colors[4](context.listenerName)} |`;
+    }
+    if(context.methodName){
+        message += ` method: ${colors[5](context.methodName)} |`;
+    }
+    if(message.endsWith(' |')){
+        message = message.slice(0, -1);
+    }
+
+    for(let i = 0; i < args.length; i++){
+        const typeOfArg = typeof args[i];
+        let color;
+        switch (typeOfArg){
+            case 'object':
+                color = colors[6]; // object color
+                const constructorName = args[i].constructor.name;
+                message += ` ${color(`${constructorName}(`)}`
+                if(constructorName === 'Error'){
+                    message += color(JSON.stringify(args[i].message, null, 2))
+                }
+                message += color(JSON.stringify(args[i], null, 2))
+                message += ` ${color(")")}`
+                break;
+            case 'string':
+                color = colors[7]; // string color
+                message += color(args[i])
+                break;
+            case "function":
+                color = colors[8]; // function color
+                message += color(args[i].toString())
+                break;
+            case "number":
+            default:
+                color = colors[9]; // number/default color
+                message += color(args[i])
+                break;
+        }
+    }
+
+    context.history.push(message);
+    if(context.history.length > 100){
+        context.history.shift();
+    }
+
+    context._log(message);
+}

package/usage.example.js

@@ -4,6 +4,29 @@ import Logger from './src/Logger.js';
 const logger = new Logger({
     level: 'trace',
 });
+
+// {
+//     room: 'CANDLE',
+//         message: {
+//     payload: Candle {
+//         market: [Market],
+//             interval: '1m',
+//             open: '41303.70',
+//             close: '41305.60',
+//             low: '41301.00',
+//             high: '41308.50',
+//             volume: [Object],
+//             openTime: [Epoch],
+//             closeTime: [Epoch],
+//             trades: '223',
+//             id: '8e884b29'
+//     },
+//     topic: 'CANDLE'
+// }
+// }
+
+
+
 const contextLogger = logger.context('APIContext')
 contextLogger.log('Started API');
 const moduleLogger = contextLogger.module('Websocket Server')
@@ -42,6 +65,7 @@ listenerLogger.level = 'trace'
 listenerLogger.error('Error',object)
 listenerLogger.warn('Warn',object)
 listenerLogger.info('Info',object)
+listenerLogger.fatal('Fatal',object)
 listenerLogger.debug('debug',object)
 listenerLogger.trace('trace',object)
 
@@ -49,6 +73,7 @@ const error = new Error('Something happened');
 listenerLogger.error('Error',error)
 listenerLogger.warn('Warn',error)
 listenerLogger.info('Info',error)
+listenerLogger.fatal('Fatal',error)
 listenerLogger.debug('debug',error)
 listenerLogger.trace('trace',error)