ntlogger 2.3.1 → 2.5.1

package/index.js

@@ -1,12 +1,41 @@
 /*!
  * ntlogger
- * Copyright(c) 2024 Kevin R
+ * Copyright(c) 2024 KR
  * 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
+ * [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/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, compilePluginComponents} = 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;
@@ -124,7 +112,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 +151,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 +188,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/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.3.1",
+  "version": "2.5.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/NightSquawk/NightTimeLogger.git"
@@ -18,21 +18,28 @@
     "log management",
     "logging utility",
     "sentry compatible",
-    "mysql compatible"
+    "mysql compatible",
+    "syslog compatible",
+    "discord compatible"
   ],
   "files": [
     "index.js",
-    "lib/*.js"
+    "lib/*.js",
+    "plugins/*.js"
   ],
   "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",
-    "dotenv": "^16.4.5"
+    "@sentry/profiling-node": "^8.25.0",
+    "dotenv": "^16.4.5",
+    "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

@@ -0,0 +1,78 @@
+/**
+ * @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'),
+    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(', ')}`);
+    }
+}
+
+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');
+            }
+
+            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);
+            }
+        }
+    } catch (err) {
+        console.error('Error initializing plugins:', err.message);
+        console.error(err.stack);
+    }
+
+    return pluginTransports;
+}
+
+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,
+};

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,
+};