ntlogger 2.5.2 → 2.6.0

package/index.js

@@ -8,11 +8,14 @@
  * 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.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ntlogger",
-  "version": "2.5.2",
+  "version": "2.6.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/NightSquawk/NightTimeLogger.git"
@@ -20,7 +20,8 @@
     "sentry compatible",
     "mysql compatible",
     "syslog compatible",
-    "discord compatible"
+    "discord compatible",
+    "teams compatible"
   ],
   "files": [
     "index.js",

package/plugins/README.md

@@ -2,19 +2,19 @@
 
 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.
 
+![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 || 'https://ptb.discord.com/api/webhooks/1271901134663192658/FmzqFlzbIJ7NunR_4rpBkPLb4QQ5aHSNEbpT311su-QM3ZlGDI6sFuC4Ff0MF_TFrf3k',
+        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",
@@ -51,7 +51,7 @@ Setup:
 }
 ```
 
-### . MySQL
+### 3. MySQL
 Description: Stores logs in a MySQL database, allowing you to persist log messages and analyze them using SQL queries.
 
 Setup:
@@ -84,6 +84,9 @@ Setup:
 ### 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
@@ -101,11 +104,140 @@ Setup:
 }
 ```
 
+### 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
-Copy code
+
 let config = {
     level: 'internal',
     file: false,

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