ntlogger 2.4.0 → 2.5.1

package/index.js

@@ -4,9 +4,30 @@
  * GPL-3.0 Licensed
  */
 
+/**
+ * TODO: [Feature] Generic Webhook Plugin for sending logs to any webhook
+ * TODO: [Feature] Email Plugin for sending logs to an email address
+ * TODO: [Feature] SMS Mail ID Plugin for sending logs to a phone number
+ */
+
 /**
  * Change Log:
  *
+ * v2.5.1 - 08/10/2024:
+ * [Bug] Fixed a bug where Jest plugin was not working due to a missing config parameter. This rule was not originally enforced until v2.5.0.
+ *
+ * v2.5.0 - 08/10/2024:
+ * [NOTE] Syslog plugin can send logs using TLS but it is not tested. Avoid sensitive data.
+ * [Feature] Added a plugin for Discord webhook integration, allowing log messages to be sent directly to a specified Discord channel.
+ * [Feature] Added a plugin for Syslog server integration, enabling log messages to be sent to a Syslog server using UDP, TCP, or TLS protocols.
+ * [Feature] Implemented clean signal handling for graceful shutdowns (SIGINT, SIGTERM).
+ *
+ * [Update] @sentry/node            ^8.17.0 --> ^8.25.0
+ * [Update] mysql2                  ^3.10.2 --> ^3.11.0
+ * [Update] winston                 ^3.13.1 --> ^3.14.1
+ * [Update] @sentry/profiling-node  ^8.17.0 --> ^8.25.0
+ * [Update] jest                    ^29.0.0 --> ^29.7.0
+ *
  * 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

package/lib/colors.js

@@ -0,0 +1,25 @@
+/**
+ * @file /lib/colors.js
+ * @description Provides color codes for console output and Discord embeds.
+ */
+
+module.exports = {
+    console: {
+        internal: '\x1b[93m', // Bright yellow
+        trace: '\x1b[90m',    // Light gray
+        debug: '\x1b[37m',    // White
+        info: '\x1b[32m',     // Green
+        warn: '\x1b[33m',     // Yellow
+        error: '\x1b[31m',    // Red
+        fatal: '\x1b[35m',    // Magenta
+    },
+    discord: {
+        internal: 0x95a5a6, // Gray
+        trace: 0x607d8b,    // Blue-gray
+        debug: 0x3498db,    // Blue
+        info: 0x2ecc71,     // Green
+        warn: 0xf39c12,     // Orange
+        error: 0xe74c3c,    // Red
+        fatal: 0x8e44ad,    // Purple
+    },
+};

package/lib/levels.js

@@ -0,0 +1,14 @@
+/**
+ * @file /lib/levels.js
+ * @description Provides a mapping of log levels to their respective numerical values.
+ */
+
+module.exports = {
+    internal: 6,
+    trace: 5,
+    debug: 4,
+    info: 3,
+    warn: 2,
+    error: 1,
+    fatal: 0,
+};

package/lib/logger.js

