mohen 1.0.0 → 1.2.0

package/README.md

@@ -1,6 +1,21 @@
-# mohen 墨痕
+<p align="center">
+  <img src="logo.png" alt="mohen logo" width="200" />
+</p>
 
-A simple, unified request/response logger for Express and tRPC that writes to a single file with JSON lines format.
+<h1 align="center">mohen 墨痕</h1>
+
+<p align="center">
+  <strong>A simple, unified request/response logger for Express and tRPC</strong><br>
+  Writes to a single file with JSON lines format
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/mohen"><img src="https://img.shields.io/npm/v/mohen.svg" alt="npm version"></a>
+  <a href="https://github.com/ivanleomk/mohen/actions"><img src="https://github.com/ivanleomk/mohen/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+  <a href="https://github.com/ivanleomk/mohen/blob/master/LICENSE"><img src="https://img.shields.io/npm/l/mohen.svg" alt="license"></a>
+</p>
+
+---
 
 ## Features
 
@@ -131,9 +146,34 @@ createLogger(filePath, {
   maxSizeBytes: 10 * 1024 * 1024, // Max file size before truncation (default: 10MB)
   includeHeaders: false,          // Log request headers (default: false)
   redact: ['password', 'token'],  // Fields to redact (default: password, token, authorization, cookie)
+  ignorePaths: ['/health', '/health/*', '/metrics'], // Paths to skip logging (supports wildcards)
+  includePaths: ['/api/*'],       // Only log these paths (supports wildcards)
+});
+```
+
+### Path Filtering
+
+Use `ignorePaths` to skip noisy endpoints like health checks:
+
+```typescript
+const logger = createLogger('./logs/app.log', {
+  ignorePaths: ['/health', '/health/*', '/metrics', '/favicon.ico'],
 });
 ```
 
+Or use `includePaths` to only log specific routes:
+
+```typescript
+const logger = createLogger('./logs/app.log', {
+  includePaths: ['/api/*', '/trpc/*'],
+});
+```
+
+Wildcard patterns:
+- `/health` - matches exactly `/health`
+- `/health/*` - matches `/health/live`, `/health/ready`, etc.
+- `/api/*` - matches any path starting with `/api/`
+
 ## Log Format
 
 Each line is a JSON object with the following structure:
@@ -162,6 +202,20 @@ Each line is a JSON object with the following structure:
 }
 ```
 
+For SSE streaming responses with text-delta events (like LLM responses), the text is automatically aggregated:
+
+```json
+{
+  "type": "http",
+  "path": "/api/chat",
+  "response": {
+    "streaming": true,
+    "chunks": [{"type": "start"}, {"type": "text-delta", "delta": "Hello"}, ...],
+    "text": "Hello world! This is the complete aggregated response."
+  }
+}
+```
+
 ## File Size Management
 
 When the log file exceeds `maxSizeBytes`, the oldest 75% of log entries are removed, keeping the most recent 25%. This happens automatically before each write.

package/dist/logger.d.ts

@@ -16,6 +16,7 @@ interface LogEntry {
         body?: unknown;
         streaming?: boolean;
         chunks?: unknown[];
+        text?: string;
     };
     error?: {
         message: string;
@@ -27,6 +28,8 @@ interface LoggerOptions {
     maxSizeBytes?: number;
     includeHeaders?: boolean;
     redact?: string[];
+    ignorePaths?: string[];
+    includePaths?: string[];
 }
 declare global {
     namespace Express {

package/dist/logger.js

@@ -47,6 +47,8 @@ class UnifiedLogger {
         this.maxSizeBytes = options.maxSizeBytes ?? 10 * 1024 * 1024; // 10MB default
         this.includeHeaders = options.includeHeaders ?? false;
         this.redactFields = new Set(options.redact ?? ['password', 'token', 'authorization', 'cookie']);
+        this.ignorePaths = options.ignorePaths ?? [];
+        this.includePaths = options.includePaths ?? [];
         // Ensure directory exists
         const dir = path.dirname(this.filePath);
         if (!fs.existsSync(dir)) {
@@ -56,6 +58,29 @@ class UnifiedLogger {
     generateRequestId() {
         return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 9)}`;
     }
+    matchPath(pattern, requestPath) {
+        // Convert wildcard pattern to regex
+        // /api/* matches /api/anything
+        // /health matches exactly /health
+        const regexPattern = pattern
+            .replace(/[.+?^${}()|[\]\\]/g, '\\$&') // Escape special regex chars except *
+            .replace(/\*/g, '.*'); // Convert * to .*
+        const regex = new RegExp(`^${regexPattern}$`);
+        return regex.test(requestPath);
+    }
+    shouldLog(requestPath) {
+        // Extract path without query string
+        const pathOnly = requestPath.split('?')[0];
+        // If includePaths is set, only log matching paths
+        if (this.includePaths.length > 0) {
+            return this.includePaths.some((pattern) => this.matchPath(pattern, pathOnly));
+        }
+        // If ignorePaths is set, skip matching paths
+        if (this.ignorePaths.length > 0) {
+            return !this.ignorePaths.some((pattern) => this.matchPath(pattern, pathOnly));
+        }
+        return true;
+    }
     redact(obj) {
         if (obj === null || obj === undefined)
             return obj;
@@ -107,18 +132,95 @@ class UnifiedLogger {
             console.error('Logger write error:', err);
         }
     }
