ntlogger 2.10.0 → 3.0.0

package/plugins/postgres.js

@@ -1,14 +1,36 @@
 /**
  * @file /plugins/postgres.js
  * @description Stores logs in PostgresSQL database.
+ *
+ * `pg` is an optional peer dependency. Install it when using this plugin:
+ *   npm install pg
  */
 
 const Transport = require('winston-transport');
-const { Pool } = require('pg');
 const levels = require('../lib/levels');
 
-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 Postgres plugin requires '${packageName}'. Install it with: npm install ${packageName}`);
+        }
+        throw err;
+    }
+}
+
+const { Pool } = requirePeer('pg', 'pg');
+
+
 
 class PostgreSQLTransport extends Transport {
     constructor(opts = {}) {
@@ -17,6 +39,11 @@ class PostgreSQLTransport extends Transport {
         this.name = 'PostgreSQL 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.logLevel = opts.level ? levels[opts.level] : levels.info;
 
@@ -26,58 +53,44 @@ class PostgreSQLTransport extends Transport {
             user: opts.user || 'postgres',
             password: opts.password || '',
             database: this.database,
+            ssl: opts.ssl,
             max: opts.connectionLimit || 10,
             idleTimeoutMillis: opts.idleTimeout || 60000,
             connectionTimeoutMillis: opts.connectionTimeout || 2000,
         };
 
-        this.init();
+        this.pool = new Pool(this.poolConfig);
+        this.pool.on('error', error => { this.lastError = error; });
+        this.ready = this.checkLogTable();
+        this.ready.catch(error => { this.lastError = error; });
     }
 
-    async init() {
-        try {
-            if (!connectionPool) {
-                connectionPool = new Pool(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 (levels[level] > this.logLevel) {
-            callback();
-            return;
-        }
-
-        const metaString = JSON.stringify(meta);
-        const timestamp = this.formatTimestamp(meta.timeCreated);
-
+        if (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.query(
                 `INSERT INTO ${this.table} (level, message, meta, timestamp) VALUES ($1, $2, $3, $4)`,
-                [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();
     }
 
     formatTimestamp(timeCreated) {
+        if (timeCreated && /^\d{4}-/.test(timeCreated)) {
+            const date = new Date(timeCreated);
+            return date.toISOString();
+        }
         if (!timeCreated) {
             return new Date().toISOString().slice(0, 19).replace('T', ' ');
         }
@@ -96,43 +109,32 @@ class PostgreSQLTransport extends Transport {
         return `${date.getFullYear()}-${(date.getMonth() + 1).toString().padStart(2, '0')}-${date.getDate().toString().padStart(2, '0')} ${hours}:${minutes}:${seconds}`;
     }
 
-    async checkLogTable() {
-        if (tableInitialized) return;
-
-        try {
-            const result = await this.pool.query(
-                `SELECT to_regclass('${this.table}') as tablename`
-            );
-
-            if (!result.rows[0].tablename) {
-                await this.pool.query(
-                    `CREATE TABLE IF NOT EXISTS ${this.table} (
-                        id SERIAL PRIMARY KEY,
-                        level VARCHAR(255) NOT NULL,
-                        message TEXT NOT NULL,
-                        meta JSONB,
-                        timestamp TIMESTAMPTZ 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.query(`CREATE TABLE IF NOT EXISTS ${this.table} (id SERIAL PRIMARY KEY, level VARCHAR(255) NOT NULL, message TEXT NOT NULL, meta JSONB, timestamp TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP)`)
+                .then(() => { this.tableInitialized = true; })
+                .catch(error => { this.tableReady = null; throw error; });
         }
+        return this.tableReady;
     }
 
     isActive() {
-        return this.pool && !this.pool.ended;
+        return this.pool && !this.closed;
+    }
+
+    async flush() {
+        await this.ready;
+        if (this.lastError) throw this.lastError;
     }
 
