hermodlog 1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) Alex Werner - 2023
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,62 @@
+# hermodlog
+
+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.
+
+
+## Install
+
+```bash
+npm i hermodlog
+```
+
+## Usage
+
+```js
+import Logger from 'hermodlog';
+
+logger = new Logger();
+logger.log("Stuff");
+
+
+contextLogger = logger.context('Node#4');
+
+moduleLogger = contextLogger.module('myModule');
+```
+
+## API
+
+### Logger
+
+#### `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.
+
+##### `log(message, level)`
+Log a message with the given level.
+
+##### `debug(message)`
+Log a message with the debug level.
+
+##### `info(message)`
+Log a message with the info level.
+
+##### `warn(message)`
+Log a message with the warn level.
+
+##### `error(message)`
+Log a message with the error level.
+
+##### `fatal(message)`
+Log a message with the fatal level.
+
+
+### License
+
+MIT

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "hermodlog",
+  "version": "1.0.0",
+  "description": "Simple contextual logger to simplify log display in heavy load context and provide easy parsing",
+  "main": "src/Logger.js",
+  "type": "module",
+  "scripts": {
+    "test": "vitest --dir .",
+    "test:dev": "vitest --dir . --watch"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Alex-Werner/hermodlog.git"
+  },
+  "author": "Alex Werner <@obusco>",
+  "license": "MIT",
+  "bugs": {
+    "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.4"
+  }
+}

package/src/Logger.js

@@ -0,0 +1,146 @@
+import chalk from 'chalk';
+export default class Logger {
+    constructor(_date, level = 'info') {
+
+        this.level = level;
+
+        this.history = [];
+
+        this.contextName = null
+        this.methodName = null
+        this.moduleName = null
+        this.listenerName = null
+        if(_date){
+            this._date = _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);
+        }
+    }
+    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);
+    }
+};

package/src/Logger.spec.js

@@ -0,0 +1,40 @@
+import {assert, describe, expect, it} from 'vitest'
+import Logger from "./Logger.js";
+
+describe('Logger', () => {
+    let silentLogger
+    let silentModuleLogger
+    it('should create an logger', () => {
+        silentLogger = new Logger(new Date('2023-07-29T01:38:00.482Z'));
+        silentLogger._log = () => {}
+        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')
+    })
+    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")
+    })
+    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")
+    })
+    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[31monTest\u001b[39m \u001b[32mHello\u001b[39m")
+    })
+    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')
+    })
+})