hermodlog 1.2.0 → 1.4.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
@@ -36,11 +37,7 @@ moduleLogger = contextLogger.module('myModule');
 #### `new Logger(options)`
 Create a new logger instance.
 
-##### `context(name)`
-Create a new context logger with the given name.
-
-##### `module(name)`
-Create a new module logger with the given name.
+#### Level methods
 
 ##### `log(message, level)`
 Log a message with the given level.
@@ -54,12 +51,100 @@ 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.
 
 ##### `fatal(message)`
 Log a message with the fatal level.
 
+#### Context methods
+
+##### `context(name)`
+Create a new context logger with the given context name.
+
+##### `module(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.
+
+##### `child(name)`
+Create a new child logger with the given child name.
+
+##### `object(object)`
+Create a new object logger with the given object.
+
+#### Other methods
+
+#### `clone(opts)`
+Clone the logger. The `opts` object can have the following properties:
+- keepHistory: Whether to keep the history of the logger. Default: `false` (unique falsy one).
+- keepContext: Whether to keep the context of the logger. Default: `true`.
+- keepModule: Whether to keep the module of the logger. Default: `true`.
+- keepListener: Whether to keep the listener of the logger. Default: `true`.
+- keepMethod: Whether to keep the method of the logger. Default: `true`.
+- keepObject: Whether to keep the object of the logger. Default: `true`.
+- keepChild: Whether to keep the child of the logger. Default: `true`.
+- keepLevel: Whether to keep the level of the logger. Default: `true`.
+- keepColors: Whether to keep the colors of the logger. Default: `true`.
+- keepDate: Whether to keep the date of the logger. Default: `true`.
+
+#### constructor options
+The `options` object can have the following properties:  
+
+##### `date`
+A date-compatible format. Default: `YYYY-MM-DD HH:mm:ss.SSS`.
+
+##### `level`
+A default log level. Can be one of 'fatal', 'error', 'warn', 'info', 'debug', 'trace'. Default: `info`.
+
+##### `history`
+The history of the logger. Default: `[]`.
+
+##### `contextName`
+The context name of the logger. Default: `null`.
+
+##### `moduleName`
+The module name of the logger. Default: `null`.
+
+##### `listenerName`
+The listener name of the logger. Default: `null`.
+
+##### `methodName`
+The method name of the logger. Default: `null`.
+
+##### `objectName`
+The object name of the logger. Default: `null`.
+
+##### `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].
+
+```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
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermodlog",
-  "version": "1.2.0",
+  "version": "1.4.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,11 @@ 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";
+import object from "./methods/object.js";
 class Logger {
     constructor(props = {}) {
         this.level = props.level ?? 'info';
@@ -18,25 +22,46 @@ class Logger {
             throw new Error(`Unknown log level ${this.level}`)
         }
 
-        this.history = [];
+        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;
 
-        this.contextName = null
-        this.methodName = null
-        this.moduleName = null
-        this.listenerName = null
         if (props.date) {
             this.date = props.date;
         }
+
+        this.LOG_COLORS = (props.colors) ?? LOG_COLORS;
     }
 
     _log(message) {
         console.log(message)
     }
 
-    clone() {
+    clone(opts = {}) {
+        const keepHistory = opts?.keepHistory ?? false;
+        const keepLevel = opts?.keepLevel ?? true;
+        const keepDate = opts?.keepDate ?? true;
+        const keepColors = opts?.keepColors ?? true;
+        const keepContext = opts?.keepContext ?? true;
+        const keepMethod = opts?.keepMethod ?? true;
+        const keepModule = opts?.keepModule ?? true;
+        const keepListener = opts?.keepListener ?? true;
+        const keepObject = opts?.keepObject ?? true;
+
         return new Logger({
-            level: this.level,
-            date: this.date,
+            level: (keepLevel) ? this.level : opts.level ?? this.level,
+            date: (keepDate) ? this.date : opts.date ?? null,
+            history: keepHistory ? this.history : [],
+            colors: (keepColors) ? this.LOG_COLORS : opts.colors ?? this.LOG_COLORS,
+            contextName: (keepContext) ? this.contextName : opts.contextName ?? null,
+            methodName: (keepMethod) ? this.methodName : opts.methodName ?? null,
+            moduleName: (keepModule) ? this.moduleName : opts.moduleName ?? null,
+            listenerName: (keepListener) ? this.listenerName : opts.listenerName ?? null,
+            objectName: (keepObject) ? this.objectName : opts.objectName ?? null,
         })
     }
 
@@ -45,12 +70,15 @@ 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;
 Logger.prototype.method = method;
+Logger.prototype.object = object;
 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')
@@ -39,6 +39,7 @@ describe('Logger', () => {
     })
     it('should handle level', function () {
         const levelLogger = new Logger({level: 'error'})
+        levelLogger._log = () => {}
         levelLogger.error('Hello');
         assert.equal(levelLogger.history.length, 1)
         levelLogger.warn('Hello');
@@ -48,4 +49,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/context.js

@@ -3,10 +3,6 @@ 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

@@ -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/listener.js

@@ -2,8 +2,6 @@ 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

@@ -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/method.js

@@ -2,9 +2,6 @@ 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

@@ -1,12 +1,8 @@
 import Logger from "../Logger.js";
 
-export default function   module(_module) {
+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/object.js

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

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,72 @@
+// 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())}]`;
+    }
+
+
+    // 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.listenerName){
+        message += ` listener: ${colors[4](context.listenerName)} |`;
+    }
+    if(context.methodName){
+        message += ` method: ${colors[5](context.methodName)} |`;
+    }
+    if(context.objectName){
+        message += ` Object[${colors[6](context.objectName)}] |`;
+    }
+
+    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

@@ -1,9 +1,12 @@
 import Logger from './src/Logger.js';
 
-
 const logger = new Logger({
     level: 'trace',
 });
+
+
+logger.context('APIContext').module('Websocket Server').listener('onMessage').method('processIncomingMessage').log('Hello World');
+
 const contextLogger = logger.context('APIContext')
 contextLogger.log('Started API');
 const moduleLogger = contextLogger.module('Websocket Server')
@@ -42,6 +45,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 +53,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)