@@ -6,40 +6,28 @@
  * any Node.js project.
  *
  * Author: Kevin R. (Kvrnn#6940, Syntax#5569)
- * Date: 03/31/2024
- * Current Version: 2.1.2
  * License: GPL-3.0
  */
+
 const winston = require('winston');
 const crypto = require('crypto');
 
-const { initPlugins } = require('../plugins/index.js');
+const { setupSignalHandlers } = require('./signalHandler');
+const { initPlugins } = require('../plugins/index');
+const colors = require('./colors');
+const levels = require('./levels');
 
 // Define a map to hold the logger instances by their location
 const loggerInstances = new Map();
 
+// Call the signal handler setup function
+setupSignalHandlers(loggerInstances);
+
 const customSettings = {
-    levels: {
-        internal: 6,
-        trace: 5,
-        debug: 4,
-        info: 3,
-        warn: 2,
-        error: 1,
-        fatal: 0,
-    },
-    colors: {
-        internal: '\x1b[93m', // Bright yellow
-        trace: '\x1b[90m',  // Light gray
-        debug: '\x1b[37m',  // White
-        info: '\x1b[32m',   // Green
-        warn: '\x1b[33m',   // Yellow
-        error: '\x1b[31m',  // Red
-        fatal: '\x1b[35m',  // Magenta
-    },
+    levels: levels,
+    colors: colors.console,
 };
 
-
 const randomBrightColor = () => {
     // Configuration variables
     const minLuminanceThreshold = 0.03928;

package/lib/signalHandler.js

@@ -0,0 +1,53 @@
+/**
+ * @file /lib/signalHandler.js
+ * @description Initializes signal handlers for the application.
+ */
+
+function setupSignalHandlers(loggerInstances) {
+    const cleanup = () => {
+        console.log('Cleaning up logger resources...');
+        for (const [location, logger] of loggerInstances) {
+            logger.end(() => {
+                console.log(`Logger for ${location} closed.`);
+            });
+
+            for (const transport of logger.transports) {
+                if (transport.close) {
+                    transport.close();
+                }
+            }
+        }
+    };
+
+    process.on('SIGINT', () => {
+        console.log('Received SIGINT. Exiting...');
+        cleanup();
+        process.exit(0);
+    });
+
+    process.on('SIGTERM', () => {
+        console.log('Received SIGTERM. Exiting...');
+        cleanup();
+        process.exit(0);
+    });
+
+    process.on('SIGQUIT', () => {
+        console.log('Received SIGQUIT. Exiting...');
+        cleanup();
+        process.exit(0);
+    });
+
+    process.on('uncaughtException', (err) => {
+        console.error('Uncaught Exception:', err);
+        cleanup();
+        process.exit(1);
+    });
+
+    process.on('unhandledRejection', (reason, promise) => {
+        console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+        cleanup();
+        process.exit(1);
+    });
+}
+
+module.exports = { setupSignalHandlers };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ntlogger",
-  "version": "2.4.0",
+  "version": "2.5.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/NightSquawk/NightTimeLogger.git"
@@ -18,7 +18,9 @@
     "log management",
     "logging utility",
     "sentry compatible",
-    "mysql compatible"
+    "mysql compatible",
+    "syslog compatible",
+    "discord compatible"
   ],
   "files": [
     "index.js",
@@ -27,15 +29,15 @@
   ],
   "license": "GPL-3.0",
   "dependencies": {
-    "@sentry/node": "^8.17.0",
-    "mysql2": "^3.10.2",
-    "winston": "^3.13.1",
+    "@sentry/node": "^8.25.0",
+    "mysql2": "^3.11.0",
+    "winston": "^3.14.1",
     "winston-transport": "^4.7.1"
   },
   "devDependencies": {
-    "@sentry/profiling-node": "^8.17.0",
+    "@sentry/profiling-node": "^8.25.0",
     "dotenv": "^16.4.5",
-    "jest": "^29.0.0"
+    "jest": "^29.7.0"
   },
   "scripts": {
     "test": "jest"

package/plugins/discord.js

@@ -0,0 +1,110 @@
+/**
+ * @file /plugins/discord.js
+ * @description Sends logs to a Discord webhook.
+ */
+
+const Transport = require('winston-transport');
+const https = require('https');
+const { URL } = require('url');
+
+const colors = require('../lib/colors');
+const levels = require('../lib/levels'); // Assuming this file contains the log levels mapping
+
+class DiscordTransport extends Transport {
+    constructor(opts = {}) {
+        super(opts);
+
+        this.name = 'Discord Webhook Transport for NTLogger';
+
+        this.webhookUrl = opts.webhookUrl;
+        this.username = opts.username || 'NTLogger';
+        this.avatarUrl = opts.avatarUrl || null;
+        this.strict = opts.strict || false;
+
+        try {
+            // Set the log level
+            this.level = opts.level || 'info';
+            if (!(this.level in levels)) {
+                throw new Error(`Invalid log level: ${this.level}`);
+            }
+            this.levelPriority = levels[this.level]; // Get the numerical priority of the log level
+        } catch (error) {
+            console.error(`Error setting log level: ${error.message}`);
+            console.error(error.stack);
+            throw error; // Rethrow the error to stop the transport creation if level is invalid
+        }
+
+        this.levelColors = colors.discord;
+    }
+
+    async log(info, callback) {
+        setImmediate(() => {
+            this.emit('logged', info);
+        });
+
+        const { level, message, ...meta } = info;
+
+        // Check if the log level matches the configured level (strict mode) or is at or below the configured level
+        if (this.strict) {
+            if (level !== this.level) {
+                callback(); // Skip sending the log if it's not exactly the configured level
+                return;
+            }
+        } else {
+            if (levels[level] > this.levelPriority) {
+                callback(); // Skip sending the log if it's above the configured level
+                return;
+            }
+        }
+
+        const payload = JSON.stringify({
+            username: this.username,
+            avatar_url: this.avatarUrl,
+            embeds: [
+                {
+                    title: `Log Level: ${level.toUpperCase()}`,
+                    description: message,
+                    color: this.levelColors[level] || 0x000000, // Default to black if the level is unknown
+                    fields: Object.keys(meta).map(key => ({
+                        name: key,
+                        value: typeof meta[key] === 'string' ? meta[key] : JSON.stringify(meta[key], null, 2),
+                        inline: false,
+                    })),
+                    timestamp: new Date().toISOString(),
+                }
+            ]
+        });
+
+        const webhookUrl = new URL(this.webhookUrl);
+
+        const options = {
+            hostname: webhookUrl.hostname,
+            path: webhookUrl.pathname + webhookUrl.search,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(payload),
+            },
+        };
+
+        const req = https.request(options, (res) => {
+            res.on('data', (chunk) => {
+                console.log(`Response from Discord: ${chunk}`);
+            });
+            res.on('end', () => {
+                callback();
+            });
+        });
+
+        req.on('error', (e) => {
+            console.error(`Failed to send log to Discord: ${e.message}`);
+        });
+
+        req.write(payload);
+        req.end();
+    }
+}
+
+module.exports = {
+    transport: DiscordTransport,
+};

package/plugins/index.js

@@ -5,15 +5,16 @@
 
 // Available plugins
 const plugins = {
-    Sentry: require('./sentry'),
-    MySQL : require('./mysql'),
-    Jest: require('./jest'),
-
-    // TODO: Implement the following plugins
-    // mongodb: require('./mongodb'),
-    // redis: require('./redis'),
+    Sentry  : require('./sentry'),
+    MySQL   : require('./mysql'),
+    Jest    : require('./jest'),
+    Syslog  : require('./syslog'),
+    Discord : require('./discord'),
+    // WIP SMSMail : require('./smsMail'),
 };
 
+// ------------------------------ DO NOT MODIFY BELOW THIS LINE ------------------------------ //
+
 function checkPluginAvailability(pluginName) {
     if (!plugins[pluginName]) {
         throw new Error(`Plugin ${pluginName} is not available\nAvailable plugins: ${Object.keys(plugins).join(', ')}`);
@@ -37,16 +38,39 @@ function initPlugins(config = {}) {
         for (let plugin of config) {
             if (!plugin.name) {
                 throw new Error('Plugin name is required');
-            } else {
+            }
+
+            try {
                 checkPluginAvailability(plugin.name);
+            } catch (availabilityError) {
+                console.error(`Plugin ${plugin.name} is not available:`, availabilityError.message);
+                console.error(availabilityError.stack);
+                continue;
+            }
+
+            try {
                 let customTransportClass = getPluginTransport(plugin.name);
+
+                if (typeof customTransportClass !== 'function') {
+                    throw new Error(`Transport class for plugin ${plugin.name} is not a constructor function`);
+                }
+
+                if (!plugin.config || typeof plugin.config !== 'object') {
+                    throw new Error(`Invalid or missing config for plugin ${plugin.name}`);
+                }
+
                 pluginTransports.push(new customTransportClass(plugin.config));
+            } catch (transportError) {
+                console.error(`Failed to initialize plugin ${plugin.name}:`, transportError.message);
+                console.error(transportError.stack);
             }
         }
-        return pluginTransports;
     } catch (err) {
-        console.error('Error initializing plugins:', err);
+        console.error('Error initializing plugins:', err.message);
+        console.error(err.stack);
     }
+
+    return pluginTransports;
 }
 
 module.exports = {

package/plugins/syslog.js

@@ -0,0 +1,84 @@
+/**
+ * @file /plugins/syslog.js
+ * @description Sends logs to a Syslog server using custom Syslog client.
+ */
+
+const Transport = require('winston-transport');
+const SyslogClient = require('./lib/syslogClient');
+
+class SyslogTransport extends Transport {
+    constructor(opts = {}) {
+        super(opts);
+
+        this.name = 'Syslog Transport for NTLogger';
+        this.client = new SyslogClient({
+            host: opts.host || 'localhost',
+            port: opts.port || 514,
+            protocol: opts.protocol || 'UDP', // Options: 'UDP', 'TCP', 'TLS'
+            rfc: opts.rfc || 'RFC-5424', // Options: 'RFC-3164', 'RFC-5424'
+            facility: opts.facility || 1,
+            appName: opts.appName || 'NTLogger',
+            hostname: opts.hostname || require('os').hostname(),
+        });
+
+        this.levels = {
+            internal: 7, // Debug level for internal logs
+            trace: 7,    // Debug
+            debug: 7,    // Debug
+            info: 6,     // Informational
+            warn: 4,     // Warning
+            error: 3,    // Error
+            fatal: 2,    // Critical
+        };
+        this.logLevel = opts.level ? this.levels[opts.level] : this.levels.info;
+
+        if (this.client.protocol === 'TCP' || this.client.protocol === 'TLS') {
+            this.client.connect().catch(err => {
+                console.error(`Failed to connect to Syslog server at ${this.client.host}:${this.client.port}:`, err);
+            });
+        }
+    }
+
+    /**
+     * Logs messages to the Syslog server.
+     * @param {Object} info - Log information.
+     * @param {Function} callback - Callback function.
+     */
+    log(info, callback) {
+        setImmediate(() => {
+            this.emit('logged', info);
+        });
+
+        const { level, message, ...meta } = info;
+
+        if (this.levels[level] > this.logLevel) {
+            callback();
+            return;
+        }
+
+        this.client.send(this.levels[level], message, meta);
+
+        callback();
+    }
+
+    /**
+     * Checks if the Syslog client is active.
+     * @returns {boolean} - True if the client is active, false otherwise.
+     */
+    isActive() {
+        return this.client && (this.client.protocol === 'UDP' || (this.client.transport && !this.client.transport.destroyed));
+    }
+
+    /**
+     * Closes the Syslog client connection.
+     * @returns {Promise<void>}
+     */
+    async close() {
+        this.client.close();
+        console.log('Closed Syslog client connection.');
+    }
+}
+
+module.exports = {
+    transport: SyslogTransport,
+};