voltlog-io 1.0.5 → 1.0.7

package/dist/index.mjs

@@ -1,40 +1,418 @@
-import {
-  LogLevel,
-  LogLevelNameMap,
-  LogLevelValueMap,
-  aiEnrichmentMiddleware,
-  alertMiddleware,
-  batchTransport,
-  browserJsonStreamTransport,
-  consoleTransport,
-  createHttpLogger,
-  createLogger,
-  createMiddleware,
-  createOpenAiErrorAnalyzer,
-  createTransport,
-  datadogTransport,
-  deduplicationMiddleware,
-  discordTransport,
-  heapUsageMiddleware,
-  ipMiddleware,
-  levelOverrideMiddleware,
-  lokiTransport,
-  nodeHttpMappers,
-  ocppMiddleware,
-  otelTraceMiddleware,
-  otelTransport,
-  prettyTransport,
-  redactionMiddleware,
-  resolveLevel,
-  ringBufferTransport,
-  samplingMiddleware,
-  sentryTransport,
-  shouldIncludeStack,
-  shouldLog,
-  slackTransport,
-  userAgentMiddleware,
-  webhookTransport
-} from "./chunk-DAFMRCAN.mjs";
+// src/core/types.ts
+var LogLevel = {
+  TRACE: 10,
+  DEBUG: 20,
+  INFO: 30,
+  WARN: 40,
+  ERROR: 50,
+  FATAL: 60,
+  SILENT: Infinity
+};
+var LogLevelNameMap = Object.fromEntries(
+  Object.entries(LogLevel).map(([k, v]) => [k.toLowerCase(), v])
+);
+var LogLevelValueMap = Object.fromEntries(
+  Object.entries(LogLevel).filter(([, v]) => Number.isFinite(v)).map(([k, v]) => [v, k])
+);
+
+// src/core/levels.ts
+function resolveLevel(level) {
+  const n = LogLevelNameMap[level.toLowerCase()];
+  return n !== void 0 ? n : LogLevel.INFO;
+}
+function shouldLog(entryLevel, filterLevel) {
+  return entryLevel >= filterLevel;
+}
+function shouldIncludeStack(entryLevel, includeStack) {
+  if (typeof includeStack === "boolean") return includeStack;
+  return entryLevel >= resolveLevel(includeStack);
+}
+
+// src/core/pipeline.ts
+function composeMiddleware(middleware, final) {
+  if (middleware.length === 0) return final;
+  return (entry) => {
+    let index = 0;
+    const next = (e) => {
+      if (index < middleware.length) {
+        const mw = middleware[index++];
+        mw(e, next);
+      } else {
+        final(e);
+      }
+    };
+    next(entry);
+  };
+}
+function fanOutToTransports(entry, transports, loggerLevel) {
+  for (const t of transports) {
+    const tLevel = t.level ? resolveLevel(t.level) : loggerLevel;
+    if (!shouldLog(entry.level, tLevel)) continue;
+    try {
+      const result = t.write(entry);
+      if (result && typeof result.catch === "function") {
+        result.catch(() => {
+        });
+      }
+    } catch {
+    }
+  }
+}
+
+// src/core/logger.ts
+var randomUUID = typeof globalThis.crypto?.randomUUID === "function" ? () => globalThis.crypto.randomUUID() : () => "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+  const r = Math.random() * 16 | 0;
+  return (c === "x" ? r : r & 3 | 8).toString(16);
+});
+var LoggerImpl = class {
+  _level;
+  _transports;
+  _middlewareList;
+  _pipeline;
+  _context;
+  _includeStack;
+  _timestampFn;
+  _idFn;
+  constructor(options = {}) {
+    this._level = resolveLevel(options.level ?? "INFO");
+    this._transports = [...options.transports ?? []];
+    this._middlewareList = [...options.middleware ?? []];
+    this._context = options.context ? { ...options.context } : {};
+    this._includeStack = options.includeStack ?? "ERROR";
+    this._timestampFn = options.timestamp ?? Date.now;
+    this._idFn = options.idGenerator !== void 0 ? options.idGenerator : randomUUID;
+    this._pipeline = this._buildPipeline();
+  }
+  // ─── Log Methods ────────────────────────────────────────────
+  trace(message, meta) {
+    if (10 < this._level) return;
+    this._log(10, "TRACE", message, meta);
+  }
+  debug(message, meta) {
+    if (20 < this._level) return;
+    this._log(20, "DEBUG", message, meta);
+  }
+  info(message, meta) {
+    if (30 < this._level) return;
+    this._log(30, "INFO", message, meta);
+  }
+  warn(message, meta) {
+    if (40 < this._level) return;
+    this._log(40, "WARN", message, meta);
+  }
+  error(message, metaOrError, error) {
+    if (50 < this._level) return;
+    if (metaOrError instanceof Error) {
+      this._log(50, "ERROR", message, void 0, metaOrError);
+    } else {
+      this._log(50, "ERROR", message, metaOrError, error);
+    }
+  }
+  fatal(message, metaOrError, error) {
+    if (metaOrError instanceof Error) {
+      this._log(60, "FATAL", message, void 0, metaOrError);
+    } else {
+      this._log(60, "FATAL", message, metaOrError, error);
+    }
+  }
+  // ─── Child Logger ───────────────────────────────────────────
+  child(context) {
+    return new ChildLoggerImpl(this, { ...this._context, ...context });
+  }
+  // ─── Dynamic Configuration ─────────────────────────────────
+  addTransport(transport) {
+    this._transports.push(transport);
+  }
+  removeTransport(name) {
+    this._transports = this._transports.filter((t) => t.name !== name);
+  }
+  addMiddleware(middleware) {
+    this._middlewareList.push(middleware);
+    this._pipeline = this._buildPipeline();
+  }
+  removeMiddleware(middleware) {
+    this._middlewareList = this._middlewareList.filter((m) => m !== middleware);
+    this._pipeline = this._buildPipeline();
+  }
+  // ─── Level Control ─────────────────────────────────────────
+  setLevel(level) {
+    this._level = resolveLevel(level);
+  }
+  getLevel() {
+    return LogLevelValueMap[this._level] ?? "INFO";
+  }
+  isLevelEnabled(level) {
+    return resolveLevel(level) >= this._level;
+  }
+  // ─── Timer ─────────────────────────────────────────────────
+  startTimer(level) {
+    const start = performance.now();
+    const logLevel = level ?? "INFO";
+    return {
+      done: (message, meta) => {
+        const durationMs = Math.round(performance.now() - start);
+        const merged = { ...meta, durationMs };
+        const methodKey = logLevel.toLowerCase();
+        this[methodKey](message, merged);
+      },
+      elapsed: () => Math.round(performance.now() - start)
+    };
+  }
+  // ─── Lifecycle ──────────────────────────────────────────────
+  async flush() {
+    await Promise.all(this._transports.map((t) => t.flush?.()).filter(Boolean));
+  }
+  async close() {
+    await this.flush();
+    await Promise.all(this._transports.map((t) => t.close?.()).filter(Boolean));
+  }
+  // ─── Internal ───────────────────────────────────────────────
+  /** @internal */
+  _log(level, levelName, message, meta, error) {
+    this._logWithContext(level, levelName, message, this._context, meta, error);
+  }
+  /** @internal — used by child loggers to inject bound context */
+  _logWithContext(level, levelName, message, context, meta, error) {
+    if (!shouldLog(level, this._level)) return;
+    const entry = {
+      id: this._idFn ? this._idFn() : "",
+      level,
+      levelName,
+      message,
+      timestamp: this._timestampFn(),
+      meta: meta ?? {},
+      context: Object.keys(context).length > 0 ? context : void 0
+    };
+    if (error) {
+      entry.error = serializeError(
+        error,
+        shouldIncludeStack(level, this._includeStack)
+      );
+    }
+    this._pipeline(entry);
+  }
+  _buildPipeline() {
+    return composeMiddleware(this._middlewareList, (entry) => {
+      fanOutToTransports(entry, this._transports, this._level);
+    });
+  }
+};
+function serializeError(error, includeStack, depth = 0) {
+  const logError = {
+    message: error.message,
+    name: error.name,
+    code: error.code
+  };
+  if (includeStack) {
+    logError.stack = error.stack;
+  }
+  if (error.cause instanceof Error && depth < 5) {
+    logError.cause = serializeError(error.cause, includeStack, depth + 1);
+  }
+  return logError;
+}
+var ChildLoggerImpl = class _ChildLoggerImpl {
+  constructor(_parent, _context) {
+    this._parent = _parent;
+    this._context = _context;
+  }
+  trace(message, meta) {
+    this._parent._logWithContext(10, "TRACE", message, this._context, meta);
+  }
+  debug(message, meta) {
+    this._parent._logWithContext(20, "DEBUG", message, this._context, meta);
+  }
+  info(message, meta) {
+    this._parent._logWithContext(30, "INFO", message, this._context, meta);
+  }
+  warn(message, meta) {
+    this._parent._logWithContext(40, "WARN", message, this._context, meta);
+  }
+  error(message, metaOrError, error) {
+    if (metaOrError instanceof Error) {
+      this._parent._logWithContext(
+        50,
+        "ERROR",
+        message,
+        this._context,
+        void 0,
+        metaOrError
+      );
+    } else {
+      this._parent._logWithContext(
+        50,
+        "ERROR",
+        message,
+        this._context,
+        metaOrError,
+        error
+      );
+    }
+  }
+  fatal(message, metaOrError, error) {
+    if (metaOrError instanceof Error) {
+      this._parent._logWithContext(
+        60,
+        "FATAL",
+        message,
+        this._context,
+        void 0,
+        metaOrError
+      );
+    } else {
+      this._parent._logWithContext(
+        60,
+        "FATAL",
+        message,
+        this._context,
+        metaOrError,
+        error
+      );
+    }
+  }
+  child(context) {
+    return new _ChildLoggerImpl(this._parent, {
+      ...this._context,
+      ...context
+    });
+  }
+  addTransport(transport) {
+    this._parent.addTransport(transport);
+  }
+  removeTransport(name) {
+    this._parent.removeTransport(name);
+  }
+  addMiddleware(middleware) {
+    this._parent.addMiddleware(middleware);
+  }
+  removeMiddleware(middleware) {
+    this._parent.removeMiddleware(middleware);
+  }
+  setLevel(level) {
+    this._parent.setLevel(level);
+  }
+  getLevel() {
+    return this._parent.getLevel();
+  }
+  isLevelEnabled(level) {
+    return this._parent.isLevelEnabled(level);
+  }
+  startTimer(level) {
+    return this._parent.startTimer(level);
+  }
+  flush() {
+    return this._parent.flush();
+  }
+  close() {
+    return this._parent.close();
+  }
+};
+function createLogger(options) {
+  return new LoggerImpl(options);
+}
+
+// src/middleware/ai-enrichment.ts
+function aiEnrichmentMiddleware(options) {
+  const minLevel = resolveLevel(options.level ?? "ERROR");
+  const timeoutMs = options.timeout ?? 2e3;
+  const swallow = options.swallowErrors ?? true;
+  const fieldName = options.targetField ?? "ai_analysis";
+  return async (entry, next) => {
+    if (entry.level < minLevel) {
+      next(entry);
+      return;
+    }
+    try {
+      const analysisPromise = options.analyzer(entry);
+      const timeoutPromise = new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("AI Analysis Timeout")), timeoutMs)
+      );
+      const result = await Promise.race([analysisPromise, timeoutPromise]);
+      if (result) {
+        entry.meta = {
+          ...entry.meta,
+          [fieldName]: result
+        };
+      }
+    } catch (err) {
+      if (!swallow) {
+        throw err;
+      }
+    }
+    next(entry);
+  };
+}
+function createOpenAiErrorAnalyzer(apiKey, model = "gpt-3.5-turbo", systemPrompt = "You are a log analyzer. Explain this error briefly and suggest a fix in 1 sentence.") {
+  return async (entry) => {
+    try {
+      const response = await fetch(
+        "https://api.openai.com/v1/chat/completions",
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`
+          },
+          body: JSON.stringify({
+            model,
+            messages: [
+              { role: "system", content: systemPrompt },
+              {
+                role: "user",
+                content: `Error Message: ${entry.message}
+Context: ${JSON.stringify(entry.meta)}`
+              }
+            ],
+            max_tokens: 150
+          })
+        }
+      );
+      if (!response.ok) return null;
+      const data = await response.json();
+      return data.choices?.[0]?.message?.content ?? null;
+    } catch {
+      return null;
+    }
+  };
+}
+
+// src/middleware/alert.ts
+function alertMiddleware(rules) {
+  const states = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    states.set(rule.name, { entries: [], lastFired: -Infinity });
+  }
+  return (entry, next) => {
+    const now = entry.timestamp;
+    for (const rule of rules) {
+      if (!rule.when(entry)) continue;
+      const state = states.get(rule.name);
+      const windowMs = rule.windowMs ?? Infinity;
+      const threshold = rule.threshold ?? 1;
+      const cooldownMs = rule.cooldownMs ?? 0;
+      if (Number.isFinite(windowMs)) {
+        state.entries = state.entries.filter(
+          (e) => now - e.timestamp < windowMs
+        );
+      }
+      state.entries.push(entry);
+      if (state.entries.length >= threshold && now - state.lastFired >= cooldownMs) {
+        const alertEntries = [...state.entries];
+        state.entries = [];
+        state.lastFired = now;
+        try {
+          const result = rule.onAlert(alertEntries);
+          if (result && typeof result.catch === "function") {
+            result.catch(() => {
+            });
+          }
+        } catch {
+        }
+      }
+    }
+    next(entry);
+  };
+}
 
 // src/middleware/async-context.ts
 import { AsyncLocalStorage } from "async_hooks";
@@ -75,10 +453,10 @@ function asyncContextMiddleware() {
 }
 
 // src/middleware/correlation-id.ts
-import { randomUUID } from "crypto";
+var _randomUUID = () => globalThis.crypto.randomUUID();
 function correlationIdMiddleware(options = {}) {
   const header = options.header ?? "x-correlation-id";
-  const generate = options.generator ?? randomUUID;
+  const generate = options.generator ?? _randomUUID;
   return (entry, next) => {
     if (entry.correlationId) {
       return next(entry);
@@ -96,6 +474,559 @@ function correlationIdMiddleware(options = {}) {
   };
 }
 
+// src/middleware/create-middleware.ts
+function createMiddleware(fn) {
+  return fn;
+}
+
+// src/middleware/deduplication.ts
+function deduplicationMiddleware(options = {}) {
+  const windowMs = options.windowMs ?? 1e3;
+  const keyFn = options.keyFn ?? ((e) => `${e.level}:${e.message}:${e.error?.message ?? ""}`);
+  const buffer = /* @__PURE__ */ new Map();
+  return (entry, next) => {
+    const key = keyFn(entry);
+    if (buffer.has(key)) {
+      const state = buffer.get(key);
+      state.count++;
+      return;
+    }
+    const timer = setTimeout(() => {
+      const state = buffer.get(key);
+      if (state) {
+        buffer.delete(key);
+        if (state.count > 1) {
+          state.entry.meta = {
+            ...state.entry.meta,
+            duplicateCount: state.count
+          };
+        }
+        next(state.entry);
+      }
+    }, windowMs);
+    buffer.set(key, {
+      entry,
+      count: 1,
+      timer
+    });
+  };
+}
+
+// src/middleware/heap-usage.ts
+function heapUsageMiddleware(options = {}) {
+  const fieldName = options.fieldName ?? "memory";
+  return (entry, next) => {
+    if (typeof process !== "undefined" && process.memoryUsage) {
+      const memory = process.memoryUsage();
+      entry.meta = {
+        ...entry.meta,
+        [fieldName]: {
+          rss: memory.rss,
+          heapTotal: memory.heapTotal,
+          heapUsed: memory.heapUsed
+        }
+      };
+    }
+    next(entry);
+  };
+}
+
+// src/middleware/http.ts
+var nodeHttpMappers = {
+  req: {
+    getMethod: (req) => req.method || "UNKNOWN",
+    getUrl: (req) => req.originalUrl || req.url || "/",
+    getIp: (req) => req.ip || req.socket?.remoteAddress || req.headers?.["x-forwarded-for"] || void 0,
+    getUserAgent: (req) => req.headers?.["user-agent"] || void 0,
+    getHeader: (req, name) => req.headers?.[name] || void 0
+  },
+  res: {
+    getStatusCode: (res) => res.statusCode || 200,
+    onFinish: (res, callback) => {
+      if (typeof res.on === "function") {
+        res.on("finish", callback);
+        res.on("close", callback);
+      } else {
+        callback();
+      }
+    }
+  }
+};
+function createHttpLogger(logger, options) {
+  const {
+    reqMapper,
+    resMapper,
+    level = "INFO",
+    skip,
+    extractContext
+  } = options;
+  return (req, res) => {
+    if (skip?.(req)) {
+      return;
+    }
+    const startTime = performance.now();
+    let finished = false;
+    resMapper.onFinish(res, () => {
+      if (finished) return;
+      finished = true;
+      const durationMs = Math.round(performance.now() - startTime);
+      const statusCode = resMapper.getStatusCode(res);
+      const method = reqMapper.getMethod(req);
+      const url = reqMapper.getUrl(req);
+      const meta = {
+        method,
+        url,
+        statusCode,
+        durationMs,
+        ip: reqMapper.getIp ? reqMapper.getIp(req) : void 0,
+        userAgent: reqMapper.getUserAgent ? reqMapper.getUserAgent(req) : void 0
+      };
+      if (extractContext) {
+        Object.assign(meta, extractContext(req, res));
+      }
+      let finalLevel = level;
+      if (statusCode >= 500) finalLevel = "ERROR";
+      else if (statusCode >= 400 && level === "INFO") finalLevel = "WARN";
+      const methodKey = finalLevel.toLowerCase();
+      logger[methodKey](
+        `${method} ${url} - ${statusCode} (${durationMs}ms)`,
+        meta
+      );
+    });
+  };
+}
+
+// src/middleware/ip.ts
+function ipMiddleware(options = {}) {
+  const targetField = options.fieldName ?? "ip";
+  const keysToCheck = options.headerKeys ?? [
+    "x-forwarded-for",
+    "x-real-ip",
+    "req.ip",
+    "ip",
+    "x-client-ip"
+  ];
+  return (entry, next) => {
+    const meta = entry.meta;
+    const headers = meta.headers || {};
+    const req = meta.req || {};
+    let foundIp;
+    for (const key of keysToCheck) {
+      if (typeof meta[key] === "string") {
+        foundIp = meta[key];
+        break;
+      }
+      if (typeof headers[key] === "string") {
+        foundIp = headers[key];
+        break;
+      }
+      if (typeof req[key] === "string") {
+        foundIp = req[key];
+        break;
+      }
+      if (key === "req.ip" && typeof req.ip === "string") {
+        foundIp = req.ip;
+        break;
+      }
+    }
+    if (foundIp) {
+      const firstIp = typeof foundIp === "string" ? foundIp.split(",")[0].trim() : String(foundIp);
+      entry.meta = {
+        ...entry.meta,
+        [targetField]: firstIp
+      };
+    }
+    next(entry);
+  };
+}
+
+// src/middleware/level-override.ts
+function levelOverrideMiddleware(options = {}) {
+  const key = options.key ?? "x-log-level";
+  const cleanup = options.cleanup ?? true;
+  return (entry, next) => {
+    const meta = entry.meta;
+    const context = entry.context;
+    const levelName = meta[key] || context?.[key] || meta.headers?.[key];
+    if (levelName && typeof levelName === "string") {
+      const upperName = levelName.toUpperCase();
+      if (LogLevel[upperName]) {
+        entry.level = LogLevel[upperName];
+        entry.levelName = upperName;
+        if (cleanup) {
+          delete meta[key];
+          if (meta.headers) {
+            delete meta.headers[key];
+          }
+        }
+      }
+    }
+    next(entry);
+  };
+}
+
+// src/middleware/ocpp.ts
+function ocppMiddleware(options = {}) {
+  const autoPayloadSize = options.autoPayloadSize ?? true;
+  const propagateCorrelationId = options.propagateCorrelationId ?? true;
+  return (entry, next) => {
+    const enriched = { ...entry, meta: { ...entry.meta } };
+    if (autoPayloadSize && enriched.meta.payloadSize === void 0 && enriched.meta.action) {
+      try {
+        enriched.meta.payloadSize = JSON.stringify(enriched.meta).length;
+      } catch {
+      }
+    }
+    if (propagateCorrelationId && enriched.meta.correlationId && !enriched.correlationId) {
+      enriched.correlationId = enriched.meta.correlationId;
+    }
+    next(enriched);
+  };
+}
+
+// src/middleware/otel-trace.ts
+function otelTraceMiddleware(options = {}) {
+  let traceApi = options.traceApi ?? null;
+  let resolved = !!traceApi;
+  let resolvePromise = null;
+  function ensureResolved() {
+    if (resolved || resolvePromise) return resolvePromise ?? Promise.resolve();
+    resolvePromise = import("@opentelemetry/api").then((api) => {
+      traceApi = api;
+      resolved = true;
+    }).catch(() => {
+      resolved = true;
+    });
+    return resolvePromise;
+  }
+  return (entry, next) => {
+    ensureResolved().catch(() => {
+    });
+    if (resolved && traceApi?.trace) {
+      try {
+        const activeSpan = traceApi.trace.getActiveSpan?.();
+        if (activeSpan) {
+          const spanContext = activeSpan.spanContext?.();
+          if (spanContext) {
+            const meta = entry.meta;
+            meta.traceId = spanContext.traceId;
+            meta.spanId = spanContext.spanId;
+            meta.traceFlags = spanContext.traceFlags;
+            if (!entry.correlationId) {
+              entry.correlationId = spanContext.traceId;
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    next(entry);
+  };
+}
+
+// src/middleware/redaction.ts
+var DEFAULT_REDACT_VALUE = "[REDACTED]";
+function redactionMiddleware(options) {
+  const paths = new Set(options.paths.map((p) => p.toLowerCase()));
+  const replacement = options.replacement ?? DEFAULT_REDACT_VALUE;
+  const deep = options.deep ?? true;
+  function redactObject(obj) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      if (paths.has(key.toLowerCase())) {
+        result[key] = replacement;
+      } else if (deep && value !== null && typeof value === "object" && !Array.isArray(value)) {
+        result[key] = redactObject(value);
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  return (entry, next) => {
+    const redacted = { ...entry };
+    if (entry.meta && typeof entry.meta === "object") {
+      redacted.meta = redactObject(
+        entry.meta
+      );
+    }
+    if (entry.context && typeof entry.context === "object") {
+      redacted.context = redactObject(entry.context);
+    }
+    next(redacted);
+  };
+}
+
+// src/middleware/sampling.ts
+function samplingMiddleware(options = {}) {
+  const keyFn = options.keyFn ?? ((entry) => entry.message);
+  const maxPerWindow = options.maxPerWindow ?? 100;
+  const windowMs = options.windowMs ?? 6e4;
+  const sampleRate = options.sampleRate ?? 1;
+  const priorityLevel = options.priorityLevel ?? 40;
+  const buckets = /* @__PURE__ */ new Map();
+  return (entry, next) => {
+    if (entry.level >= priorityLevel) {
+      return next(entry);
+    }
+    if (sampleRate < 1 && Math.random() > sampleRate) {
+      return;
+    }
+    const key = keyFn(entry);
+    const now = entry.timestamp;
+    let bucket = buckets.get(key);
+    if (!bucket || now - bucket.windowStart >= windowMs) {
+      bucket = { count: 0, windowStart: now };
+      buckets.set(key, bucket);
+    }
+    if (bucket.count < maxPerWindow) {
+      bucket.count++;
+      next(entry);
+    }
+    if (buckets.size > 2e3) {
+      const expireBefore = now - windowMs * 2;
+      for (const [k, b] of buckets) {
+        if (b.windowStart < expireBefore) {
+          buckets.delete(k);
+        }
+      }
+    }
+  };
+}
+
+// src/middleware/user-agent.ts
+function userAgentMiddleware(options = {}) {
+  const sourceField = options.sourceField;
+  const targetField = options.targetField ?? "client";
+  return (entry, next) => {
+    const meta = entry.meta;
+    const context = entry.context;
+    const ua = (sourceField ? meta[sourceField] : void 0) || meta.userAgent || meta["user-agent"] || context?.userAgent || context?.["user-agent"];
+    if (ua) {
+      const info = parseUserAgent(ua);
+      entry.meta = {
+        ...entry.meta,
+        [targetField]: info
+      };
+    }
+    next(entry);
+  };
+}
+function parseUserAgent(ua) {
+  const browser = /(opera|chrome|safari|firefox|msie|trident(?=\/))\/?\s*(\d+)/i.exec(ua) || [];
+  let name = browser[1] ? browser[1].toLowerCase() : "unknown";
+  let version = browser[2] || "unknown";
+  if (/trident/i.test(name)) {
+    name = "ie";
+  } else if (name === "chrome") {
+    const edge = /edg(e)?\/(\d+)/i.exec(ua);
+    if (edge) {
+      name = "edge";
+      version = edge[2];
+    }
+  }
+  const osResult = /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i.exec(
+    ua
+  );
+  const os = osResult ? osResult[0].toLowerCase() : "desktop";
+  return { browser: name, version, os };
+}
+
+// src/transports/batch.ts
+function batchTransport(inner, options = {}) {
+  const batchSize = options.batchSize ?? 100;
+  const flushIntervalMs = options.flushIntervalMs ?? 5e3;
+  let buffer = [];
+  let flushTimer = null;
+  function scheduleFlush() {
+    if (flushTimer) return;
+    flushTimer = setTimeout(() => {
+      flushTimer = null;
+      doFlush();
+    }, flushIntervalMs);
+  }
+  function doFlush() {
+    if (buffer.length === 0) return;
+    const batch = buffer;
+    buffer = [];
+    for (const entry of batch) {
+      try {
+        const result = inner.write(entry);
+        if (result && typeof result.catch === "function") {
+          result.catch(() => {
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  return {
+    name: `batch(${inner.name})`,
+    level: inner.level,
+    write(entry) {
+      buffer.push(entry);
+      if (buffer.length >= batchSize) {
+        doFlush();
+      } else {
+        scheduleFlush();
+      }
+    },
+    async flush() {
+      if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+      }
+      doFlush();
+      await inner.flush?.();
+    },
+    async close() {
+      await this.flush?.();
+      await inner.close?.();
+    }
+  };
+}
+
+// src/transports/console.ts
+function consoleTransport(options = {}) {
+  const useConsoleLevels = options.useConsoleLevels ?? true;
+  const formatter = options.formatter ?? ((entry) => JSON.stringify(entry));
+  return {
+    name: "console",
+    level: options.level,
+    write(entry) {
+      const output = formatter(entry);
+      if (!useConsoleLevels) {
+        console.log(output);
+        return;
+      }
+      if (entry.level >= LogLevel.FATAL) {
+        console.error(output);
+      } else if (entry.level >= LogLevel.ERROR) {
+        console.error(output);
+      } else if (entry.level >= LogLevel.WARN) {
+        console.warn(output);
+      } else if (entry.level >= LogLevel.INFO) {
+        console.info(output);
+      } else if (entry.level >= LogLevel.DEBUG) {
+        console.debug(output);
+      } else {
+        console.log(output);
+      }
+    }
+  };
+}
+
+// src/transports/create-transport.ts
+function createTransport(name, write, options = {}) {
+  return {
+    name,
+    write,
+    ...options
+  };
+}
+
+// src/transports/datadog.ts
+function datadogTransport(options) {
+  const {
+    apiKey,
+    site = "datadoghq.com",
+    service,
+    ddSource = "nodejs",
+    hostname,
+    tags,
+    level
+  } = options;
+  const url = `https://http-intake.logs.${site}/api/v2/logs`;
+  return {
+    name: "datadog",
+    level,
+    async write(entry) {
+      const payload = {
+        ddsource: ddSource,
+        ddtags: tags,
+        hostname,
+        service,
+        message: entry.message,
+        status: entry.levelName.toLowerCase(),
+        // Datadog uses lowercase status
+        ...entry.meta,
+        timestamp: entry.timestamp
+        // Datadog auto-parses this
+      };
+      try {
+        await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "DD-API-KEY": apiKey
+          },
+          body: JSON.stringify(payload)
+        });
+      } catch (err) {
+        console.error("[voltlog] Datadog push failed", err);
+      }
+    }
+  };
+}
+
+// src/transports/discord.ts
+function discordTransport(options) {
+  const { webhookUrl, username, avatarUrl, level = "ERROR" } = options;
+  return {
+    name: "discord",
+    level,
+    async write(entry) {
+      try {
+        await fetch(webhookUrl, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(
+            formatDiscordPayload(entry, username, avatarUrl)
+          )
+        });
+      } catch (_err) {
+      }
+    }
+  };
+}
+function formatDiscordPayload(entry, username, avatar_url) {
+  const color = getLevelColor(entry.level);
+  return {
+    username: username || "VoltLog",
+    avatar_url,
+    embeds: [
+      {
+        title: `${entry.levelName} - ${entry.message}`,
+        color,
+        timestamp: new Date(entry.timestamp).toISOString(),
+        fields: [
+          {
+            name: "Meta",
+            value: `\`\`\`json
+${JSON.stringify(entry.meta, null, 2).slice(
+              0,
+              1e3
+            )}
+\`\`\``
+          },
+          entry.error?.stack ? {
+            name: "Stack",
+            value: `\`\`\`js
+${entry.error.stack.slice(0, 1e3)}
+\`\`\``
+          } : null
+        ].filter(Boolean)
+      }
+    ]
+  };
+}
+function getLevelColor(level) {
+  if (level >= 50) return 15158332;
+  if (level >= 40) return 16776960;
+  if (level >= 30) return 3447003;
+  return 9807270;
+}
+
 // src/transports/file.ts
 import fs from "fs";
 import path from "path";
