fix order of execution for logging

Author: sebastiancrossa

package.json

@@ -1,6 +1,6 @@
 {
   "name": "zeroeval",
-  "version": "0.1.10",
+  "version": "0.1.13",
   "description": "ZeroEval TypeScript SDK",
   "keywords": [
     "observability",
@@ -79,8 +79,7 @@
     "example:openai": "npm run build && npx ts-node --esm examples/03-openai.ts",
     "example:langchain": "npm run build && npx ts-node --esm examples/04-langchain.ts",
     "example:vercel-ai": "npm run build && npx ts-node --esm examples/05-vercel-ai.ts",
-    "example:signals": "npm run build && npx ts-node --esm examples/06-signals.ts",
-    "prepublishOnly": "npm run clean && npm run lint && npm run test && npm run build"
+    "example:signals": "npm run build && npx ts-node --esm examples/06-signals.ts"
   },
   "peerDependencies": {
     "@ai-sdk/openai": "^1.3.22",

src/observability/Tracer.ts

@@ -8,7 +8,12 @@ import { BackendSpanWriter } from './writer';
 import { setInterval } from 'timers';
 import { discoverIntegrations } from './integrations/utils';
 import type { Integration } from './integrations/base';
-import { getLogger } from './logger';
+import { getLogger, Logger } from './logger';
+
+// Check for debug mode early
+if (process.env.ZEROEVAL_DEBUG?.toLowerCase() === 'true') {
+  Logger.setDebugMode(true);
+}
 
 const logger = getLogger('zeroeval.tracer');
 

src/observability/logger.ts

@@ -24,10 +24,22 @@ export enum LogLevel {
   CRITICAL = 4,
 }
 
+// Buffer to store early logs before debug mode is determined
+interface BufferedLog {
+  logger: Logger;
+  level: LogLevel;
+  levelName: string;
+  levelColor: string;
+  message: string;
+  args: unknown[];
+}
+
 class Logger {
   private name: string;
   private static globalLevel: LogLevel = LogLevel.WARN;
   private static isDebugMode: boolean = false;
+  private static earlyLogs: BufferedLog[] = [];
+  private static bufferEarlyLogs: boolean = true;
 
   constructor(name: string) {
     this.name = name;
@@ -36,6 +48,28 @@ class Logger {
   static setDebugMode(enabled: boolean): void {
     Logger.isDebugMode = enabled;
     Logger.globalLevel = enabled ? LogLevel.DEBUG : LogLevel.WARN;
+
+    // Stop buffering after debug mode is set
+    Logger.bufferEarlyLogs = false;
+
+    // Replay buffered logs if debug mode is enabled
+    if (enabled && Logger.earlyLogs.length > 0) {
+      console.log('[zeroeval] Replaying buffered debug logs...');
+      for (const log of Logger.earlyLogs) {
+        if (Logger.globalLevel <= log.level) {
+          const fn = log.level <= LogLevel.INFO ? console.log : console.error;
+          fn(
+            log.logger.formatMessage(
+              log.levelName,
+              log.levelColor,
+              log.message
+            ),
+            ...log.args
+          );
+        }
+      }
+      Logger.earlyLogs = [];
+    }
   }
 
   static isDebugEnabled(): boolean {
@@ -66,12 +100,38 @@ class Logger {
   }
 
   debug(message: string, ...args: unknown[]): void {
+    // Buffer debug logs if we haven't determined debug mode yet
+    if (Logger.bufferEarlyLogs && LogLevel.DEBUG >= Logger.globalLevel) {
+      Logger.earlyLogs.push({
+        logger: this,
+        level: LogLevel.DEBUG,
+        levelName: 'DEBUG',
+        levelColor: colors.blue,
+        message,
+        args,
+      });
+      return;
+    }
+
     if (Logger.globalLevel <= LogLevel.DEBUG) {
       console.log(this.formatMessage('DEBUG', colors.blue, message), ...args);
     }
   }
 
   info(message: string, ...args: unknown[]): void {
+    // Buffer info logs if we haven't determined debug mode yet
+    if (Logger.bufferEarlyLogs && LogLevel.INFO >= Logger.globalLevel) {
+      Logger.earlyLogs.push({
+        logger: this,
+        level: LogLevel.INFO,
+        levelName: 'INFO',
+        levelColor: colors.green,
+        message,
+        args,
+      });
+      return;
+    }
+
     if (Logger.globalLevel <= LogLevel.INFO) {
       console.log(this.formatMessage('INFO', colors.green, message), ...args);
     }