ntlogger 2.9.1 → 3.0.0

package/plugins/teams.js

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

package/transports/pino.js

@@ -1,6 +1,17 @@
 'use strict';
 
 const split = require('split2');
+const { isMainThread } = require('worker_threads');
+const fs = require('fs');
+
+function writeOutput(line) {
+  if (isMainThread) return process.stdout.write(line);
+  // ThreadStream.end() can block the parent on Atomics.wait. Worker stdout
+  // callbacks need that parent's event loop, so write to the fd directly.
+  const bytes = Buffer.from(line);
+  let offset = 0;
+  while (offset < bytes.length) offset += fs.writeSync(1, bytes, offset, bytes.length - offset);
+}
 const colors = require('../lib/colors');
 
 const levelColors = colors.console;
@@ -38,6 +49,31 @@ const STATUS_COLORS = {
   5: '\x1b[31m',
 };
 
+/**
+ * Structured context fields rendered as a compact `{k=v ...}` suffix right
+ * after the module label. Order here is the render order.
+ */
+const CONTEXT_KEYS = [
+  'tenantId',
+  'userId',
+  'correlationId',
+  'traceId',
+  'spanId',
+  'jobId',
+  'agentUuid',
+  'commandId',
+];
+
+/**
+ * Boilerplate messages emitted by pino-http/Fastify for the request-start
+ * line. They carry no information once the method and URL are rendered.
+ */
+const GENERIC_REQUEST_MESSAGES = new Set(['incoming request', 'request received']);
+
+// Defaults for the in-flight request map. Both are overridable per transport.
+const DEFAULT_MAX_INFLIGHT_REQUESTS = 1000;
+const DEFAULT_INFLIGHT_TTL_MS = 60000;
+
 /**
  * Format a timestamp to YYYY-MM-DD HH:mm:ss (NTL style).
  */
@@ -59,14 +95,108 @@ function padLevel(name) {
   return name.padEnd(8);
 }
 
+/**
+ * Bounded map of in-flight HTTP requests.
+ *
+ * pino-http/Fastify split a request across two lines: the request-start line
+ * carries `req.method` / `req.url`, the completion line carries only
+ * `res.statusCode` and `responseTime`. Remembering the start line lets the
+ * completion line render `METHOD /path — STATUS (Nms)`.
+ *
+ * A request that never completes (aborted socket, crashed handler) would leak
+ * an entry forever, so entries expire by age and the map is capped. Both
+ * sweeps are lazy — no timers, nothing that can keep a process alive.
+ *
+ * @param {Object} opts
+ * @param {number} [opts.maxInflightRequests=1000] Hard cap on tracked requests.
+ * @param {number} [opts.inflightTtlMs=60000] Max age of a tracked request.
+ */
+function createRequestTracker(opts = {}) {
+  const max = Number.isFinite(opts.maxInflightRequests) && opts.maxInflightRequests > 0
+    ? Math.floor(opts.maxInflightRequests)
+    : DEFAULT_MAX_INFLIGHT_REQUESTS;
+  const ttl = Number.isFinite(opts.inflightTtlMs) && opts.inflightTtlMs > 0
+    ? opts.inflightTtlMs
+    : DEFAULT_INFLIGHT_TTL_MS;
+
+  // Map preserves insertion order, and entries are always (re)inserted at the
+  // tail, so the head is always the oldest entry.
+  const entries = new Map();
+
+  function prune(now = Date.now()) {
+    for (const [key, value] of entries) {
+      if (now - value.at < ttl) break;
+      entries.delete(key);
+    }
+    while (entries.size > max) {
+      const oldest = entries.keys().next();
+      if (oldest.done) break;
+      entries.delete(oldest.value);
+    }
+  }
+
+  return {
+    /**
+     * Remember an in-flight request. Re-tracking an id refreshes its position.
+     */
+    track(id, method, url, now = Date.now()) {
+      if (!id) return;
+      if (entries.has(id)) entries.delete(id);
+      entries.set(id, { method: method || '', url: url || '', at: now });
+      prune(now);
+    },
+    /**
+     * Look up and forget a tracked request.
+     * @returns {{method: string, url: string}|null}
+     */
+    take(id) {
+      if (!id) return null;
+      const entry = entries.get(id);
+      if (!entry) return null;
+      entries.delete(id);
+      return { method: entry.method, url: entry.url };
+    },
+    prune,
+    get size() {
+      return entries.size;
+    },
+    get maxInflightRequests() {
+      return max;
+    },
+    get inflightTtlMs() {
+      return ttl;
+    },
+  };
+}
+
+/**
+ * Render the structured context suffix, e.g. `{tenantId=t1 correlationId=c9}`.
+ * Only keys that are actually present (and non-empty) are rendered.
+ *
+ * @returns {string} Dim-wrapped suffix, or '' when no context keys are present.
+ */
+function formatContext(obj) {
+  const pairs = [];
+  for (const key of CONTEXT_KEYS) {
+    const value = obj[key];
+    if (value === undefined || value === null || value === '') continue;
+    pairs.push(`${key}=${typeof value === 'object' ? JSON.stringify(value) : value}`);
+  }
+  if (pairs.length === 0) return '';
+  return `${DIM}{${pairs.join(' ')}}${RESET}`;
+}
+
 /**
  * Format a single Pino log object into an NTL-style string.
  *
  * @param {Object} obj - Pino JSON log object
  * @param {Object} opts - Transport options
+ * @param {Object} [tracker] - Optional in-flight request tracker (see
+ *   createRequestTracker). When omitted, request/response pairing is skipped
+ *   and only inline `req` data is used.
  * @returns {string} Formatted log line
  */