@@ -207,6 +1138,431 @@ function jsonStreamTransport(options) {
   };
 }
 
+// src/transports/loki.ts
+function lokiTransport(options) {
+  const { host, level } = options;
+  const staticLabels = options.labels ?? { app: "voltlog" };
+  const batchSize = options.batchSize ?? 10;
+  const interval = options.interval ?? 5e3;
+  const includeMetadata = options.includeMetadata !== false;
+  const retryEnabled = options.retry ?? false;
+  const maxRetries = options.maxRetries ?? 3;
+  const url = `${host.replace(/\/$/, "")}/loki/api/v1/push`;
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (options.basicAuthUser && options.basicAuthPassword) {
+    const creds = btoa(`${options.basicAuthUser}:${options.basicAuthPassword}`);
+    headers.Authorization = `Basic ${creds}`;
+  }
+  if (options.tenantId) {
+    headers["X-Scope-OrgID"] = options.tenantId;
+  }
+  let buffer = [];
+  let timer = null;
+  function buildLogLine(entry) {
+    const payload = {
+      level: entry.levelName,
+      message: entry.message,
+      ...entry.meta
+    };
+    if (includeMetadata) {
+      if (entry.correlationId) {
+        payload.correlationId = entry.correlationId;
+      }
+      if (entry.context) {
+        payload.context = entry.context;
+      }
+      if (entry.error) {
+        payload.error = entry.error;
+      }
+    }
+    return JSON.stringify(payload);
+  }
+  function buildStreams(batch) {
+    if (!options.dynamicLabels) {
+      return [
+        {
+          stream: staticLabels,
+          values: batch.map((e) => [
+            String(e.timestamp * 1e6),
+            // Loki wants nanoseconds
+            buildLogLine(e)
+          ])
+        }
+      ];
+    }
+    const grouped = /* @__PURE__ */ new Map();
+    for (const entry of batch) {
+      const dynamic = options.dynamicLabels(entry);
+      const merged = { ...staticLabels };
+      for (const [k, v] of Object.entries(dynamic)) {
+        if (v !== void 0) merged[k] = v;
+      }
+      const key = JSON.stringify(merged);
+      let group = grouped.get(key);
+      if (!group) {
+        group = { labels: merged, values: [] };
+        grouped.set(key, group);
+      }
+      group.values.push([
+        String(entry.timestamp * 1e6),
+        buildLogLine(entry)
+      ]);
+    }
+    return Array.from(grouped.values()).map((g) => ({
+      stream: g.labels,
+      values: g.values
+    }));
+  }
+  async function pushWithRetry(batch) {
+    const body = JSON.stringify({ streams: buildStreams(batch) });
+    let lastError;
+    const attempts = retryEnabled ? maxRetries : 1;
+    for (let attempt = 0; attempt < attempts; attempt++) {
+      try {
+        const response = await fetch(url, { method: "POST", headers, body });
+        if (response.ok) return;
+        if (response.status >= 400 && response.status < 500) {
+          console.error(`[voltlog] Loki push failed: ${response.status}`);
+          return;
+        }
+        lastError = new Error(`Loki HTTP ${response.status}`);
+      } catch (err) {
+        lastError = err;
+      }
+      if (attempt < attempts - 1) {
+        await new Promise((r) => setTimeout(r, 100 * 2 ** attempt));
+      }
+    }
+    console.error("[voltlog] Loki push failed after retries", lastError);
+  }
+  const doFlush = async () => {
+    if (buffer.length === 0) return;
+    const batch = buffer;
+    buffer = [];
+    await pushWithRetry(batch);
+  };
+  const schedule = () => {
+    if (!timer) {
+      timer = setTimeout(() => {
+        timer = null;
+        doFlush();
+      }, interval);
+    }
+  };
+  return {
+    name: "loki",
+    level,
+    write(entry) {
+      buffer.push(entry);
+      if (buffer.length >= batchSize) {
+        if (timer) clearTimeout(timer);
+        timer = null;
+        doFlush();
+      } else {
+        schedule();
+      }
+    },
+    async flush() {
+      if (timer) clearTimeout(timer);
+      await doFlush();
+    },
+    async close() {
+      await this.flush?.();
+    }
+  };
+}
+
+// src/transports/otel.ts
+var OTEL_SEVERITY_MAP = {
+  TRACE: { number: 1, text: "TRACE" },
+  DEBUG: { number: 5, text: "DEBUG" },
+  INFO: { number: 9, text: "INFO" },
+  WARN: { number: 13, text: "WARN" },
+  ERROR: { number: 17, text: "ERROR" },
+  FATAL: { number: 21, text: "FATAL" }
+};
+function otelTransport(options) {
+  const { endpoint, serviceName, level, resource = {} } = options;
+  const batchSize = options.batchSize ?? 20;
+  const interval = options.interval ?? 5e3;
+  const url = `${endpoint.replace(/\/$/, "")}/v1/logs`;
+  const headers = {
+    "Content-Type": "application/json",
+    ...options.headers
+  };
+  const resourceAttributes = [
+    { key: "service.name", value: { stringValue: serviceName } },
+    ...Object.entries(resource).map(([key, val]) => ({
+      key,
+      value: { stringValue: val }
+    }))
+  ];
+  let buffer = [];
+  let timer = null;
+  function toOtlpLogRecord(entry) {
+    const severity = OTEL_SEVERITY_MAP[entry.levelName] ?? OTEL_SEVERITY_MAP.INFO;
+    const attributes = [];
+    if (entry.meta && typeof entry.meta === "object") {
+      for (const [key, val] of Object.entries(entry.meta)) {
+        if (key === "traceId" || key === "spanId" || key === "traceFlags")
+          continue;
+        if (val !== void 0 && val !== null) {
+          attributes.push({
+            key,
+            value: typeof val === "number" ? { intValue: val } : { stringValue: String(val) }
+          });
+        }
+      }
+    }
+    if (entry.context) {
+      for (const [key, val] of Object.entries(entry.context)) {
+        if (val !== void 0 && val !== null) {
+          attributes.push({
+            key: `context.${key}`,
+            value: { stringValue: String(val) }
+          });
+        }
+      }
+    }
+    if (entry.error) {
+      attributes.push({
+        key: "error.message",
+        value: { stringValue: entry.error.message }
+      });
+      if (entry.error.name) {
+        attributes.push({
+          key: "error.type",
+          value: { stringValue: entry.error.name }
+        });
+      }
+      if (entry.error.stack) {
+        attributes.push({
+          key: "error.stack",
+          value: { stringValue: entry.error.stack }
+        });
+      }
+    }
+    const record = {
+      timeUnixNano: String(entry.timestamp * 1e6),
+      // ms → ns
+      severityNumber: severity?.number,
+      severityText: severity?.text,
+      body: { stringValue: entry.message },
+      attributes
+    };
+    const meta = entry.meta;
+    if (meta?.traceId) {
+      record.traceId = meta.traceId;
+    }
+    if (meta?.spanId) {
+      record.spanId = meta.spanId;
+    }
+    if (meta?.traceFlags !== void 0) {
+      record.flags = meta.traceFlags;
+    }
+    return record;
+  }
+  async function sendBatch(batch) {
+    const payload = {
+      resourceLogs: [
+        {
+          resource: { attributes: resourceAttributes },
+          scopeLogs: [
+            {
+              scope: { name: "voltlog-io" },
+              logRecords: batch.map(toOtlpLogRecord)
+            }
+          ]
+        }
+      ]
+    };
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        console.error(
+          `[voltlog] OTLP push failed: ${response.status} ${response.statusText}`
+        );
+      }
+    } catch (err) {
+      console.error("[voltlog] OTLP push failed", err);
+    }
+  }
+  function flush() {
+    if (buffer.length === 0) return;
+    const batch = buffer;
+    buffer = [];
+    sendBatch(batch).catch(() => {
+    });
+  }
+  function schedule() {
+    if (!timer) {
+      timer = setTimeout(() => {
+        timer = null;
+        flush();
+      }, interval);
+    }
+  }
+  return {
+    name: "otel",
+    level,
+    write(entry) {
+      buffer.push(entry);
+      if (buffer.length >= batchSize) {
+        if (timer) clearTimeout(timer);
+        timer = null;
+        flush();
+      } else {
+        schedule();
+      }
+    },
+    async flush() {
+      if (timer) clearTimeout(timer);
+      timer = null;
+      if (buffer.length === 0) return;
+      const batch = buffer;
+      buffer = [];
+      await sendBatch(batch);
+    },
+    async close() {
+      await this.flush?.();
+    }
+  };
+}
+
+// src/transports/pretty.ts
+var RESET = "\x1B[0m";
+var DIM = "\x1B[2m";
+var BOLD = "\x1B[1m";
+var COLORS = {
+  TRACE: "\x1B[90m",
+  // gray
+  DEBUG: "\x1B[36m",
+  // cyan
+  INFO: "\x1B[32m",
+  // green
+  WARN: "\x1B[33m",
+  // yellow
+  ERROR: "\x1B[31m",
+  // red
+  FATAL: "\x1B[35;1m"
+  // bold magenta
+};
+var ICONS = {
+  TRACE: "\u{1F50D}",
+  DEBUG: "\u{1F41B}",
+  INFO: "\u2139",
+  WARN: "\u26A0",
+  ERROR: "\u2716",
+  FATAL: "\u{1F480}"
+};
+var EXCHANGE_ICONS = {
+  CALL: "\u26A1",
+  CALLRESULT: "\u2714",
+  CALLERROR: "\u{1F6A8}"
+};
+var DIRECTION_ARROWS = {
+  IN: "\u2192",
+  OUT: "\u2190"
+};
+function prettyTransport(options = {}) {
+  const showTimestamps = options.timestamps ?? true;
+  const useColors = options.colors ?? true;
+  const hideMeta = options.hideMeta ?? false;
+  const prettyMeta = options.prettyMeta ?? false;
+  function colorize(text, color) {
+    return useColors ? `${color}${text}${RESET}` : text;
+  }
+  function formatExchange(entry) {
+    const meta = entry.meta;
+    if (!meta || !meta.action || !meta.messageType) return null;
+    const icon = EXCHANGE_ICONS[meta.messageType] ?? "\u2022";
+    const arrow = DIRECTION_ARROWS[meta.direction ?? "IN"] ?? "\u2192";
+    const cpId = meta.chargePointId ?? "unknown";
+    const action = meta.action;
+    const msgType = meta.messageType;
+    const dir = meta.direction ?? "";
+    let line = `${icon} ${colorize(cpId, BOLD)}  ${arrow}  ${colorize(
+      action,
+      BOLD
+    )}  [${dir}]  ${colorize(msgType, DIM)}`;
+    if (meta.status || meta.latencyMs !== void 0) {
+      const statusIcon = meta.messageType === "CALLERROR" ? "\u274C" : "\u2714";
+      const status = meta.status ?? "";
+      const latency = meta.latencyMs !== void 0 ? `(${meta.latencyMs}ms)` : "";
+      line += `
+${statusIcon} ${status}  ${colorize(latency, DIM)}`;
+    }
+    return line;
+  }
+  function formatStandard(entry) {
+    const icon = ICONS[entry.levelName] ?? "\u2022";
+    const levelColor = COLORS[entry.levelName] ?? "";
+    const level = colorize(entry.levelName.padEnd(5), levelColor);
+    const ts = showTimestamps ? `${colorize(new Date(entry.timestamp).toISOString(), DIM)}  ` : "";
+    let line = `${icon} ${ts}${level}  ${entry.message}`;
+    if (entry.context && Object.keys(entry.context).length > 0) {
+      const kvStr = Object.entries(entry.context).map(
+        ([k, v]) => `${k}:${typeof v === "string" ? v : JSON.stringify(v)}`
+      ).join(" ");
+      line += `  ${colorize(kvStr, DIM)}`;
+    }
+    if (!hideMeta && entry.meta && Object.keys(entry.meta).length > 0) {
+      if (prettyMeta) {
+        const metaEntries = Object.entries(
+          entry.meta
+        );
+        const parts = metaEntries.map(([key, value]) => {
+          const valStr = typeof value === "string" ? value : JSON.stringify(value);
+          return `${colorize(`${key}:`, DIM)}${valStr}`;
+        });
+        line += `  ${parts.join(" ")}`;
+      } else {
+        const kvStr = Object.entries(entry.meta).map(
+          ([k, v]) => `${k}:${typeof v === "string" ? v : JSON.stringify(v)}`
+        ).join(" ");
+        line += `  ${colorize(kvStr, DIM)}`;
+      }
+    }
+    if (entry.error) {
+      line += `
+  ${colorize(
+        `${entry.error.name ?? "Error"}: ${entry.error.message}`,
+        COLORS.ERROR ?? ""
+      )}`;
+      if (entry.error.stack) {
+        line += `
+${colorize(entry.error.stack, DIM)}`;
+      }
+    }
+    return line;
+  }
+  return {
+    name: "pretty",
+    level: options.level,
+    write(entry) {
+      const exchangeOutput = formatExchange(entry);
+      if (exchangeOutput) {
+        console.log(exchangeOutput);
+        return;
+      }
+      const output = formatStandard(entry);
+      if (entry.level >= LogLevel.ERROR) {
+        console.error(output);
+      } else if (entry.level >= LogLevel.WARN) {
+        console.warn(output);
+      } else {
+        console.log(output);
+      }
+    }
+  };
+}
+
 // src/transports/redis.ts
 function redisTransport(options) {
   const { client, streamKey = "logs", maxLen, level } = options;
@@ -246,6 +1602,283 @@ function redisTransport(options) {
     }
   };
 }
