ntlogger 2.8.2 → 2.9.1

package/lib/logger.js

@@ -86,15 +86,26 @@ const colorRgb = {
 };
 const colorAnsiCode = `\x1b[38;2;${colorRgb.r};${colorRgb.g};${colorRgb.b}m`;
 
+// Helper function to strip ANSI codes from a string
+function stripAnsiCodes(str) {
+    if (typeof str !== 'string') {
+        return str;
+    }
+    // Remove ANSI escape codes: \u001b[ followed by numbers, semicolons, and ending with 'm'
+    return str.replace(/\u001b\[[0-9;]*m/g, '');
+}
+
 // Custom console formatter with random color for session ID and set color for log level and message
 const consoleFormatter = (config) => winston.format.combine(
     winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
     winston.format.printf(({ timestamp, level, message, ...meta }) => {
         const shortSessionId = sessionId.substring(sessionId.length - 6); // Get the last 6 characters of the session ID
-        const paddedLevel = level.padEnd(8); // Pad the level to ensure consistent spacing
+        // Strip ANSI codes and normalize the level string before padding to ensure consistent alignment
+        const cleanLevel = stripAnsiCodes(String(level)).trim();
+        const paddedLevel = cleanLevel.padEnd(8); // Pad the level to ensure consistent spacing
 
         // Retrieve the corresponding ANSI color code for the level from custom settings
-        const levelColor = customSettings.colors[level] || ''; // Default to no color if the level is unknown
+        const levelColor = customSettings.colors[cleanLevel] || customSettings.colors[level] || ''; // Default to no color if the level is unknown
         const resetCode = '\x1b[0m';
 
         // Build location string (optionally include filePath if reportPath is enabled)
@@ -113,7 +124,9 @@ const consoleFormatter = (config) => winston.format.combine(
 const fileFormatter = (config) => winston.format.combine(
     winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
     winston.format.printf(({ timestamp, level, message, ...meta }) => {
-        const paddedLevel = level.padEnd(8); // Pad the level to ensure consistent spacing
+        // Strip ANSI codes and normalize the level string before padding to ensure consistent alignment
+        const cleanLevel = stripAnsiCodes(String(level)).trim();
+        const paddedLevel = cleanLevel.padEnd(8); // Pad the level to ensure consistent spacing
 
         // Build location string (optionally include filePath if reportPath is enabled)
         let locationStr = meta.location || 'Unknown';
@@ -489,11 +502,39 @@ const createLoggerInstance = (location = "Unknown", config = {}, transports, par
 const logger = (location = "Unknown", config = {}) => {
     // Check if a logger for the given location already exists
     if (loggerInstances.has(location) && !config.skipCache) {
-        // If it does, grab the existing logger instance from the map
-        const logger = loggerInstances.get(location);
-
-        logger.internal(`Logger instance retrieved for location ${location}`); // Log the retrieval of the logger instance
-        return logger;
+        const cachedLogger = loggerInstances.get(location);
+        
+        // Check if config has advanced features (sampling, rateLimit, deduplication)
+        // If so, we need to recreate the logger to apply these features
+        const hasAdvancedFeatures = (
+            (config.sampling && Object.keys(config.sampling).length > 0) ||
+            (config.rateLimit && Object.keys(config.rateLimit).length > 0) ||
+            (config.deduplication && config.deduplication.enabled === true)
+        );
+        
+        // If advanced features are requested but logger was cached without them, recreate it
+        if (hasAdvancedFeatures) {
+            // Check if cached logger has these features by checking if getStats returns non-null values
+            const stats = cachedLogger.getStats ? cachedLogger.getStats() : null;
+            const cachedHasFeatures = stats && (
+                (stats.sampling !== null) ||
+                (stats.deduplication !== null)
+            );
+            
+            // If cached logger doesn't have the features but config requests them, recreate
+            if (!cachedHasFeatures) {
+                // Remove from cache and recreate with new config
+                loggerInstances.delete(location);
+            } else {
+                // Cached logger has features, return it
+                cachedLogger.internal(`Logger instance retrieved for location ${location}`);
+                return cachedLogger;
+            }
+        } else {
+            // No advanced features requested, return cached logger
+            cachedLogger.internal(`Logger instance retrieved for location ${location}`);
+            return cachedLogger;
+        }
     }
 
     let transports = null;

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "ntlogger",
-  "version": "2.8.2",
+  "version": "2.9.1",
   "description": "A Custom Ready-To-Go Logging Wrapper Built on Winston",
   "keywords": [
     "custom logger",
     "discord compatible",
+    "fastify logger",
     "log management",
     "logger",
     "logger wrapper",
     "logging",
     "logging utility",
     "mysql compatible",
+    "pino transport",
     "sentry compatible",
     "syslog compatible",
     "teams compatible",
@@ -24,26 +26,43 @@
     "type": "git",
     "url": "git+https://github.com/NightSquawk/NightTimeLogger.git"
   },
+  "exports": {
+    ".": "./index.js",
+    "./pino": "./pino.js"
+  },
   "files": [
     "index.js",
     "index.d.ts",
+    "pino.js",
     "lib/*.js",
-    "plugins/**/*"
+    "plugins/**/*",
+    "transports/"
   ],
   "scripts": {
     "test": "jest"
   },
   "dependencies": {
-    "@sentry/node": "^10.25.0",
-    "mysql2": "^3.15.3",
-    "pg": "^8.16.3",
-    "winston": "^3.18.3",
+    "@sentry/node": "^10.34.0",
+    "mysql2": "^3.16.1",
+    "pg": "^8.17.1",
+    "winston": "^3.19.0",
     "winston-transport": "^4.9.0"
   },
+  "optionalDependencies": {
+    "split2": "^4.2.0"
+  },
+  "peerDependencies": {
+    "pino": ">=8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "pino": {
+      "optional": true
+    }
+  },
   "devDependencies": {
-    "@sentry/profiling-node": "^10.25.0",
-    "dotenv": "^17.2.3",
-    "jest": "^30.2.0"
+    "@sentry/profiling-node": "^10.38.0",
+    "dotenv": "^17.2.4",
+    "jest": "^30.3.0"
   },
   "overrides": {
     "glob": "^11.1.0"

package/pino.js

@@ -0,0 +1,36 @@
+'use strict';
+
+// Re-export the transport for use with Pino's transport option
+// Usage: transport: { target: 'ntlogger/pino' }
+module.exports = require('./transports/pino');
+
+// Helper for creating a pre-configured Pino instance
+module.exports.createLogger = function (opts = {}) {
+  const pino = require('pino');
+  const path = require('path');
+
+  const isDev = process.env.NODE_ENV !== 'production';
+  const level = opts.level || process.env.LOG_LEVEL || (isDev ? 'debug' : 'info');
+
+  const loggerOpts = {
+    level,
+  };
+
+  // Add module name as a mixin if provided
+  if (opts.module) {
+    loggerOpts.mixin = () => ({ module: opts.module });
+  }
+
+  // In dev: use NTL formatter. In production: plain JSON.
+  if (isDev) {
+    loggerOpts.transport = {
+      target: path.join(__dirname, 'transports', 'pino.js'),
+      options: {
+        defaultModule: opts.module || opts.defaultModule,
+        colorize: opts.colorize,
+      },
+    };
+  }
+
+  return pino(loggerOpts);
+};

package/transports/pino.js

@@ -0,0 +1,172 @@
+'use strict';
+
+const split = require('split2');
+const colors = require('../lib/colors');
+
+const levelColors = colors.console;
+
+// Utility ANSI codes not exported by lib/colors.js
+const RESET = '\x1b[0m';
+const DIM = '\x1b[2m';
+const GREY = '\x1b[90m';
+const GREEN = '\x1b[32m';
+const MAGENTA = '\x1b[35m';
+const CYAN = '\x1b[36m';
+
+/**
+ * Map Pino numeric levels to NTL level names and colors.
+ *
+ * Pino levels: 10=trace, 20=debug, 30=info, 40=warn, 50=error, 60=fatal
+ * NTL levels:  trace(5), debug(4), info(3), warn(2), error(1), fatal(0)
+ *
+ * We only need the display names and colors here, not NTL's numeric ordering.
+ */
+const PINO_LEVEL_MAP = {
+  10: { name: 'trace', color: levelColors.trace },
+  20: { name: 'debug', color: levelColors.debug },
+  30: { name: 'info',  color: levelColors.info },
+  40: { name: 'warn',  color: levelColors.warn },
+  50: { name: 'error', color: levelColors.error },
+  60: { name: 'fatal', color: levelColors.fatal },
+};
+
+// Status code colors
+const STATUS_COLORS = {
+  2: GREEN,
+  3: CYAN,
+  4: '\x1b[33m',
+  5: '\x1b[31m',
+};
+
+/**
+ * Format a timestamp to YYYY-MM-DD HH:mm:ss (NTL style).
+ */
+function formatTimestamp(epoch) {
+  const d = new Date(epoch);
+  const Y = d.getFullYear();
+  const M = String(d.getMonth() + 1).padStart(2, '0');
+  const D = String(d.getDate()).padStart(2, '0');
+  const h = String(d.getHours()).padStart(2, '0');
+  const m = String(d.getMinutes()).padStart(2, '0');
+  const s = String(d.getSeconds()).padStart(2, '0');
+  return `${Y}-${M}-${D} ${h}:${m}:${s}`;
+}
+
+/**
+ * Pad level name to 8 chars (NTL style: [info    ], [error   ], [warn    ]).
+ */
+function padLevel(name) {
+  return name.padEnd(8);
+}
+
+/**
+ * Format a single Pino log object into an NTL-style string.
+ *
+ * @param {Object} obj - Pino JSON log object
+ * @param {Object} opts - Transport options
+ * @returns {string} Formatted log line
+ */
+function formatLine(obj, opts = {}) {
+  const parts = [];
+
+  // 1. Timestamp
+  const ts = formatTimestamp(obj.time);
+  parts.push(`${GREY}${ts}${RESET}`);
+
+  // 2. Level — [info    ] padded and colored
+  const levelInfo = PINO_LEVEL_MAP[obj.level] || { name: 'unknown', color: '' };
+  parts.push(`${levelInfo.color}[${padLevel(levelInfo.name)}]${RESET}`);
+
+  // 3. Request/Session ID — [ID: xxx]
+  const id = obj.reqId || obj.requestId || obj.sessionId || null;
+  if (id) {
+    parts.push(`${MAGENTA}[ID: ${id}]${RESET}`);
+  }
+
+  // 4. Location/Module label — [ModuleName]
+  const location = obj.module || obj.location || obj.name || opts.defaultModule || null;
+  if (location) {
+    parts.push(`${GREEN}[${location}]${RESET}:`);
+  }
+
+  // 5. Message
+  let msg = obj.msg || obj.message || '';
+
+  // 6. HTTP request completion — format as: METHOD /path — STATUS (TIMEms)
+  if (obj.res && obj.responseTime !== undefined) {
+    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;
+
+    if (method && url) {
+      msg = `${method} ${url} — ${statusColor}${status}${RESET} ${GREY}(${time}ms)${RESET}`;
+    } else if (msg) {
+      msg = `${msg} — ${statusColor}${status}${RESET} ${GREY}(${time}ms)${RESET}`;
+    } else {
+      msg = `${statusColor}${status}${RESET} ${GREY}(${time}ms)${RESET}`;
+    }
+  }
+
+  // 7. Error stack traces
+  if (obj.err) {
+    const stack = obj.err.stack || obj.err.message || '';
+    if (stack) {
+      msg += `\n${levelInfo.color}${stack}${RESET}`;
+    }
+  }
+
+  parts.push(msg);
+
+  return parts.join(' ');
+}
+
+/**
+ * NightTimeLogger Pino Transport.
+ *
+ * Usage with Fastify:
+ *   const app = Fastify({
+ *     logger: {
+ *       transport: {
+ *         target: 'ntlogger/pino',
+ *         options: { defaultModule: 'API' }
+ *       }
+ *     }
+ *   });
+ *
+ * Usage with plain Pino:
+ *   const pino = require('pino');
+ *   const logger = pino({
+ *     transport: {
+ *       target: 'ntlogger/pino',
+ *       options: { defaultModule: 'MyApp' }
+ *     }
+ *   });
+ *
+ * Options:
+ *   - defaultModule: Default location label when obj.module is not set (e.g., 'API')
+ *
+ * @param {Object} opts - Transport options
+ */
+module.exports = function (opts = {}) {
+  return split(function (line) {
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      process.stdout.write(line + '\n');
+      return;
+    }
+    const formatted = formatLine(obj, opts);
+    process.stdout.write(formatted + '\n');
+  });
+};
+
+// Export internals for testing
+module.exports.formatLine = formatLine;
+module.exports.formatTimestamp = formatTimestamp;
+module.exports.padLevel = padLevel;