+    /**
+     * Decode chunk to string, handling Uint8Array/Buffer from TextEncoderStream
+     */
+    decodeChunk(chunk) {
+        if (chunk === null || chunk === undefined) {
+            return '';
+        }
+        // Handle Uint8Array (from TextEncoderStream in AI SDK)
+        if (chunk instanceof Uint8Array) {
+            return Buffer.from(chunk).toString('utf-8');
+        }
+        // Handle Buffer
+        if (Buffer.isBuffer(chunk)) {
+            return chunk.toString('utf-8');
+        }
+        // Handle string
+        if (typeof chunk === 'string') {
+            return chunk;
+        }
+        // Fallback: try toString but check if it looks like byte array
+        const str = chunk.toString();
+        // Detect if toString produced a comma-separated byte list like "100,97,116,97"
+        // This happens when Uint8Array.toString() is called without proper decoding
+        if (/^\d+(,\d+)*$/.test(str) && str.includes(',')) {
+            try {
+                const bytes = new Uint8Array(str.split(',').map(Number));
+                return Buffer.from(bytes).toString('utf-8');
+            }
+            catch {
+                return str;
+            }
+        }
+        return str;
+    }
+    /**
+     * Check if content looks like SSE data
+     */
+    looksLikeSSE(content) {
+        return content.trimStart().startsWith('data:') ||
+            content.includes('\ndata:') ||
+            content.trimStart().startsWith('event:');
+    }
     // ===========================================================================
     // Express Middleware
     // ===========================================================================
     expressMiddleware() {
         return (req, res, next) => {
+            const requestPath = req.originalUrl || req.url;
+            // Check if we should log this path
+            if (!this.shouldLog(requestPath)) {
+                return next();
+            }
             const start = Date.now();
             const requestId = this.generateRequestId();
             // Initialize metadata object on request
             req.logMetadata = {};
-            // Detect SSE - check both request Accept header and response Content-Type
+            // Detect SSE - check request Accept header initially
             let isSSE = req.headers.accept === 'text/event-stream';
             const chunks = [];
+            const textDeltas = []; // Collect text-delta content
+            // Helper to check Content-Type header for SSE
+            const checkContentTypeForSSE = (headers) => {
+                if (!headers)
+                    return;
+                // headers can be an object or array of [key, value] pairs
+                if (Array.isArray(headers)) {
+                    for (let i = 0; i < headers.length; i += 2) {
+                        const key = headers[i];
+                        const value = headers[i + 1];
+                        if (typeof key === 'string' &&
+                            key.toLowerCase() === 'content-type' &&
+                            typeof value === 'string' &&
+                            value.includes('text/event-stream')) {
+                            isSSE = true;
+                            return;
+                        }
+                    }
+                }
+                else if (typeof headers === 'object') {
+                    for (const [key, value] of Object.entries(headers)) {
+                        if (key.toLowerCase() === 'content-type' &&
+                            typeof value === 'string' &&
+                            value.includes('text/event-stream')) {
+                            isSSE = true;
+                            return;
+                        }
+                    }
+                }
+            };
             // Intercept setHeader to detect SSE by Content-Type
             const originalSetHeader = res.setHeader.bind(res);
             res.setHeader = ((name, value) => {
@@ -129,6 +231,20 @@ class UnifiedLogger {
                 }
                 return originalSetHeader(name, value);
             });
+            // Intercept writeHead to detect SSE (used by AI SDK's pipeUIMessageStreamToResponse)
+            const originalWriteHead = res.writeHead.bind(res);
+            res.writeHead = ((statusCode, statusMessageOrHeaders, maybeHeaders) => {
+                // writeHead can be called as:
+                // writeHead(statusCode)
+                // writeHead(statusCode, headers)
+                // writeHead(statusCode, statusMessage, headers)
+                let headers = maybeHeaders;
+                if (!headers && typeof statusMessageOrHeaders === 'object') {
+                    headers = statusMessageOrHeaders;
+                }
+                checkContentTypeForSSE(headers);
+                return originalWriteHead(statusCode, statusMessageOrHeaders, maybeHeaders);
+            });
             // Capture request info
             const requestInfo = {
                 body: req.body,
@@ -145,12 +261,18 @@ class UnifiedLogger {
             let responseBody;
             let logged = false;
             res.write = ((chunk, encodingOrCallback, callback) => {
-                // If write is called, treat as streaming
-                if (chunk && isSSE) {
-                    const chunkStr = chunk.toString();
-                    const parsed = this.parseSSEChunk(chunkStr);
-                    if (parsed) {
-                        chunks.push(parsed);
+                if (chunk) {
+                    // Properly decode the chunk (handles Uint8Array from TextEncoderStream)
+                    const chunkStr = this.decodeChunk(chunk);
+                    // Auto-detect SSE from content if not already detected
+                    if (!isSSE && this.looksLikeSSE(chunkStr)) {
+                        isSSE = true;
+                    }
+                    if (isSSE) {
+                        const parsed = this.parseSSEChunk(chunkStr, textDeltas);
+                        if (parsed) {
+                            chunks.push(parsed);
+                        }
                     }
                 }
                 return originalWrite(chunk, encodingOrCallback, callback);
@@ -162,8 +284,8 @@ class UnifiedLogger {
                 if (isSSE) {
                     // SSE streaming path
                     if (chunk) {
-                        const chunkStr = chunk.toString();
-                        const parsed = this.parseSSEChunk(chunkStr);
+                        const chunkStr = this.decodeChunk(chunk);
+                        const parsed = this.parseSSEChunk(chunkStr, textDeltas);
                         if (parsed) {
                             chunks.push(parsed);
                         }
@@ -173,7 +295,7 @@ class UnifiedLogger {
                         requestId,
                         type: 'http',
                         method: req.method,
-                        path: req.originalUrl || req.url,
+                        path: requestPath,
                         statusCode: res.statusCode,
                         duration: Date.now() - start,
                         request: requestInfo,
@@ -182,6 +304,10 @@ class UnifiedLogger {
                             chunks,
                         },
                     };
+                    // Add aggregated text if we collected text-deltas
+                    if (textDeltas.length > 0) {
+                        entry.response.text = textDeltas.join('');
+                    }
                     if (req.logMetadata && Object.keys(req.logMetadata).length > 0) {
                         entry.metadata = req.logMetadata;
                     }
@@ -194,7 +320,7 @@ class UnifiedLogger {
                         requestId,
                         type: 'http',
                         method: req.method,
-                        path: req.originalUrl || req.url,
+                        path: requestPath,
                         statusCode: res.statusCode,
                         duration: Date.now() - start,
                         request: requestInfo,
@@ -219,7 +345,7 @@ class UnifiedLogger {
                     requestId,
                     type: 'http',
                     method: req.method,
-                    path: req.originalUrl || req.url,
+                    path: requestPath,
                     statusCode: res.statusCode,
                     duration: Date.now() - start,
                     request: requestInfo,
@@ -253,22 +379,35 @@ class UnifiedLogger {
             next();
         };
     }
-    parseSSEChunk(raw) {
+    parseSSEChunk(raw, textDeltas) {
         const lines = raw.split('\n');
+        const results = [];
         for (const line of lines) {
             if (line.startsWith('data: ')) {
                 const data = line.slice(6).trim();
-                if (data === '[DONE]')
-                    return { done: true };
+                if (data === '[DONE]') {
+                    results.push({ type: 'done' });
+                    continue;
+                }
                 try {
-                    return JSON.parse(data);
+                    const parsed = JSON.parse(data);
+                    // Handle text-delta type - collect the delta text
+                    if (parsed.type === 'text-delta' && typeof parsed.delta === 'string') {
+                        textDeltas.push(parsed.delta);
+                    }
+                    results.push(parsed);
                 }
                 catch {
-                    return { raw: data };
+                    results.push({ raw: data });
                 }
             }
         }
-        return null;
+        // Return single result or array
+        if (results.length === 0)
+            return null;
+        if (results.length === 1)
+            return results[0];
+        return results;
     }
     // ===========================================================================
     // tRPC Middleware
@@ -276,6 +415,10 @@ class UnifiedLogger {
     trpcMiddleware() {
         const logger = this;
         return async function loggerMiddleware(opts) {
+            // Check if we should log this path
+            if (!logger.shouldLog(opts.path)) {
+                return opts.next();
+            }
             const start = Date.now();
             const requestId = logger.generateRequestId();
             // Initialize metadata on context if not present
@@ -386,4 +529,4 @@ function attachTrpcMetadata(ctx, metadata) {
 }
 // Default export for simpler imports
 exports.default = createLogger;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logger.js","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport type { Request, Response, NextFunction } from 'express';\n\n// ============================================================================\n// Types\n// ============================================================================\n\ninterface LogEntry {\n  timestamp: string;\n  requestId: string;\n  type: 'http' | 'trpc';\n  method: string;\n  path: string;\n  statusCode?: number;\n  duration: number;\n  request?: {\n    body?: unknown;\n    query?: unknown;\n    headers?: Record<string, string>;\n  };\n  response?: {\n    body?: unknown;\n    streaming?: boolean;\n    chunks?: unknown[];\n  };\n  error?: {\n    message: string;\n    stack?: string;\n  };\n  metadata?: Record<string, unknown>;\n}\n\ninterface LoggerOptions {\n  maxSizeBytes?: number;      // Default: 10MB\n  includeHeaders?: boolean;   // Default: false\n  redact?: string[];          // Fields to redact from logs\n}\n\n// Extend Express Request to include metadata\ndeclare global {\n  namespace Express {\n    interface Request {\n      logMetadata?: Record<string, unknown>;\n    }\n  }\n}\n\n// ============================================================================\n// Core Logger Class\n// ============================================================================\n\nclass UnifiedLogger {\n  private filePath: string;\n  private maxSizeBytes: number;\n  private includeHeaders: boolean;\n  private redactFields: Set<string>;\n\n  constructor(filePath: string, options: LoggerOptions = {}) {\n    this.filePath = path.resolve(filePath);\n    this.maxSizeBytes = options.maxSizeBytes ?? 10 * 1024 * 1024; // 10MB default\n    this.includeHeaders = options.includeHeaders ?? false;\n    this.redactFields = new Set(options.redact ?? ['password', 'token', 'authorization', 'cookie']);\n\n    // Ensure directory exists\n    const dir = path.dirname(this.filePath);\n    if (!fs.existsSync(dir)) {\n      fs.mkdirSync(dir, { recursive: true });\n    }\n  }\n\n  private generateRequestId(): string {\n    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 9)}`;\n  }\n\n  private redact(obj: unknown): unknown {\n    if (obj === null || obj === undefined) return obj;\n    if (typeof obj !== 'object') return obj;\n\n    if (Array.isArray(obj)) {\n      return obj.map((item) => this.redact(item));\n    }\n\n    const result: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {\n      if (this.redactFields.has(key.toLowerCase())) {\n        result[key] = '[REDACTED]';\n      } else if (typeof value === 'object') {\n        result[key] = this.redact(value);\n      } else {\n        result[key] = value;\n      }\n    }\n    return result;\n  }\n\n  private checkAndRotate(): void {\n    try {\n      if (!fs.existsSync(this.filePath)) return;\n\n      const stats = fs.statSync(this.filePath);\n      if (stats.size > this.maxSizeBytes) {\n        // Read file, keep last 25% of lines\n        const content = fs.readFileSync(this.filePath, 'utf-8');\n        const lines = content.trim().split('\\n');\n        const keepCount = Math.floor(lines.length * 0.25);\n        const newContent = lines.slice(-keepCount).join('\\n') + '\\n';\n        fs.writeFileSync(this.filePath, newContent);\n      }\n    } catch (err) {\n      console.error('Logger rotation error:', err);\n    }\n  }\n\n  write(entry: LogEntry): void {\n    try {\n      this.checkAndRotate();\n      const redactedEntry = this.redact(entry) as LogEntry;\n      const line = JSON.stringify(redactedEntry) + '\\n';\n      fs.appendFileSync(this.filePath, line);\n    } catch (err) {\n      console.error('Logger write error:', err);\n    }\n  }\n\n  // ===========================================================================\n  // Express Middleware\n  // ===========================================================================\n\n  expressMiddleware() {\n    return (req: Request, res: Response, next: NextFunction) => {\n      const start = Date.now();\n      const requestId = this.generateRequestId();\n\n      // Initialize metadata object on request\n      req.logMetadata = {};\n\n      // Detect SSE - check both request Accept header and response Content-Type\n      let isSSE = req.headers.accept === 'text/event-stream';\n      const chunks: unknown[] = [];\n      \n      // Intercept setHeader to detect SSE by Content-Type\n      const originalSetHeader = res.setHeader.bind(res);\n      res.setHeader = ((name: string, value: string | number | readonly string[]): Response => {\n        if (name.toLowerCase() === 'content-type' && \n            typeof value === 'string' && \n            value.includes('text/event-stream')) {\n          isSSE = true;\n        }\n        return originalSetHeader(name, value);\n      }) as typeof res.setHeader;\n\n      // Capture request info\n      const requestInfo: LogEntry['request'] = {\n        body: req.body,\n        query: req.query,\n      };\n\n      if (this.includeHeaders) {\n        requestInfo.headers = req.headers as Record<string, string>;\n      }\n\n      // Intercept write/end for streaming detection\n      const originalWrite = res.write.bind(res);\n      const originalEnd = res.end.bind(res);\n      const originalJson = res.json.bind(res);\n      const originalSend = res.send.bind(res);\n      let responseBody: unknown;\n      let logged = false;\n\n      res.write = ((chunk: any, encodingOrCallback?: any, callback?: any): boolean => {\n        // If write is called, treat as streaming\n        if (chunk && isSSE) {\n          const chunkStr = chunk.toString();\n          const parsed = this.parseSSEChunk(chunkStr);\n          if (parsed) {\n            chunks.push(parsed);\n          }\n        }\n        return originalWrite(chunk, encodingOrCallback, callback);\n      }) as typeof res.write;\n\n      res.end = ((chunk?: any, encodingOrCallback?: any, callback?: any): Response => {\n        if (logged) return originalEnd(chunk, encodingOrCallback, callback);\n        logged = true;\n\n        if (isSSE) {\n          // SSE streaming path\n          if (chunk) {\n            const chunkStr = chunk.toString();\n            const parsed = this.parseSSEChunk(chunkStr);\n            if (parsed) {\n              chunks.push(parsed);\n            }\n          }\n\n          const entry: LogEntry = {\n            timestamp: new Date().toISOString(),\n            requestId,\n            type: 'http',\n            method: req.method,\n            path: req.originalUrl || req.url,\n            statusCode: res.statusCode,\n            duration: Date.now() - start,\n            request: requestInfo,\n            response: {\n              streaming: true,\n              chunks,\n            },\n          };\n\n          if (req.logMetadata && Object.keys(req.logMetadata).length > 0) {\n            entry.metadata = req.logMetadata;\n          }\n\n          this.write(entry);\n        } else {\n          // Regular response path\n          const entry: LogEntry = {\n            timestamp: new Date().toISOString(),\n            requestId,\n            type: 'http',\n            method: req.method,\n            path: req.originalUrl || req.url,\n            statusCode: res.statusCode,\n            duration: Date.now() - start,\n            request: requestInfo,\n            response: {\n              body: responseBody,\n              streaming: false,\n            },\n          };\n\n          if (req.logMetadata && Object.keys(req.logMetadata).length > 0) {\n            entry.metadata = req.logMetadata;\n          }\n\n          this.write(entry);\n        }\n\n        return originalEnd(chunk, encodingOrCallback, callback);\n      }) as typeof res.end;\n\n      const logResponse = () => {\n        if (logged) return;\n        logged = true;\n\n        const entry: LogEntry = {\n          timestamp: new Date().toISOString(),\n          requestId,\n          type: 'http',\n          method: req.method,\n          path: req.originalUrl || req.url,\n          statusCode: res.statusCode,\n          duration: Date.now() - start,\n          request: requestInfo,\n          response: {\n            body: responseBody,\n            streaming: false,\n          },\n        };\n\n        if (req.logMetadata && Object.keys(req.logMetadata).length > 0) {\n          entry.metadata = req.logMetadata;\n        }\n\n        this.write(entry);\n      };\n\n      res.json = (body: any) => {\n        responseBody = body;\n        logResponse();\n        return originalJson(body);\n      };\n\n      res.send = (body: any) => {\n        if (!logged) {\n          try {\n            responseBody = typeof body === 'string' ? JSON.parse(body) : body;\n          } catch {\n            responseBody = body;\n          }\n          logResponse();\n        }\n        return originalSend(body);\n      };\n\n      next();\n    };\n  }\n\n  private parseSSEChunk(raw: string): unknown {\n    const lines = raw.split('\\n');\n    for (const line of lines) {\n      if (line.startsWith('data: ')) {\n        const data = line.slice(6).trim();\n        if (data === '[DONE]') return { done: true };\n        try {\n          return JSON.parse(data);\n        } catch {\n          return { raw: data };\n        }\n      }\n    }\n    return null;\n  }\n\n  // ===========================================================================\n  // tRPC Middleware\n  // ===========================================================================\n\n  trpcMiddleware<TContext extends Record<string, unknown> = Record<string, unknown>>() {\n    const logger = this;\n\n    return async function loggerMiddleware(opts: {\n      path: string;\n      type: 'query' | 'mutation' | 'subscription';\n      input: unknown;\n      ctx: TContext & { logMetadata?: Record<string, unknown> };\n      next: () => Promise<{ ok: boolean; data?: unknown; error?: Error }>;\n    }) {\n      const start = Date.now();\n      const requestId = logger.generateRequestId();\n\n      // Initialize metadata on context if not present\n      if (!opts.ctx.logMetadata) {\n        opts.ctx.logMetadata = {};\n      }\n\n      try {\n        const result = await opts.next();\n\n        const entry: LogEntry = {\n          timestamp: new Date().toISOString(),\n          requestId,\n          type: 'trpc',\n          method: opts.type.toUpperCase(),\n          path: opts.path,\n          statusCode: result.ok ? 200 : 500,\n          duration: Date.now() - start,\n          request: {\n            body: opts.input,\n          },\n          response: {\n            body: result.data,\n            streaming: false,\n          },\n        };\n\n        // Attach metadata if present\n        if (opts.ctx.logMetadata && Object.keys(opts.ctx.logMetadata).length > 0) {\n          entry.metadata = opts.ctx.logMetadata;\n        }\n\n        if (result.error) {\n          entry.error = {\n            message: result.error.message,\n            stack: result.error.stack,\n          };\n        }\n\n        logger.write(entry);\n\n        return result;\n      } catch (error) {\n        const err = error as Error;\n\n        const entry: LogEntry = {\n          timestamp: new Date().toISOString(),\n          requestId,\n          type: 'trpc',\n          method: opts.type.toUpperCase(),\n          path: opts.path,\n          statusCode: 500,\n          duration: Date.now() - start,\n          request: {\n            body: opts.input,\n          },\n          error: {\n            message: err.message,\n            stack: err.stack,\n          },\n        };\n\n        // Attach metadata if present\n        if (opts.ctx.logMetadata && Object.keys(opts.ctx.logMetadata).length > 0) {\n          entry.metadata = opts.ctx.logMetadata;\n        }\n\n        logger.write(entry);\n\n        throw error;\n      }\n    };\n  }\n}\n\n// ============================================================================\n// Factory Function (Main Export)\n// ============================================================================\n\nexport function createLogger(filePath: string, options?: LoggerOptions) {\n  const logger = new UnifiedLogger(filePath, options);\n\n  return {\n    /** Express middleware - use with app.use() */\n    express: () => logger.expressMiddleware(),\n\n    /** tRPC middleware - use with t.procedure.use() */\n    trpc: <TContext extends Record<string, unknown> = Record<string, unknown>>() => \n      logger.trpcMiddleware<TContext>(),\n\n    /** Direct write access for custom logging */\n    write: (entry: Partial<LogEntry>) => logger.write({\n      timestamp: new Date().toISOString(),\n      requestId: `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 9)}`,\n      type: 'http',\n      method: 'CUSTOM',\n      path: '/',\n      duration: 0,\n      ...entry,\n    } as LogEntry),\n  };\n}\n\n// ============================================================================\n// Helper to attach metadata (for cleaner API)\n// ============================================================================\n\n/**\n * Attach metadata to the current request log entry (Express)\n */\nexport function attachMetadata(req: Request, metadata: Record<string, unknown>): void {\n  if (!req.logMetadata) {\n    req.logMetadata = {};\n  }\n  Object.assign(req.logMetadata, metadata);\n}\n\n/**\n * Attach metadata to the current request log entry (tRPC)\n */\nexport function attachTrpcMetadata<TContext extends { logMetadata?: Record<string, unknown> }>(\n  ctx: TContext,\n  metadata: Record<string, unknown>\n): void {\n  if (!ctx.logMetadata) {\n    ctx.logMetadata = {};\n  }\n  Object.assign(ctx.logMetadata, metadata);\n}\n\n// Default export for simpler imports\nexport default createLogger;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logger.js","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport type { Request, Response, NextFunction } from 'express';\n\n// ============================================================================\n// Types\n// ============================================================================\n\ninterface LogEntry {\n  timestamp: string;\n  requestId: string;\n  type: 'http' | 'trpc';\n  method: string;\n  path: string;\n  statusCode?: number;\n  duration: number;\n  request?: {\n    body?: unknown;\n    query?: unknown;\n    headers?: Record<string, string>;\n  };\n  response?: {\n    body?: unknown;\n    streaming?: boolean;\n    chunks?: unknown[];\n    text?: string; // Aggregated text from text-delta chunks\n  };\n  error?: {\n    message: string;\n    stack?: string;\n  };\n  metadata?: Record<string, unknown>;\n}\n\ninterface LoggerOptions {\n  maxSizeBytes?: number;      // Default: 10MB\n  includeHeaders?: boolean;   // Default: false\n  redact?: string[];          // Fields to redact from logs\n  ignorePaths?: string[];     // Paths to ignore (supports wildcards like /health/*)\n  includePaths?: string[];    // Only log these paths (supports wildcards)\n}\n\n// Extend Express Request to include metadata\ndeclare global {\n  namespace Express {\n    interface Request {\n      logMetadata?: Record<string, unknown>;\n    }\n  }\n}\n\n// ============================================================================\n// Core Logger Class\n// ============================================================================\n\nclass UnifiedLogger {\n  private filePath: string;\n  private maxSizeBytes: number;\n  private includeHeaders: boolean;\n  private redactFields: Set<string>;\n  private ignorePaths: string[];\n  private includePaths: string[];\n\n  constructor(filePath: string, options: LoggerOptions = {}) {\n    this.filePath = path.resolve(filePath);\n    this.maxSizeBytes = options.maxSizeBytes ?? 10 * 1024 * 1024; // 10MB default\n    this.includeHeaders = options.includeHeaders ?? false;\n    this.redactFields = new Set(options.redact ?? ['password', 'token', 'authorization', 'cookie']);\n    this.ignorePaths = options.ignorePaths ?? [];\n    this.includePaths = options.includePaths ?? [];\n\n    // Ensure directory exists\n    const dir = path.dirname(this.filePath);\n    if (!fs.existsSync(dir)) {\n      fs.mkdirSync(dir, { recursive: true });\n    }\n  }\n\n  private generateRequestId(): string {\n    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 9)}`;\n  }\n\n  private matchPath(pattern: string, requestPath: string): boolean {\n    // Convert wildcard pattern to regex\n    // /api/* matches /api/anything\n    // /health matches exactly /health\n    const regexPattern = pattern\n      .replace(/[.+?^${}()|[\\]\\\\]/g, '\\\\$&') // Escape special regex chars except *\n      .replace(/\\*/g, '.*'); // Convert * to .*\n    const regex = new RegExp(`^${regexPattern}$`);\n    return regex.test(requestPath);\n  }\n\n  private shouldLog(requestPath: string): boolean {\n    // Extract path without query string\n    const pathOnly = requestPath.split('?')[0];\n\n    // If includePaths is set, only log matching paths\n    if (this.includePaths.length > 0) {\n      return this.includePaths.some((pattern) => this.matchPath(pattern, pathOnly));\n    }\n\n    // If ignorePaths is set, skip matching paths\n    if (this.ignorePaths.length > 0) {\n      return !this.ignorePaths.some((pattern) => this.matchPath(pattern, pathOnly));\n    }\n\n    return true;\n  }\n\n  private redact(obj: unknown): unknown {\n    if (obj === null || obj === undefined) return obj;\n    if (typeof obj !== 'object') return obj;\n\n    if (Array.isArray(obj)) {\n      return obj.map((item) => this.redact(item));\n    }\n\n    const result: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {\n      if (this.redactFields.has(key.toLowerCase())) {\n        result[key] = '[REDACTED]';\n      } else if (typeof value === 'object') {\n        result[key] = this.redact(value);\n      } else {\n        result[key] = value;\n      }\n    }\n    return result;\n  }\n\n  private checkAndRotate(): void {\n    try {\n      if (!fs.existsSync(this.filePath)) return;\n\n      const stats = fs.statSync(this.filePath);\n      if (stats.size > this.maxSizeBytes) {\n        // Read file, keep last 25% of lines\n        const content = fs.readFileSync(this.filePath, 'utf-8');\n        const lines = content.trim().split('\\n');\n        const keepCount = Math.floor(lines.length * 0.25);\n        const newContent = lines.slice(-keepCount).join('\\n') + '\\n';\n        fs.writeFileSync(this.filePath, newContent);\n      }\n    } catch (err) {\n      console.error('Logger rotation error:', err);\n    }\n  }\n\n  write(entry: LogEntry): void {\n    try {\n      this.checkAndRotate();\n      const redactedEntry = this.redact(entry) as LogEntry;\n      const line = JSON.stringify(redactedEntry) + '\\n';\n      fs.appendFileSync(this.filePath, line);\n    } catch (err) {\n      console.error('Logger write error:', err);\n    }\n  }\n\n  /**\n   * Decode chunk to string, handling Uint8Array/Buffer from TextEncoderStream\n   */\n  private decodeChunk(chunk: any): string {\n    if (chunk === null || chunk === undefined) {\n      return '';\n    }\n    \n    // Handle Uint8Array (from TextEncoderStream in AI SDK)\n    if (chunk instanceof Uint8Array) {\n      return Buffer.from(chunk).toString('utf-8');\n    }\n    \n    // Handle Buffer\n    if (Buffer.isBuffer(chunk)) {\n      return chunk.toString('utf-8');\n    }\n    \n    // Handle string\n    if (typeof chunk === 'string') {\n      return chunk;\n    }\n    \n    // Fallback: try toString but check if it looks like byte array\n    const str = chunk.toString();\n    \n    // Detect if toString produced a comma-separated byte list like \"100,97,116,97\"\n    // This happens when Uint8Array.toString() is called without proper decoding\n    if (/^\\d+(,\\d+)*$/.test(str) && str.includes(',')) {\n      try {\n        const bytes = new Uint8Array(str.split(',').map(Number));\n        return Buffer.from(bytes).toString('utf-8');\n      } catch {\n        return str;\n      }\n    }\n    \n    return str;\n  }\n\n  /**\n   * Check if content looks like SSE data\n   */\n  private looksLikeSSE(content: string): boolean {\n    return content.trimStart().startsWith('data:') || \n           content.includes('\\ndata:') ||\n           content.trimStart().startsWith('event:');\n  }\n\n  // ===========================================================================\n  // Express Middleware\n  // ===========================================================================\n\n  expressMiddleware() {\n    return (req: Request, res: Response, next: NextFunction) => {\n      const requestPath = req.originalUrl || req.url;\n\n      // Check if we should log this path\n      if (!this.shouldLog(requestPath)) {\n        return next();\n      }\n\n      const start = Date.now();\n      const requestId = this.generateRequestId();\n\n      // Initialize metadata object on request\n      req.logMetadata = {};\n\n      // Detect SSE - check request Accept header initially\n      let isSSE = req.headers.accept === 'text/event-stream';\n      const chunks: unknown[] = [];\n      const textDeltas: string[] = []; // Collect text-delta content\n\n      // Helper to check Content-Type header for SSE\n      const checkContentTypeForSSE = (headers: any): void => {\n        if (!headers) return;\n        \n        // headers can be an object or array of [key, value] pairs\n        if (Array.isArray(headers)) {\n          for (let i = 0; i < headers.length; i += 2) {\n            const key = headers[i];\n            const value = headers[i + 1];\n            if (typeof key === 'string' && \n                key.toLowerCase() === 'content-type' && \n                typeof value === 'string' && \n                value.includes('text/event-stream')) {\n              isSSE = true;\n              return;\n            }\n          }\n        } else if (typeof headers === 'object') {\n          for (const [key, value] of Object.entries(headers)) {\n            if (key.toLowerCase() === 'content-type' && \n                typeof value === 'string' && \n                value.includes('text/event-stream')) {\n              isSSE = true;\n              return;\n            }\n          }\n        }\n      };\n      \n      // Intercept setHeader to detect SSE by Content-Type\n      const originalSetHeader = res.setHeader.bind(res);\n      res.setHeader = ((name: string, value: string | number | readonly string[]): Response => {\n        if (name.toLowerCase() === 'content-type' && \n            typeof value === 'string' && \n            value.includes('text/event-stream')) {\n          isSSE = true;\n        }\n        return originalSetHeader(name, value);\n      }) as typeof res.setHeader;\n\n      // Intercept writeHead to detect SSE (used by AI SDK's pipeUIMessageStreamToResponse)\n      const originalWriteHead = res.writeHead.bind(res);\n      res.writeHead = ((\n        statusCode: number,\n        statusMessageOrHeaders?: string | any,\n        maybeHeaders?: any\n      ): Response => {\n        // writeHead can be called as:\n        // writeHead(statusCode)\n        // writeHead(statusCode, headers)\n        // writeHead(statusCode, statusMessage, headers)\n        let headers = maybeHeaders;\n        if (!headers && typeof statusMessageOrHeaders === 'object') {\n          headers = statusMessageOrHeaders;\n        }\n        \n        checkContentTypeForSSE(headers);\n        \n        return originalWriteHead(statusCode, statusMessageOrHeaders as any, maybeHeaders);\n      }) as typeof res.writeHead;\n\n      // Capture request info\n      const requestInfo: LogEntry['request'] = {\n        body: req.body,\n        query: req.query,\n      };\n\n      if (this.includeHeaders) {\n        requestInfo.headers = req.headers as Record<string, string>;\n      }\n\n      // Intercept write/end for streaming detection\n      const originalWrite = res.write.bind(res);\n      const originalEnd = res.end.bind(res);\n      const originalJson = res.json.bind(res);\n      const originalSend = res.send.bind(res);\n      let responseBody: unknown;\n      let logged = false;\n\n      res.write = ((chunk: any, encodingOrCallback?: any, callback?: any): boolean => {\n        if (chunk) {\n          // Properly decode the chunk (handles Uint8Array from TextEncoderStream)\n          const chunkStr = this.decodeChunk(chunk);\n          \n          // Auto-detect SSE from content if not already detected\n          if (!isSSE && this.looksLikeSSE(chunkStr)) {\n            isSSE = true;\n          }\n          \n          if (isSSE) {\n            const parsed = this.parseSSEChunk(chunkStr, textDeltas);\n            if (parsed) {\n              chunks.push(parsed);\n            }\n          }\n        }\n        return originalWrite(chunk, encodingOrCallback, callback);\n      }) as typeof res.write;\n\n      res.end = ((chunk?: any, encodingOrCallback?: any, callback?: any): Response => {\n        if (logged) return originalEnd(chunk, encodingOrCallback, callback);\n        logged = true;\n\n        if (isSSE) {\n          // SSE streaming path\n          if (chunk) {\n            const chunkStr = this.decodeChunk(chunk);\n            const parsed = this.parseSSEChunk(chunkStr, textDeltas);\n            if (parsed) {\n              chunks.push(parsed);\n            }\n          }\n\n          const entry: LogEntry = {\n            timestamp: new Date().toISOString(),\n            requestId,\n            type: 'http',\n            method: req.method,\n            path: requestPath,\n            statusCode: res.statusCode,\n            duration: Date.now() - start,\n            request: requestInfo,\n            response: {\n              streaming: true,\n              chunks,\n            },\n          };\n\n          // Add aggregated text if we collected text-deltas\n          if (textDeltas.length > 0) {\n            entry.response!.text = textDeltas.join('');\n          }\n\n          if (req.logMetadata && Object.keys(req.logMetadata).length > 0) {\n            entry.metadata = req.logMetadata;\n          }\n\n          this.write(entry);\n        } else {\n          // Regular response path\n          const entry: LogEntry = {\n            timestamp: new Date().toISOString(),\n            requestId,\n            type: 'http',\n            method: req.method,\n            path: requestPath,\n            statusCode: res.statusCode,\n            duration: Date.now() - start,\n            request: requestInfo,\n            response: {\n              body: responseBody,\n              streaming: false,\n            },\n          };\n\n          if (req.logMetadata && Object.keys(req.logMetadata).length > 0) {\n            entry.metadata = req.logMetadata;\n          }\n\n          this.write(entry);\n        }\n\n        return originalEnd(chunk, encodingOrCallback, callback);\n      }) as typeof res.end;\n\n      const logResponse = () => {\n        if (logged) return;\n        logged = true;\n\n        const entry: LogEntry = {\n          timestamp: new Date().toISOString(),\n          requestId,\n          type: 'http',\n          method: req.method,\n          path: requestPath,\n          statusCode: res.statusCode,\n          duration: Date.now() - start,\n          request: requestInfo,\n          response: {\n            body: responseBody,\n            streaming: false,\n          },\n        };\n\n        if (req.logMetadata && Object.keys(req.logMetadata).length > 0) {\n          entry.metadata = req.logMetadata;\n        }\n\n        this.write(entry);\n      };\n\n      res.json = (body: any) => {\n        responseBody = body;\n        logResponse();\n        return originalJson(body);\n      };\n\n      res.send = (body: any) => {\n        if (!logged) {\n          try {\n            responseBody = typeof body === 'string' ? JSON.parse(body) : body;\n          } catch {\n            responseBody = body;\n          }\n          logResponse();\n        }\n        return originalSend(body);\n      };\n\n      next();\n    };\n  }\n\n  private parseSSEChunk(raw: string, textDeltas: string[]): unknown {\n    const lines = raw.split('\\n');\n    const results: unknown[] = [];\n\n    for (const line of lines) {\n      if (line.startsWith('data: ')) {\n        const data = line.slice(6).trim();\n        if (data === '[DONE]') {\n          results.push({ type: 'done' });\n          continue;\n        }\n        try {\n          const parsed = JSON.parse(data);\n          \n          // Handle text-delta type - collect the delta text\n          if (parsed.type === 'text-delta' && typeof parsed.delta === 'string') {\n            textDeltas.push(parsed.delta);\n          }\n          \n          results.push(parsed);\n        } catch {\n          results.push({ raw: data });\n        }\n      }\n    }\n\n    // Return single result or array\n    if (results.length === 0) return null;\n    if (results.length === 1) return results[0];\n    return results;\n  }\n\n  // ===========================================================================\n  // tRPC Middleware\n  // ===========================================================================\n\n  trpcMiddleware<TContext extends Record<string, unknown> = Record<string, unknown>>() {\n    const logger = this;\n\n    return async function loggerMiddleware(opts: {\n      path: string;\n      type: 'query' | 'mutation' | 'subscription';\n      input: unknown;\n      ctx: TContext & { logMetadata?: Record<string, unknown> };\n      next: () => Promise<{ ok: boolean; data?: unknown; error?: Error }>;\n    }) {\n      // Check if we should log this path\n      if (!logger.shouldLog(opts.path)) {\n        return opts.next();\n      }\n\n      const start = Date.now();\n      const requestId = logger.generateRequestId();\n\n      // Initialize metadata on context if not present\n      if (!opts.ctx.logMetadata) {\n        opts.ctx.logMetadata = {};\n      }\n\n      try {\n        const result = await opts.next();\n\n        const entry: LogEntry = {\n          timestamp: new Date().toISOString(),\n          requestId,\n          type: 'trpc',\n          method: opts.type.toUpperCase(),\n          path: opts.path,\n          statusCode: result.ok ? 200 : 500,\n          duration: Date.now() - start,\n          request: {\n            body: opts.input,\n          },\n          response: {\n            body: result.data,\n            streaming: false,\n          },\n        };\n\n        // Attach metadata if present\n        if (opts.ctx.logMetadata && Object.keys(opts.ctx.logMetadata).length > 0) {\n          entry.metadata = opts.ctx.logMetadata;\n        }\n\n        if (result.error) {\n          entry.error = {\n            message: result.error.message,\n            stack: result.error.stack,\n          };\n        }\n\n        logger.write(entry);\n\n        return result;\n      } catch (error) {\n        const err = error as Error;\n\n        const entry: LogEntry = {\n          timestamp: new Date().toISOString(),\n          requestId,\n          type: 'trpc',\n          method: opts.type.toUpperCase(),\n          path: opts.path,\n          statusCode: 500,\n          duration: Date.now() - start,\n          request: {\n            body: opts.input,\n          },\n          error: {\n            message: err.message,\n            stack: err.stack,\n          },\n        };\n\n        // Attach metadata if present\n        if (opts.ctx.logMetadata && Object.keys(opts.ctx.logMetadata).length > 0) {\n          entry.metadata = opts.ctx.logMetadata;\n        }\n\n        logger.write(entry);\n\n        throw error;\n      }\n    };\n  }\n}\n\n// ============================================================================\n// Factory Function (Main Export)\n// ============================================================================\n\nexport function createLogger(filePath: string, options?: LoggerOptions) {\n  const logger = new UnifiedLogger(filePath, options);\n\n  return {\n    /** Express middleware - use with app.use() */\n    express: () => logger.expressMiddleware(),\n\n    /** tRPC middleware - use with t.procedure.use() */\n    trpc: <TContext extends Record<string, unknown> = Record<string, unknown>>() => \n      logger.trpcMiddleware<TContext>(),\n\n    /** Direct write access for custom logging */\n    write: (entry: Partial<LogEntry>) => logger.write({\n      timestamp: new Date().toISOString(),\n      requestId: `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 9)}`,\n      type: 'http',\n      method: 'CUSTOM',\n      path: '/',\n      duration: 0,\n      ...entry,\n    } as LogEntry),\n  };\n}\n\n// ============================================================================\n// Helper to attach metadata (for cleaner API)\n// ============================================================================\n\n/**\n * Attach metadata to the current request log entry (Express)\n */\nexport function attachMetadata(req: Request, metadata: Record<string, unknown>): void {\n  if (!req.logMetadata) {\n    req.logMetadata = {};\n  }\n  Object.assign(req.logMetadata, metadata);\n}\n\n/**\n * Attach metadata to the current request log entry (tRPC)\n */\nexport function attachTrpcMetadata<TContext extends { logMetadata?: Record<string, unknown> }>(\n  ctx: TContext,\n  metadata: Record<string, unknown>\n): void {\n  if (!ctx.logMetadata) {\n    ctx.logMetadata = {};\n  }\n  Object.assign(ctx.logMetadata, metadata);\n}\n\n// Default export for simpler imports\nexport default createLogger;\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mohen",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Unified request/response logger for Express and tRPC with SSE support (墨痕 - ink trace)",
   "main": "dist/logger.js",
   "types": "dist/logger.d.ts",

package/src/logger.ts

@@ -23,6 +23,7 @@ interface LogEntry {
     body?: unknown;
     streaming?: boolean;
     chunks?: unknown[];
+    text?: string; // Aggregated text from text-delta chunks
   };
   error?: {
     message: string;
@@ -35,6 +36,8 @@ interface LoggerOptions {
   maxSizeBytes?: number;      // Default: 10MB
   includeHeaders?: boolean;   // Default: false
   redact?: string[];          // Fields to redact from logs
+  ignorePaths?: string[];     // Paths to ignore (supports wildcards like /health/*)
+  includePaths?: string[];    // Only log these paths (supports wildcards)
 }
 
 // Extend Express Request to include metadata
@@ -55,12 +58,16 @@ class UnifiedLogger {
   private maxSizeBytes: number;
   private includeHeaders: boolean;
   private redactFields: Set<string>;
+  private ignorePaths: string[];
+  private includePaths: string[];
 
   constructor(filePath: string, options: LoggerOptions = {}) {
     this.filePath = path.resolve(filePath);
     this.maxSizeBytes = options.maxSizeBytes ?? 10 * 1024 * 1024; // 10MB default
     this.includeHeaders = options.includeHeaders ?? false;
     this.redactFields = new Set(options.redact ?? ['password', 'token', 'authorization', 'cookie']);
+    this.ignorePaths = options.ignorePaths ?? [];
+    this.includePaths = options.includePaths ?? [];
 
     // Ensure directory exists
     const dir = path.dirname(this.filePath);
@@ -73,6 +80,34 @@ class UnifiedLogger {
     return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 9)}`;
   }
 
+  private matchPath(pattern: string, requestPath: string): boolean {
+    // Convert wildcard pattern to regex
+    // /api/* matches /api/anything
+    // /health matches exactly /health
+    const regexPattern = pattern
+      .replace(/[.+?^${}()|[\]\\]/g, '\\$&') // Escape special regex chars except *
+      .replace(/\*/g, '.*'); // Convert * to .*
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(requestPath);
+  }
+
+  private shouldLog(requestPath: string): boolean {
+    // Extract path without query string
+    const pathOnly = requestPath.split('?')[0];
+
+    // If includePaths is set, only log matching paths
+    if (this.includePaths.length > 0) {
+      return this.includePaths.some((pattern) => this.matchPath(pattern, pathOnly));
+    }
+
+    // If ignorePaths is set, skip matching paths
+    if (this.ignorePaths.length > 0) {
+      return !this.ignorePaths.some((pattern) => this.matchPath(pattern, pathOnly));
+    }
+
+    return true;
+  }
+
   private redact(obj: unknown): unknown {
     if (obj === null || obj === undefined) return obj;
     if (typeof obj !== 'object') return obj;
@@ -123,21 +158,107 @@ class UnifiedLogger {
     }
   }
 
+  /**
+   * Decode chunk to string, handling Uint8Array/Buffer from TextEncoderStream
+   */
+  private decodeChunk(chunk: any): string {
+    if (chunk === null || chunk === undefined) {
+      return '';
+    }
+    
+    // Handle Uint8Array (from TextEncoderStream in AI SDK)
+    if (chunk instanceof Uint8Array) {
+      return Buffer.from(chunk).toString('utf-8');
+    }
+    
+    // Handle Buffer
+    if (Buffer.isBuffer(chunk)) {
+      return chunk.toString('utf-8');
+    }
+    
+    // Handle string
+    if (typeof chunk === 'string') {
+      return chunk;
+    }
+    
+    // Fallback: try toString but check if it looks like byte array
+    const str = chunk.toString();
+    
+    // Detect if toString produced a comma-separated byte list like "100,97,116,97"
+    // This happens when Uint8Array.toString() is called without proper decoding
+    if (/^\d+(,\d+)*$/.test(str) && str.includes(',')) {
+      try {
+        const bytes = new Uint8Array(str.split(',').map(Number));
+        return Buffer.from(bytes).toString('utf-8');
+      } catch {
+        return str;
+      }
+    }
+    
+    return str;
+  }
+
+  /**
+   * Check if content looks like SSE data
+   */
+  private looksLikeSSE(content: string): boolean {
+    return content.trimStart().startsWith('data:') || 
+           content.includes('\ndata:') ||
+           content.trimStart().startsWith('event:');
+  }
+
   // ===========================================================================
   // Express Middleware
   // ===========================================================================
 
   expressMiddleware() {
     return (req: Request, res: Response, next: NextFunction) => {
+      const requestPath = req.originalUrl || req.url;
+
+      // Check if we should log this path
+      if (!this.shouldLog(requestPath)) {
+        return next();
+      }
+
       const start = Date.now();
       const requestId = this.generateRequestId();
 
       // Initialize metadata object on request
       req.logMetadata = {};
 
-      // Detect SSE - check both request Accept header and response Content-Type
+      // Detect SSE - check request Accept header initially
       let isSSE = req.headers.accept === 'text/event-stream';
       const chunks: unknown[] = [];
+      const textDeltas: string[] = []; // Collect text-delta content
+
+      // Helper to check Content-Type header for SSE
+      const checkContentTypeForSSE = (headers: any): void => {
+        if (!headers) return;
+        
+        // headers can be an object or array of [key, value] pairs
+        if (Array.isArray(headers)) {
+          for (let i = 0; i < headers.length; i += 2) {
+            const key = headers[i];
+            const value = headers[i + 1];
+            if (typeof key === 'string' && 
+                key.toLowerCase() === 'content-type' && 
+                typeof value === 'string' && 
+                value.includes('text/event-stream')) {
+              isSSE = true;
+              return;
+            }
+          }
+        } else if (typeof headers === 'object') {
+          for (const [key, value] of Object.entries(headers)) {
+            if (key.toLowerCase() === 'content-type' && 
+                typeof value === 'string' && 
+                value.includes('text/event-stream')) {
+              isSSE = true;
+              return;
+            }
+          }
+        }
+      };
       
       // Intercept setHeader to detect SSE by Content-Type
       const originalSetHeader = res.setHeader.bind(res);
@@ -150,6 +271,27 @@ class UnifiedLogger {
         return originalSetHeader(name, value);
       }) as typeof res.setHeader;
 
+      // Intercept writeHead to detect SSE (used by AI SDK's pipeUIMessageStreamToResponse)
+      const originalWriteHead = res.writeHead.bind(res);
+      res.writeHead = ((
+        statusCode: number,
+        statusMessageOrHeaders?: string | any,
+        maybeHeaders?: any
+      ): Response => {
+        // writeHead can be called as:
+        // writeHead(statusCode)
+        // writeHead(statusCode, headers)
+        // writeHead(statusCode, statusMessage, headers)
+        let headers = maybeHeaders;
+        if (!headers && typeof statusMessageOrHeaders === 'object') {
+          headers = statusMessageOrHeaders;
+        }
+        
+        checkContentTypeForSSE(headers);
+        
+        return originalWriteHead(statusCode, statusMessageOrHeaders as any, maybeHeaders);
+      }) as typeof res.writeHead;
+
       // Capture request info
       const requestInfo: LogEntry['request'] = {
         body: req.body,
@@ -169,12 +311,20 @@ class UnifiedLogger {
       let logged = false;
 
       res.write = ((chunk: any, encodingOrCallback?: any, callback?: any): boolean => {
-        // If write is called, treat as streaming
-        if (chunk && isSSE) {
-          const chunkStr = chunk.toString();
-          const parsed = this.parseSSEChunk(chunkStr);
-          if (parsed) {
-            chunks.push(parsed);
+        if (chunk) {
+          // Properly decode the chunk (handles Uint8Array from TextEncoderStream)
+          const chunkStr = this.decodeChunk(chunk);
+          
+          // Auto-detect SSE from content if not already detected
+          if (!isSSE && this.looksLikeSSE(chunkStr)) {
+            isSSE = true;
+          }
+          
+          if (isSSE) {
+            const parsed = this.parseSSEChunk(chunkStr, textDeltas);
+            if (parsed) {
+              chunks.push(parsed);
+            }
           }
         }
         return originalWrite(chunk, encodingOrCallback, callback);
@@ -187,8 +337,8 @@ class UnifiedLogger {
         if (isSSE) {
           // SSE streaming path
           if (chunk) {
-            const chunkStr = chunk.toString();
-            const parsed = this.parseSSEChunk(chunkStr);
+            const chunkStr = this.decodeChunk(chunk);
+            const parsed = this.parseSSEChunk(chunkStr, textDeltas);
             if (parsed) {
               chunks.push(parsed);
             }
@@ -199,7 +349,7 @@ class UnifiedLogger {
             requestId,
             type: 'http',
             method: req.method,
-            path: req.originalUrl || req.url,
+            path: requestPath,
             statusCode: res.statusCode,
             duration: Date.now() - start,
             request: requestInfo,
@@ -209,6 +359,11 @@ class UnifiedLogger {
             },
           };
 
+          // Add aggregated text if we collected text-deltas
+          if (textDeltas.length > 0) {
+            entry.response!.text = textDeltas.join('');
+          }
+
           if (req.logMetadata && Object.keys(req.logMetadata).length > 0) {
             entry.metadata = req.logMetadata;
           }
@@ -221,7 +376,7 @@ class UnifiedLogger {
             requestId,
             type: 'http',
             method: req.method,
-            path: req.originalUrl || req.url,
+            path: requestPath,
             statusCode: res.statusCode,
             duration: Date.now() - start,
             request: requestInfo,
@@ -250,7 +405,7 @@ class UnifiedLogger {
           requestId,
           type: 'http',
           method: req.method,
-          path: req.originalUrl || req.url,
+          path: requestPath,
           statusCode: res.statusCode,
           duration: Date.now() - start,
           request: requestInfo,
@@ -289,20 +444,36 @@ class UnifiedLogger {
     };
   }
 
-  private parseSSEChunk(raw: string): unknown {
+  private parseSSEChunk(raw: string, textDeltas: string[]): unknown {
     const lines = raw.split('\n');
+    const results: unknown[] = [];
+
     for (const line of lines) {
       if (line.startsWith('data: ')) {
         const data = line.slice(6).trim();
-        if (data === '[DONE]') return { done: true };
+        if (data === '[DONE]') {
+          results.push({ type: 'done' });
+          continue;
+        }
         try {
-          return JSON.parse(data);
+          const parsed = JSON.parse(data);
+          
+          // Handle text-delta type - collect the delta text
+          if (parsed.type === 'text-delta' && typeof parsed.delta === 'string') {
+            textDeltas.push(parsed.delta);
+          }
+          
+          results.push(parsed);
         } catch {
-          return { raw: data };
+          results.push({ raw: data });
         }
       }
     }
-    return null;
+
+    // Return single result or array
+    if (results.length === 0) return null;
+    if (results.length === 1) return results[0];
+    return results;
   }
 
   // ===========================================================================
@@ -319,6 +490,11 @@ class UnifiedLogger {
       ctx: TContext & { logMetadata?: Record<string, unknown> };
       next: () => Promise<{ ok: boolean; data?: unknown; error?: Error }>;
     }) {
+      // Check if we should log this path
+      if (!logger.shouldLog(opts.path)) {
+        return opts.next();
+      }
+
       const start = Date.now();
       const requestId = logger.generateRequestId();
 

package/test/logger.test.ts

@@ -196,7 +196,7 @@ describe('mohen logger', () => {
             { count: 1 },
             { count: 2 },
             { count: 3 },
-            { done: true },
+            { type: 'done' },
           ],
         },
       });
@@ -468,6 +468,211 @@ describe('mohen logger', () => {
     });
   });
 
+  describe('Path Filtering', () => {
+    it('should ignore paths matching ignorePaths patterns', async () => {
+      vi.useRealTimers();
+      clearLogFile();
+      
+      const filteredLogger = createLogger(TEST_LOG_FILE, {
+        ignorePaths: ['/health', '/health/*', '/metrics'],
+      });
+
+      const filteredApp = express();
+      filteredApp.use(express.json());
+      filteredApp.use(filteredLogger.express());
+      filteredApp.get('/health', (req, res) => res.json({ status: 'ok' }));
+      filteredApp.get('/health/live', (req, res) => res.json({ live: true }));
+      filteredApp.get('/metrics', (req, res) => res.json({ cpu: 50 }));
+      filteredApp.get('/api/users', (req, res) => res.json({ users: [] }));
+
+      await request(filteredApp).get('/health').expect(200);
+      await request(filteredApp).get('/health/live').expect(200);
+      await request(filteredApp).get('/metrics').expect(200);
+      await request(filteredApp).get('/api/users').expect(200);
+
+      const entries = readLogEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0].path).toBe('/api/users');
+    });
+
+    it('should only log paths matching includePaths patterns', async () => {
+      vi.useRealTimers();
+      clearLogFile();
+      
+      const filteredLogger = createLogger(TEST_LOG_FILE, {
+        includePaths: ['/api/*'],
+      });
+
+      const filteredApp = express();
+      filteredApp.use(express.json());
+      filteredApp.use(filteredLogger.express());
+      filteredApp.get('/health', (req, res) => res.json({ status: 'ok' }));
+      filteredApp.get('/api/users', (req, res) => res.json({ users: [] }));
+      filteredApp.get('/api/orders', (req, res) => res.json({ orders: [] }));
+
+      await request(filteredApp).get('/health').expect(200);
+      await request(filteredApp).get('/api/users').expect(200);
+      await request(filteredApp).get('/api/orders').expect(200);
+
+      const entries = readLogEntries();
+      expect(entries).toHaveLength(2);
+      expect(entries[0].path).toBe('/api/users');
+      expect(entries[1].path).toBe('/api/orders');
+    });
+  });
+
+  describe('AI SDK Style Streaming', () => {
+    it('should detect SSE via writeHead (AI SDK pipeUIMessageStreamToResponse)', async () => {
+      app.get('/api/ai-stream', (req, res) => {
+        // AI SDK uses writeHead instead of setHeader
+        res.writeHead(200, {
+          'Content-Type': 'text/event-stream',
+          'Cache-Control': 'no-cache',
+          'Connection': 'keep-alive',
+        });
+
+        res.write('data: {"type":"start"}\n\n');
+        res.write('data: {"type":"text-delta","delta":"Hello"}\n\n');
+        res.write('data: {"type":"finish"}\n\n');
+        res.end();
+      });
+
+      await request(app)
+        .get('/api/ai-stream')
+        .expect(200);
+
+      const entries = readLogEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0]).toMatchObject({
+        type: 'http',
+        method: 'GET',
+        path: '/api/ai-stream',
+        response: {
+          streaming: true,
+          text: 'Hello',
+        },
+      });
+      expect(entries[0].response.chunks).toContainEqual({ type: 'start' });
+    });
+
+    it('should handle Uint8Array chunks from TextEncoderStream', async () => {
+      app.get('/api/binary-stream', (req, res) => {
+        res.writeHead(200, {
+          'Content-Type': 'text/event-stream',
+        });
+
+        // Simulate TextEncoderStream output (Uint8Array)
+        const encoder = new TextEncoder();
+        res.write(encoder.encode('data: {"type":"start"}\n\n'));
+        res.write(encoder.encode('data: {"type":"text-delta","delta":"Binary"}\n\n'));
+        res.write(encoder.encode('data: {"type":"text-delta","delta":" works"}\n\n'));
+        res.write(encoder.encode('data: [DONE]\n\n'));
+        res.end();
+      });
+
+      await request(app)
+        .get('/api/binary-stream')
+        .expect(200);
+
+      const entries = readLogEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0]).toMatchObject({
+        type: 'http',
+        path: '/api/binary-stream',
+        response: {
+          streaming: true,
+          text: 'Binary works',
+        },
+      });
+    });
+
+    it('should auto-detect SSE from content when headers not set', async () => {
+      app.get('/api/auto-detect', (req, res) => {
+        // No SSE headers set, but content is SSE format
+        res.write('data: {"type":"start"}\n\n');
+        res.write('data: {"type":"text-delta","delta":"Auto"}\n\n');
+        res.write('data: {"type":"text-delta","delta":" detected"}\n\n');
+        res.end();
+      });
+
+      await request(app)
+        .get('/api/auto-detect')
+        .expect(200);
+
+      const entries = readLogEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0]).toMatchObject({
+        type: 'http',
+        path: '/api/auto-detect',
+        response: {
+          streaming: true,
+          text: 'Auto detected',
+        },
+      });
+    });
+
+    it('should handle writeHead with statusMessage parameter', async () => {
+      app.get('/api/writehead-msg', (req, res) => {
+        // writeHead(statusCode, statusMessage, headers)
+        res.writeHead(200, 'OK', {
+          'Content-Type': 'text/event-stream',
+        });
+
+        res.write('data: {"type":"text-delta","delta":"Test"}\n\n');
+        res.end();
+      });
+
+      await request(app)
+        .get('/api/writehead-msg')
+        .expect(200);
+
+      const entries = readLogEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0].response.streaming).toBe(true);
+      expect(entries[0].response.text).toBe('Test');
+    });
+  });
+
+  describe('SSE Text Delta Parsing', () => {
+    it('should aggregate text-delta chunks into text field', async () => {
+      app.get('/api/stream', (req, res) => {
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.setHeader('Connection', 'keep-alive');
+
+        res.write('data: {"type":"start"}\n\n');
+        res.write('data: {"type":"text-delta","id":"0","delta":"Hello"}\n\n');
+        res.write('data: {"type":"text-delta","id":"0","delta":" world"}\n\n');
+        res.write('data: {"type":"text-delta","id":"0","delta":"!"}\n\n');
+        res.write('data: {"type":"finish","finishReason":"stop"}\n\n');
+        res.write('data: [DONE]\n\n');
+        res.end();
+      });
+
+      await request(app)
+        .get('/api/stream')
+        .set('Accept', 'text/event-stream')
+        .expect(200);
+
+      const entries = readLogEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0]).toMatchObject({
+        timestamp: '2024-01-15T10:30:00.000Z',
+        type: 'http',
+        method: 'GET',
+        path: '/api/stream',
+        statusCode: 200,
+        response: {
+          streaming: true,
+          text: 'Hello world!',
+        },
+      });
+      expect(entries[0].response.chunks).toContainEqual({ type: 'start' });
+      expect(entries[0].response.chunks).toContainEqual({ type: 'text-delta', id: '0', delta: 'Hello' });
+      expect(entries[0].response.chunks).toContainEqual({ type: 'done' });
+    });
+  });
+
   describe('File Size Management', () => {
     it('should truncate log file when exceeding max size', async () => {
       vi.useRealTimers(); // Use real timers for this test