-    async close() {
-        if (connectionPool) {
-            await connectionPool.end();
-            connectionPool = null;
-            console.log('Closed PostgreSQL connection pool.');
+    close() {
+        if (!this.closePromise) {
+            this.closed = true;
+            this.closePromise = this.ready.catch(() => {}).then(() => this.pool.end());
         }
+        return this.closePromise;
     }
+
 }
 
 module.exports = {

package/plugins/sentry.js

@@ -1,10 +1,33 @@
 /**
  * @file /plugins/sentry.js
  * @description Initializes the Sentry SDK for error tracking and defines a custom Winston transport.
+ *
+ * `@sentry/node` is an optional peer dependency. Install it when using this plugin:
+ *   npm install @sentry/node
  */
 
 const Transport = require('winston-transport');
-const Sentry = require("@sentry/node");
+
+/**
+ * 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 Sentry plugin requires '${packageName}'. Install it with: npm install ${packageName}`);
+        }
+        throw err;
+    }
+}
+
+const Sentry = requirePeer('@sentry/node', '@sentry/node');
 
 /**
  * Custom Winston transport for sending logs to Sentry.
@@ -14,6 +37,7 @@ class SentryTransport extends Transport {
         super(opts);
 
         this.name = 'Sentry Transport for NTLogger';
+        this.flushTimeout = opts.flushTimeout ?? 5000;
         this.init(opts);
     }
 
@@ -37,13 +61,22 @@ class SentryTransport extends Transport {
         const { level, message, ...meta } = info;
 
         if (level === 'error') {
-            Sentry.captureException(new Error(message), { extra: meta });
+            const error = new Error(message);
+            if (meta.stack) error.stack = meta.stack;
+            Sentry.captureException(error, { extra: meta });
         } else {
-            Sentry.captureMessage(message, { level, extra: meta });
+            Sentry.captureMessage(message, { level: ({ warn: 'warning', trace: 'debug', internal: 'debug' })[level] || level, extra: meta });
         }
 
         callback();
     }
+    async flush() {
+        if (!await Sentry.flush(this.flushTimeout)) throw new Error('Sentry flush timed out');
+    }
+
+    // Flush without disabling the SDK shared with the host application.
+    close() { return this.flush(); }
+
 }
 
 module.exports = {

package/plugins/syslog.js

@@ -16,12 +16,12 @@ class SyslogTransport extends Transport {
             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,
+            facility: opts.facility ?? 1,
             appName: opts.appName || 'NTLogger',
             hostname: opts.hostname || require('os').hostname(),
         });
 
-        this.levels = {
+        this.severities = {
             internal: 7, // Debug level for internal logs
             trace: 7,    // Debug
             debug: 7,    // Debug
@@ -30,7 +30,7 @@ class SyslogTransport extends Transport {
             error: 3,    // Error
             fatal: 2,    // Critical
         };
-        this.logLevel = opts.level ? this.levels[opts.level] : this.levels.info;
+        this.logLevel = opts.level ? this.severities[opts.level] : this.severities.info;
 
         if (this.client.protocol === 'TCP' || this.client.protocol === 'TLS') {
             this.client.connect().catch(err => {
@@ -51,14 +51,12 @@ class SyslogTransport extends Transport {
 
         const { level, message, ...meta } = info;
 
-        if (this.levels[level] > this.logLevel) {
+        if (this.severities[level] > this.logLevel) {
             callback();
             return;
         }
 
-        this.client.send(this.levels[level], message, meta);
-
-        callback();
+        this.client.send(this.severities[level], message, meta, callback);
     }
 
     /**
@@ -74,8 +72,7 @@ class SyslogTransport extends Transport {
      * @returns {Promise<void>}
      */
     async close() {
-        this.client.close();
-        console.log('Closed Syslog client connection.');
+        await this.client.close();
     }
 }
 

package/plugins/teams.js

@@ -4,8 +4,7 @@
  */
 
 const Transport = require('winston-transport');
-const https = require('https');
-const { URL } = require('url');
+const { HttpDelivery } = require('./lib/httpDelivery');
 
 const levels = require('../lib/levels');
 
@@ -16,13 +15,9 @@ class TeamsTransport extends Transport {
         this.name = 'Teams Webhook Transport for NTLogger';
 
         this.webhookUrl = opts.webhookUrl;
+        this.delivery = new HttpDelivery(opts.webhookUrl, opts);
         this.strict = opts.strict || false;
 
-        // Retry logic with exponential back-off
-        // https://learn.microsoft.com/en-us/microsoftteams/platform/webhooks-and-connectors/how-to/connectors-using?tabs=cURL%2Ctext1#rate-limiting-for-connectors
-        this.maxRetries = opts.maxRetries || 3;
-        this.retryDelay = opts.retryDelay || 1000; // Initial delay for exponential back-off (in ms)
-
         try {
             // Set the log level
             this.level = opts.level || 'info';
@@ -38,10 +33,6 @@ class TeamsTransport extends Transport {
     }
 
     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
@@ -57,62 +48,14 @@ class TeamsTransport extends Transport {
             }
         }
 
-        const payload = this.createPayload(level, message, meta);
-        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 sendLog = (retryCount = 0) => {
-            const req = https.request(options, (res) => {
-                let responseContent = '';
-
-                res.on('data', (chunk) => {
-                    responseContent += chunk;
-                });
-
-                res.on('end', () => {
-                    if (responseContent.includes("Microsoft Teams endpoint returned HTTP error 429")) {
-                        console.error('Rate limit hit, retrying with exponential back-off...');
-                        if (retryCount < this.maxRetries) {
-                            setTimeout(() => {
-                                sendLog(retryCount + 1);
-                            }, this.retryDelay * Math.pow(2, retryCount)); // Exponential back-off
-                        } else {
-                            console.error('Max retries reached, log sending failed.');
-                            callback();
-                        }
-                    } else {
-                        callback();
-                    }
-                });
-            });
-
-            req.on('error', (e) => {
-                console.error(`Failed to send log to Teams: ${e.message}`);
-                if (retryCount < this.maxRetries) {
-                    console.log(`Retrying... (${retryCount + 1}/${this.maxRetries})`);
-                    setTimeout(() => {
-                        sendLog(retryCount + 1);
-                    }, this.retryDelay * Math.pow(2, retryCount));
-                } else {
-                    console.error('Max retries reached, log sending failed.');
-                    callback();
-                }
-            });
-
-            req.write(payload);
-            req.end();
-        };
+        try {
+            const payload = this.createPayload(level, message, meta);
+            if (this.closed) throw new Error('HTTP transport is closed');
+            await this.delivery.send(payload);
+            this.emit('logged', info);
+            callback();
+        } catch (error) { callback(error); }
 
-        sendLog();
     }
 
     createPayload(level, message, meta) {
@@ -132,7 +75,7 @@ class TeamsTransport extends Transport {
         const metaArray = Array.isArray(meta) ? meta : Object.values(meta);
 
         metaArray.forEach(item => {
-            if (typeof item !== 'object' || !item.type) {
+            if (!item || typeof item !== 'object' || !item.type) {
                 return;
             }
 
@@ -304,6 +247,12 @@ class TeamsTransport extends Transport {
             ]
         });
     }
+    flush() { return this.delivery.flush(); }
+    close() {
+        this.closed = true;
+        return this.delivery.flush();
+    }
+
 }
 
 module.exports = {