ntlogger 2.5.1 → 2.6.0

package/index.js

@@ -8,33 +8,39 @@
  * 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
+ * TODO: [Feature] Allow for custom log levels and colors
  */
 
 /**
  * Change Log:
+ * v2.6.0 - 08/15/2024:
+ * [FEATURE] Teams Plugin! Send logs to a Microsoft Teams channel using incoming webhooks.
+ *
+ * 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.
+ * [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).
+ * [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
+ * [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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ntlogger",
-  "version": "2.5.1",
+  "version": "2.6.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/NightSquawk/NightTimeLogger.git"
@@ -20,12 +20,13 @@
     "sentry compatible",
     "mysql compatible",
     "syslog compatible",
-    "discord compatible"
+    "discord compatible",
+    "teams compatible"
   ],
   "files": [
     "index.js",
     "lib/*.js",
-    "plugins/*.js"
+    "plugins/**/*"
   ],
   "license": "GPL-3.0",
   "dependencies": {

package/plugins/README.md

@@ -0,0 +1,295 @@
+# 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.
+
+## Available Plugins
+
+### 1. Discord
+**Description:** Sends logs to a Discord webhook, allowing you to receive log messages directly in a specified Discord channel.
+
+![Discord Plugin Output](https://github.com/NightSquawk/NightTimeLogger/blob/main/images/plugins/discord/pluginDiscordOutput.png)
+
+**Setup:**
+```javascript
+{
+    name: 'Discord',
+    config: {
+        webhookUrl: process.env.DISCORD_WEBHOOK_URL
+        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
+    }
+}
+```
+
+### 3. 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.
+
+![Syslog Plugin Output](https://github.com/NightSquawk/NightTimeLogger/blob/main/images/plugins/syslog/pluginSyslogOutput.png)
+
+
+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',
+    },
+}
+```
+
+### 6. Teams
+**Description:** Sends logs to a Microsoft Teams channel using an incoming webhook connector. This plugin allows you to receive log messages directly in a specified Teams channel.
+
+
+![Teams Mixed Object Plugin Output](https://github.com/NightSquawk/NightTimeLogger/blob/main/images/plugins/teams/pluginTeamsMixedOutput.png)
+
+
+**Setup:**
+
+``` javascript
+{
+    name: 'Teams',
+        config: {
+        webhookUrl: process.env.TEAMS_WEBHOOK_URL || "im not leaking my webhook url again",
+            level: process.env.LOG_LEVEL || "info",
+            strict: process.env.LOG_STRICT_LOGGING || true,
+    },
+},
+```
+
+This plugin supports additional configuration at the meta level. This allows you to create complex Teams messages with custom formatting and attachments..
+
+![Teams Simple Object Plugin Output](https://github.com/NightSquawk/NightTimeLogger/blob/main/images/plugins/teams/pluginTeamsSimpleOutput.png)
+
+```javascript
+log.info('Informational message',   [
+    { type: "location", district: "District 1", store: "Store 1", department: "Department 1"},
+    { type: "button", actionableBoxName: "First Button!", actionableURL: 'firstURL' },
+    { type: "button", actionableBoxName: "Second Button!", actionableURL: 'secondURL' },
+    // { type: "ping", mentionId: "example@example.com"}, // MUST BE A VALID USER EMAIL
+    // { type: "ping", mentionId: "example@example.com"}, // MUST BE A VALID USER EMAIL
+    { "type": "error", "message": "An unexpected error occurred.", "stack": "Error stack trace here" },
+    { "type": "metric", "name": "CPU Usage", "value": "85%" },
+    { "type": "metric", "name": "Request Count", "value": 123 },
+]);
+```
+
+It also supports the complete https://adaptivecards.io/explorer/AdaptiveCard.html schema.
+
+![Teams Raw Object Plugin Output](https://github.com/NightSquawk/NightTimeLogger/blob/main/images/plugins/teams/pluginTeamsRawOutput.png)
+
+```javascript
+log.error('Error message',[
+    { type: "raw", raw: {
+    body: [
+        { type: "TextBlock", text: "Raw Type" },
+        {
+            type: "ColumnSet",
+            columns: [
+                { type: "Column",
+                    items: [
+                        { "type": "TextBlock", "text": "Cats" },
+                        { type: "Image",url: "https://png.pngtree.com/png-clipart/20230511/ourmid/pngtree-isolated-cat-on-white-background-png-image_7094927.png", altText: "Cat", wrap: true, size: "auto", separator: true, },
+                    ]
+                },
+                { type: "Column",
+                    items: [
+                        { "type": "TextBlock", "text": "Dogs" },
+                        { type: "Image",url: "https://i.pinimg.com/originals/07/b2/40/07b240561cb656aec289df602e603bee.png", altText: "Dog", wrap: true, size: "auto", separator: true, },
+                    ]
+                },
+                { type: "Column",
+                    items: [
+                        { "type": "TextBlock", "text": "Birds" },
+                        { type: "Image",url: "https://cdn.pixabay.com/photo/2016/03/02/13/59/bird-1232416_1280.png", altText: "Bird", wrap: true, size: "auto", separator: true, }
+                    ]
+                },
+            ]
+        },
+        {
+            "type": "FactSet",
+            "facts": [
+                {
+                    "title": "Fact 1",
+                    "value": "Value 1"
+                },
+                {
+                    "title": "Fact 2",
+                    "value": "Value 2"
+                },
+                {
+                    "title": "Fact 3",
+                    "value": "Value 3"
+                },
+                {
+                    "title": "Fact 4",
+                    "value": "Value 5"
+                }
+            ]
+        },
+    ],
+    action: [
+        {
+            type: 'Action.OpenUrl',
+            title: "See more cats!",
+            url: 'https://www.google.com/search?q=cute%20cats&udm=2'
+        },
+        {
+            type: 'Action.OpenUrl',
+            title: "Chickens?",
+            url: 'https://www.google.com/search?q=chickens&udm=2'
+        },
+        {
+            "type": "Action.ShowCard",
+            "title": "Whats this?",
+            "card": {
+                "type": "AdaptiveCard",
+                "body": [
+                    {
+                        "type": "TextBlock",
+                        "text": "Cool?"
+                    }
+                ],
+                "actions": [
+                    {
+                        "type": "Action.Submit",
+                        "title": "You betcha!",
+                        "data": {
+                            "betcha": "true"
+                        }
+                    }
+                ]
+            }
+        }
+        ]},
+    },
+]);
+```
+
+### Example Logger Configuration
+Here is an example configuration for NightTimeLogger using multiple plugins:
+
+``` javascript
+
+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

@@ -8,7 +8,7 @@ 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
+const levels = require('../lib/levels');
 
 class DiscordTransport extends Transport {
     constructor(opts = {}) {

package/plugins/index.js

@@ -10,6 +10,7 @@ const plugins = {
     Jest    : require('./jest'),
     Syslog  : require('./syslog'),
     Discord : require('./discord'),
+    Teams   : require('./teams'),
     // WIP SMSMail : require('./smsMail'),
 };
 

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/teams.js

@@ -0,0 +1,311 @@
+/**
+ * @file /plugins/teams.js
+ * @description Sends logs to a Teams webhook.
+ */
+
+const Transport = require('winston-transport');
+const https = require('https');
+const { URL } = require('url');
+
+const levels = require('../lib/levels');
+
+class TeamsTransport extends Transport {
+    constructor(opts = {}) {
+        super(opts);
+
+        this.name = 'Teams Webhook Transport for NTLogger';
+
+        this.webhookUrl = opts.webhookUrl;
+        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';
+            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
+        }
+    }
+
+    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 = 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();
+        };
+
+        sendLog();
+    }
+
+    createPayload(level, message, meta) {
+        const actions = [];
+        const body = [
+            {
+                type: 'TextBlock',
+                text: `Log Level: ${level.toUpperCase()} - ${message}`,
+                weight: 'Bolder',
+                size: 'Medium'
+            }
+        ];
+        const mentions = [];
+        let mentionTextAdded = false;  // Track if the mention text block has been added
+
+        // Ensure meta is treated as an array
+        const metaArray = Array.isArray(meta) ? meta : Object.values(meta);
+
+        metaArray.forEach(item => {
+            if (typeof item !== 'object' || !item.type) {
+                return;
+            }
+
+            switch (item.type) {
+                case 'raw':
+                    if (item.raw && Array.isArray(item.raw.body)) {
+                        body.push(...item.raw.body);
+                    }
+                    if (item.raw && Array.isArray(item.raw.action)) {
+                        actions.push(...item.raw.action);
+                    }
+                    break;
+
+                case 'location':
+                    body.push({
+                        type: 'FactSet',
+                        facts: [
+                            { title: "District", value: item.district || "N/A" },
+                            { title: "Store", value: item.store || "N/A" },
+                            { title: "Department", value: item.department || "N/A" }
+                        ]
+                    });
+                    break;
+
+                case 'button':
+                    actions.push({
+                        type: 'Action.OpenUrl',
+                        title: item.actionableBoxName || "Button",
+                        url: item.actionableURL || '#'
+                    });
+                    break;
+
+                case 'ping':
+                    if (!mentionTextAdded) {
+                        body.push({
+                            type: 'Container',
+                            items: [
+                                {
+                                    type: 'TextBlock',
+                                    text: `<at>${item.mentionId}</at>`,
+                                    wrap: true
+                                }
+                            ]
+                        });
+                        mentionTextAdded = true;
+                    }
+                    mentions.push({
+                        type: 'mention',
+                        text: `<at>${item.mentionId}</at>`,
+                        mentioned: {
+                            id: item.mentionId
+                        }
+                    });
+                    break;
+
+                case 'error':
+                    body.push({
+                        type: 'TextBlock',
+                        text: `Error: ${item.message || "No message"}`,
+                        weight: 'Bolder',
+                        color: 'Attention',
+                        wrap: true
+                    });
+                    if (item.stack) {
+                        body.push({
+                            type: 'TextBlock',
+                            text: `Stack Trace: ${item.stack}`,
+                            color: 'Attention',
+                            wrap: true
+                        });
+                    }
+                    break;
+
+                case 'metric':
+                    body.push({
+                        type: 'FactSet',
+                        facts: [
+                            { title: item.name || "Metric", value: item.value || "N/A" }
+                        ]
+                    });
+                    break;
+
+                case 'ColumnSet':
+                    if (item.complexity === 'complex') {
+                        const columns = item.table[0].map((header, colIndex) => ({
+                            type: 'Column',
+                            items: [
+                                {
+                                    type: 'TextBlock',
+                                    text: header.text || header,
+                                    weight: 'Bolder',
+                                    separator: true,
+                                    wrap: true
+                                },
+                                ...item.table.slice(1).map(row => {
+                                    return row[colIndex]
+                                })
+                            ],
+                            width: 'auto'
+                        }));
+
+                        const columnSet = {
+                            type: 'ColumnSet',
+                            separator: true,
+                            columns: columns
+                        };
+
+                        body.push(columnSet);
+                        break;
+                    } else {
+                        const columns = item.table[0].map((header, colIndex) => ({
+                            type: 'Column',
+                            items: [
+                                {
+                                    type: 'TextBlock',
+                                    text: header,
+                                    weight: 'Bolder',
+                                    separator: true,
+                                    wrap: true
+                                },
+                                ...item.table.slice(1).map(row => ({
+                                    type: 'TextBlock',
+                                    text: row[colIndex],
+                                    separator: true,
+                                    wrap: true
+                                }))
+                            ],
+                            width: 'auto'
+                        }));
+
+                        const columnSet = {
+                            type: 'ColumnSet',
+                            separator: true,
+                            columns: columns
+                        };
+
+                        body.push(columnSet);
+                        break;
+                    }
+                    break;
+
+                default:
+                    body.push({
+                        type: 'TextBlock',
+                        text: `Unsupported type: ${item.type}`,
+                        color: 'Warning',
+                        wrap: true
+                    });
+                    break;
+            }
+        });
+
+        return JSON.stringify({
+            type: 'message',
+            attachments: [
+                {
+                    summary: `Log Level: ${level.toUpperCase()} - ${message}`,
+                    contentType: 'application/vnd.microsoft.card.adaptive',
+                    content: {
+                        $schema: 'http://adaptivecards.io/schemas/adaptive-card.json',
+                        version: '1.2',
+                        msteams: {
+                            entities: mentions
+                        },
+                        body: body,
+                        actions: actions
+                    }
+                }
+            ]
+        });
+    }
+}
+
+module.exports = {
+    transport: TeamsTransport,
+};