+
+// src/transports/ring-buffer.ts
+function ringBufferTransport(options = {}) {
+  const maxSize = options.maxSize ?? 1e3;
+  const buffer = [];
+  let head = 0;
+  let count = 0;
+  return {
+    name: "ring-buffer",
+    level: options.level,
+    write(entry) {
+      if (count < maxSize) {
+        buffer.push(entry);
+        count++;
+      } else {
+        buffer[head] = entry;
+      }
+      head = (head + 1) % maxSize;
+    },
+    getEntries(query) {
+      let entries;
+      if (count < maxSize) {
+        entries = buffer.slice();
+      } else {
+        entries = [...buffer.slice(head), ...buffer.slice(0, head)];
+      }
+      if (query?.level) {
+        const minLevel = resolveLevel(query.level);
+        entries = entries.filter((e) => e.level >= minLevel);
+      }
+      if (query?.since) {
+        const since = query.since;
+        entries = entries.filter((e) => e.timestamp >= since);
+      }
+      if (query?.limit) {
+        entries = entries.slice(-query.limit);
+      }
+      return entries;
+    },
+    clear() {
+      buffer.length = 0;
+      head = 0;
+      count = 0;
+    },
+    get size() {
+      return count;
+    }
+  };
+}
+
+// src/transports/sentry.ts
+function sentryTransport(options) {
+  const { sentry } = options;
+  const errorLevelValue = resolveLevel(options.errorLevel ?? "ERROR");
+  const breadcrumbLevelValue = resolveLevel(options.breadcrumbLevel ?? "INFO");
+  return {
+    name: "sentry",
+    write(entry) {
+      if (entry.level >= errorLevelValue) {
+        if (entry.error) {
+          sentry.captureException(entry.error, {
+            extra: {
+              ...entry.meta,
+              context: entry.context
+            },
+            level: "error"
+          });
+        } else {
+          sentry.captureMessage(entry.message, "error");
+        }
+      }
+      if (entry.level >= breadcrumbLevelValue) {
+        sentry.addBreadcrumb({
+          category: "log",
+          message: entry.message,
+          level: mapLevelToSentry(entry.level),
+          data: { ...entry.meta, ...entry.context },
+          timestamp: entry.timestamp / 1e3
+        });
+      }
+    }
+  };
+}
+function mapLevelToSentry(level) {
+  if (level >= 60) return "fatal";
+  if (level >= 50) return "error";
+  if (level >= 40) return "warning";
+  if (level >= 30) return "info";
+  return "debug";
+}
+
+// src/transports/slack.ts
+function slackTransport(options) {
+  const { webhookUrl, username, iconEmoji, level } = options;
+  return {
+    name: "slack",
+    level: level ?? "ERROR",
+    // Default to ERROR to prevent spamming
+    async write(entry) {
+      try {
+        const payload = formatSlackMessage(entry, username, iconEmoji);
+        const response = await fetch(webhookUrl, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(payload)
+        });
+        if (!response.ok) {
+        }
+      } catch (_err) {
+      }
+    }
+  };
+}
+function formatSlackMessage(entry, username, icon_emoji) {
+  const levelEmoji = getLevelEmoji(entry.level);
+  const color = getLevelColor2(entry.level);
+  const blocks = [
+    {
+      type: "header",
+      text: {
+        type: "plain_text",
+        text: `${levelEmoji} ${entry.levelName}: ${entry.message}`,
+        emoji: true
+      }
+    },
+    {
+      type: "context",
+      elements: [
+        {
+          type: "mrkdwn",
+          text: `*Time:* ${new Date(entry.timestamp).toISOString()}`
+        },
+        {
+          type: "mrkdwn",
+          text: `*ID:* \`${entry.id}\``
+        }
+      ]
+    }
+  ];
+  if (entry.correlationId) {
+    blocks[1].elements.push({
+      type: "mrkdwn",
+      text: `*Trace:* \`${entry.correlationId}\``
+    });
+  }
+  if (Object.keys(entry.meta).length > 0) {
+    blocks.push({
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `*Metadata:*
+\`\`\`${JSON.stringify(entry.meta, null, 2)}\`\`\``,
+        emoji: true
+      }
+    });
+  }
+  if (entry.error?.stack) {
+    blocks.push({
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `*Error Stack:*
+\`\`\`${entry.error.stack}\`\`\``,
+        emoji: true
+      }
+    });
+  }
+  return {
+    username,
+    icon_emoji,
+    attachments: [
+      {
+        color,
+        blocks
+      }
+    ]
+  };
+}
+function getLevelEmoji(level) {
+  if (level >= 60) return "\u{1F525}";
+  if (level >= 50) return "\u{1F6A8}";
+  if (level >= 40) return "\u26A0\uFE0F";
+  if (level >= 30) return "\u2139\uFE0F";
+  if (level >= 20) return "\u{1F41B}";
+  return "\u{1F50D}";
+}
+function getLevelColor2(level) {
+  if (level >= 60) return "#ff0000";
+  if (level >= 50) return "#ff4444";
+  if (level >= 40) return "#ffbb33";
+  if (level >= 30) return "#33b5e5";
+  if (level >= 20) return "#99cc00";
+  return "#aa66cc";
+}
+
+// src/transports/webhook.ts
+function webhookTransport(options) {
+  const {
+    url,
+    method = "POST",
+    headers = {},
+    batchSize = 1,
+    flushIntervalMs = 5e3,
+    retry = false,
+    maxRetries = 3
+  } = options;
+  const serialize = options.serializer ?? ((entries) => JSON.stringify({
+    entries,
+    count: entries.length,
+    timestamp: Date.now()
+  }));
+  let buffer = [];
+  let flushTimer = null;
+  async function sendBatch(entries, attempt = 0) {
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          ...headers
+        },
+        body: serialize(entries)
+      });
+      if (!response.ok && retry && attempt < maxRetries) {
+        const delay = Math.min(1e3 * 2 ** attempt, 3e4);
+        await new Promise((r) => setTimeout(r, delay));
+        return sendBatch(entries, attempt + 1);
+      }
+    } catch {
+      if (retry && attempt < maxRetries) {
+        const delay = Math.min(1e3 * 2 ** attempt, 3e4);
+        await new Promise((r) => setTimeout(r, delay));
+        return sendBatch(entries, attempt + 1);
+      }
+    }
+  }
+  function scheduleFlush() {
+    if (flushTimer) return;
+    flushTimer = setTimeout(() => {
+      flushTimer = null;
+      doFlush();
+    }, flushIntervalMs);
+  }
+  function doFlush() {
+    if (buffer.length === 0) return;
+    const batch = buffer;
+    buffer = [];
+    sendBatch(batch).catch(() => {
+    });
+  }
+  return {
+    name: "webhook",
+    level: options.level,
+    write(entry) {
+      buffer.push(entry);
+      if (buffer.length >= batchSize) {
+        doFlush();
+      } else {
+        scheduleFlush();
+      }
+    },
+    async flush() {
+      if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+      }
+      if (buffer.length > 0) {
+        const batch = buffer;
+        buffer = [];
+        await sendBatch(batch);
+      }
+    },
+    async close() {
+      await this.flush?.();
+    }
+  };
+}
 export {
   LogLevel,
   LogLevelNameMap,
@@ -254,7 +1887,6 @@ export {
   alertMiddleware,
   asyncContextMiddleware,
   batchTransport,
-  browserJsonStreamTransport,
   consoleTransport,
   correlationIdMiddleware,
   createHttpLogger,