monten 0.1.3 → 0.1.4

package/dist/logger/format.js

@@ -1,6 +1,115 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatLog = formatLog;
+// ANSI color codes
+const colors = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+    bright: '\x1b[1m',
+};
+function colorize(text, color) {
+    return `${colors[color]}${text}${colors.reset}`;
+}
+function getLevelColor(level) {
+    switch (level) {
+        case 'error':
+            return 'red';
+        case 'warn':
+            return 'yellow';
+        case 'info':
+            return 'green';
+        case 'debug':
+            return 'cyan';
+        default:
+            return 'reset';
+    }
+}
+function getLatencyColor(latencyMs) {
+    if (!latencyMs)
+        return 'reset';
+    if (latencyMs > 1000)
+        return 'red'; // > 1s = too slow
+    if (latencyMs > 300)
+        return 'yellow'; // > 300ms = moderate
+    return 'green'; // fast
+}
+function formatTimestamp(timestamp) {
+    const date = new Date(timestamp);
+    return date.toISOString();
+}
 function formatLog(entry) {
-    return JSON.stringify(entry);
+    const timestamp = colorize(formatTimestamp(entry.timestamp), 'gray');
+    const level = colorize(entry.level.toUpperCase().padEnd(5), getLevelColor(entry.level));
+    const service = colorize(`[${entry.serviceName}]`, 'cyan');
+    const message = colorize(entry.message, 'bright');
+    let output = `${timestamp} ${level} ${service}`;
+    if (entry.requestId) {
+        output += ` ${colorize(`reqId:${entry.requestId.slice(0, 8)}`, 'magenta')}`;
+    }
+    output += ` ${message}`;
+    if (entry.fields) {
+        const fields = entry.fields;
+        // Special handling for HTTP request logs
+        if (fields.method && fields.path) {
+            output += `\n  ${colorize('→', 'gray')} ${colorize(fields.method, 'blue')} ${fields.path}`;
+            if (fields.statusCode) {
+                const statusColor = fields.statusCode >= 500
+                    ? 'red'
+                    : fields.statusCode >= 400
+                        ? 'yellow'
+                        : 'green';
+                output += ` ${colorize(`[${fields.statusCode}]`, statusColor)}`;
+            }
+            if (fields.latencyMs !== undefined) {
+                const latencyColor = getLatencyColor(fields.latencyMs);
+                output += ` ${colorize(`${fields.latencyMs}ms`, latencyColor)}`;
+            }
+            if (fields.dbTimeMs !== undefined) {
+                const dbColor = getLatencyColor(fields.dbTimeMs);
+                output += ` ${colorize(`(db: ${fields.dbTimeMs}ms)`, dbColor)}`;
+            }
+        }
+        // Special handling for metrics flush
+        else if (fields.metrics && Array.isArray(fields.metrics)) {
+            output += `\n  ${colorize('→', 'gray')} Flushed ${colorize(String(fields.count), 'yellow')} metrics`;
+            fields.metrics.forEach((metric, idx) => {
+                if (metric.type === 'http_request') {
+                    const latencyColor = getLatencyColor(metric.latencyMs);
+                    const statusColor = metric.statusCode >= 500
+                        ? 'red'
+                        : metric.statusCode >= 400
+                            ? 'yellow'
+                            : 'green';
+                    output += `\n    ${colorize(`${idx + 1}.`, 'gray')} ${colorize(metric.method, 'blue')} ${metric.path} `;
+                    output += `${colorize(`[${metric.statusCode}]`, statusColor)} `;
+                    output += `${colorize(`${metric.latencyMs}ms`, latencyColor)}`;
+                }
+            });
+        }
+        // Generic field display
+        else {
+            const fieldEntries = Object.entries(fields);
+            if (fieldEntries.length > 0) {
+                output +=
+                    '\n  ' +
+                        fieldEntries
+                            .map(([key, value]) => {
+                            let valueColor = 'reset';
+                            // Color numeric values based on size
+                            if (typeof value === 'number') {
+                                valueColor = getLatencyColor(value);
+                            }
+                            return `${colorize(key, 'gray')}: ${colorize(String(value), valueColor)}`;
+                        })
+                            .join(', ');
+            }
+        }
+    }
+    return output;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monten",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Lightweight observability utilities for Express-based Node.js backends (experimental).",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",