ntlogger 2.10.0 → 3.0.0

package/plugins/mysql.js

@@ -1,13 +1,35 @@
 /**
  * @file /plugins/mysql.js
  * @description Stores logs in MySQL database.
+ *
+ * `mysql2` is an optional peer dependency. Install it when using this plugin:
+ *   npm install mysql2
  */
 
 const Transport = require('winston-transport');
-const mysql = require('mysql2/promise');
 
-let connectionPool = null;
-let tableInitialized = false;
+/**
+ * Requires an optional peer dependency, translating only that package's
+ * MODULE_NOT_FOUND into an actionable install message. Any other failure
+ * (including a missing module *inside* the package) propagates unchanged.
+ * @param {string} moduleId - The module specifier to require.
+ * @param {string} packageName - The npm package to install.
+ * @returns {*} The resolved module.
+ */
+function requirePeer(moduleId, packageName) {
+    try {
+        return require(moduleId);
+    } catch (err) {
+        if (err && err.code === 'MODULE_NOT_FOUND' && String(err.message).includes(`'${moduleId}'`)) {
+            throw new Error(`ntlogger MySQL plugin requires '${packageName}'. Install it with: npm install ${packageName}`);
+        }
+        throw err;
+    }
+}
+
+const mysql = requirePeer('mysql2/promise', 'mysql2');
+
+
 
 class MySQLTransport extends Transport {
     constructor(opts = {}) {
@@ -16,6 +38,11 @@ class MySQLTransport extends Transport {
         this.name = 'MySQL Transport for NTLogger';
         this.database = opts.database || 'test';
         this.table = opts.table || 'logs';
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(this.table)) {
+            throw new Error('Log table must be a simple SQL identifier');
+        }
+        this.tableInitialized = false;
+        this.closed = false;
 
         this.levels = {
             internal: 6,
@@ -34,70 +61,52 @@ class MySQLTransport extends Transport {
             user: opts.user || 'root',
             password: opts.password || '',
             database: this.database,
-            waitForConnections: opts.waitForConnections || true,
+            ssl: opts.ssl,
+            timezone: "+00:00",
+            waitForConnections: opts.waitForConnections ?? true,
             connectionLimit: opts.connectionLimit || 10,
             queueLimit: opts.queueLimit || 0,
-            maxIdle: opts.maxIdle || 10,
+            maxIdle: opts.maxIdle ?? 10,
             idleTimeout: opts.idleTimeout || 60000,
-            enableKeepAlive: opts.enableKeepAlive || true,
+            enableKeepAlive: opts.enableKeepAlive ?? true,
             keepAliveInitialDelay: opts.keepAliveInitialDelay || 0,
         };
 
-        this.init();
+        this.pool = mysql.createPool(this.poolConfig);
+        this.pool.on('error', error => { this.lastError = error; });
+        this.ready = this.checkLogTable();
+        this.ready.catch(error => { this.lastError = error; });
     }
 
     /**
      * 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 init() { return this.ready; }
 
     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);
-
+        if (this.levels[info.level] > this.logLevel) { callback(); return; }
         try {
+            if (this.closed) throw new Error('Database transport is closed');
+            await this.ready;
+            const { level, message, ...meta } = info;
+            const timestamp = this.formatTimestamp(meta.timestamp);
             await this.pool.execute(
                 `INSERT INTO ${this.table} (level, message, meta, timestamp) VALUES (?, ?, ?, ?)`,
-                [level, message, metaString, timestamp]
+                [level, message, JSON.stringify(meta), timestamp]
             );
-        } catch (err) {
-            console.error(`Failed to log message to ${this.name}:`, err);
+            this.emit('logged', info);
+            callback();
+        } catch (error) {
+            this.lastError = error;
+            callback(error);
         }
-
-        callback();
     }
 
-    /**
-     * Formats the timestamp for the MySQL database.
-     * @param {string} timeCreated - The time created string.
-     * @returns {string} - The formatted timestamp.
-     */
     formatTimestamp(timeCreated) {
+        if (timeCreated && /^\d{4}-/.test(timeCreated)) {
+            const date = new Date(timeCreated);
+            return date.toISOString().slice(0, 23).replace('T', ' ');
+        }
         if (!timeCreated) {
             return new Date().toISOString().slice(0, 19).replace('T', ' ');
         }
@@ -119,55 +128,36 @@ class MySQLTransport extends Transport {
     /**
      * 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);
+    checkLogTable() {
+        if (!this.tableReady) {
+            this.tableReady = 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(3) DEFAULT CURRENT_TIMESTAMP(3))`)
+                .then(() => { this.tableInitialized = true; })
+                .catch(error => { this.tableReady = null; throw error; });
         }
+        return this.tableReady;
     }
 
-    /**
-     * 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;
+        return this.pool && !this.closed;
     }
 
     /**
      * Closes the MySQL connection pool.
      * @returns {Promise<void>}
      */
-    async close() {
-        if (connectionPool) {
-            await connectionPool.end();
-            connectionPool = null;
-            console.log('Closed MySQL connection pool.');
+    async flush() {
+        await this.ready;
+        if (this.lastError) throw this.lastError;
+    }
+
+    close() {
+        if (!this.closePromise) {
+            this.closed = true;
+            this.closePromise = this.ready.catch(() => {}).then(() => this.pool.end());
         }
+        return this.closePromise;
     }
+
 }
 
 module.exports = {

package/plugins/openobserve.js

@@ -4,10 +4,9 @@
  */
 
 const Transport = require('winston-transport');
-const https = require('https');
-const http = require('http');
 const { URL } = require('url');
 const levels = require('../lib/levels');
+const { HttpDelivery } = require('./lib/httpDelivery');
 
 /**
  * Strips ANSI escape codes from a string
@@ -44,7 +43,7 @@ function cleanObject(obj) {
         const cleaned = {};
         for (const [key, value] of Object.entries(obj)) {
             // Skip timestamp fields
-            if (key === 'timestamp' || key === 'timeCreated') {
+            if (key === 'timeCreated') {
                 continue;
             }
             cleaned[key] = cleanObject(value);
@@ -86,7 +85,10 @@ class OpenObserveTransport extends Transport {
 
         // Optional configuration
         this.batchSize = opts.batchSize || 100;
-        this.timeThreshold = opts.timeThreshold || 5000;
+        this.timeThreshold = opts.timeThreshold ?? 5000;
+        if (!Number.isInteger(this.batchSize) || this.batchSize < 1 || !Number.isFinite(this.timeThreshold) || this.timeThreshold < 0) {
+            throw new Error('Invalid batching configuration');
+        }
 
         // Set log level
         try {
@@ -104,17 +106,8 @@ class OpenObserveTransport extends Transport {
         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}`);
-        }
+        const url = new URL(this.host);
+        this.pathname = url.pathname.replace(/\/$/, '') || '';
 
         // Create Basic Auth header
         const auth = Buffer.from(`${this.username}:${this.password}`).toString('base64');
@@ -122,210 +115,43 @@ class OpenObserveTransport extends Transport {
 
         // 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);
+        const endpoint = new URL(this.host);
+        endpoint.pathname = this.apiPath;
+        this.delivery = new HttpDelivery(endpoint, opts);
     }
 
     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;
+        if (levels[info.level] > this.levelPriority) { callback(); return; }
+        if (this.closed) { callback(new Error('OpenObserve transport is closed')); return; }
+        this.logQueue.push(info);
+        if (this.logQueue.length >= this.batchSize) this._flush();
+        else if (!this.flushTimer) {
+            this.flushTimer = setTimeout(() => this._flush(), this.timeThreshold);
+            this.flushTimer.unref();
         }
-
-        // 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}`);
-        });
+        clearTimeout(this.flushTimer);
+        this.flushTimer = null;
+        if (!this.logQueue.length) return;
+        const batch = this.logQueue.splice(0);
+        try {
+            const payload = JSON.stringify(batch.map(log => cleanObject(log)));
+            this.delivery.send(payload, { Authorization: this.authHeader }).catch(() => {});
+        } catch (error) { this.delivery.failure = error; }
+    }
 
-        req.write(payload);
-        req.end();
+    async flush() {
+        this._flush();
+        await this.delivery.flush();
     }
 
-    /**
-     * Closes the transport and flushes any remaining logs
-     */
     close() {
-        if (this.flushTimer) {
-            clearTimeout(this.flushTimer);
-            this.flushTimer = null;
-        }
-        this._flush();
+        this.closed = true;
+        return this.flush();
     }
 }
 
-module.exports = {
-    transport: OpenObserveTransport,
-};
-
+module.exports = { transport: OpenObserveTransport };

package/plugins/otel.js

@@ -128,7 +128,7 @@ class OpenTelemetryTransport extends Transport {
         }
 
         const Processor = opts.useSimpleProcessor ? SimpleLogRecordProcessor : BatchLogRecordProcessor;
-        const processor = new Processor(exporter, opts.processorOptions || {});
+        const processor = new Processor({ ...(opts.processorOptions || {}), exporter });
 
         let resource;
         const resources = tryRequire('@opentelemetry/resources');
@@ -211,6 +211,7 @@ class OpenTelemetryTransport extends Transport {
             severityText,
             body,
             attributes: this._toAttributes(meta),
+            ...(meta.timestamp ? { timestamp: new Date(meta.timestamp) } : {}),
         };
 
         if (this._traceApi) {
@@ -228,7 +229,8 @@ class OpenTelemetryTransport extends Transport {
         try {
             this.otelLogger.emit(record);
         } catch (err) {
-            console.error(`OpenTelemetry transport emit failed: ${err.message}`);
+            callback(err);
+            return;
         }
 
         callback();
@@ -249,11 +251,7 @@ class OpenTelemetryTransport extends Transport {
      */
     async close() {
         if (this._ownsProvider && this.loggerProvider && typeof this.loggerProvider.shutdown === 'function') {
-            try {
-                await this.loggerProvider.shutdown();
-            } catch (err) {
-                console.error(`OpenTelemetry transport shutdown failed: ${err.message}`);
-            }
+            await this.loggerProvider.shutdown();
         }
     }
 }