ntlogger 2.4.0 → 2.5.2

package/index.js

@@ -4,16 +4,40 @@
  * 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.2 - 08/11/2024:
+ * [BUG] Fixed an issue where the /plugins/lib folder was not being pushed to npmjs.com.
+ *
+ * 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).
+ *
+ * [UPDATED] @sentry/node            ^8.17.0 --> ^8.25.0
+ * [UPDATED] mysql2                  ^3.10.2 --> ^3.11.0
+ * [UPDATED] winston                 ^3.13.1 --> ^3.14.1
+ * [UPDATED] @sentry/profiling-node  ^8.17.0 --> ^8.25.0
+ * [UPDATED] 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)
+ * [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

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.2",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/NightSquawk/NightTimeLogger.git"
@@ -18,24 +18,26 @@
     "log management",
     "logging utility",
     "sentry compatible",
-    "mysql compatible"
+    "mysql compatible",
+    "syslog compatible",
+    "discord compatible"
   ],
   "files": [
     "index.js",
     "lib/*.js",
-    "plugins/*.js"
+    "plugins/**/*"
   ],
   "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/README.md

@@ -0,0 +1,163 @@
+# NightTimeLogger Plugins
+
+NightTimeLogger is a powerful and flexible logging utility with various plugins to extend its functionality. This README provides an overview of the available plugins and instructions on how to set them up.
+
+![Discord Plugin Output](https://github.com/NightSquawk/NightTimeLogger/blob/main/images/plugins/pluginDiscordOutput.png)
+
+## Available Plugins
+
+### 1. Discord
+**Description:** Sends logs to a Discord webhook, allowing you to receive log messages directly in a specified Discord channel.
+
+**Setup:**
+```javascript
+{
+    name: 'Discord',
+    config: {
+        webhookUrl: process.env.DISCORD_WEBHOOK_URL || 'https://ptb.discord.com/api/webhooks/1271901134663192658/FmzqFlzbIJ7NunR_4rpBkPLb4QQ5aHSNEbpT311su-QM3ZlGDI6sFuC4Ff0MF_TFrf3k',
+        avatarUrl: process.env.DISCORD_AVATAR_URL || 'https://pbs.twimg.com/profile_images/997535493624508416/V7Ed1k2o_400x400.jpg',
+        username: process.env.DISCORD_USERNAME || 'NTLogger - Info',
+        level: "info",
+        strict: true,
+    },
+}
+```
+
+### 2. Sentry
+Description: Initializes the Sentry SDK for error tracking and defines a custom Winston transport for capturing and sending error logs to Sentry.
+
+Setup:
+
+``` javascript
+{
+    name: 'Sentry',
+    config: {
+        dsn: process.env.SENTRY_DSN || null,
+        release: process.env.SENTRY_RELEASE || null,
+        tracesSampleRate: 1.0,
+        profilesSampleRate: 1.0,
+        environment: process.env.NODE_ENV || 'development',
+        debug: false,
+        attachStacktrace: true,
+        integrations: [
+            nodeProfilingIntegration()
+        ],
+        serverName: null,
+        maxBreadcrumbs: 100,
+        autoSessionTracking: true,
+        sessionTracking: {},
+        tracesSampler: null
+    }
+}
+```
+
+### . MySQL
+Description: Stores logs in a MySQL database, allowing you to persist log messages and analyze them using SQL queries.
+
+Setup:
+
+``` javascript
+{
+    name: 'MySQL',
+    config: {
+        host: process.env.MYSQL_DB_HOST || 'localhost',
+        port: process.env.MYSQL_DB_PORT || 3306,
+        user: process.env.MYSQL_DB_USER || 'root',
+        password: process.env.MYSQL_DB_PASSWORD || '',
+        database: process.env.MYSQL_DB_NAME || 'test',
+        table: process.env.MYSQL_DB_TABLE || 'logs',
+        logLevel: process.env.LOG_LEVEL || 'info',
+    },
+}
+````
+### 4. Jest
+Description: Stores log messages in memory for testing purposes, particularly useful when running tests with Jest.
+
+Setup:
+
+``` javascript
+{
+    name: 'Jest',
+}
+```
+
+### 5. Syslog
+Description: Sends logs to a Syslog server using a custom Syslog client. This allows integration with traditional logging systems that rely on Syslog.
+
+Setup:
+
+``` javascript
+{
+    name: 'Syslog',
+    config: {
+        host: process.env.SYSLOG_HOST || 'localhost',
+        port: process.env.SYSLOG_PORT || 514,
+        protocol: process.env.SYSLOG_PROTOCOL || 'UDP', // Options: 'UDP', 'TCP', 'TLS'
+        rfc: process.env.SYSLOG_RFC || 'RFC-5424', // Options: 'RFC-3164', 'RFC-5424'
+        facility: process.env.SYSLOG_FACILITY || 1, // Local0
+        appName: process.env.SYSLOG_APP_NAME || 'MyApp',
+        level: 'info',
+    },
+}
+```
+
+### Example Logger Configuration
+Here is an example configuration for NightTimeLogger using multiple plugins:
+
+``` javascript
+Copy code
+let config = {
+    level: 'internal',
+    file: false,
+    plugins: [
+        {
+            name: 'Discord',
+            config: {
+                webhookUrl: process.env.DISCORD_WEBHOOK_URL,
+                avatarUrl: process.env.DISCORD_AVATAR_URL,
+                username: process.env.DISCORD_USERNAME || 'MyAppLogger',
+                level: 'info',
+                strict: false,
+            },
+        },
+        {
+            name: 'Sentry',
+            config: {
+                dsn: process.env.SENTRY_DSN,
+                release: process.env.SENTRY_RELEASE,
+                tracesSampleRate: 1.0,
+                environment: process.env.NODE_ENV || 'development',
+            },
+        },
+        {
+            name: 'MySQL',
+            config: {
+                host: process.env.MYSQL_DB_HOST,
+                port: process.env.MYSQL_DB_PORT || 3306,
+                user: process.env.MYSQL_DB_USER || 'root',
+                password: process.env.MYSQL_DB_PASSWORD || '',
+                database: process.env.MYSQL_DB_NAME || 'logs',
+                table: 'log_entries',
+            },
+        },
+        {
+            name: 'Jest',
+        },
+        {
+            name: 'Syslog',
+            config: {
+                host: process.env.SYSLOG_HOST || 'localhost',
+                port: process.env.SYSLOG_PORT || 514,
+                protocol: 'UDP',
+                facility: 1,
+                appName: 'MyAppLogger',
+            },
+        },
+    ],
+};
+```
+
+### Conclusion
+The NightTimeLogger is highly customizable and supports various plugins for different logging requirements. By leveraging these plugins, you can easily integrate logging into your existing infrastructure, whether it be storing logs in databases, sending them to monitoring tools like Sentry, or receiving alerts directly in Discord.
+
+For more details on each plugin, refer to the specific plugin files in the project.

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/lib/syslogClient.js

@@ -0,0 +1,112 @@
+/**
+ * @file /plugins/lib/syslogClient.js
+ * @description Custom Syslog client supporting UDP, TCP, and TLS transports with RFC-3164 and RFC-5424 formats.
+ */
+
+const net = require('net');
+const tls = require('tls');
+const dgram = require('dgram');
+
+class SyslogClient {
+    constructor(opts = {}) {
+        this.host = opts.host || 'localhost';
+        this.port = opts.port || 514;
+        this.protocol = opts.protocol || 'UDP'; // 'UDP', 'TCP', 'TLS'
+        this.rfc = opts.rfc || 'RFC-5424'; // 'RFC-3164', 'RFC-5424'
+        this.facility = opts.facility || 1; // Default to user-level messages
+        this.appName = opts.appName || 'NTLogger';
+        this.hostname = opts.hostname || require('os').hostname();
+        this.transport = null;
+
+        if (this.protocol === 'UDP') {
+            this.transport = dgram.createSocket('udp4');
+        } else if (this.protocol === 'TCP') {
+            this.transport = new net.Socket();
+        } else if (this.protocol === 'TLS') {
+            this.transport = new tls.TLSSocket();
+        }
+    }
+
+    /**
+     * Connects to the Syslog server if using TCP or TLS.
+     */
+    connect() {
+        if (this.protocol === 'TCP' || this.protocol === 'TLS') {
+            return new Promise((resolve, reject) => {
+                const options = { host: this.host, port: this.port };
+                const connectListener = () => resolve();
+                const errorListener = (err) => reject(err);
+
+                if (this.protocol === 'TCP') {
+                    this.transport.connect(options, connectListener).on('error', errorListener);
+                } else if (this.protocol === 'TLS') {
+                    this.transport.connect(options, connectListener).on('error', errorListener);
+                }
+            });
+        }
+    }
+
+    /**
+     * Sends a log message to the Syslog server.
+     * @param {string} severity - The severity level of the log.
+     * @param {string} message - The log message.
+     * @param {object} [meta] - Additional metadata for RFC-5424 structured data.
+     */
+    send(severity, message, meta = {}) {
+        const formattedMessage = this.formatMessage(severity, message, meta);
+        if (this.protocol === 'UDP') {
+            this.transport.send(Buffer.from(formattedMessage), 0, formattedMessage.length, this.port, this.host);
+        } else {
+            this.transport.write(formattedMessage + '\n');
+        }
+    }
+
+    /**
+     * Formats the Syslog message according to the selected RFC standard.
+     * @param {string} severity - The severity level of the log.
+     * @param {string} message - The log message.
+     * @param {object} [meta] - Additional metadata for RFC-5424 structured data.
+     * @returns {string} - The formatted Syslog message.
+     */
+    formatMessage(severity, message, meta) {
+        const timestamp = new Date().toISOString();
+        const priority = (this.facility * 8) + severity;
+
+        if (this.rfc === 'RFC-3164') {
+            return `<${priority}>${timestamp} ${this.hostname} ${this.appName}: ${message}`;
+        } else if (this.rfc === 'RFC-5424') {
+            const structuredData = this.formatStructuredData(meta.structuredData || {});
+            return `<${priority}>1 ${timestamp} ${this.hostname} ${this.appName} - - ${structuredData} ${message}`;
+        }
+    }
+
+    /**
+     * Formats the structured data for RFC-5424.
+     * @param {object} structuredData - The structured data to include in the log message.
+     * @returns {string} - The formatted structured data string.
+     */
+    formatStructuredData(structuredData) {
+        let sdString = '';
+        for (const [key, value] of Object.entries(structuredData)) {
+            sdString += `[${key}`;
+            for (const [param, val] of Object.entries(value)) {
+                sdString += ` ${param}="${val}"`;
+            }
+            sdString += ']';
+        }
+        return sdString || '-';
+    }
+
+    /**
+     * Closes the transport connection.
+     */
+    close() {
+        if (this.transport && (this.protocol === 'TCP' || this.protocol === 'TLS')) {
+            this.transport.end();
+        } else if (this.protocol === 'UDP') {
+            this.transport.close();
+        }
+    }
+}
+
+module.exports = SyslogClient;

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