-function formatLine(obj, opts = {}) {
+function formatLine(obj, opts = {}, tracker = null) {
   const parts = [];
 
   // 1. Timestamp
@@ -89,20 +219,45 @@ function formatLine(obj, opts = {}) {
     parts.push(`${GREEN}[${location}]${RESET}:`);
   }
 
-  // 5. Message
+  // 5. Structured context — {tenantId=… correlationId=…}
+  const context = formatContext(obj);
+  if (context) {
+    parts.push(context);
+  }
+
+  // 6. Message
   let msg = obj.msg || obj.message || '';
 
-  // 6. HTTP request completion — format as: METHOD /path — STATUS (TIMEms)
-  if (obj.res && obj.responseTime !== undefined) {
+  if (obj.req && !obj.res) {
+    // Request start — remember it so the completion line can name the route.
+    const method = (obj.req.method) || '';
+    const url = (obj.req.url) || '';
+    if (tracker && (method || url)) {
+      tracker.track(id, method, url);
+    }
+    if (method && url) {
+      msg = GENERIC_REQUEST_MESSAGES.has(msg) || !msg
+        ? `${method} ${url}`
+        : `${method} ${url} ${GREY}—${RESET} ${msg}`;
+    }
+  } else if (obj.res && obj.responseTime !== undefined) {
+    // 7. HTTP request completion — format as: METHOD /path — STATUS (TIMEms)
     const status = obj.res.statusCode;
     const statusGroup = Math.floor(status / 100);
     const statusColor = STATUS_COLORS[statusGroup] || '';
-    const method = (obj.req && obj.req.method) || '';
-    const url = (obj.req && obj.req.url) || '';
     const time = typeof obj.responseTime === 'number'
       ? obj.responseTime.toFixed(1)
       : obj.responseTime;
 
+    // Inline req wins; otherwise fall back to the tracked request-start line.
+    let method = (obj.req && obj.req.method) || '';
+    let url = (obj.req && obj.req.url) || '';
+    const tracked = tracker ? tracker.take(id) : null;
+    if (!(method && url) && tracked) {
+      method = tracked.method;
+      url = tracked.url;
+    }
+
     if (method && url) {
       msg = `${method} ${url} — ${statusColor}${status}${RESET} ${GREY}(${time}ms)${RESET}`;
     } else if (msg) {
@@ -112,7 +267,7 @@ function formatLine(obj, opts = {}) {
     }
   }
 
-  // 7. Error stack traces
+  // 8. Error stack traces
   if (obj.err) {
     const stack = obj.err.stack || obj.err.message || '';
     if (stack) {
@@ -122,7 +277,8 @@ function formatLine(obj, opts = {}) {
 
   parts.push(msg);
 
-  return parts.join(' ');
+  const line = parts.join(' ');
+  return opts.colorize === false ? line.replace(/\x1b\[[0-9;]*m/g, '') : line;
 }
 
 /**
@@ -149,24 +305,44 @@ function formatLine(obj, opts = {}) {
  *
  * Options:
  *   - defaultModule: Default location label when obj.module is not set (e.g., 'API')
+ *   - colorize: Set to false to strip all ANSI codes from the output
+ *   - maxInflightRequests: Cap on remembered in-flight requests (default 1000)
+ *   - inflightTtlMs: Max age of a remembered in-flight request (default 60000)
  *
  * @param {Object} opts - Transport options
  */
 module.exports = function (opts = {}) {
-  return split(function (line) {
+  const tracker = createRequestTracker(opts);
+
+  const stream = split(function (line) {
     let obj;
     try {
       obj = JSON.parse(line);
     } catch {
-      process.stdout.write(line + '\n');
+      writeOutput(line + '\n');
       return;
     }
-    const formatted = formatLine(obj, opts);
-    process.stdout.write(formatted + '\n');
+    const formatted = formatLine(obj, opts, tracker);
+    writeOutput(formatted + '\n');
+  });
+  // The worker consumes only the writable side; drain the readable side so
+  // split2 can emit end/close and let Pino terminate its worker.
+  const flush = stream._flush.bind(stream);
+  stream._flush = callback => flush(error => {
+    if (error) return callback(error);
+    // stdout is asynchronous in a Pino worker. Wait for preceding writes before
+    // signalling completion, otherwise worker shutdown can discard the output.
+    if (isMainThread) process.stdout.write('', callback);
+    else callback();
   });
+  stream.resume();
+  return stream;
 };
 
 // Export internals for testing
 module.exports.formatLine = formatLine;
 module.exports.formatTimestamp = formatTimestamp;
 module.exports.padLevel = padLevel;
+module.exports.formatContext = formatContext;
+module.exports.createRequestTracker = createRequestTracker;
+module.exports.CONTEXT_KEYS = CONTEXT_KEYS;