@statly/observe 1.1.0 → 1.2.0

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -18,6 +20,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/span.ts
@@ -105,14 +115,14 @@ async function trace(name, operation, tags) {
   try {
     const result = await operation(span);
     return result;
-  } catch (error) {
+  } catch (error2) {
     span.setStatus("error" /* ERROR */);
     span.setTag("error", "true");
-    if (error instanceof Error) {
-      span.setTag("exception.type", error.name);
-      span.setTag("exception.message", error.message);
+    if (error2 instanceof Error) {
+      span.setTag("exception.type", error2.name);
+      span.setTag("exception.message", error2.message);
     }
-    throw error;
+    throw error2;
   } finally {
     provider.finishSpan(span);
   }
@@ -172,6 +182,18 @@ var init_telemetry = __esm({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AIFeatures: () => AIFeatures,
+  ConsoleDestination: () => ConsoleDestination,
+  DEFAULT_LEVELS: () => DEFAULT_LEVELS,
+  EXTENDED_LEVELS: () => EXTENDED_LEVELS,
+  FileDestination: () => FileDestination,
+  LOG_LEVELS: () => LOG_LEVELS,
+  Logger: () => Logger,
+  ObserveDestination: () => ObserveDestination,
+  REDACTED: () => REDACTED,
+  SCRUB_PATTERNS: () => SCRUB_PATTERNS,
+  SENSITIVE_KEYS: () => SENSITIVE_KEYS,
+  Scrubber: () => Scrubber,
   Statly: () => Statly,
   StatlyClient: () => StatlyClient,
   addBreadcrumb: () => addBreadcrumb,
@@ -183,16 +205,30 @@ __export(index_exports, {
   createRequestCapture: () => createRequestCapture,
   expressErrorHandler: () => expressErrorHandler,
   flush: () => flush,
+  formatJson: () => formatJson,
+  formatJsonPretty: () => formatJsonPretty,
+  formatPretty: () => formatPretty,
   getClient: () => getClient,
+  getConsoleMethod: () => getConsoleMethod,
+  getDefaultLogger: () => getDefaultLogger,
   init: () => init,
+  isSensitiveKey: () => isSensitiveKey,
+  logAudit: () => audit,
+  logDebug: () => debug,
+  logError: () => error,
+  logFatal: () => fatal,
+  logInfo: () => info,
+  logTrace: () => trace2,
+  logWarn: () => warn,
   requestHandler: () => requestHandler,
+  setDefaultLogger: () => setDefaultLogger,
   setTag: () => setTag,
   setTags: () => setTags,
   setUser: () => setUser,
   startSpan: () => startSpan,
   statlyFastifyPlugin: () => statlyFastifyPlugin,
   statlyPlugin: () => statlyPlugin,
-  trace: () => trace2,
+  trace: () => trace3,
   withStatly: () => withStatly,
   withStatlyGetServerSideProps: () => withStatlyGetServerSideProps,
   withStatlyGetStaticProps: () => withStatlyGetStaticProps,
@@ -261,10 +297,10 @@ var Transport = class {
     this.queue = [];
     try {
       await this.sendBatch(events);
-    } catch (error) {
+    } catch (error2) {
       this.queue = [...events, ...this.queue].slice(0, this.maxQueueSize);
       if (this.debug) {
-        console.error("[Statly] Failed to send events:", error);
+        console.error("[Statly] Failed to send events:", error2);
       }
     } finally {
       this.isSending = false;
@@ -304,13 +340,13 @@ var Transport = class {
         console.log(`[Statly] Sent ${events.length} event(s)`);
       }
       return { success: true, status: response.status };
-    } catch (error) {
+    } catch (error2) {
       if (this.debug) {
-        console.error("[Statly] Network error:", error);
+        console.error("[Statly] Network error:", error2);
       }
       return {
         success: false,
-        error: error instanceof Error ? error.message : "Network error"
+        error: error2 instanceof Error ? error2.message : "Network error"
       };
     }
   }
@@ -377,16 +413,16 @@ var GlobalHandlers = class {
       if (!this.errorCallback) {
         return;
       }
-      let error;
+      let error2;
       if (event.reason instanceof Error) {
-        error = event.reason;
+        error2 = event.reason;
       } else if (typeof event.reason === "string") {
-        error = new Error(event.reason);
+        error2 = new Error(event.reason);
       } else {
-        error = new Error("Unhandled Promise Rejection");
-        error.reason = event.reason;
+        error2 = new Error("Unhandled Promise Rejection");
+        error2.reason = event.reason;
       }
-      this.errorCallback(error, {
+      this.errorCallback(error2, {
         mechanism: { type: "onunhandledrejection", handled: false }
       });
     };
@@ -429,13 +465,13 @@ var GlobalHandlers = class {
   }
   installOnError() {
     this.originalOnError = window.onerror;
-    window.onerror = (message, source, lineno, colno, error) => {
+    window.onerror = (message, source, lineno, colno, error2) => {
       if (this.originalOnError) {
-        this.originalOnError.call(window, message, source, lineno, colno, error);
+        this.originalOnError.call(window, message, source, lineno, colno, error2);
       }
       if (this.errorCallback) {
-        const errorObj = error || new Error(String(message));
-        if (!error && source) {
+        const errorObj = error2 || new Error(String(message));
+        if (!error2 && source) {
           errorObj.filename = source;
           errorObj.lineno = lineno;
           errorObj.colno = colno;
@@ -600,8 +636,8 @@ var StatlyClient = class {
     }
     this.initialized = true;
     if (this.options.autoCapture) {
-      this.globalHandlers.install((error, context) => {
-        this.captureError(error, context);
+      this.globalHandlers.install((error2, context) => {
+        this.captureError(error2, context);
       });
     }
     if (this.options.captureConsole) {
@@ -624,15 +660,15 @@ var StatlyClient = class {
   /**
    * Capture an exception/error
    */
-  captureException(error, context) {
+  captureException(error2, context) {
     let errorObj;
-    if (error instanceof Error) {
-      errorObj = error;
-    } else if (typeof error === "string") {
-      errorObj = new Error(error);
+    if (error2 instanceof Error) {
+      errorObj = error2;
+    } else if (typeof error2 === "string") {
+      errorObj = new Error(error2);
     } else {
       errorObj = new Error("Unknown error");
-      errorObj.originalError = error;
+      errorObj.originalError = error2;
     }
     return this.captureError(errorObj, context);
   }
@@ -673,18 +709,18 @@ var StatlyClient = class {
   /**
    * Internal method to capture an error
    */
-  captureError(error, context) {
+  captureError(error2, context) {
     if (Math.random() > this.options.sampleRate) {
       return "";
     }
     const event = this.buildEvent({
-      message: error.message,
+      message: error2.message,
       level: "error",
-      stack: error.stack,
+      stack: error2.stack,
       exception: {
-        type: error.name,
-        value: error.message,
-        stacktrace: this.parseStackTrace(error.stack)
+        type: error2.name,
+        value: error2.message,
+        stacktrace: this.parseStackTrace(error2.stack)
       },
       extra: context
     });
@@ -917,8 +953,8 @@ function requestHandler() {
 }
 function expressErrorHandler(options = {}) {
   return (err, req, res, next) => {
-    const error = err instanceof Error ? err : new Error(String(err));
-    if (options.shouldHandleError && !options.shouldHandleError(error)) {
+    const error2 = err instanceof Error ? err : new Error(String(err));
+    if (options.shouldHandleError && !options.shouldHandleError(error2)) {
       return next(err);
     }
     const context = {
@@ -942,7 +978,7 @@ function expressErrorHandler(options = {}) {
     if (req.statlyContext?.transactionName) {
       Statly.setTag("transaction", req.statlyContext.transactionName);
     }
-    Statly.captureException(error, context);
+    Statly.captureException(error2, context);
     next(err);
   };
 }
@@ -995,7 +1031,7 @@ function withStatlyPagesApi(handler) {
       try {
         const result = await handler(req, res);
         return result;
-      } catch (error) {
+      } catch (error2) {
         const context = {
           request: {
             method: req.method,
@@ -1004,8 +1040,8 @@ function withStatlyPagesApi(handler) {
             query: req.query
           }
         };
-        Statly.captureException(error, context);
-        throw error;
+        Statly.captureException(error2, context);
+        throw error2;
       }
     });
   };
@@ -1031,7 +1067,7 @@ function withStatly(handler) {
           span.setTag("http.status_code", result.status.toString());
         }
         return result;
-      } catch (error) {
+      } catch (error2) {
         const headers = {};
         request.headers.forEach((value, key) => {
           headers[key] = value;
@@ -1050,17 +1086,17 @@ function withStatly(handler) {
           } catch {
           }
         }
-        Statly.captureException(error, errorContext);
-        throw error;
+        Statly.captureException(error2, errorContext);
+        throw error2;
       }
     });
   };
   return wrappedHandler;
 }
-function captureNextJsError(error, context) {
-  return Statly.captureException(error, {
+function captureNextJsError(error2, context) {
+  return Statly.captureException(error2, {
     ...context,
-    digest: error.digest,
+    digest: error2.digest,
     source: "nextjs-error-boundary"
   });
 }
@@ -1068,12 +1104,12 @@ function withStatlyGetServerSideProps(handler) {
   return async (context) => {
     try {
       return await handler(context);
-    } catch (error) {
-      Statly.captureException(error, {
+    } catch (error2) {
+      Statly.captureException(error2, {
         source: "getServerSideProps",
         url: context.req?.url || context.resolvedUrl
       });
-      throw error;
+      throw error2;
     }
   };
 }
@@ -1081,12 +1117,12 @@ function withStatlyGetStaticProps(handler) {
   return async (context) => {
     try {
       return await handler(context);
-    } catch (error) {
-      Statly.captureException(error, {
+    } catch (error2) {
+      Statly.captureException(error2, {
         source: "getStaticProps",
         params: context.params
       });
-      throw error;
+      throw error2;
     }
   };
 }
@@ -1102,12 +1138,12 @@ function withStatlyServerAction(action, actionName) {
       });
       try {
         return await action(...args);
-      } catch (error) {
-        Statly.captureException(error, {
+      } catch (error2) {
+        Statly.captureException(error2, {
           source: "server-action",
           actionName
         });
-        throw error;
+        throw error2;
       }
     });
   };
@@ -1162,16 +1198,16 @@ function statlyFastifyPlugin(fastify, options, done) {
     });
     hookDone();
   });
-  fastify.setErrorHandler((error, request, reply) => {
-    const statusCode = error.statusCode || 500;
+  fastify.setErrorHandler((error2, request, reply) => {
+    const statusCode = error2.statusCode || 500;
     if (skipStatusCodes.includes(statusCode)) {
-      throw error;
+      throw error2;
     }
-    if (!captureValidationErrors && error.validation) {
-      throw error;
+    if (!captureValidationErrors && error2.validation) {
+      throw error2;
     }
-    if (shouldCapture && !shouldCapture(error)) {
-      throw error;
+    if (shouldCapture && !shouldCapture(error2)) {
+      throw error2;
     }
     const context = {
       request: {
@@ -1184,27 +1220,27 @@ function statlyFastifyPlugin(fastify, options, done) {
         params: request.params
       },
       error: {
-        statusCode: error.statusCode,
-        code: error.code
+        statusCode: error2.statusCode,
+        code: error2.code
       }
     };
     if (request.ip) {
       context.ip = request.ip;
     }
-    if (error.validation) {
-      context.validation = error.validation;
+    if (error2.validation) {
+      context.validation = error2.validation;
     }
     Statly.setTag("http.method", request.method);
     Statly.setTag("http.url", request.routerPath || request.url);
     Statly.setTag("http.status_code", String(statusCode));
-    Statly.captureException(error, context);
-    throw error;
+    Statly.captureException(error2, context);
+    throw error2;
   });
   done();
 }
 var statlyPlugin = statlyFastifyPlugin;
 function createRequestCapture(request) {
-  return (error, additionalContext) => {
+  return (error2, additionalContext) => {
     const context = {
       request: {
         id: request.id,
@@ -1214,7 +1250,7 @@ function createRequestCapture(request) {
       },
       ...additionalContext
     };
-    return Statly.captureException(error, context);
+    return Statly.captureException(error2, context);
   };
 }
 function sanitizeHeaders3(headers) {
@@ -1230,6 +1266,1400 @@ function sanitizeHeaders3(headers) {
   return sanitized;
 }
 
+// src/logger/types.ts
+var LOG_LEVELS = {
+  trace: 0,
+  debug: 1,
+  info: 2,
+  warn: 3,
+  error: 4,
+  fatal: 5,
+  audit: 6
+  // Special: always logged, never sampled
+};
+var DEFAULT_LEVELS = ["debug", "info", "warn", "error", "fatal"];
+var EXTENDED_LEVELS = ["trace", "debug", "info", "warn", "error", "fatal", "audit"];
+
+// src/logger/scrubbing/patterns.ts
+var SENSITIVE_KEYS = /* @__PURE__ */ new Set([
+  "password",
+  "passwd",
+  "pwd",
+  "secret",
+  "api_key",
+  "apikey",
+  "api-key",
+  "token",
+  "access_token",
+  "accesstoken",
+  "refresh_token",
+  "auth",
+  "authorization",
+  "bearer",
+  "credential",
+  "credentials",
+  "private_key",
+  "privatekey",
+  "private-key",
+  "secret_key",
+  "secretkey",
+  "secret-key",
+  "session_id",
+  "sessionid",
+  "session-id",
+  "session",
+  "cookie",
+  "x-api-key",
+  "x-auth-token",
+  "x-access-token"
+]);
+var SCRUB_PATTERNS = {
+  apiKey: {
+    regex: /(?:api[_-]?key|apikey)\s*[=:]\s*["']?([a-zA-Z0-9_\-]{20,})["']?/gi,
+    description: "API keys in various formats"
+  },
+  password: {
+    regex: /(?:password|passwd|pwd|secret)\s*[=:]\s*["']?([^"'\s]{3,})["']?/gi,
+    description: "Passwords and secrets"
+  },
+  token: {
+    regex: /(?:bearer\s+|token\s*[=:]\s*["']?)([a-zA-Z0-9_\-\.]{20,})["']?/gi,
+    description: "Bearer tokens and auth tokens"
+  },
+  creditCard: {
+    // Visa, Mastercard, Amex, Discover, etc.
+    regex: /\b(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13}|6(?:011|5[0-9]{2})[0-9]{12}|(?:2131|1800|35\d{3})\d{11})\b/g,
+    description: "Credit card numbers"
+  },
+  ssn: {
+    regex: /\b\d{3}[-\s]?\d{2}[-\s]?\d{4}\b/g,
+    description: "US Social Security Numbers"
+  },
+  email: {
+    regex: /\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b/g,
+    description: "Email addresses"
+  },
+  ipAddress: {
+    regex: /\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b/g,
+    description: "IPv4 addresses"
+  },
+  awsKey: {
+    regex: /(?:AKIA|ABIA|ACCA)[A-Z0-9]{16}/g,
+    description: "AWS Access Key IDs"
+  },
+  privateKey: {
+    regex: /-----BEGIN (?:RSA |EC |DSA )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |DSA )?PRIVATE KEY-----/g,
+    description: "Private keys in PEM format"
+  },
+  jwt: {
+    regex: /eyJ[a-zA-Z0-9_-]*\.eyJ[a-zA-Z0-9_-]*\.[a-zA-Z0-9_-]*/g,
+    description: "JSON Web Tokens"
+  }
+};
+var REDACTED = "[REDACTED]";
+function isSensitiveKey(key) {
+  const lowerKey = key.toLowerCase();
+  return SENSITIVE_KEYS.has(lowerKey);
+}
+
+// src/logger/scrubbing/scrubber.ts
+var Scrubber = class {
+  constructor(config = {}) {
+    this.enabled = config.enabled !== false;
+    this.patterns = /* @__PURE__ */ new Map();
+    this.customPatterns = config.customPatterns || [];
+    this.allowlist = new Set((config.allowlist || []).map((k) => k.toLowerCase()));
+    this.customScrubber = config.customScrubber;
+    const patternNames = config.patterns || [
+      "apiKey",
+      "password",
+      "token",
+      "creditCard",
+      "ssn",
+      "awsKey",
+      "privateKey",
+      "jwt"
+    ];
+    for (const name of patternNames) {
+      const pattern = SCRUB_PATTERNS[name];
+      if (pattern) {
+        this.patterns.set(name, new RegExp(pattern.regex.source, pattern.regex.flags));
+      }
+    }
+  }
+  /**
+   * Scrub sensitive data from a value
+   */
+  scrub(value) {
+    if (!this.enabled) {
+      return value;
+    }
+    return this.scrubValue(value, "");
+  }
+  /**
+   * Scrub a log message string
+   */
+  scrubMessage(message) {
+    if (!this.enabled) {
+      return message;
+    }
+    let result = message;
+    for (const [, regex] of this.patterns) {
+      result = result.replace(regex, REDACTED);
+    }
+    for (const regex of this.customPatterns) {
+      result = result.replace(regex, REDACTED);
+    }
+    return result;
+  }
+  /**
+   * Recursively scrub sensitive data
+   */
+  scrubValue(value, key) {
+    if (key && this.allowlist.has(key.toLowerCase())) {
+      return value;
+    }
+    if (this.customScrubber && key) {
+      const result = this.customScrubber(key, value);
+      if (result !== value) {
+        return result;
+      }
+    }
+    if (key && isSensitiveKey(key)) {
+      return REDACTED;
+    }
+    if (value === null || value === void 0) {
+      return value;
+    }
+    if (typeof value === "string") {
+      return this.scrubString(value);
+    }
+    if (Array.isArray(value)) {
+      return value.map((item, index) => this.scrubValue(item, String(index)));
+    }
+    if (typeof value === "object") {
+      return this.scrubObject(value);
+    }
+    return value;
+  }
+  /**
+   * Scrub sensitive patterns from a string
+   */
+  scrubString(value) {
+    let result = value;
+    for (const [, regex] of this.patterns) {
+      regex.lastIndex = 0;
+      result = result.replace(regex, REDACTED);
+    }
+    for (const regex of this.customPatterns) {
+      const newRegex = new RegExp(regex.source, regex.flags);
+      result = result.replace(newRegex, REDACTED);
+    }
+    return result;
+  }
+  /**
+   * Scrub sensitive data from an object
+   */
+  scrubObject(obj) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = this.scrubValue(value, key);
+    }
+    return result;
+  }
+  /**
+   * Add a custom pattern at runtime
+   */
+  addPattern(pattern) {
+    this.customPatterns.push(pattern);
+  }
+  /**
+   * Add a key to the allowlist
+   */
+  addToAllowlist(key) {
+    this.allowlist.add(key.toLowerCase());
+  }
+  /**
+   * Check if scrubbing is enabled
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+  /**
+   * Enable or disable scrubbing
+   */
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+};
+
+// src/logger/formatters/console.ts
+var COLORS = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  // Foreground colors
+  black: "\x1B[30m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m",
+  // Background colors
+  bgRed: "\x1B[41m",
+  bgYellow: "\x1B[43m"
+};
+var LEVEL_COLORS = {
+  trace: COLORS.gray,
+  debug: COLORS.cyan,
+  info: COLORS.green,
+  warn: COLORS.yellow,
+  error: COLORS.red,
+  fatal: `${COLORS.bgRed}${COLORS.white}`,
+  audit: COLORS.magenta
+};
+var LEVEL_LABELS = {
+  trace: "TRACE",
+  debug: "DEBUG",
+  info: "INFO ",
+  warn: "WARN ",
+  error: "ERROR",
+  fatal: "FATAL",
+  audit: "AUDIT"
+};
+function formatPretty(entry, options = {}) {
+  const {
+    colors = true,
+    timestamps = true,
+    showLevel = true,
+    showLogger = true,
+    showContext = true,
+    showSource = false
+  } = options;
+  const parts = [];
+  if (timestamps) {
+    const date = new Date(entry.timestamp);
+    const time = date.toISOString().replace("T", " ").replace("Z", "");
+    parts.push(colors ? `${COLORS.dim}${time}${COLORS.reset}` : time);
+  }
+  if (showLevel) {
+    const levelColor = colors ? LEVEL_COLORS[entry.level] : "";
+    const levelLabel = LEVEL_LABELS[entry.level];
+    parts.push(colors ? `${levelColor}${levelLabel}${COLORS.reset}` : levelLabel);
+  }
+  if (showLogger && entry.loggerName) {
+    parts.push(colors ? `${COLORS.blue}[${entry.loggerName}]${COLORS.reset}` : `[${entry.loggerName}]`);
+  }
+  parts.push(entry.message);
+  if (showSource && entry.source) {
+    const { file, line, function: fn } = entry.source;
+    const loc = [file, line, fn].filter(Boolean).join(":");
+    if (loc) {
+      parts.push(colors ? `${COLORS.dim}(${loc})${COLORS.reset}` : `(${loc})`);
+    }
+  }
+  let result = parts.join(" ");
+  if (showContext && entry.context && Object.keys(entry.context).length > 0) {
+    const contextStr = JSON.stringify(entry.context, null, 2);
+    result += "\n" + (colors ? `${COLORS.dim}${contextStr}${COLORS.reset}` : contextStr);
+  }
+  return result;
+}
+function formatJson(entry) {
+  return JSON.stringify(entry);
+}
+function formatJsonPretty(entry) {
+  return JSON.stringify(entry, null, 2);
+}
+function getConsoleMethod(level) {
+  switch (level) {
+    case "trace":
+      return "trace";
+    case "debug":
+      return "debug";
+    case "info":
+      return "info";
+    case "warn":
+      return "warn";
+    case "error":
+    case "fatal":
+      return "error";
+    case "audit":
+      return "info";
+    default:
+      return "log";
+  }
+}
+
+// src/logger/destinations/console.ts
+var ConsoleDestination = class {
+  constructor(config = {}) {
+    this.name = "console";
+    this.config = {
+      enabled: config.enabled !== false,
+      colors: config.colors !== false,
+      format: config.format || "pretty",
+      timestamps: config.timestamps !== false,
+      levels: config.levels || ["trace", "debug", "info", "warn", "error", "fatal", "audit"]
+    };
+    this.minLevel = 0;
+  }
+  /**
+   * Write a log entry to the console
+   */
+  write(entry) {
+    if (!this.config.enabled) {
+      return;
+    }
+    if (!this.config.levels.includes(entry.level)) {
+      return;
+    }
+    if (LOG_LEVELS[entry.level] < this.minLevel) {
+      return;
+    }
+    let output;
+    if (this.config.format === "json") {
+      output = formatJson(entry);
+    } else {
+      output = formatPretty(entry, {
+        colors: this.config.colors && this.supportsColors(),
+        timestamps: this.config.timestamps
+      });
+    }
+    const method = getConsoleMethod(entry.level);
+    console[method](output);
+  }
+  /**
+   * Check if the environment supports colors
+   */
+  supportsColors() {
+    if (typeof window !== "undefined") {
+      return true;
+    }
+    if (typeof process !== "undefined") {
+      if (process.stdout && "isTTY" in process.stdout) {
+        return Boolean(process.stdout.isTTY);
+      }
+      const env = process.env;
+      if (env.FORCE_COLOR !== void 0) {
+        return env.FORCE_COLOR !== "0";
+      }
+      if (env.NO_COLOR !== void 0) {
+        return false;
+      }
+      if (env.TERM === "dumb") {
+        return false;
+      }
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Set minimum log level
+   */
+  setMinLevel(level) {
+    this.minLevel = LOG_LEVELS[level];
+  }
+  /**
+   * Enable or disable the destination
+   */
+  setEnabled(enabled) {
+    this.config.enabled = enabled;
+  }
+  /**
+   * Set color mode
+   */
+  setColors(enabled) {
+    this.config.colors = enabled;
+  }
+  /**
+   * Set output format
+   */
+  setFormat(format) {
+    this.config.format = format;
+  }
+};
+
+// src/logger/destinations/observe.ts
+var DEFAULT_BATCH_SIZE = 50;
+var DEFAULT_FLUSH_INTERVAL = 5e3;
+var DEFAULT_SAMPLING = {
+  trace: 0.01,
+  // 1%
+  debug: 0.1,
+  // 10%
+  info: 0.5,
+  // 50%
+  warn: 1,
+  // 100%
+  error: 1,
+  // 100%
+  fatal: 1,
+  // 100%
+  audit: 1
+  // 100% - never sampled
+};
+var ObserveDestination = class {
+  constructor(dsn, config = {}) {
+    this.name = "observe";
+    this.queue = [];
+    this.isFlushing = false;
+    this.minLevel = 0;
+    this.dsn = dsn;
+    this.endpoint = this.parseEndpoint(dsn);
+    this.config = {
+      enabled: config.enabled !== false,
+      batchSize: config.batchSize || DEFAULT_BATCH_SIZE,
+      flushInterval: config.flushInterval || DEFAULT_FLUSH_INTERVAL,
+      sampling: { ...DEFAULT_SAMPLING, ...config.sampling },
+      levels: config.levels || ["trace", "debug", "info", "warn", "error", "fatal", "audit"]
+    };
+    this.startFlushTimer();
+  }
+  /**
+   * Parse DSN to construct endpoint
+   */
+  parseEndpoint(dsn) {
+    try {
+      const url = new URL(dsn);
+      return `${url.protocol}//${url.host}/api/v1/logs/ingest`;
+    } catch {
+      return "https://statly.live/api/v1/logs/ingest";
+    }
+  }
+  /**
+   * Start the flush timer
+   */
+  startFlushTimer() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+    }
+    if (typeof setInterval !== "undefined") {
+      this.flushTimer = setInterval(() => {
+        this.flush();
+      }, this.config.flushInterval);
+    }
+  }
+  /**
+   * Write a log entry (queues for batching)
+   */
+  write(entry) {
+    if (!this.config.enabled) {
+      return;
+    }
+    if (!this.config.levels.includes(entry.level)) {
+      return;
+    }
+    if (LOG_LEVELS[entry.level] < this.minLevel) {
+      return;
+    }
+    if (entry.level !== "audit") {
+      const sampleRate = this.config.sampling[entry.level] ?? 1;
+      if (Math.random() > sampleRate) {
+        return;
+      }
+    }
+    this.queue.push(entry);
+    if (this.queue.length >= this.config.batchSize) {
+      this.flush();
+    }
+  }
+  /**
+   * Flush all queued entries to the server
+   */
+  async flush() {
+    if (this.isFlushing || this.queue.length === 0) {
+      return;
+    }
+    this.isFlushing = true;
+    const entries = [...this.queue];
+    this.queue = [];
+    try {
+      await this.sendBatch(entries);
+    } catch (error2) {
+      const maxQueue = this.config.batchSize * 3;
+      this.queue = [...entries, ...this.queue].slice(0, maxQueue);
+      console.error("[Statly Logger] Failed to send logs:", error2);
+    } finally {
+      this.isFlushing = false;
+    }
+  }
+  /**
+   * Send a batch of entries to the server
+   */
+  async sendBatch(entries) {
+    if (entries.length === 0) {
+      return;
+    }
+    const response = await fetch(this.endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Statly-DSN": this.dsn
+      },
+      body: JSON.stringify({ logs: entries }),
+      keepalive: true
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+  }
+  /**
+   * Close the destination
+   */
+  async close() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+    }
+    await this.flush();
+  }
+  /**
+   * Set minimum log level
+   */
+  setMinLevel(level) {
+    this.minLevel = LOG_LEVELS[level];
+  }
+  /**
+   * Set sampling rate for a level
+   */
+  setSamplingRate(level, rate) {
+    this.config.sampling[level] = Math.max(0, Math.min(1, rate));
+  }
+  /**
+   * Enable or disable the destination
+   */
+  setEnabled(enabled) {
+    this.config.enabled = enabled;
+  }
+  /**
+   * Get the current queue size
+   */
+  getQueueSize() {
+    return this.queue.length;
+  }
+};
+
+// src/logger/destinations/file.ts
+function parseSize(size) {
+  const match = size.match(/^(\d+(?:\.\d+)?)\s*(KB|MB|GB|B)?$/i);
+  if (!match) return 10 * 1024 * 1024;
+  const value = parseFloat(match[1]);
+  const unit = (match[2] || "B").toUpperCase();
+  switch (unit) {
+    case "KB":
+      return value * 1024;
+    case "MB":
+      return value * 1024 * 1024;
+    case "GB":
+      return value * 1024 * 1024 * 1024;
+    default:
+      return value;
+  }
+}
+function formatDate(date) {
+  return date.toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19);
+}
+var FileDestination = class {
+  constructor(config) {
+    this.name = "file";
+    this.minLevel = 0;
+    this.buffer = [];
+    this.currentSize = 0;
+    this.writePromise = Promise.resolve();
+    // File system operations (injected for Node.js compatibility)
+    this.fs = null;
+    this.config = {
+      enabled: config.enabled !== false,
+      path: config.path,
+      format: config.format || "json",
+      rotation: config.rotation || { type: "size", maxSize: "10MB", maxFiles: 5 },
+      levels: config.levels || ["trace", "debug", "info", "warn", "error", "fatal", "audit"]
+    };
+    this.maxSize = parseSize(this.config.rotation.maxSize || "10MB");
+    this.lastRotation = /* @__PURE__ */ new Date();
+    this.rotationInterval = this.getRotationInterval();
+    this.initFileSystem();
+  }
+  /**
+   * Initialize file system operations
+   */
+  async initFileSystem() {
+    if (typeof process !== "undefined" && process.versions?.node) {
+      try {
+        const fs = await import("fs/promises");
+        const path = await import("path");
+        const fsOps = {
+          appendFile: fs.appendFile,
+          rename: fs.rename,
+          stat: fs.stat,
+          mkdir: (p, opts) => fs.mkdir(p, opts),
+          readdir: fs.readdir,
+          unlink: fs.unlink
+        };
+        this.fs = fsOps;
+        const dir = path.dirname(this.config.path);
+        await fsOps.mkdir(dir, { recursive: true });
+      } catch {
+        console.warn("[Statly Logger] File destination not available (not Node.js)");
+        this.config.enabled = false;
+      }
+    } else {
+      this.config.enabled = false;
+    }
+  }
+  /**
+   * Get rotation interval in milliseconds
+   */
+  getRotationInterval() {
+    const { interval } = this.config.rotation;
+    switch (interval) {
+      case "hourly":
+        return 60 * 60 * 1e3;
+      case "daily":
+        return 24 * 60 * 60 * 1e3;
+      case "weekly":
+        return 7 * 24 * 60 * 60 * 1e3;
+      default:
+        return Infinity;
+    }
+  }
+  /**
+   * Write a log entry
+   */
+  write(entry) {
+    if (!this.config.enabled || !this.fs) {
+      return;
+    }
+    if (!this.config.levels.includes(entry.level)) {
+      return;
+    }
+    if (LOG_LEVELS[entry.level] < this.minLevel) {
+      return;
+    }
+    let line;
+    if (this.config.format === "json") {
+      line = formatJson(entry);
+    } else {
+      const date = new Date(entry.timestamp).toISOString();
+      line = `${date} [${entry.level.toUpperCase()}] ${entry.loggerName ? `[${entry.loggerName}] ` : ""}${entry.message}`;
+      if (entry.context && Object.keys(entry.context).length > 0) {
+        line += ` ${JSON.stringify(entry.context)}`;
+      }
+    }
+    this.buffer.push(line + "\n");
+    this.currentSize += line.length + 1;
+    if (this.buffer.length >= 100 || this.currentSize >= 64 * 1024) {
+      this.scheduleWrite();
+    }
+  }
+  /**
+   * Schedule a buffered write
+   */
+  scheduleWrite() {
+    this.writePromise = this.writePromise.then(() => this.writeBuffer());
+  }
+  /**
+   * Write buffer to file
+   */
+  async writeBuffer() {
+    if (!this.fs || this.buffer.length === 0) {
+      return;
+    }
+    await this.checkRotation();
+    const data = this.buffer.join("");
+    this.buffer = [];
+    this.currentSize = 0;
+    try {
+      await this.fs.appendFile(this.config.path, data);
+    } catch (error2) {
+      console.error("[Statly Logger] Failed to write to file:", error2);
+    }
+  }
+  /**
+   * Check if rotation is needed
+   */
+  async checkRotation() {
+    if (!this.fs) return;
+    const { type } = this.config.rotation;
+    let shouldRotate = false;
+    if (type === "size") {
+      try {
+        const stats = await this.fs.stat(this.config.path);
+        shouldRotate = stats.size >= this.maxSize;
+      } catch {
+      }
+    } else if (type === "time") {
+      const now = /* @__PURE__ */ new Date();
+      shouldRotate = now.getTime() - this.lastRotation.getTime() >= this.rotationInterval;
+    }
+    if (shouldRotate) {
+      await this.rotate();
+    }
+  }
+  /**
+   * Rotate the log file
+   */
+  async rotate() {
+    if (!this.fs) return;
+    try {
+      const rotatedPath = `${this.config.path}.${formatDate(/* @__PURE__ */ new Date())}`;
+      await this.fs.rename(this.config.path, rotatedPath);
+      this.lastRotation = /* @__PURE__ */ new Date();
+      await this.cleanupOldFiles();
+    } catch (error2) {
+      console.error("[Statly Logger] Failed to rotate file:", error2);
+    }
+  }
+  /**
+   * Clean up old rotated files
+   */
+  async cleanupOldFiles() {
+    if (!this.fs) return;
+    const { maxFiles, retentionDays } = this.config.rotation;
+    try {
+      const path = await import("path");
+      const dir = path.dirname(this.config.path);
+      const basename = path.basename(this.config.path);
+      const files = await this.fs.readdir(dir);
+      const rotatedFiles = files.filter((f) => f.startsWith(basename + ".")).map((f) => ({ name: f, path: path.join(dir, f) })).sort((a, b) => b.name.localeCompare(a.name));
+      if (maxFiles) {
+        for (const file of rotatedFiles.slice(maxFiles)) {
+          await this.fs.unlink(file.path);
+        }
+      }
+      if (retentionDays) {
+        const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
+        for (const file of rotatedFiles) {
+          const match = file.name.match(/\.(\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2})$/);
+          if (match) {
+            const fileDate = new Date(match[1].replace("_", "T").replace(/-/g, ":"));
+            if (fileDate.getTime() < cutoff) {
+              await this.fs.unlink(file.path);
+            }
+          }
+        }
+      }
+    } catch (error2) {
+      console.error("[Statly Logger] Failed to cleanup old files:", error2);
+    }
+  }
+  /**
+   * Flush buffered writes
+   */
+  async flush() {
+    this.scheduleWrite();
+    await this.writePromise;
+  }
+  /**
+   * Close the destination
+   */
+  async close() {
+    await this.flush();
+  }
+  /**
+   * Set minimum log level
+   */
+  setMinLevel(level) {
+    this.minLevel = LOG_LEVELS[level];
+  }
+  /**
+   * Enable or disable the destination
+   */
+  setEnabled(enabled) {
+    this.config.enabled = enabled;
+  }
+};
+
+// src/logger/ai/index.ts
+var AIFeatures = class {
+  constructor(dsn, config = {}) {
+    this.dsn = dsn;
+    this.config = {
+      enabled: config.enabled ?? true,
+      apiKey: config.apiKey || "",
+      model: config.model || "claude-3-haiku-20240307",
+      endpoint: config.endpoint || this.parseEndpoint(dsn)
+    };
+  }
+  /**
+   * Parse DSN to construct AI endpoint
+   */
+  parseEndpoint(dsn) {
+    try {
+      const url = new URL(dsn);
+      return `${url.protocol}//${url.host}/api/v1/logs/ai`;
+    } catch {
+      return "https://statly.live/api/v1/logs/ai";
+    }
+  }
+  /**
+   * Explain an error using AI
+   */
+  async explainError(error2) {
+    if (!this.config.enabled) {
+      return {
+        summary: "AI features are disabled",
+        possibleCauses: []
+      };
+    }
+    const errorData = this.normalizeError(error2);
+    try {
+      const response = await fetch(`${this.config.endpoint}/explain`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Statly-DSN": this.dsn,
+          ...this.config.apiKey && { "X-AI-API-Key": this.config.apiKey }
+        },
+        body: JSON.stringify({
+          error: errorData,
+          model: this.config.model
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      return await response.json();
+    } catch (err) {
+      console.error("[Statly Logger AI] Failed to explain error:", err);
+      return {
+        summary: "Failed to get AI explanation",
+        possibleCauses: []
+      };
+    }
+  }
+  /**
+   * Suggest fixes for an error using AI
+   */
+  async suggestFix(error2, context) {
+    if (!this.config.enabled) {
+      return {
+        summary: "AI features are disabled",
+        suggestedFixes: []
+      };
+    }
+    const errorData = this.normalizeError(error2);
+    try {
+      const response = await fetch(`${this.config.endpoint}/suggest-fix`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Statly-DSN": this.dsn,
+          ...this.config.apiKey && { "X-AI-API-Key": this.config.apiKey }
+        },
+        body: JSON.stringify({
+          error: errorData,
+          context,
+          model: this.config.model
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      return await response.json();
+    } catch (err) {
+      console.error("[Statly Logger AI] Failed to suggest fix:", err);
+      return {
+        summary: "Failed to get AI fix suggestion",
+        suggestedFixes: []
+      };
+    }
+  }
+  /**
+   * Analyze a batch of logs for patterns
+   */
+  async analyzePatterns(logs) {
+    if (!this.config.enabled) {
+      return {
+        patterns: [],
+        summary: "AI features are disabled",
+        recommendations: []
+      };
+    }
+    try {
+      const response = await fetch(`${this.config.endpoint}/analyze-patterns`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Statly-DSN": this.dsn,
+          ...this.config.apiKey && { "X-AI-API-Key": this.config.apiKey }
+        },
+        body: JSON.stringify({
+          logs: logs.slice(0, 1e3),
+          // Limit to 1000 logs
+          model: this.config.model
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      return await response.json();
+    } catch (err) {
+      console.error("[Statly Logger AI] Failed to analyze patterns:", err);
+      return {
+        patterns: [],
+        summary: "Failed to analyze patterns",
+        recommendations: []
+      };
+    }
+  }
+  /**
+   * Normalize error input to a standard format
+   */
+  normalizeError(error2) {
+    if (typeof error2 === "string") {
+      return { message: error2 };
+    }
+    if (error2 instanceof Error) {
+      return {
+        message: error2.message,
+        stack: error2.stack,
+        type: error2.name
+      };
+    }
+    return {
+      message: error2.message,
+      type: error2.level,
+      context: error2.context
+    };
+  }
+  /**
+   * Set API key for AI features
+   */
+  setApiKey(apiKey) {
+    this.config.apiKey = apiKey;
+  }
+  /**
+   * Enable or disable AI features
+   */
+  setEnabled(enabled) {
+    this.config.enabled = enabled;
+  }
+  /**
+   * Check if AI features are enabled
+   */
+  isEnabled() {
+    return this.config.enabled;
+  }
+};
+
+// src/logger/logger.ts
+var SDK_NAME2 = "@statly/observe";
+var SDK_VERSION2 = "1.1.0";
+var Logger = class _Logger {
+  constructor(config = {}) {
+    this.destinations = [];
+    this.ai = null;
+    this.context = {};
+    this.tags = {};
+    this.name = config.loggerName || "default";
+    this.config = config;
+    this.minLevel = LOG_LEVELS[config.level || "debug"];
+    this.enabledLevels = this.parseLevelSet(config.levels || "default");
+    this.scrubber = new Scrubber(config.scrubbing);
+    this.context = config.context || {};
+    this.tags = config.tags || {};
+    this.sessionId = this.generateId();
+    this.initDestinations();
+    if (config.dsn) {
+      this.ai = new AIFeatures(config.dsn);
+    }
+  }
+  /**
+   * Parse level set configuration
+   */
+  parseLevelSet(levels) {
+    if (levels === "default") {
+      return new Set(DEFAULT_LEVELS);
+    }
+    if (levels === "extended") {
+      return new Set(EXTENDED_LEVELS);
+    }
+    return new Set(levels);
+  }
+  /**
+   * Initialize destinations from config
+   */
+  initDestinations() {
+    const { destinations } = this.config;
+    if (!destinations || destinations.console?.enabled !== false) {
+      this.destinations.push(new ConsoleDestination(destinations?.console));
+    }
+    if (destinations?.file?.enabled && destinations.file.path) {
+      this.destinations.push(new FileDestination(destinations.file));
+    }
+    if (this.config.dsn && destinations?.observe?.enabled !== false) {
+      this.destinations.push(new ObserveDestination(this.config.dsn, destinations?.observe));
+    }
+  }
+  /**
+   * Generate a unique ID
+   */
+  generateId() {
+    if (typeof crypto !== "undefined" && crypto.randomUUID) {
+      return crypto.randomUUID();
+    }
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+      const r = Math.random() * 16 | 0;
+      const v = c === "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  }
+  /**
+   * Check if a level should be logged
+   */
+  shouldLog(level) {
+    if (level === "audit") {
+      return true;
+    }
+    if (LOG_LEVELS[level] < this.minLevel) {
+      return false;
+    }
+    return this.enabledLevels.has(level);
+  }
+  /**
+   * Get source location (if available)
+   */
+  getSource() {
+    try {
+      const err = new Error();
+      const stack = err.stack?.split("\n");
+      if (!stack || stack.length < 5) return void 0;
+      for (let i = 3; i < stack.length; i++) {
+        const frame = stack[i];
+        if (!frame.includes("logger.ts") && !frame.includes("Logger.")) {
+          const match = frame.match(/at\s+(?:(.+?)\s+\()?(.+?):(\d+)(?::\d+)?\)?/);
+          if (match) {
+            return {
+              function: match[1] || void 0,
+              file: match[2],
+              line: parseInt(match[3], 10)
+            };
+          }
+        }
+      }
+    } catch {
+    }
+    return void 0;
+  }
+  /**
+   * Create a log entry
+   */
+  createEntry(level, message, context) {
+    return {
+      level,
+      message: this.scrubber.scrubMessage(message),
+      timestamp: Date.now(),
+      loggerName: this.name,
+      context: context ? this.scrubber.scrub({ ...this.context, ...context }) : this.scrubber.scrub(this.context),
+      tags: this.tags,
+      source: this.getSource(),
+      traceId: this.traceId,
+      spanId: this.spanId,
+      sessionId: this.sessionId,
+      environment: this.config.environment,
+      release: this.config.release,
+      sdkName: SDK_NAME2,
+      sdkVersion: SDK_VERSION2
+    };
+  }
+  /**
+   * Write to all destinations
+   */
+  write(entry) {
+    for (const dest of this.destinations) {
+      try {
+        dest.write(entry);
+      } catch (error2) {
+        console.error(`[Statly Logger] Failed to write to ${dest.name}:`, error2);
+      }
+    }
+  }
+  // ==================== Public Logging Methods ====================
+  /**
+   * Log a trace message
+   */
+  trace(message, context) {
+    if (!this.shouldLog("trace")) return;
+    this.write(this.createEntry("trace", message, context));
+  }
+  /**
+   * Log a debug message
+   */
+  debug(message, context) {
+    if (!this.shouldLog("debug")) return;
+    this.write(this.createEntry("debug", message, context));
+  }
+  /**
+   * Log an info message
+   */
+  info(message, context) {
+    if (!this.shouldLog("info")) return;
+    this.write(this.createEntry("info", message, context));
+  }
+  /**
+   * Log a warning message
+   */
+  warn(message, context) {
+    if (!this.shouldLog("warn")) return;
+    this.write(this.createEntry("warn", message, context));
+  }
+  error(messageOrError, context) {
+    if (!this.shouldLog("error")) return;
+    if (messageOrError instanceof Error) {
+      const entry = this.createEntry("error", messageOrError.message, {
+        ...context,
+        stack: messageOrError.stack,
+        errorType: messageOrError.name
+      });
+      this.write(entry);
+    } else {
+      this.write(this.createEntry("error", messageOrError, context));
+    }
+  }
+  fatal(messageOrError, context) {
+    if (!this.shouldLog("fatal")) return;
+    if (messageOrError instanceof Error) {
+      const entry = this.createEntry("fatal", messageOrError.message, {
+        ...context,
+        stack: messageOrError.stack,
+        errorType: messageOrError.name
+      });
+      this.write(entry);
+    } else {
+      this.write(this.createEntry("fatal", messageOrError, context));
+    }
+  }
+  /**
+   * Log an audit message (always logged, never sampled)
+   */
+  audit(message, context) {
+    this.write(this.createEntry("audit", message, context));
+  }
+  /**
+   * Log at a specific level
+   */
+  log(level, message, context) {
+    if (!this.shouldLog(level)) return;
+    this.write(this.createEntry(level, message, context));
+  }
+  // ==================== Context & Tags ====================
+  /**
+   * Set persistent context
+   */
+  setContext(context) {
+    this.context = { ...this.context, ...context };
+  }
+  /**
+   * Clear context
+   */
+  clearContext() {
+    this.context = {};
+  }
+  /**
+   * Set a tag
+   */
+  setTag(key, value) {
+    this.tags[key] = value;
+  }
+  /**
+   * Set multiple tags
+   */
+  setTags(tags) {
+    this.tags = { ...this.tags, ...tags };
+  }
+  /**
+   * Clear tags
+   */
+  clearTags() {
+    this.tags = {};
+  }
+  // ==================== Tracing ====================
+  /**
+   * Set trace ID for distributed tracing
+   */
+  setTraceId(traceId) {
+    this.traceId = traceId;
+  }
+  /**
+   * Set span ID
+   */
+  setSpanId(spanId) {
+    this.spanId = spanId;
+  }
+  /**
+   * Clear tracing context
+   */
+  clearTracing() {
+    this.traceId = void 0;
+    this.spanId = void 0;
+  }
+  // ==================== Child Loggers ====================
+  /**
+   * Create a child logger with additional context
+   */
+  child(options = {}) {
+    const childConfig = {
+      ...this.config,
+      loggerName: options.name || `${this.name}.child`,
+      context: { ...this.context, ...options.context },
+      tags: { ...this.tags, ...options.tags }
+    };
+    const child = new _Logger(childConfig);
+    child.traceId = this.traceId;
+    child.spanId = this.spanId;
+    child.sessionId = this.sessionId;
+    return child;
+  }
+  // ==================== AI Features ====================
+  /**
+   * Explain an error using AI
+   */
+  async explainError(error2) {
+    if (!this.ai) {
+      return {
+        summary: "AI features not available (no DSN configured)",
+        possibleCauses: []
+      };
+    }
+    return this.ai.explainError(error2);
+  }
+  /**
+   * Suggest fixes for an error using AI
+   */
+  async suggestFix(error2, context) {
+    if (!this.ai) {
+      return {
+        summary: "AI features not available (no DSN configured)",
+        suggestedFixes: []
+      };
+    }
+    return this.ai.suggestFix(error2, context);
+  }
+  /**
+   * Configure AI features
+   */
+  configureAI(config) {
+    if (this.ai) {
+      if (config.apiKey) this.ai.setApiKey(config.apiKey);
+      if (config.enabled !== void 0) this.ai.setEnabled(config.enabled);
+    }
+  }
+  // ==================== Destination Management ====================
+  /**
+   * Add a custom destination
+   */
+  addDestination(destination) {
+    this.destinations.push(destination);
+  }
+  /**
+   * Remove a destination by name
+   */
+  removeDestination(name) {
+    this.destinations = this.destinations.filter((d) => d.name !== name);
+  }
+  /**
+   * Get all destinations
+   */
+  getDestinations() {
+    return [...this.destinations];
+  }
+  // ==================== Level Configuration ====================
+  /**
+   * Set minimum log level
+   */
+  setLevel(level) {
+    this.minLevel = LOG_LEVELS[level];
+  }
+  /**
+   * Get current minimum level
+   */
+  getLevel() {
+    const entries = Object.entries(LOG_LEVELS);
+    const entry = entries.find(([, value]) => value === this.minLevel);
+    return entry ? entry[0] : "debug";
+  }
+  /**
+   * Check if a level is enabled
+   */
+  isLevelEnabled(level) {
+    return this.shouldLog(level);
+  }
+  // ==================== Lifecycle ====================
+  /**
+   * Flush all destinations
+   */
+  async flush() {
+    await Promise.all(
+      this.destinations.filter((d) => d.flush).map((d) => d.flush())
+    );
+  }
+  /**
+   * Close the logger and all destinations
+   */
+  async close() {
+    await Promise.all(
+      this.destinations.filter((d) => d.close).map((d) => d.close())
+    );
+  }
+  /**
+   * Get logger name
+   */
+  getName() {
+    return this.name;
+  }
+  /**
+   * Get session ID
+   */
+  getSessionId() {
+    return this.sessionId;
+  }
+};
+
+// src/logger/index.ts
+var defaultLogger = null;
+function getDefaultLogger() {
+  if (!defaultLogger) {
+    defaultLogger = new Logger();
+  }
+  return defaultLogger;
+}
+function setDefaultLogger(logger) {
+  defaultLogger = logger;
+}
+function trace2(message, context) {
+  getDefaultLogger().trace(message, context);
+}
+function debug(message, context) {
+  getDefaultLogger().debug(message, context);
+}
+function info(message, context) {
+  getDefaultLogger().info(message, context);
+}
+function warn(message, context) {
+  getDefaultLogger().warn(message, context);
+}
+function error(messageOrError, context) {
+  if (messageOrError instanceof Error) {
+    getDefaultLogger().error(messageOrError, context);
+  } else {
+    getDefaultLogger().error(messageOrError, context);
+  }
+}
+function fatal(messageOrError, context) {
+  if (messageOrError instanceof Error) {
+    getDefaultLogger().fatal(messageOrError, context);
+  } else {
+    getDefaultLogger().fatal(messageOrError, context);
+  }
+}
+function audit(message, context) {
+  getDefaultLogger().audit(message, context);
+}
+
 // src/index.ts
 var client = null;
 function loadDsnFromEnv() {
@@ -1264,12 +2694,12 @@ function init(options) {
   client = new StatlyClient(finalOptions);
   client.init();
 }
-function captureException(error, context) {
+function captureException(error2, context) {
   if (!client) {
     console.warn("[Statly] SDK not initialized. Call Statly.init() first.");
     return "";
   }
-  return client.captureException(error, context);
+  return client.captureException(error2, context);
 }
 function captureMessage(message, level = "info") {
   if (!client) {
@@ -1322,7 +2752,7 @@ async function close() {
 function getClient() {
   return client;
 }
-async function trace2(name, operation, tags) {
+async function trace3(name, operation, tags) {
   if (!client) {
     return operation(null);
   }
@@ -1347,12 +2777,24 @@ var Statly = {
   flush,
   close,
   getClient,
-  trace: trace2,
+  trace: trace3,
   startSpan,
   captureSpan
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AIFeatures,
+  ConsoleDestination,
+  DEFAULT_LEVELS,
+  EXTENDED_LEVELS,
+  FileDestination,
+  LOG_LEVELS,
+  Logger,
+  ObserveDestination,
+  REDACTED,
+  SCRUB_PATTERNS,
+  SENSITIVE_KEYS,
+  Scrubber,
   Statly,
   StatlyClient,
   addBreadcrumb,
@@ -1364,9 +2806,23 @@ var Statly = {
   createRequestCapture,
   expressErrorHandler,
   flush,
+  formatJson,
+  formatJsonPretty,
+  formatPretty,
   getClient,
+  getConsoleMethod,
+  getDefaultLogger,
   init,
+  isSensitiveKey,
+  logAudit,
+  logDebug,
+  logError,
+  logFatal,
+  logInfo,
+  logTrace,
+  logWarn,
   requestHandler,
+  setDefaultLogger,
   setTag,
   setTags,
   setUser,