hermodlog 1.5.2 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermodlog",
-  "version": "1.5.2",
+  "version": "1.7.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/Logger.js

@@ -13,6 +13,7 @@ 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 submethod from "./methods/submethod.js";
 
 import LOG_COLORS from "./LOG_COLORS.js";
 import object from "./methods/object.js";
@@ -29,6 +30,11 @@ class Logger {
                 writable: true,
                 enumerable: false
             },
+            historyLimit: {
+                value: props.historyLimit ?? 100,
+                writable: true,
+                enumerable: true
+            },
             level: {
                 value: props.level ?? 'info',
                 writable: true,
@@ -54,11 +60,17 @@ class Logger {
                 writable: true,
                 enumerable: true
             },
+            submethodName: {
+                value: props.submethodName ?? null,
+                writable: true,
+                enumerable: true
+            },
             objectName: {
                 value: props.objectName ?? null,
                 writable: true,
                 enumerable: true
             }
+
         });
 
         if (props.date) {
@@ -86,6 +98,7 @@ class Logger {
         const keepContext = opts?.keepContext ?? true;
         const keepMethod = opts?.keepMethod ?? true;
         const keepModule = opts?.keepModule ?? true;
+        const keepSubmethod = opts?.keepSubmethod ?? true;
         const keepListener = opts?.keepListener ?? true;
         const keepObject = opts?.keepObject ?? true;
 
@@ -98,9 +111,14 @@ class Logger {
             methodName: (keepMethod) ? this.methodName : opts.methodName ?? null,
             moduleName: (keepModule) ? this.moduleName : opts.moduleName ?? null,
             listenerName: (keepListener) ? this.listenerName : opts.listenerName ?? null,
+            submethodName: (keepSubmethod) ? this.submethodName : opts.submethodName ?? null,
             objectName: (keepObject) ? this.objectName : opts.objectName ?? null,
         })
     }
+
+    getHistory(limit = 100) {
+        return this.history.slice(-limit);
+    }
 };
 
 Logger.prototype.context = context;
@@ -113,6 +131,7 @@ Logger.prototype.listener = listener;
 Logger.prototype.log = log;
 Logger.prototype.method = method;
 Logger.prototype.object = object;
+Logger.prototype.submethod = submethod;
 Logger.prototype.module = module;
 Logger.prototype.trace = trace;
 Logger.prototype.warn = warn;

package/src/methods/submethod.js

@@ -0,0 +1,8 @@
+import Logger from "../Logger.js";
+
+export default function submethod(_submethod) {
+    const logger = this.clone();
+    logger.submethodName = _submethod;
+    logger._log = this._log.bind(logger);
+    return logger;
+}

package/src/utils/log.js

@@ -31,36 +31,59 @@ export default function log(level, args, context) {
         message += `[${colors[1](type)}]`;
     }
 
-    if (context.contextName) {
+
+    const hasContext = !!context.contextName;
+    const hasModule = !!context.moduleName;
+    const hasListener = !!context.listenerName;
+    const hasMethod = !!context.methodName;
+    const hasSubmethod = !!context.submethodName;
+    const hasObject = !!context.objectName;
+
+    if (hasContext) {
         message += ` context: ${colors[2](context.contextName)}`;
-        if (context.moduleName || context.listenerName || context.methodName) {
+        const hasNext = hasModule || hasListener || hasMethod || hasSubmethod;
+        if (hasNext) {
             message += ' |';
         }
     }
     
-    if (context.moduleName) {
+    if (hasModule) {
         message += ` module:${colors[3](context.moduleName)}`;
-        if (context.listenerName || context.methodName) {
+        const hasNext = hasListener || hasMethod || hasSubmethod;
+        if (hasNext) {
             message += ' |';
         }
     }
     
-    if (context.listenerName) {
-        message += ` listener: ${colors[4](context.listenerName)}`;
-        if (context.methodName) {
+    if (hasMethod) {
+        message += ` method: ${colors[5](context.methodName)}`;
+        const hasNext = hasSubmethod;
+        if (hasNext) {
             message += ' |';
         }
     }
-    
-    if (context.methodName) {
-        message += ` method: ${colors[5](context.methodName)}`;
+
+    if (hasSubmethod) {
+        message += ` submethod: ${colors[6](context.submethodName)}`;
+        const hasNext = hasListener || hasMethod;
+        if (hasNext) {
+            message += ' |';
+        }
+    }
+
+    if (hasListener) {
+        message += ` listener: ${colors[4](context.listenerName)}`;
+        const hasNext = hasObject;
+        if (hasNext) {
+            message += ' |';
+        }
     }
 
-    if (context.objectName) {
+    if (hasObject) {
         message += ` Object[${colors[6](context.objectName)}]`;
     }
 
-    message += ' ';
+    message += ' - ';
 
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
@@ -126,7 +149,8 @@ export default function log(level, args, context) {
     }
 
     context.history.push(message);
-    if (context.history.length > 100) {
+    const historyLimit = context.historyLimit || 100;
+    if (context.history.length > historyLimit) {
         context.history.shift();
     }
 

package/usage.example.js

@@ -6,6 +6,7 @@ const logger = new Logger({
 
 
 
+
 const listenerLogger = logger.listener('onConnection')
 const object = {
     x:42,
@@ -17,5 +18,18 @@ const object = {
 
 listenerLogger.log(`${object}`);
 
+// listenerLogger.submethod('processIncomingMessage').log('Received from ws client',object)
+
+
+
+// console.log({logger});
+
+const el = logger.context('APIContext').module('Websocket Server').method('setListeners').listener('onMessage').submethod('processIncomingMessage')
+el.log('Received from ws client');
 
-console.log({logger});
+el.log(1);
+el.log(2);
+el.log(3);
+el.log(4);
+el.log(5);
+console.log(el.getHistory(2));