ntlogger 2.7.0 → 2.8.2

package/package.json

@@ -1,47 +1,51 @@
 {
   "name": "ntlogger",
-  "version": "2.7.0",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/NightSquawk/NightTimeLogger.git"
-  },
-  "author": "Kevin R. (Kvrnn#6940, Syntax#5569)",
+  "version": "2.8.2",
   "description": "A Custom Ready-To-Go Logging Wrapper Built on Winston",
   "keywords": [
+    "custom logger",
+    "discord compatible",
+    "log management",
     "logger",
-    "winston wrapper",
     "logger wrapper",
-    "wrapper",
-    "winston logger",
-    "custom logger",
     "logging",
-    "log management",
     "logging utility",
-    "sentry compatible",
     "mysql compatible",
+    "sentry compatible",
     "syslog compatible",
-    "discord compatible",
-    "teams compatible"
+    "teams compatible",
+    "winston logger",
+    "winston wrapper",
+    "wrapper"
   ],
+  "author": "Kevin R. (Kvrnn#6940, Syntax#5569)",
+  "license": "GPL-3.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NightSquawk/NightTimeLogger.git"
+  },
   "files": [
     "index.js",
+    "index.d.ts",
     "lib/*.js",
     "plugins/**/*"
   ],
-  "license": "GPL-3.0",
+  "scripts": {
+    "test": "jest"
+  },
   "dependencies": {
-    "@sentry/node": "^8.26.0",
-    "mysql2": "^3.11.0",
-    "pg": "^8.12.0",
-    "winston": "^3.14.2",
-    "winston-transport": "^4.7.1"
+    "@sentry/node": "^10.25.0",
+    "mysql2": "^3.15.3",
+    "pg": "^8.16.3",
+    "winston": "^3.18.3",
+    "winston-transport": "^4.9.0"
   },
   "devDependencies": {
-    "@sentry/profiling-node": "^8.26.0",
-    "dotenv": "^16.4.5",
-    "jest": "^29.7.0"
+    "@sentry/profiling-node": "^10.25.0",
+    "dotenv": "^17.2.3",
+    "jest": "^30.2.0"
   },
-  "scripts": {
-    "test": "jest"
+  "overrides": {
+    "glob": "^11.1.0"
   }
 }

package/plugins/README.md

@@ -233,6 +233,34 @@ log.error('Error message',[
 ]);
 ```
 
+### 7. OpenObserve
+**Description:** Sends logs to OpenObserve, an open-source observability platform. This plugin automatically strips ANSI escape codes, removes timestamps, and sends clean structured JSON logs to OpenObserve's HTTP API with batching support for improved performance.
+
+**Setup:**
+
+```javascript
+{
+    name: 'OpenObserve',
+    config: {
+        host: process.env.OPENOBSERVE_HOST || 'http://localhost:5080',
+        organization: process.env.OPENOBSERVE_ORGANIZATION || 'default',
+        stream: process.env.OPENOBSERVE_STREAM || 'logs',
+        username: process.env.OPENOBSERVE_USERNAME || 'root@example.com',
+        password: process.env.OPENOBSERVE_PASSWORD || 'ComplexPass#123',
+        batchSize: 100, // Optional: Number of logs to batch before sending (default: 100)
+        timeThreshold: 5000, // Optional: Time in milliseconds before sending batch (default: 5000)
+        level: 'info', // Optional: Minimum log level to send (default: 'info')
+    },
+}
+```
+
+**Features:**
+- Automatic ANSI code stripping from all log messages and metadata
+- Timestamp removal (OpenObserve adds its own `_timestamp` field)
+- Batching support to reduce HTTP requests and improve performance
+- Clean structured JSON output suitable for OpenObserve ingestion
+- Support for all log levels with configurable filtering
+
 ### Example Logger Configuration
 Here is an example configuration for NightTimeLogger using multiple plugins:
 
@@ -285,6 +313,19 @@ let config = {
                 appName: 'MyAppLogger',
             },
         },
+        {
+            name: 'OpenObserve',
+            config: {
+                host: process.env.OPENOBSERVE_HOST || 'http://localhost:5080',
+                organization: process.env.OPENOBSERVE_ORGANIZATION || 'default',
+                stream: process.env.OPENOBSERVE_STREAM || 'logs',
+                username: process.env.OPENOBSERVE_USERNAME,
+                password: process.env.OPENOBSERVE_PASSWORD,
+                batchSize: 100,
+                timeThreshold: 5000,
+                level: 'info',
+            },
+        },
     ],
 };
 ```

