hermodlog 1.4.0 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermodlog",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Simple contextual logger to simplify log display in heavy load context and provide easy parsing",
   "main": "src/Logger.js",
   "type": "module",
@@ -18,10 +18,7 @@
     "url": "https://github.com/Alex-Werner/hermodlog/issues"
   },
   "homepage": "https://github.com/Alex-Werner/hermodlog#readme",
-  "dependencies": {
-    "chalk": "^5.3.0"
-  },
   "devDependencies": {
-    "vitest": "^0.34.5"
+    "vitest": "^2.1.8"
   }
 }

package/src/LOG_COLORS.js

@@ -1,13 +1,13 @@
-import chalk from "chalk";
+import colors from './utils/colors.js';
 
 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],
+    debug: [colors.gray, colors.blue, colors.blueBright, colors.gray, colors.cyan, colors.yellow, colors.blue, colors.blue, colors.blue, colors.blue],
+    error: [colors.gray, colors.red, colors.blueBright, colors.gray, colors.cyan, colors.yellow, colors.red, colors.red, colors.red, colors.red],
+    fatal: [colors.gray, colors.magenta, colors.blueBright, colors.gray, colors.cyan, colors.yellow, colors.magenta, colors.magenta, colors.magenta, colors.magenta],
+    info: [colors.gray, colors.green, colors.blueBright, colors.gray, colors.cyan, colors.yellow, colors.green, colors.green, colors.green, colors.green],
+    trace: [colors.gray, colors.gray, colors.blueBright, colors.gray, colors.cyan, colors.yellow, colors.gray, colors.gray, colors.gray, colors.gray],
+    warn: [colors.gray, colors.yellow, colors.blueBright, colors.gray, colors.cyan, colors.yellow, colors.yellow, colors.yellow, colors.yellow, colors.yellow],
 }
 
 export default LOG_COLORS;

package/src/Logger.js

@@ -2,6 +2,7 @@ import LOG_LEVELS from "./LOG_LEVELS.js";
 
 import context from "./methods/context.js";
 import debug from "./methods/debug.js";
+import dir from "./methods/dir.js";
 import error from "./methods/error.js";
 import info from "./methods/info.js";
 import listener from "./methods/listener.js";
@@ -17,24 +18,61 @@ import LOG_COLORS from "./LOG_COLORS.js";
 import object from "./methods/object.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 = props.history ?? [];
-
-        this.contextName = props.contextName ?? null;
-        this.methodName = props.methodName ?? null;
-        this.moduleName = props.moduleName ?? null;
-        this.listenerName = props.listenerName ?? null;
-        this.objectName = props.objectName ?? null;
+        // Define non-enumerable properties
+        Object.defineProperties(this, {
+            LOG_COLORS: {
+                value: props.colors ?? LOG_COLORS,
+                writable: true,
+                enumerable: false
+            },
+            history: {
+                value: props.history ?? [],
+                writable: true,
+                enumerable: false
+            },
+            level: {
+                value: props.level ?? 'info',
+                writable: true,
+                enumerable: true
+            },
+            contextName: {
+                value: props.contextName ?? null,
+                writable: true,
+                enumerable: true
+            },
+            methodName: {
+                value: props.methodName ?? null,
+                writable: true,
+                enumerable: true
+            },
+            moduleName: {
+                value: props.moduleName ?? null,
+                writable: true,
+                enumerable: true
+            },
+            listenerName: {
+                value: props.listenerName ?? null,
+                writable: true,
+                enumerable: true
+            },
+            objectName: {
+                value: props.objectName ?? null,
+                writable: true,
+                enumerable: true
+            }
+        });
 
         if (props.date) {
-            this.date = props.date;
+            Object.defineProperty(this, 'date', {
+                value: props.date,
+                writable: true,
+                enumerable: false
+            });
         }
 
-        this.LOG_COLORS = (props.colors) ?? LOG_COLORS;
+        if (!LOG_LEVELS.hasOwnProperty(this.level)) {
+            throw new Error(`Unknown log level ${this.level}`)
+        }
     }
 
     _log(message) {
@@ -64,11 +102,11 @@ class Logger {
             objectName: (keepObject) ? this.objectName : opts.objectName ?? null,
         })
     }
-
 };
 
 Logger.prototype.context = context;
 Logger.prototype.debug = debug;
+Logger.prototype.dir = dir;
 Logger.prototype.error = error;
 Logger.prototype.fatal = fatal;
 Logger.prototype.info = info;

package/src/Logger.spec.js

