@johpaz/hive-core 1.0.7 → 1.0.10

package/src/utils/logger.ts

@@ -1,4 +1,4 @@
-import * as fs from "node:fs";
+import { mkdirSync, unlinkSync, renameSync, existsSync } from "node:fs";
 import * as path from "node:path";
 
 export type LogLevel = "debug" | "info" | "warn" | "error";
@@ -12,6 +12,18 @@ export interface LoggerConfig {
   console: boolean;
 }
 
+export interface LogMeta extends Record<string, unknown> {
+  correlationId?: string;
+  sessionId?: string;
+  userId?: string;
+  agentId?: string;
+  channel?: string;
+  toolName?: string;
+  duration?: number;
+  error?: string;
+  stack?: string;
+}
+
 const LOG_LEVELS: Record<LogLevel, number> = {
   debug: 0,
   info: 1,
@@ -78,16 +90,18 @@ function formatTimestamp(): string {
   return new Date().toISOString();
 }
 
-function formatMessage(level: LogLevel, message: string, meta?: unknown): string {
+function formatMessage(level: LogLevel, message: string, meta?: unknown, correlationId?: string): string {
   const timestamp = formatTimestamp();
+  const corrStr = correlationId ? ` [${correlationId.slice(0, 8)}]` : "";
   const metaStr = meta ? ` ${JSON.stringify(meta)}` : "";
-  return `[${timestamp}] [${level.toUpperCase()}] ${message}${metaStr}`;
+  return `[${timestamp}]${corrStr} [${level.toUpperCase()}] ${message}${metaStr}`;
 }
 
 export class Logger {
   private config: LoggerConfig;
   private logFile: string | null = null;
   private currentSize = 0;
+  private correlationContext: LogMeta = {};
 
   constructor(config: Partial<LoggerConfig> = {}) {
     this.config = {
@@ -102,20 +116,35 @@ export class Logger {
     this.initLogFile();
   }
 
+  setCorrelationContext(context: Partial<LogMeta>): void {
+    this.correlationContext = { ...this.correlationContext, ...context };
+  }
+
+  clearCorrelationContext(): void {
+    this.correlationContext = {};
+  }
+
+  getCorrelationId(): string | undefined {
+    return this.correlationContext.correlationId;
+  }
+
+  withCorrelationId(id: string): this {
+    this.correlationContext.correlationId = id;
+    return this;
+  }
+
   private initLogFile(): void {
     const logDir = expandPath(this.config.dir);
-    
+
     try {
-      if (!fs.existsSync(logDir)) {
-        fs.mkdirSync(logDir, { recursive: true });
+      if (!existsSync(logDir)) {
+        mkdirSync(logDir, { recursive: true });
       }
 
       this.logFile = path.join(logDir, `hive-${new Date().toISOString().split("T")[0]}.log`);
-      
-      if (fs.existsSync(this.logFile)) {
-        const stats = fs.statSync(this.logFile);
-        this.currentSize = stats.size;
-      }
+
+      const file = Bun.file(this.logFile);
+      this.currentSize = file.size ?? 0;
     } catch {
       this.logFile = null;
     }
@@ -129,13 +158,31 @@ export class Logger {
     if (!this.config.console) return;
 
     const color = COLORS[level];
-    const displayMeta = this.config.redactSensitive && meta ? redact(meta) : meta;
-    const metaStr = displayMeta ? ` ${JSON.stringify(displayMeta)}` : "";
+    const mergedMeta = this.mergeMeta(meta);
+    const displayMeta = this.config.redactSensitive && mergedMeta ? redact(mergedMeta) : mergedMeta;
+    const metaStr = displayMeta && Object.keys(displayMeta as object).length > 0
+      ? ` ${JSON.stringify(displayMeta)}`
+      : "";
 
     const prefix = `${COLORS.dim}${formatTimestamp()}${COLORS.reset}`;
+    const corrStr = this.correlationContext.correlationId
+      ? ` ${COLORS.dim}[${this.correlationContext.correlationId.slice(0, 8)}]${COLORS.reset}`
+      : "";
     const levelStr = `${color}${COLORS.bright}[${level.toUpperCase().padEnd(5)}]${COLORS.reset}`;
-    
-    console.log(`${prefix} ${levelStr} ${message}${metaStr}`);
+
+    console.log(`${prefix}${corrStr} ${levelStr} ${message}${metaStr}`);
+  }
+
+  private mergeMeta(meta?: unknown): LogMeta | undefined {
+    if (!meta && Object.keys(this.correlationContext).length === 0) return undefined;
+
+    const contextWithoutCorrId = { ...this.correlationContext };
+    delete contextWithoutCorrId.correlationId;
+
+    if (!meta) return contextWithoutCorrId;
+    if (typeof meta !== "object") return meta as LogMeta;
+
+    return { ...contextWithoutCorrId, ...(meta as LogMeta) };
   }
 
   private writeToFile(message: string): void {
@@ -144,12 +191,15 @@ export class Logger {
     try {
       const line = message + "\n";
       const bytes = Buffer.byteLength(line);
-      
+
       if (this.currentSize + bytes > this.config.maxSizeMB * 1024 * 1024) {
         this.rotateLogs();
       }
 
-      fs.appendFileSync(this.logFile, line);
+      // Use sync append for logging reliability
+      const encoder = new TextEncoder();
+      const data = encoder.encode(line);
+      Bun.write(this.logFile, data).catch(() => { });
       this.currentSize += bytes;
     } catch {
       // Silently fail if we can't write to log file
@@ -165,13 +215,13 @@ export class Logger {
     for (let i = this.config.maxFiles - 1; i >= 1; i--) {
       const oldFile = path.join(logDir, `${baseName}.${i}.log`);
       const newFile = path.join(logDir, `${baseName}.${i + 1}.log`);
-      
+
       try {
-        if (fs.existsSync(oldFile)) {
+        if (existsSync(oldFile)) {
           if (i === this.config.maxFiles - 1) {
-            fs.unlinkSync(oldFile);
+            unlinkSync(oldFile);
           } else {
-            fs.renameSync(oldFile, newFile);
+            renameSync(oldFile, newFile);
           }
         }
       } catch {
@@ -180,7 +230,7 @@ export class Logger {
     }
 
     try {
-      fs.renameSync(this.logFile, path.join(logDir, `${baseName}.1.log`));
+      renameSync(this.logFile, path.join(logDir, `${baseName}.1.log`));
       this.currentSize = 0;
     } catch {
       // Continue even if rotation fails
@@ -189,34 +239,38 @@ export class Logger {
 
   debug(message: string, meta?: unknown): void {
     if (!this.shouldLog("debug")) return;
-    const formatted = formatMessage("debug", message, meta);
+    const mergedMeta = this.mergeMeta(meta);
+    const formatted = formatMessage("debug", message, mergedMeta, this.correlationContext.correlationId);
     this.writeToConsole("debug", message, meta);
     this.writeToFile(formatted);
   }
 
   info(message: string, meta?: unknown): void {
     if (!this.shouldLog("info")) return;
-    const formatted = formatMessage("info", message, meta);
+    const mergedMeta = this.mergeMeta(meta);
+    const formatted = formatMessage("info", message, mergedMeta, this.correlationContext.correlationId);
     this.writeToConsole("info", message, meta);
     this.writeToFile(formatted);
   }
 
   warn(message: string, meta?: unknown): void {
     if (!this.shouldLog("warn")) return;
-    const formatted = formatMessage("warn", message, meta);
+    const mergedMeta = this.mergeMeta(meta);
+    const formatted = formatMessage("warn", message, mergedMeta, this.correlationContext.correlationId);
     this.writeToConsole("warn", message, meta);
     this.writeToFile(formatted);
   }
 
   error(message: string, meta?: unknown): void {
     if (!this.shouldLog("error")) return;
-    const formatted = formatMessage("error", message, meta);
+    const mergedMeta = this.mergeMeta(meta);
+    const formatted = formatMessage("error", message, mergedMeta, this.correlationContext.correlationId);
     this.writeToConsole("error", message, meta);
     this.writeToFile(formatted);
   }
 
   child(context: string): ChildLogger {
-    return new ChildLogger(this, context);
+    return new ChildLogger(this, context, this.correlationContext);
   }
 
   setLevel(level: LogLevel): void {
@@ -227,27 +281,52 @@ export class Logger {
 export class ChildLogger {
   constructor(
     private parent: Logger,
-    private context: string
-  ) {}
+    private context: string,
+    private correlationContext: LogMeta = {}
+  ) { }
 
   private prefix(message: string): string {
     return `[${this.context}] ${message}`;
   }
 
+  withCorrelationId(id: string): this {
+    this.correlationContext.correlationId = id;
+    return this;
+  }
+
+  setContext(context: Partial<LogMeta>): void {
+    this.correlationContext = { ...this.correlationContext, ...context };
+  }
+
   debug(message: string, meta?: unknown): void {
-    this.parent.debug(this.prefix(message), meta);
+    this.parent.debug(this.prefix(message), this.mergeMeta(meta));
   }
 
   info(message: string, meta?: unknown): void {
-    this.parent.info(this.prefix(message), meta);
+    this.parent.info(this.prefix(message), this.mergeMeta(meta));
   }
 
   warn(message: string, meta?: unknown): void {
-    this.parent.warn(this.prefix(message), meta);
+    this.parent.warn(this.prefix(message), this.mergeMeta(meta));
   }
 
   error(message: string, meta?: unknown): void {
-    this.parent.error(this.prefix(message), meta);
+    this.parent.error(this.prefix(message), this.mergeMeta(meta));
+  }
+
+  child(subContext: string): ChildLogger {
+    return new ChildLogger(
+      this.parent,
+      `${this.context}:${subContext}`,
+      this.correlationContext
+    );
+  }
+
+  private mergeMeta(meta?: unknown): LogMeta | undefined {
+    if (!meta && Object.keys(this.correlationContext).length === 0) return undefined;
+    if (!meta) return { ...this.correlationContext };
+    if (typeof meta !== "object") return meta as LogMeta;
+    return { ...this.correlationContext, ...(meta as LogMeta) };
   }
 }