package/plugins/index.js

@@ -5,13 +5,14 @@
 
 // Available plugins
 const plugins = {
-    Sentry  : require('./sentry'),
-    MySQL   : require('./mysql'),
-    Postgres: require('./postgres'),
-    Jest    : require('./jest'),
-    Syslog  : require('./syslog'),
-    Discord : require('./discord'),
-    Teams   : require('./teams'),
+    Sentry      : require('./sentry'),
+    MySQL       : require('./mysql'),
+    Postgres    : require('./postgres'),
+    Jest        : require('./jest'),
+    Syslog      : require('./syslog'),
+    Discord     : require('./discord'),
+    Teams       : require('./teams'),
+    OpenObserve : require('./openobserve'),
 
     // WIP SMSMail : require('./smsMail'),
 };
@@ -51,7 +52,7 @@ function initPlugins(config = {}) {
 
             try {
                 if (!plugin.enabled) {
-                    console.log(`Plugin ${plugin.name} is disabled`);
+                    if (config.alerts === true) {console.log(`Plugin ${plugin.name} is disabled`);}
                     continue;
                 }
             } catch (enabledError) {

package/plugins/openobserve.js

@@ -0,0 +1,331 @@
+/**
+ * @file /plugins/openobserve.js
+ * @description Sends logs to OpenObserve using HTTP API with batching support.
+ */
+
+const Transport = require('winston-transport');
+const https = require('https');
+const http = require('http');
+const { URL } = require('url');
+const levels = require('../lib/levels');
+
+/**
+ * Strips ANSI escape codes from a string
+ * @param {string} str - String to clean
+ * @returns {string} - Cleaned string
+ */
+function stripAnsiCodes(str) {
+    if (typeof str !== 'string') {
+        return str;
+    }
+    // Remove ANSI escape codes: \u001b[ followed by numbers, semicolons, and ending with 'm'
+    return str.replace(/\u001b\[[0-9;]*m/g, '');
+}
+
+/**
+ * Recursively strips ANSI codes from all string values in an object
+ * @param {any} obj - Object or value to clean
+ * @returns {any} - Cleaned object or value
+ */
+function cleanObject(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+
+    if (typeof obj === 'string') {
+        return stripAnsiCodes(obj);
+    }
+
+    if (Array.isArray(obj)) {
+        return obj.map(item => cleanObject(item));
+    }
+
+    if (typeof obj === 'object') {
+        const cleaned = {};
+        for (const [key, value] of Object.entries(obj)) {
+            // Skip timestamp fields
+            if (key === 'timestamp' || key === 'timeCreated') {
+                continue;
+            }
+            cleaned[key] = cleanObject(value);
+        }
+        return cleaned;
+    }
+
+    return obj;
+}
+
+class OpenObserveTransport extends Transport {
+    constructor(opts = {}) {
+        super(opts);
+
+        this.name = 'OpenObserve Transport for NTLogger';
+
+        // Required configuration
+        if (!opts.host) {
+            throw new Error('OpenObserve host is required');
+        }
+        if (!opts.organization) {
+            throw new Error('OpenObserve organization is required');
+        }
+        if (!opts.stream) {
+            throw new Error('OpenObserve stream is required');
+        }
+        if (!opts.username) {
+            throw new Error('OpenObserve username is required');
+        }
+        if (!opts.password) {
+            throw new Error('OpenObserve password is required');
+        }
+
+        this.host = opts.host;
+        this.organization = opts.organization;
+        this.stream = opts.stream;
+        this.username = opts.username;
+        this.password = opts.password;
+
+        // Optional configuration
+        this.batchSize = opts.batchSize || 100;
+        this.timeThreshold = opts.timeThreshold || 5000;
+
+        // Set log level
+        try {
+            this.level = opts.level || 'info';
+            if (!(this.level in levels)) {
+                throw new Error(`Invalid log level: ${this.level}`);
+            }
+            this.levelPriority = levels[this.level];
+        } catch (error) {
+            console.error(`Error setting log level: ${error.message}`);
+            throw error;
+        }
+
+        // Batching queue
+        this.logQueue = [];
+        this.flushTimer = null;
+
+        // Parse URL to determine protocol
+        try {
+            const url = new URL(this.host);
+            this.protocol = url.protocol === 'https:' ? https : http;
+            this.hostname = url.hostname;
+            this.port = url.port || (url.protocol === 'https:' ? 443 : 80);
+            // Normalize pathname: remove trailing slash if present, keep empty if no path
+            this.pathname = url.pathname.replace(/\/$/, '') || '';
+        } catch (error) {
+            throw new Error(`Invalid host URL: ${error.message}`);
+        }
+
+        // Create Basic Auth header
+        const auth = Buffer.from(`${this.username}:${this.password}`).toString('base64');
+        this.authHeader = `Basic ${auth}`;
+
+        // Build API endpoint path
+        this.apiPath = `${this.pathname}/api/${encodeURIComponent(this.organization)}/${encodeURIComponent(this.stream)}/_json`;
+    }
+
+    /**
+     * Flushes the log queue to OpenObserve
+     */
+    flush() {
+        if (this.logQueue.length === 0) {
+            return;
+        }
+
+        const logsToSend = [...this.logQueue];
+        this.logQueue = [];
+
+        // Clear the timer since we're flushing now
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+
+        // Clean all logs: strip ANSI codes and remove timestamps
+        const cleanedLogs = logsToSend.map(log => {
+            const cleaned = cleanObject(log);
+            // Ensure we have the essential fields
+            // Note: filePath (from reportPath feature) is preserved in metadata as a separate JSON field
+            // It's not in the formatted message string, ensuring clean structured data for OpenObserve
+            return {
+                level: cleaned.level,
+                message: cleaned.message,
+                ...cleaned  // Includes all metadata fields like filePath, location, ID, etc.
+            };
+        });
+
+        const payload = JSON.stringify(cleanedLogs);
+
+        const options = {
+            hostname: this.hostname,
+            port: this.port,
+            path: this.apiPath,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(payload),
+                'Authorization': this.authHeader,
+            },
+        };
+
+        const req = this.protocol.request(options, (res) => {
+            let responseData = '';
+            res.on('data', (chunk) => {
+                responseData += chunk;
+            });
+            res.on('end', () => {
+                if (res.statusCode >= 200 && res.statusCode < 300) {
+                    // Success
+                } else {
+                    console.error(`OpenObserve API error: ${res.statusCode} - ${responseData}`);
+                }
+            });
+        });
+
+        req.on('error', (e) => {
+            console.error(`Failed to send logs to OpenObserve: ${e.message}`);
+        });
+
+        req.write(payload);
+        req.end();
+    }
+
+    /**
+     * Schedules a flush after timeThreshold milliseconds
+     */
+    scheduleFlush() {
+        if (this.flushTimer) {
+            return; // Already scheduled
+        }
+
+        this.flushTimer = setTimeout(() => {
+            this._flush();
+        }, this.timeThreshold);
+    }
+
+    log(info, callback) {
+        setImmediate(() => {
+            this.emit('logged', info);
+        });
+
+        const { level, message, ...meta } = info;
+
+        // Check if log level is at or below the configured level
+        if (levels[level] > this.levelPriority) {
+            callback();
+            return;
+        }
+
+        // Add log to queue
+        this.logQueue.push({
+            level,
+            message,
+            ...meta
+        });
+
+        // Flush if batch size is reached
+        if (this.logQueue.length >= this.batchSize) {
+            this._flush();
+        } else {
+            // Schedule a flush after timeThreshold
+            this.scheduleFlush();
+        }
+
+        callback();
+    }
+
+    /**
+     * Flushes the log queue (can be called manually)
+     * @returns {Promise} - Promise that resolves when flush is complete
+     */
+    flush() {
+        return new Promise((resolve) => {
+            setImmediate(() => {
+                this._flush();
+                resolve();
+            });
+        });
+    }
+
+    /**
+     * Internal flush method (synchronous)
+     */
+    _flush() {
+        if (this.logQueue.length === 0) {
+            return;
+        }
+
+        const logsToSend = [...this.logQueue];
+        this.logQueue = [];
+
+        // Clear the timer since we're flushing now
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+
+        // Clean all logs: strip ANSI codes and remove timestamps
+        const cleanedLogs = logsToSend.map(log => {
+            const cleaned = cleanObject(log);
+            // Ensure we have the essential fields
+            // Note: filePath (from reportPath feature) is preserved in metadata as a separate JSON field
+            // It's not in the formatted message string, ensuring clean structured data for OpenObserve
+            return {
+                level: cleaned.level,
+                message: cleaned.message,
+                ...cleaned  // Includes all metadata fields like filePath, location, ID, etc.
+            };
+        });
+
+        const payload = JSON.stringify(cleanedLogs);
+
+        const options = {
+            hostname: this.hostname,
+            port: this.port,
+            path: this.apiPath,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(payload),
+                'Authorization': this.authHeader,
+            },
+        };
+
+        const req = this.protocol.request(options, (res) => {
+            let responseData = '';
+            res.on('data', (chunk) => {
+                responseData += chunk;
+            });
+            res.on('end', () => {
+                if (res.statusCode >= 200 && res.statusCode < 300) {
+                    // Success
+                } else {
+                    console.error(`OpenObserve API error: ${res.statusCode} - ${responseData}`);
+                }
+            });
+        });
+
+        req.on('error', (e) => {
+            console.error(`Failed to send logs to OpenObserve: ${e.message}`);
+        });
+
+        req.write(payload);
+        req.end();
+    }
+
+    /**
+     * Closes the transport and flushes any remaining logs
+     */
+    close() {
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        this._flush();
+    }
+}
+
+module.exports = {
+    transport: OpenObserveTransport,
+};
+

package/plugins/smsMail.js

@@ -0,0 +1,91 @@
+/**
+ * @file /plugins/smsMail.js
+ * @description Sends logs via SMS using an email-to-SMS gateway.
+ */
+
+const Transport = require('winston-transport');
+const { spawn } = require('child_process');
+const os = require('os');
+
+const levels = require('../lib/levels');
+
+class SMSTransport extends Transport {
+    constructor(opts = {}) {
+        super(opts);
+
+        this.name = 'SMS Transport for NTLogger';
+
+        // Required options for the SMTP transport
+        this.smsMailId = opts.smsMailId; // SMS email gateway address (e.g., 1234567890@carrier.com)
+        this.from = opts.from || `noreply@${os.hostname()}`; // Default from address
+        this.subjectPrefix = opts.subjectPrefix || 'Log Notification'; // Subject prefix for emails
+        this.smtpCommand = opts.smtpCommand || 'msmtp'; // Default to msmtp if no command provided
+
+        this.strict = opts.strict || false;
+
+        try {
+            this.level = opts.level || 'info';
+            if (!(this.level in levels)) {
+                throw new Error(`Invalid log level: ${this.level}`);
+            }
+            this.levelPriority = levels[this.level];
+        } catch (error) {
+            console.error(`Error setting log level: ${error.message}`);
+            console.error(error.stack);
+            throw error;
+        }
+    }
+
+    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;
+            }
+        }
+
+        // Construct the email content
+        const emailSubject = `${this.subjectPrefix}: ${level.toUpperCase()}`;
+        const emailText = `${message}\n\n${JSON.stringify(meta, null, 2)}`;
+
+        // Use the configured SMTP command to send the email
+        const smtpProcess = spawn(this.smtpCommand, ['-t']);
+
+        // Write the email content
+        smtpProcess.stdin.write(`To: ${this.smsMailId}\n`);
+        smtpProcess.stdin.write(`From: ${this.from}\n`);
+        smtpProcess.stdin.write(`Subject: ${emailSubject}\n`);
+        smtpProcess.stdin.write('\n'); // End of headers
+        smtpProcess.stdin.write(`${emailText}\n`);
+        smtpProcess.stdin.end();
+
+        smtpProcess.on('error', (err) => {
+            console.error(`Failed to send log via SMS: ${err.message}`);
+            console.error(`Please provide information for a valid SMTP server to use.`);
+        });
+
+        smtpProcess.on('close', (code) => {
+            if (code !== 0) {
+                console.error(`SMTP process exited with code ${code}`);
+                console.error(`Ensure that the SMTP server information is correct.`);
+            }
+            callback();
+        });
+    }
+}
+
+module.exports = {
+    transport: SMSTransport,
+};