vedatrace 0.1.8 → 0.2.0

package/dist/index.mjs

@@ -1,26 +1,60 @@
-import { VedaTraceHttpTransport, VedaTraceConsoleTransport } from './transports/index.mjs';
+import { VedaTraceHttpTransportBrowser, VedaTraceHttpTransport, VedaTraceConsoleTransport } from './transports/index.mjs';
 
 class VedaTraceBatcher {
-  constructor(transports, config, onError, onSuccess, immediateFlush = false) {
+  constructor(transports, config, immediateFlush = false) {
     this.transports = transports;
     this.config = config;
-    this.onError = onError;
-    this.onSuccess = onSuccess;
     this.immediateFlush = immediateFlush;
-    this.startFlushTimer();
+    this.context = config.executionContext;
   }
   queue = [];
   flushTimer = null;
+  flushDebounceTimer = null;
   isFlushing = false;
   pendingFlush = null;
-  /** Add log to queue */
+  context;
+  /** Attach execution context after initialization */
+  setContext(ctx) {
+    this.context = ctx;
+  }
+  /** Get current context */
+  getContext() {
+    return this.context;
+  }
+  /** Add log to queue with context-aware flush */
   add(log) {
     this.queue.push(log);
-    if (this.immediateFlush || this.queue.length >= this.config.batchSize) {
+    if (!this.flushTimer && !this.immediateFlush) {
+      this.startFlushTimer();
+    }
+    if (this.immediateFlush || this.context) {
+      this.debouncedFlush();
+    } else if (this.queue.length >= this.config.batchSize) {
       this.flush();
     }
   }
-  /** Flush logs to all transports */
+  /** Debounced flush - prevents rapid-fire flushes */
+  debouncedFlush() {
+    if (this.flushDebounceTimer) {
+      clearTimeout(this.flushDebounceTimer);
+    }
+    this.flushDebounceTimer = setTimeout(() => {
+      this.flushDebounceTimer = null;
+      this.flush().catch((error) => {
+        if (this.config.onError) {
+          this.config.onError(
+            error instanceof Error ? error : new Error(String(error))
+          );
+        } else {
+          console.error(
+            "[VedaTrace] Debounced flush error:",
+            error instanceof Error ? error.message : String(error)
+          );
+        }
+      });
+    }, 100);
+  }
+  /** Flush logs to all transports with waitUntil protection */
   async flush() {
     if (this.isFlushing) {
       return this.pendingFlush ?? Promise.resolve();
@@ -31,13 +65,16 @@ class VedaTraceBatcher {
     this.isFlushing = true;
     const logsToSend = [...this.queue];
     this.queue = [];
-    this.pendingFlush = this.sendWithRetry(logsToSend).finally(() => {
+    const flushPromise = this.sendWithRetry(logsToSend).finally(() => {
       this.isFlushing = false;
       this.pendingFlush = null;
     });
-    return this.pendingFlush;
+    this.pendingFlush = flushPromise;
+    if (this.context) {
+      this.context.waitUntil(flushPromise);
+    }
+    return flushPromise;
   }
-  /** Send logs with retry logic */
   async sendWithRetry(logs, attempt = 0) {
     const errors = [];
     for (const transport of this.transports) {
@@ -55,16 +92,17 @@ class VedaTraceBatcher {
       const combinedError = new Error(
         `Failed to send logs after ${this.config.maxRetries} retries: ${errors.map((e) => e.message).join(", ")}`
       );
-      if (this.onError) {
-        this.onError(combinedError);
+      if (this.config.onError) {
+        this.config.onError(combinedError);
       } else {
         console.error("[VedaTrace]", combinedError.message);
       }
       return;
     }
-    this.onSuccess?.();
+    if (this.config.onSuccess) {
+      this.config.onSuccess();
+    }
   }
-  /** Start the flush interval timer */
   startFlushTimer() {
     if (this.flushTimer) {
       clearInterval(this.flushTimer);
@@ -72,8 +110,8 @@ class VedaTraceBatcher {
     this.flushTimer = setInterval(() => {
       if (this.queue.length > 0) {
         this.flush().catch((error) => {
-          if (this.onError) {
-            this.onError(
+          if (this.config.onError) {
+            this.config.onError(
               error instanceof Error ? error : new Error(String(error))
             );
           } else {
@@ -89,30 +127,84 @@ class VedaTraceBatcher {
       this.flushTimer.unref();
     }
   }
-  /** Stop the flush timer */
   stop() {
     if (this.flushTimer) {
       clearInterval(this.flushTimer);
       this.flushTimer = null;
     }
+    if (this.flushDebounceTimer) {
+      clearTimeout(this.flushDebounceTimer);
+      this.flushDebounceTimer = null;
+    }
+  }
+  start() {
+    if (!this.flushTimer && !this.immediateFlush) {
+      this.startFlushTimer();
+    }
   }
-  /** Delay helper */
   delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
-  /** Get current queue size */
   getQueueSize() {
     return this.queue.length;
   }
+  setExecutionContext(ctx) {
+    this.context = ctx;
+  }
+}
+
+function detectRuntime() {
+  if (typeof navigator !== "undefined" && navigator.userAgent === "Cloudflare-Workers") {
+    return "cloudflare";
+  }
+  const g = globalThis;
+  if (g?.Deno && g.Deno.version?.deno) {
+    return "deno";
+  }
+  if (g?.Bun) {
+    return "bun";
+  }
+  if (typeof g?.WebSocketPair !== "undefined") {
+    return "cloudflare";
+  }
+  if (typeof process !== "undefined" && process.versions?.node) {
+    return "node";
+  }
+  if (typeof window !== "undefined" && typeof document !== "undefined") {
+    return "browser";
+  }
+  if (typeof fetch !== "undefined" && typeof window === "undefined" && typeof process === "undefined") {
+    return "edge";
+  }
+  return "edge";
+}
+function isEdgeRuntime() {
+  const runtime = detectRuntime();
+  return runtime === "cloudflare" || runtime === "deno" || runtime === "bun" || runtime === "edge";
+}
+function isServerless() {
+  const runtime = detectRuntime();
+  return runtime === "cloudflare" || runtime === "edge";
+}
+function isLongRunning() {
+  const runtime = detectRuntime();
+  return runtime === "node" || runtime === "bun" || runtime === "deno";
+}
+function isBrowser() {
+  return detectRuntime() === "browser";
 }
 
-const SDK_VERSION = "1.0.0";
+const SDK_VERSION = process.env.npm_package_version ?? "0.0.0";
 class VedaTraceLogger {
   batcher = null;
+  runtime;
   config;
   childDefaults;
+  _context;
   constructor(config = {}, childDefaults = {}) {
+    this.runtime = config.runtime ?? detectRuntime();
     this.childDefaults = childDefaults;
+    this._context = config.executionContext;
     this.config = {
       service: config.service,
       apiKey: config.apiKey,
@@ -122,61 +214,68 @@ class VedaTraceLogger {
       flushInterval: config.flushInterval ?? 5e3,
       maxRetries: config.maxRetries ?? 3,
       retryDelay: config.retryDelay ?? 1e3,
-      onError: config.onError,
-      onSuccess: config.onSuccess,
       debug: config.debug ?? false,
       immediateFlush: config.immediateFlush ?? false,
-      unrefTimer: config.unrefTimer
+      unrefTimer: config.unrefTimer ?? false
     };
     if (!config.disabled) {
       this.initializeBatcher(config);
     }
   }
-  /** Initialize the batcher with transports */
   initializeBatcher(config) {
     const transports = config.transports ?? [];
-    if (config.apiKey && transports.length === 0) ;
     if (transports.length > 0) {
+      const batcherConfig = {
+        batchSize: this.config.batchSize,
+        flushInterval: this.config.flushInterval,
+        maxRetries: this.config.maxRetries,
+        retryDelay: this.config.retryDelay,
+        unrefTimer: this.config.unrefTimer,
+        executionContext: this._context,
+        onError: config.onError,
+        onSuccess: config.onSuccess
+      };
       this.batcher = new VedaTraceBatcher(
         transports,
-        {
-          batchSize: this.config.batchSize,
-          flushInterval: this.config.flushInterval,
-          maxRetries: this.config.maxRetries,
-          retryDelay: this.config.retryDelay,
-          unrefTimer: this.config.unrefTimer
-        },
-        this.config.onError,
-        this.config.onSuccess,
+        batcherConfig,
         this.config.immediateFlush
       );
     }
   }
-  /** Set batcher (called from factory function) */
   setBatcher(batcher) {
     this.batcher = batcher;
   }
-  /** Log at debug level */
+  /** Attach execution context for waitUntil support (Cloudflare Workers / Pages) */
+  withContext(ctx) {
+    this._context = ctx;
+    if (this.batcher) {
+      this.batcher.setContext(ctx);
+    }
+    return this;
+  }
+  /** Check if context is attached */
+  hasContext() {
+    return this._context !== void 0;
+  }
+  /** Get current execution context */
+  getContext() {
+    return this._context;
+  }
   debug(message, metadata) {
     this.log("debug", message, metadata);
   }
-  /** Log at info level */
   info(message, metadata) {
     this.log("info", message, metadata);
   }
-  /** Log at warn level */
   warn(message, metadata) {
     this.log("warn", message, metadata);
   }
-  /** Log at error level */
   error(message, metadata) {
     this.log("error", message, metadata);
   }
-  /** Log at fatal level */
   fatal(message, metadata) {
     this.log("fatal", message, metadata);
   }
-  /** Internal log method */
   log(level, message, metadata) {
     if (!this.batcher) {
       return;
@@ -191,7 +290,7 @@ class VedaTraceLogger {
       timestamp: Date.now(),
       metadata: cleanMetadata,
       _sdk: {
-        source: this.detectEnvironment(),
+        source: detectRuntime(),
         version: SDK_VERSION
       }
     };
@@ -204,7 +303,6 @@ class VedaTraceLogger {
     }
     this.batcher.add(logEntry);
   }
-  /** Create a child logger with default metadata */
   child(defaults) {
     const mergedDefaults = { ...this.childDefaults, ...defaults };
     const childLogger = new VedaTraceLogger(
@@ -213,7 +311,8 @@ class VedaTraceLogger {
         apiKey: this.config.apiKey,
         endpoint: this.config.endpoint,
         environment: this.config.environment,
-        disabled: !this.batcher
+        disabled: !this.batcher,
+        executionContext: this._context
       },
       mergedDefaults
     );
@@ -222,27 +321,132 @@ class VedaTraceLogger {
     }
     return childLogger;
   }
-  /** Flush pending logs */
   async flush() {
     if (this.batcher) {
-      await this.batcher.flush();
+      const flushPromise = this.batcher.flush();
+      if (this._context) {
+        this._context.waitUntil(flushPromise);
+      }
+      return flushPromise;
     }
   }
-  /** Stop the batcher and flush timer */
   stop() {
     if (this.batcher) {
       this.batcher.stop();
     }
   }
-  /** Detect runtime environment */
-  detectEnvironment() {
-    if (typeof globalThis !== "undefined" && "navigator" in globalThis) {
-      return "browser";
+  start() {
+    if (this.batcher) {
+      this.batcher.start();
     }
-    if (typeof process !== "undefined" && process.versions?.node) {
-      return "node";
+  }
+}
+
+class BrowserLifecycle {
+  constructor(config) {
+    this.config = config;
+    this.boundVisibilityHandler = this.handleVisibilityChange.bind(this);
+    this.boundPageHideHandler = this.handlePageHide.bind(this);
+    this.boundBeforeUnloadHandler = this.handleBeforeUnload.bind(this);
+    this.boundUnloadHandler = this.handleUnload.bind(this);
+  }
+  boundVisibilityHandler;
+  boundPageHideHandler;
+  boundBeforeUnloadHandler;
+  boundUnloadHandler;
+  isAttached = false;
+  pendingFlush = null;
+  /** Start listening for browser lifecycle events */
+  attach() {
+    if (this.isAttached) return;
+    if (typeof document !== "undefined") {
+      document.addEventListener("visibilitychange", this.boundVisibilityHandler);
+      window.addEventListener("pagehide", this.boundPageHideHandler);
+      window.addEventListener("beforeunload", this.boundBeforeUnloadHandler);
+      window.addEventListener("unload", this.boundUnloadHandler);
+    }
+    this.isAttached = true;
+    if (this.config.debug) {
+      console.log("[VedaTrace] Browser lifecycle handlers attached");
+    }
+  }
+  /** Stop listening for browser lifecycle events */
+  detach() {
+    if (!this.isAttached) return;
+    if (typeof document !== "undefined") {
+      document.removeEventListener(
+        "visibilitychange",
+        this.boundVisibilityHandler
+      );
+      window.removeEventListener("pagehide", this.boundPageHideHandler);
+      window.removeEventListener("beforeunload", this.boundBeforeUnloadHandler);
+      window.removeEventListener("unload", this.boundUnloadHandler);
+    }
+    this.isAttached = false;
+    if (this.config.debug) {
+      console.log("[VedaTrace] Browser lifecycle handlers detached");
     }
-    return "edge";
+  }
+  /** Handle visibility change - flush when page becomes hidden */
+  handleVisibilityChange() {
+    if (document.visibilityState === "hidden") {
+      if (this.config.debug) {
+        console.log("[VedaTrace] Page became hidden, flushing logs");
+      }
+      this.scheduleFlush();
+    }
+  }
+  /** Handle pagehide event - primary flush handler for Safari */
+  handlePageHide(event) {
+    if (this.config.debug) {
+      console.log(
+        "[VedaTrace] Page hide event",
+        event.persisted ? "(cached)" : "(navigation)"
+      );
+    }
+    if (event.persisted) {
+      this.scheduleFlush();
+    } else {
+      this.finalFlush();
+    }
+  }
+  /** Handle beforeunload - backup flush mechanism */
+  handleBeforeUnload(event) {
+    if (this.config.debug) {
+      console.log("[VedaTrace] Before unload event");
+    }
+    this.finalFlush();
+  }
+  /** Handle unload - fallback for older browsers */
+  handleUnload() {
+    if (this.config.debug) {
+      console.log("[VedaTrace] Unload event");
+    }
+    this.finalFlush();
+  }
+  /** Schedule a debounced flush (for visibility change) */
+  scheduleFlush() {
+    if (this.pendingFlush) return;
+    this.pendingFlush = this.config.flush().finally(() => {
+      this.pendingFlush = null;
+    });
+  }
+  /**
+   * Final flush using keepalive fetch
+   * For sending logs after the page context is destroyed
+   */
+  finalFlush() {
+    for (const transport of this.config.transports) {
+      if (transport.name === "http" && "flush" in transport) {
+        transport.flush?.();
+      }
+    }
+    this.config.flush().catch(() => {
+    });
+  }
+  /** Check if handlers are attached */
+  isActive() {
+    return this.isAttached;
   }
 }
 
@@ -320,26 +524,55 @@ function redactPii(value, mask) {
   return result;
 }
 
+const RUNTIME_FLUSH_INTERVALS = {
+  node: 3e3,
+  bun: 3e3,
+  deno: 3e3,
+  browser: 3e3,
+  cloudflare: 1e3,
+  edge: 1e3
+};
 function vedatrace(config = {}) {
+  const runtime = detectRuntime();
   const logger = new VedaTraceLogger(config);
   if (config.apiKey && (!config.transports || config.transports.length === 0)) {
-    const httpConfig = { apiKey: config.apiKey };
+    const isBrowserEnv = isBrowser();
+    const isServerlessEnv = isServerless();
+    const isLongRunningEnv = isLongRunning();
+    const HttpTransport = isBrowserEnv ? VedaTraceHttpTransportBrowser : VedaTraceHttpTransport;
+    const httpConfig = {
+      apiKey: config.apiKey,
+      keepalive: isBrowserEnv
+    };
     if (config.endpoint) httpConfig.endpoint = config.endpoint;
-    const httpTransport = new VedaTraceHttpTransport(httpConfig);
+    const httpTransport = new HttpTransport(httpConfig);
+    let immediateFlush = config.immediateFlush ?? false;
+    let shouldUnrefTimer = false;
+    if (isServerlessEnv) {
+      immediateFlush = config.immediateFlush ?? !config.executionContext;
+    } else if (isLongRunningEnv) {
+      immediateFlush = config.immediateFlush ?? false;
+      shouldUnrefTimer = true;
+    } else if (isBrowserEnv) {
+      immediateFlush = config.immediateFlush ?? false;
+    }
+    const flushInterval = config.flushInterval ?? RUNTIME_FLUSH_INTERVALS[runtime] ?? 3e3;
     const batcher = new VedaTraceBatcher(
       [httpTransport],
       {
         batchSize: config.batchSize ?? 100,
-        flushInterval: config.flushInterval ?? 1e3,
+        flushInterval,
         maxRetries: config.maxRetries ?? 3,
         retryDelay: config.retryDelay ?? 1e3,
-        unrefTimer: config.unrefTimer
+        unrefTimer: config.unrefTimer ?? shouldUnrefTimer,
+        executionContext: config.executionContext,
+        onError: config.onError,
+        onSuccess: config.onSuccess
       },
-      config.onError,
-      config.onSuccess
+      immediateFlush
     );
     logger.setBatcher(batcher);
-    if (typeof process !== "undefined") {
+    if (typeof process !== "undefined" && isLongRunningEnv) {
       const flushLogs = async () => {
         await batcher.flush();
       };
@@ -347,6 +580,15 @@ function vedatrace(config = {}) {
       process.on("SIGTERM", flushLogs);
       process.on("SIGINT", flushLogs);
     }
+    if (isBrowserEnv) {
+      const lifecycle = new BrowserLifecycle({
+        transports: [httpTransport],
+        flush: () => batcher.flush(),
+        debug: config.debug
+      });
+      lifecycle.attach();
+      logger._lifecycle = lifecycle;
+    }
   }
   return logger;
 }
@@ -363,4 +605,4 @@ function devVedatrace(config = {}) {
   });
 }
 
-export { VedaTraceBatcher, VedaTraceConsoleTransport, VedaTraceHttpTransport, VedaTraceLogger, vedatrace as default, devVedatrace, redact, vedatrace };
+export { BrowserLifecycle, VedaTraceBatcher, VedaTraceConsoleTransport, VedaTraceHttpTransport, VedaTraceHttpTransportBrowser, VedaTraceLogger, vedatrace as default, detectRuntime, devVedatrace, isBrowser, isEdgeRuntime, isLongRunning, isServerless, redact, vedatrace };

package/dist/integrations/express.d.cts

@@ -1,5 +1,5 @@
 import { Request, Response, NextFunction } from 'express';
-import { V as VedaTraceLoggerInterface, a as VedaTraceConfig, L as LogMetadata } from '../types-CcdFb-vY.cjs';
+import { V as VedaTraceLoggerInterface, a as VedaTraceConfig, L as LogMetadata } from '../types-BU0UESs9.cjs';
 
 /**
  * Express.js middleware integration for VedaTrace

package/dist/integrations/express.d.mts

@@ -1,5 +1,5 @@
 import { Request, Response, NextFunction } from 'express';
-import { V as VedaTraceLoggerInterface, a as VedaTraceConfig, L as LogMetadata } from '../types-CcdFb-vY.mjs';
+import { V as VedaTraceLoggerInterface, a as VedaTraceConfig, L as LogMetadata } from '../types-BU0UESs9.mjs';
 
 /**
  * Express.js middleware integration for VedaTrace

package/dist/integrations/nextjs.d.cts

@@ -1,4 +1,4 @@
-import { a as VedaTraceConfig, L as LogMetadata, V as VedaTraceLoggerInterface } from '../types-CcdFb-vY.cjs';
+import { a as VedaTraceConfig, L as LogMetadata, V as VedaTraceLoggerInterface } from '../types-BU0UESs9.cjs';
 
 /**
  * Next.js integration for VedaTrace

package/dist/integrations/nextjs.d.mts

@@ -1,4 +1,4 @@
-import { a as VedaTraceConfig, L as LogMetadata, V as VedaTraceLoggerInterface } from '../types-CcdFb-vY.mjs';
+import { a as VedaTraceConfig, L as LogMetadata, V as VedaTraceLoggerInterface } from '../types-BU0UESs9.mjs';
 
 /**
  * Next.js integration for VedaTrace

package/dist/integrations/react.cjs

@@ -39,10 +39,9 @@ function useVedaTrace() {
 function useVedaTraceChild(metadata) {
   const parentLogger = useVedaTrace();
   const metadataRef = react.useRef(metadata);
-  const childLogger = react.useMemo(() => {
+  return react.useMemo(() => {
     return parentLogger.child(metadataRef.current);
   }, [parentLogger]);
-  return childLogger;
 }
 function useVedaTraceLifecycle(componentName, metadata) {
   const logger = useVedaTrace();

package/dist/integrations/react.d.cts

@@ -1,5 +1,5 @@
 import { ReactNode, ReactElement } from 'react';
-import { a as VedaTraceConfig, V as VedaTraceLoggerInterface, L as LogMetadata } from '../types-CcdFb-vY.cjs';
+import { a as VedaTraceConfig, V as VedaTraceLoggerInterface, L as LogMetadata } from '../types-BU0UESs9.cjs';
 
 /**
  * React integration for VedaTrace

package/dist/integrations/react.d.mts

@@ -1,5 +1,5 @@
 import { ReactNode, ReactElement } from 'react';
-import { a as VedaTraceConfig, V as VedaTraceLoggerInterface, L as LogMetadata } from '../types-CcdFb-vY.mjs';
+import { a as VedaTraceConfig, V as VedaTraceLoggerInterface, L as LogMetadata } from '../types-BU0UESs9.mjs';
 
 /**
  * React integration for VedaTrace

package/dist/integrations/react.mjs

@@ -37,10 +37,9 @@ function useVedaTrace() {
 function useVedaTraceChild(metadata) {
   const parentLogger = useVedaTrace();
   const metadataRef = useRef(metadata);
-  const childLogger = useMemo(() => {
+  return useMemo(() => {
     return parentLogger.child(metadataRef.current);
   }, [parentLogger]);
-  return childLogger;
 }
 function useVedaTraceLifecycle(componentName, metadata) {
   const logger = useVedaTrace();

package/dist/transports/index.cjs

@@ -82,11 +82,13 @@ class VedaTraceHttpTransport {
   apiKey;
   timeout;
   headers;
+  keepalive;
   constructor(config) {
     this.apiKey = config.apiKey;
     this.endpoint = config.endpoint ?? "https://ingest.vedatrace.dev/v1/logs";
     this.timeout = config.timeout ?? 3e4;
     this.headers = config.headers ?? {};
+    this.keepalive = config.keepalive ?? false;
   }
   /** Send logs via HTTP POST */
   async send(logs) {
@@ -108,7 +110,8 @@ class VedaTraceHttpTransport {
           ...this.headers
         },
         body: JSON.stringify(payload),
-        signal: controller.signal
+        signal: controller.signal,
+        keepalive: this.keepalive
       });
       clearTimeout(timeoutId);
       if (!response.ok) {
@@ -126,7 +129,29 @@ class VedaTraceHttpTransport {
       throw new Error(String(error));
     }
   }
+  /** Flush pending logs - called on page unload */
+  async flush() {
+    return Promise.resolve();
+  }
+  /** Check if keepalive is enabled */
+  isKeepaliveEnabled() {
+    return this.keepalive;
+  }
+  /** Enable/disable keepalive */
+  setKeepalive(enabled) {
+    this.keepalive = enabled;
+  }
+}
+class VedaTraceHttpTransportBrowser extends VedaTraceHttpTransport {
+  constructor(config) {
+    super({ ...config, keepalive: true });
+  }
+  async flush() {
+    this.setKeepalive(true);
+    return super.flush();
+  }
 }
 
 exports.VedaTraceConsoleTransport = VedaTraceConsoleTransport;
 exports.VedaTraceHttpTransport = VedaTraceHttpTransport;
+exports.VedaTraceHttpTransportBrowser = VedaTraceHttpTransportBrowser;