ntlogger 2.3.1 → 2.4.0

package/index.js

@@ -1,12 +1,20 @@
 /*!
  * ntlogger
- * Copyright(c) 2024 Kevin R
+ * Copyright(c) 2024 KR
  * GPL-3.0 Licensed
  */
 
 /**
  * Change Log:
  *
+ * v2.4.0 - 08/01/2024:
+ * [NOTE] Damn its been 4 months.. kinda. forgot to log last changes
+ * [CRITICAL] Fixed `includes` in package.json which prevented plugins folder from being pushed to npmjs.com
+ * [QA] Added test cases using jest
+ * [Feature] Added session ID to logger meta, try `console.log(log.defaultMeta.ID)`
+ * [Feature] Created the plugin jest. Added a custom transport for in memory logging and testing
+ * [Feature] Created the config var `skipCache` to allow you to create a new logger instance within the same file. (Usual behavior is to return the same instance within the same file)
+ *
  * v2.2.3 - 04/01/2024:
  * Reduced GitHub Actions to only NPM publish
  * Fixed export

package/lib/logger.js

@@ -13,7 +13,7 @@
 const winston = require('winston');
 const crypto = require('crypto');
 
-const { initPlugins, compilePluginComponents} = require('../plugins/index.js');
+const { initPlugins } = require('../plugins/index.js');
 
 // Define a map to hold the logger instances by their location
 const loggerInstances = new Map();
@@ -124,7 +124,8 @@ const createLoggerInstance = (location = "Unknown", config = {}, transports) =>
         path = './logs',
         maxSize = 1048576,
         maxFiles = 5,
-        timestamp = true
+        timestamp = true,
+        skipCache = false,
     } = config;
 
     let logTransport = [].filter(Boolean);
@@ -162,6 +163,7 @@ const createLoggerInstance = (location = "Unknown", config = {}, transports) =>
         transports: logTransport,
         defaultMeta: {
             location,
+            ID: sessionId,
             timeCreated: new Date().toLocaleTimeString('en-US', {hour12: true, hour: '2-digit', minute: '2-digit', second: '2-digit', fractionalSecondDigits: 3})
         }
     });
@@ -198,7 +200,7 @@ const createLoggerInstance = (location = "Unknown", config = {}, transports) =>
     */
 const logger = (location = "Unknown", config = {}) => {
     // Check if a logger for the given location already exists
-    if (loggerInstances.has(location)) {
+    if (loggerInstances.has(location) && !config.skipCache) {
         // If it does, grab the existing logger instance from the map
         const logger = loggerInstances.get(location);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ntlogger",
-  "version": "2.3.1",
+  "version": "2.4.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/NightSquawk/NightTimeLogger.git"
@@ -22,7 +22,8 @@
   ],
   "files": [
     "index.js",
-    "lib/*.js"
+    "lib/*.js",
+    "plugins/*.js"
   ],
   "license": "GPL-3.0",
   "dependencies": {
@@ -33,6 +34,10 @@
   },
   "devDependencies": {
     "@sentry/profiling-node": "^8.17.0",
-    "dotenv": "^16.4.5"
+    "dotenv": "^16.4.5",
+    "jest": "^29.0.0"
+  },
+  "scripts": {
+    "test": "jest"
   }
 }

package/plugins/index.js

@@ -0,0 +1,54 @@
+/**
+ * @file /plugins/index.js
+ * @description Initializes any plugins required by the application.
+ */
+
+// Available plugins
+const plugins = {
+    Sentry: require('./sentry'),
+    MySQL : require('./mysql'),
+    Jest: require('./jest'),
+
+    // TODO: Implement the following plugins
+    // mongodb: require('./mongodb'),
+    // redis: require('./redis'),
+};
+
+function checkPluginAvailability(pluginName) {
+    if (!plugins[pluginName]) {
+        throw new Error(`Plugin ${pluginName} is not available\nAvailable plugins: ${Object.keys(plugins).join(', ')}`);
+    }
+}
+
+function getPluginTransport(pluginName) {
+    checkPluginAvailability(pluginName);
+    return plugins[pluginName].transport;
+}
+
+/**
+ * Initializes plugins named and configured in the configuration object.
+ * @param {Object} config - The configuration object for the plugins
+ * @param {string} config.sentry - The configuration object for Sentry
+ * @returns {Array} - An array of plugin components
+ */
+function initPlugins(config = {}) {
+    let pluginTransports = [];
+    try {
+        for (let plugin of config) {
+            if (!plugin.name) {
+                throw new Error('Plugin name is required');
+            } else {
+                checkPluginAvailability(plugin.name);
+                let customTransportClass = getPluginTransport(plugin.name);
+                pluginTransports.push(new customTransportClass(plugin.config));
+            }
+        }
+        return pluginTransports;
+    } catch (err) {
+        console.error('Error initializing plugins:', err);
+    }
+}
+
+module.exports = {
+    initPlugins,
+};

package/plugins/jest.js

@@ -0,0 +1,60 @@
+/**
+ * @file /plugins/jest.js
+ * @description Stores log messages in memory for Jest testing.
+ */
+
+const Transport = require('winston-transport');
+
+/**
+ * Custom Winston transport for storing logs in memory for Jest assertions.
+ */
+class JestTransport extends Transport {
+    constructor(opts = {}) {
+        super(opts);
+
+        this.name = 'JestTransport';
+        this.disc = 'Stores log messages in memory for Jest testing.';
+        this.logMessages = [];
+    }
+
+    /**
+     * Logs the message and stores it in memory.
+     * @param {Object} info - The log information object containing the message, level, and other metadata.
+     * @param {Function} callback - Callback function to indicate logging completion.
+     */
+    log(info, callback) {
+        setImmediate(() => {
+            this.emit('logged', info);
+        });
+
+        const { level, message, ...meta } = info;
+
+        // Store the log message in memory
+        this.logMessages.push({ level, message, meta });
+
+        callback();
+    }
+
+    /**
+     * Retrieve stored log messages filtered by a specific level, if provided.
+     * @param {string} [level] - The log level to filter messages by (e.g., 'info', 'error').
+     * @returns {Array} Array of filtered or all log messages.
+     */
+    getMessages(level) {
+        if (level) {
+            return this.logMessages.filter(log => log.level === level);
+        }
+        return this.logMessages;
+    }
+
+    /**
+     * Clear all stored log messages.
+     */
+    clearMessages() {
+        this.logMessages = [];
+    }
+}
+
+module.exports = {
+    transport: JestTransport,
+};

package/plugins/mysql.js

@@ -0,0 +1,175 @@
+/**
+ * @file /plugins/mysql.js
+ * @description Stores logs in MySQL database.
+ */
+
+const Transport = require('winston-transport');
+const mysql = require('mysql2/promise');
+
+let connectionPool = null;
+let tableInitialized = false;
+
+class MySQLTransport extends Transport {
+    constructor(opts = {}) {
+        super(opts);
+
+        this.name = 'MySQL Transport for NTLogger';
+        this.database = opts.database || 'test';
+        this.table = opts.table || 'logs';
+
+        this.levels = {
+            internal: 6,
+            trace: 5,
+            debug: 4,
+            info: 3,
+            warn: 2,
+            error: 1,
+            fatal: 0,
+        };
+        this.logLevel = opts.level ? this.levels[opts.level] : this.levels.info;
+
+        this.poolConfig = {
+            host: opts.host || 'localhost',
+            port: opts.port || 3306,
+            user: opts.user || 'root',
+            password: opts.password || '',
+            database: this.database,
+            waitForConnections: opts.waitForConnections || true,
+            connectionLimit: opts.connectionLimit || 10,
+            queueLimit: opts.queueLimit || 0,
+            maxIdle: opts.maxIdle || 10,
+            idleTimeout: opts.idleTimeout || 60000,
+            enableKeepAlive: opts.enableKeepAlive || true,
+            keepAliveInitialDelay: opts.keepAliveInitialDelay || 0,
+        };
+
+        this.init();
+    }
+
+    /**
+     * Initializes the MySQL connection pool and checks the log table.
+     */
+    async init() {
+        try {
+            if (!connectionPool) {
+                connectionPool = mysql.createPool(this.poolConfig);
+            }
+            this.pool = connectionPool;
+            await this.checkLogTable();
+        } catch (err) {
+            console.error(`Failed to initialize ${this.name}:`, err);
+        }
+    }
+
+    async log(info, callback) {
+        setImmediate(() => {
+            this.emit('logged', info);
+        });
+
+        if (!tableInitialized) {
+            await this.checkLogTable();
+        }
+
+        const { level, message, ...meta } = info;
+
+        if (this.levels[level] > this.logLevel) {
+            callback();
+            return;
+        }
+
+        const metaString = JSON.stringify(meta);
+        const timestamp = this.formatTimestamp(meta.timeCreated);
+
+        try {
+            await this.pool.execute(
+                `INSERT INTO ${this.table} (level, message, meta, timestamp) VALUES (?, ?, ?, ?)`,
+                [level, message, metaString, timestamp]
+            );
+        } catch (err) {
+            console.error(`Failed to log message to ${this.name}:`, err);
+        }
+
+        callback();
+    }
+
+    /**
+     * Formats the timestamp for the MySQL database.
+     * @param {string} timeCreated - The time created string.
+     * @returns {string} - The formatted timestamp.
+     */
+    formatTimestamp(timeCreated) {
+        if (!timeCreated) {
+            return new Date().toISOString().slice(0, 19).replace('T', ' ');
+        }
+
+        const date = new Date();
+        const [time, modifier] = timeCreated.split(' ');
+        let [hours, minutes, seconds] = time.split(':');
+
+        if (modifier === 'PM' && hours !== '12') {
+            hours = parseInt(hours, 10) + 12;
+        }
+        if (modifier === 'AM' && hours === '12') {
+            hours = '00';
+        }
+
+        return `${date.getFullYear()}-${(date.getMonth() + 1).toString().padStart(2, '0')}-${date.getDate().toString().padStart(2, '0')} ${hours}:${minutes}:${seconds}`;
+    }
+
+    /**
+     * Checks if the log table exists in the MySQL database. If it does not exist, it will create it.
+     */
+    async checkLogTable() {
+        if (tableInitialized) return;
+
+        try {
+            const [rows] = await this.pool.execute(
+                `SELECT COUNT(*) AS count
+                 FROM information_schema.tables 
+                 WHERE table_schema = ? 
+                 AND table_name = ?`,
+                [this.database, this.table]
+            );
+
+            if (rows[0].count === 0) {
+                await this.pool.execute(
+                    `CREATE TABLE IF NOT EXISTS ${this.table} (
+                        id INT AUTO_INCREMENT PRIMARY KEY,
+                        level VARCHAR(255) NOT NULL,
+                        message TEXT NOT NULL,
+                        meta TEXT,
+                        timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                    )`
+                );
+            }
+
+            tableInitialized = true;
+        } catch (err) {
+            console.error(`Failed to check or create table ${this.table}:`, err);
+        }
+    }
+
+    /**
+     * Checks if the MySQL connection pool is active.
+     * @returns {boolean} - True if the connection pool is active, false otherwise.
+     */
+    isActive() {
+        return this.pool && !this.pool.ended;
+    }
+
+    /**
+     * Closes the MySQL connection pool.
+     * @returns {Promise<void>}
+     */
+    async close() {
+        if (connectionPool) {
+            await connectionPool.end();
+            connectionPool = null;
+            console.log('Closed MySQL connection pool.');
+        }
+    }
+}
+
+module.exports = {
+    transport: MySQLTransport,
+};

package/plugins/sentry.js

@@ -0,0 +1,51 @@
+/**
+ * @file /plugins/sentry.js
+ * @description Initializes the Sentry SDK for error tracking and defines a custom Winston transport.
+ */
+
+const Transport = require('winston-transport');
+const Sentry = require("@sentry/node");
+
+/**
+ * Custom Winston transport for sending logs to Sentry.
+ */
+class SentryTransport extends Transport {
+    constructor(opts = {}) {
+        super(opts);
+
+        this.name = 'Sentry Transport for NTLogger';
+        this.init(opts);
+    }
+
+    /**
+     * Initializes the Sentry SDK with the provided configuration.
+     * @param {Object} config - The configuration object for Sentry initialization.
+     */
+    init(config = {}) {
+        try {
+            Sentry.init({...config});
+        } catch (err) {
+            console.error(`Failed to initialize ${this.name}:`, err);
+        }
+    }
+
+    log(info, callback) {
+        setImmediate(() => {
+            this.emit('logged', info);
+        });
+
+        const { level, message, ...meta } = info;
+
+        if (level === 'error') {
+            Sentry.captureException(new Error(message), { extra: meta });
+        } else {
+            Sentry.captureMessage(message, { level, extra: meta });
+        }
+
+        callback();
+    }
+}
+
+module.exports = {
+    transport: SentryTransport,
+};