monten 0.1.3 → 0.1.5

package/README.md

@@ -71,7 +71,7 @@ pnpm add monten
 
 ```ts
 import express from 'express'
-import { initObservability, httpObservabilityMiddleware } from 'monten'
+import { initObservability, monten } from 'monten'
 
 const app = express()
 
@@ -83,7 +83,7 @@ initObservability({
 })
 
 // Add middleware (single line!)
-app.use(httpObservabilityMiddleware())
+app.use(monten())
 
 app.get('/health', (_req, res) => {
   res.status(200).json({ ok: true })
@@ -132,12 +132,12 @@ initObservability({
 })
 ```
 
-### `httpObservabilityMiddleware()`
+### `monten()`
 
 Express middleware that captures request timing, errors, and emits logs/metrics.
 
 ```ts
-app.use(httpObservabilityMiddleware())
+app.use(monten())
 ```
 
 ### `withDbTiming<T>(fn: () => Promise<T>): Promise<T>`
@@ -175,7 +175,7 @@ Each request produces a structured JSON log entry:
 ┌─────────────────────────────────────────────────────────┐
 │                    Express App                          │
 ├─────────────────────────────────────────────────────────┤
-│  httpObservabilityMiddleware()                          │
+│  monten()                                              │
 │  ┌───────────────────────────────────────────────────┐  │
 │  │  AsyncLocalStorage Context                        │  │
 │  │  • requestId                                      │  │
@@ -201,7 +201,7 @@ Each request produces a structured JSON log entry:
 This library is designed to be fully removable:
 
 1. Remove `initObservability()` call
-2. Remove `app.use(httpObservabilityMiddleware())`
+2. Remove `app.use(monten())`
 3. Remove `withDbTiming()` wrappers (just call the inner function directly)
 
 Your application will continue to function normally.

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 import type { ObservabilityInitConfig } from './types';
 export declare function initObservability(config: ObservabilityInitConfig): void;
-export declare function httpObservabilityMiddleware(): (req: any, res: any, next: (err?: any) => void) => void;
+export declare function monten(): (req: any, res: any, next: (err?: any) => void) => void;
 export declare function withDbTiming<T>(fn: () => Promise<T>): Promise<T>;

package/dist/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initObservability = initObservability;
-exports.httpObservabilityMiddleware = httpObservabilityMiddleware;
+exports.monten = monten;
 exports.withDbTiming = withDbTiming;
 const observability_config_1 = require("./config/observability.config");
 const httpMiddleware_1 = require("./middleware/httpMiddleware");
@@ -9,8 +9,8 @@ const dbTimer_1 = require("./db/dbTimer");
 function initObservability(config) {
     (0, observability_config_1.initObservabilityInternal)(config);
 }
-function httpObservabilityMiddleware() {
-    return (0, httpMiddleware_1.httpObservabilityMiddleware)();
+function monten() {
+    return (0, httpMiddleware_1.monten)();
 }
 function withDbTiming(fn) {
     return (0, dbTimer_1.withDbTiming)(fn);

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/dist/middleware/httpMiddleware.d.ts

@@ -1 +1 @@
-export declare function httpObservabilityMiddleware(): (req: any, res: any, next: (err?: any) => void) => void;
+export declare function monten(): (req: any, res: any, next: (err?: any) => void) => void;

package/dist/middleware/httpMiddleware.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.httpObservabilityMiddleware = httpObservabilityMiddleware;
+exports.monten = monten;
 const observability_config_1 = require("../config/observability.config");
 const requestContext_1 = require("../context/requestContext");
 const logger_1 = require("../logger/logger");
 const metricsBuffer_1 = require("../metrics/metricsBuffer");
 const time_1 = require("../utils/time");
 const uuid_1 = require("../utils/uuid");
-function httpObservabilityMiddleware() {
+function monten() {
     return function httpMiddleware(req, res, next) {
         const cfg = (0, observability_config_1.getObservabilityConfig)();
         const requestId = (0, uuid_1.generateRequestId)();

package/package.json

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