@@ -10,32 +10,36 @@ describe('Logger', () => {
         assert.equal(silentLogger.history.length, 0)
         silentLogger.log('Hello');
         assert.equal(silentLogger.history.length, 1)
-        assert.equal(silentLogger.history[0], '[\u001b[90m2023-07-29T01:38:00.482Z\u001b[39m]\u001b[32mHello\u001b[39m')
+        const expected = '[\u001b[90m2023-07-29T01:38:00.482Z\u001b[0m] \u001b[32mHello\u001b[0m'
+        assert.equal(silentLogger.history[0], expected)
     })
     it('should create an logger with module', () => {
         silentModuleLogger = silentLogger.module('test-module')
         silentModuleLogger.log('Hello');
         assert.equal(silentModuleLogger.history.length, 1)
-        assert.equal(silentModuleLogger.history[0], "[\u001b[90m2023-07-29T01:38:00.482Z\u001b[39m] module:\u001b[90mtest-module\u001b[39m \u001b[32mHello\u001b[39m")
+        const expected = '[\u001b[90m2023-07-29T01:38:00.482Z\u001b[0m] module:\u001b[90mtest-module\u001b[0m \u001b[32mHello\u001b[0m'
+        assert.equal(silentModuleLogger.history[0], expected)
     })
     it('should create an logger with context', () => {
         const silentContextLogger = silentModuleLogger.context('test-context')
         silentContextLogger.log('Hello');
         assert.equal(silentContextLogger.history.length, 1)
-        assert.equal(silentContextLogger.history[0], "[\u001b[90m2023-07-29T01:38:00.482Z\u001b[39m] context: \u001b[94mtest-context\u001b[39m | module:\u001b[90mtest-module\u001b[39m \u001b[32mHello\u001b[39m")
+        const expected = '[\u001b[90m2023-07-29T01:38:00.482Z\u001b[0m] context: \u001b[94mtest-context\u001b[0m | module:\u001b[90mtest-module\u001b[0m \u001b[32mHello\u001b[0m'
+        assert.equal(silentContextLogger.history[0], expected)
     })
     it('should create an logger with listener', () => {
         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[36monTest\u001b[39m \u001b[32mHello\u001b[39m")
+        const expected = '[\u001b[90m2023-07-29T01:38:00.482Z\u001b[0m] module:\u001b[90mtest-module\u001b[0m | listener: \u001b[36monTest\u001b[0m \u001b[32mHello\u001b[0m'
+        assert.equal(silentListenerLogger.history[0], expected)
     })
     it('should create an logger with method', () => {
         const silentMethodLogger = silentModuleLogger.method('test-method')
         silentMethodLogger.log('Hello');
         assert.equal(silentMethodLogger.history.length, 1)
-
-        assert.equal(silentMethodLogger.history[0], '[\u001b[90m2023-07-29T01:38:00.482Z\u001b[39m] module:\u001b[90mtest-module\u001b[39m | method: \u001b[33mtest-method\u001b[39m \u001b[32mHello\u001b[39m')
+        const expected = '[\u001b[90m2023-07-29T01:38:00.482Z\u001b[0m] module:\u001b[90mtest-module\u001b[0m | method: \u001b[33mtest-method\u001b[0m \u001b[32mHello\u001b[0m'
+        assert.equal(silentMethodLogger.history[0], expected)
     })
     it('should handle level', function () {
         const levelLogger = new Logger({level: 'error'})
@@ -60,17 +64,7 @@ describe('Logger', () => {
         }
         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`)
+        const expected =  `[\u001b[90m2023-07-29T01:38:00.482Z\u001b[0m] module:\u001b[90mtest-module\u001b[0m \u001b[32mReceived from ws client\u001b[0m \u001b[32mObject(\u001b[0m\u001b[32m{\n  \"x\": 42,\n  \"y\": {\n    \"b\": [\n      1,\n      2,\n      3\n    ]\n  },\n  \"req\": \"getCar\"\n}\u001b[0m\u001b[32m)\u001b[0m`;
+        assert.equal(silentModuleLogger.history[1], expected)
     });
 })

package/src/methods/dir.js

@@ -0,0 +1,10 @@
+import LOG_LEVELS from "../LOG_LEVELS.js";
+import log from "../utils/log.js";
+
+export default function dir(label, object) {
+    if(LOG_LEVELS[this.level] > LOG_LEVELS['info']){
+        return;
+    }
+    log('log', [label], this);
+    console.dir(object, { depth: 1, colors: true });
+} 

package/src/utils/colors.js

@@ -0,0 +1,17 @@
+const ESC = '\x1b';
+
+const createColorFn = (code) => (text) => `${ESC}[${code}m${text}${ESC}[0m`;
+
+const colors = {
+    gray: createColorFn('90'),
+    red: createColorFn('31'),
+    green: createColorFn('32'),
+    yellow: createColorFn('33'),
+    blue: createColorFn('34'),
+    magenta: createColorFn('35'),
+    cyan: createColorFn('36'),
+    // Bright variants
+    blueBright: createColorFn('94'),
+};
+
+export default colors; 

package/src/utils/log.js

@@ -1,70 +1,113 @@
-// src/utils/log.js
+function safeStringify(obj, indent = 2, depth = 5, level = 0) {
+    let cache = [];
+    const retVal = JSON.stringify(
+        obj,
+        (key, value) => {
+            if (level > depth) return '...';
+            if (typeof value === "object" && value !== null) {
+                if (cache.includes(value)) return undefined;
+                cache.push(value);
+                level++;
+            }
+            return value;
+        },
+        indent
+    );
+    cache = null;
+    return retVal;
+}
+
 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)}]`;
+    let message = `[${colors[0](date.toISOString())}]`;
 
-    if(level === 'log'){
-        message = `[${colors[0](date.toISOString())}]`;
+    if (level !== 'log') {
+        message += `[${colors[1](type)}]`;
     }
 
-
-    // TODO: It would be neat to just have a single parents array that would be used
-    //  to generate the context string.
-    if(context.contextName){
-        message += ` context: ${colors[2](context.contextName)} |`;
-    }
-    if(context.moduleName){
-        message += ` module:${colors[3](context.moduleName)} |`;
+    if (context.contextName) {
+        message += ` context: ${colors[2](context.contextName)}`;
+        if (context.moduleName || context.listenerName || context.methodName) {
+            message += ' |';
+        }
     }
-    if(context.listenerName){
-        message += ` listener: ${colors[4](context.listenerName)} |`;
+    
+    if (context.moduleName) {
+        message += ` module:${colors[3](context.moduleName)}`;
+        if (context.listenerName || context.methodName) {
+            message += ' |';
+        }
     }
-    if(context.methodName){
-        message += ` method: ${colors[5](context.methodName)} |`;
+    
+    if (context.listenerName) {
+        message += ` listener: ${colors[4](context.listenerName)}`;
+        if (context.methodName) {
+            message += ' |';
+        }
     }
-    if(context.objectName){
-        message += ` Object[${colors[6](context.objectName)}] |`;
+    
+    if (context.methodName) {
+        message += ` method: ${colors[5](context.methodName)}`;
     }
 
-    if(message.endsWith(' |')){
-        message = message.slice(0, -1);
+    if (context.objectName) {
+        message += ` Object[${colors[6](context.objectName)}]`;
     }
 
-    for(let i = 0; i < args.length; i++){
-        const typeOfArg = typeof args[i];
+    message += ' ';
+
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        const typeOfArg = typeof arg;
         let color;
-        switch (typeOfArg){
+
+        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))
+                color = colors[6];
+                if (!arg) {
+                    message += `${color('null')}`;
+                    break;
+                }
+                const constructorName = arg?.constructor?.name;
+                if (constructorName === 'Object') {
+                    message += `${color('Object(')}${color(safeStringify(arg, 2))}${color(')')}`;
+                } else if (constructorName === 'Error') {
+                    message += `${color(constructorName)}(${color(arg.message)})\n`;
+                    if (arg.stack) {
+                        const stackLines = arg.stack.split('\n');
+                        // Skip first line as it contains the error message we already logged
+                        for (let j = 1; j < stackLines.length; j++) {
+                            message += `${color(stackLines[j].trim())}\n`;
+                        }
+                    }
+                } else {
+                    message += `${color(constructorName)}(${color(safeStringify(arg, 2))})`;
                 }
-                message += color(JSON.stringify(args[i], null, 2))
-                message += ` ${color(")")}`
                 break;
             case 'string':
-                color = colors[7]; // string color
-                message += color(args[i])
+                color = colors[7];
+                message += color(arg);
                 break;
             case "function":
-                color = colors[8]; // function color
-                message += color(args[i].toString())
+                color = colors[8];
+                message += color(arg.toString());
                 break;
-            case "number":
             default:
-                color = colors[9]; // number/default color
-                message += color(args[i])
+                color = colors[9];
+                message += color(String(arg));
                 break;
         }
+        
+        if (i < args.length - 1) {
+            message += ' ';
+        }
     }
 
     context.history.push(message);
-    if(context.history.length > 100){
+    if (context.history.length > 100) {
         context.history.shift();
     }
 

package/usage.example.js

@@ -57,3 +57,9 @@ listenerLogger.fatal('Fatal',error)
 listenerLogger.debug('debug',error)
 listenerLogger.trace('trace',error)
 
+
+const errorWithStack = new Error('Something happened with stack');
+errorWithStack.stack = '\nThis is a stack trace with a new line \n and a tab \t';
+listenerLogger.error('Error',errorWithStack)
+
+console.dir(listenerLogger, { depth: null });