@statly/observe 0.1.0

package/dist/chunk-PETWPVHU.mjs

@@ -0,0 +1,1090 @@
+// src/transport.ts
+var Transport = class {
+  constructor(options) {
+    this.queue = [];
+    this.isSending = false;
+    this.maxQueueSize = 100;
+    this.flushInterval = 5e3;
+    this.dsn = options.dsn;
+    this.debug = options.debug ?? false;
+    this.endpoint = this.parseEndpoint(options.dsn);
+    this.startFlushTimer();
+  }
+  parseEndpoint(dsn) {
+    try {
+      const url = new URL(dsn);
+      return `${url.protocol}//${url.host}/api/v1/observe/ingest`;
+    } catch {
+      return `https://statly.live/api/v1/observe/ingest`;
+    }
+  }
+  startFlushTimer() {
+    if (typeof window !== "undefined") {
+      this.flushTimer = setInterval(() => {
+        this.flush();
+      }, this.flushInterval);
+    }
+  }
+  /**
+   * Add an event to the queue
+   */
+  enqueue(event) {
+    if (this.queue.length >= this.maxQueueSize) {
+      this.queue.shift();
+      if (this.debug) {
+        console.warn("[Statly] Event queue full, dropping oldest event");
+      }
+    }
+    this.queue.push(event);
+    if (this.queue.length >= 10) {
+      this.flush();
+    }
+  }
+  /**
+   * Send a single event immediately
+   */
+  async send(event) {
+    return this.sendBatch([event]);
+  }
+  /**
+   * Flush all queued events
+   */
+  async flush() {
+    if (this.isSending || this.queue.length === 0) {
+      return;
+    }
+    this.isSending = true;
+    const events = [...this.queue];
+    this.queue = [];
+    try {
+      await this.sendBatch(events);
+    } catch (error) {
+      this.queue = [...events, ...this.queue].slice(0, this.maxQueueSize);
+      if (this.debug) {
+        console.error("[Statly] Failed to send events:", error);
+      }
+    } finally {
+      this.isSending = false;
+    }
+  }
+  /**
+   * Send a batch of events
+   */
+  async sendBatch(events) {
+    if (events.length === 0) {
+      return { success: true };
+    }
+    const payload = events.length === 1 ? events[0] : { events };
+    try {
+      const response = await fetch(this.endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Statly-DSN": this.dsn
+        },
+        body: JSON.stringify(payload),
+        // Use keepalive for better reliability during page unload
+        keepalive: true
+      });
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => "Unknown error");
+        if (this.debug) {
+          console.error("[Statly] API error:", response.status, errorText);
+        }
+        return {
+          success: false,
+          status: response.status,
+          error: errorText
+        };
+      }
+      if (this.debug) {
+        console.log(`[Statly] Sent ${events.length} event(s)`);
+      }
+      return { success: true, status: response.status };
+    } catch (error) {
+      if (this.debug) {
+        console.error("[Statly] Network error:", error);
+      }
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Network error"
+      };
+    }
+  }
+  /**
+   * Clean up resources
+   */
+  destroy() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+    }
+    this.flush();
+  }
+};
+
+// src/breadcrumbs.ts
+var BreadcrumbManager = class {
+  constructor(maxBreadcrumbs = 100) {
+    this.breadcrumbs = [];
+    this.maxBreadcrumbs = maxBreadcrumbs;
+  }
+  /**
+   * Add a breadcrumb
+   */
+  add(breadcrumb) {
+    const crumb = {
+      timestamp: Date.now(),
+      ...breadcrumb
+    };
+    this.breadcrumbs.push(crumb);
+    if (this.breadcrumbs.length > this.maxBreadcrumbs) {
+      this.breadcrumbs = this.breadcrumbs.slice(-this.maxBreadcrumbs);
+    }
+  }
+  /**
+   * Get all breadcrumbs
+   */
+  getAll() {
+    return [...this.breadcrumbs];
+  }
+  /**
+   * Clear all breadcrumbs
+   */
+  clear() {
+    this.breadcrumbs = [];
+  }
+  /**
+   * Set maximum breadcrumbs to keep
+   */
+  setMaxBreadcrumbs(max) {
+    this.maxBreadcrumbs = max;
+    if (this.breadcrumbs.length > max) {
+      this.breadcrumbs = this.breadcrumbs.slice(-max);
+    }
+  }
+};
+
+// src/integrations/global-handlers.ts
+var GlobalHandlers = class {
+  constructor(options = {}) {
+    this.originalOnError = null;
+    this.originalOnUnhandledRejection = null;
+    this.errorCallback = null;
+    this.handleUnhandledRejection = (event) => {
+      if (!this.errorCallback) {
+        return;
+      }
+      let error;
+      if (event.reason instanceof Error) {
+        error = event.reason;
+      } else if (typeof event.reason === "string") {
+        error = new Error(event.reason);
+      } else {
+        error = new Error("Unhandled Promise Rejection");
+        error.reason = event.reason;
+      }
+      this.errorCallback(error, {
+        mechanism: { type: "onunhandledrejection", handled: false }
+      });
+    };
+    this.options = {
+      onerror: options.onerror !== false,
+      onunhandledrejection: options.onunhandledrejection !== false
+    };
+  }
+  /**
+   * Install global error handlers
+   */
+  install(callback) {
+    this.errorCallback = callback;
+    if (typeof window === "undefined") {
+      return;
+    }
+    if (this.options.onerror) {
+      this.installOnError();
+    }
+    if (this.options.onunhandledrejection) {
+      this.installOnUnhandledRejection();
+    }
+  }
+  /**
+   * Uninstall global error handlers
+   */
+  uninstall() {
+    if (typeof window === "undefined") {
+      return;
+    }
+    if (this.originalOnError !== null) {
+      window.onerror = this.originalOnError;
+      this.originalOnError = null;
+    }
+    if (this.originalOnUnhandledRejection !== null) {
+      window.removeEventListener("unhandledrejection", this.handleUnhandledRejection);
+      this.originalOnUnhandledRejection = null;
+    }
+    this.errorCallback = null;
+  }
+  installOnError() {
+    this.originalOnError = window.onerror;
+    window.onerror = (message, source, lineno, colno, error) => {
+      if (this.originalOnError) {
+        this.originalOnError.call(window, message, source, lineno, colno, error);
+      }
+      if (this.errorCallback) {
+        const errorObj = error || new Error(String(message));
+        if (!error && source) {
+          errorObj.filename = source;
+          errorObj.lineno = lineno;
+          errorObj.colno = colno;
+        }
+        this.errorCallback(errorObj, {
+          mechanism: { type: "onerror", handled: false },
+          source,
+          lineno,
+          colno
+        });
+      }
+      return false;
+    };
+  }
+  installOnUnhandledRejection() {
+    this.originalOnUnhandledRejection = this.handleUnhandledRejection.bind(this);
+    window.addEventListener("unhandledrejection", this.handleUnhandledRejection);
+  }
+};
+
+// src/integrations/console.ts
+var ConsoleIntegration = class {
+  constructor() {
+    this.originalMethods = {};
+    this.callback = null;
+    this.levels = ["debug", "info", "warn", "error", "log"];
+  }
+  /**
+   * Install console breadcrumb tracking
+   */
+  install(callback, levels) {
+    this.callback = callback;
+    if (levels) {
+      this.levels = levels;
+    }
+    if (typeof console === "undefined") {
+      return;
+    }
+    for (const level of this.levels) {
+      this.wrapConsoleMethod(level);
+    }
+  }
+  /**
+   * Uninstall console breadcrumb tracking
+   */
+  uninstall() {
+    if (typeof console === "undefined") {
+      return;
+    }
+    for (const level of this.levels) {
+      if (this.originalMethods[level]) {
+        console[level] = this.originalMethods[level];
+        delete this.originalMethods[level];
+      }
+    }
+    this.callback = null;
+  }
+  wrapConsoleMethod(level) {
+    const originalMethod = console[level];
+    if (!originalMethod) {
+      return;
+    }
+    this.originalMethods[level] = originalMethod;
+    const self = this;
+    console[level] = function(...args) {
+      if (self.callback) {
+        self.callback({
+          category: "console",
+          message: self.formatArgs(args),
+          level: self.mapLevel(level),
+          data: args.length > 1 ? { arguments: args } : void 0
+        });
+      }
+      originalMethod.apply(console, args);
+    };
+  }
+  formatArgs(args) {
+    return args.map((arg) => {
+      if (typeof arg === "string") {
+        return arg;
+      }
+      if (arg instanceof Error) {
+        return arg.message;
+      }
+      try {
+        return JSON.stringify(arg);
+      } catch {
+        return String(arg);
+      }
+    }).join(" ");
+  }
+  mapLevel(consoleLevel) {
+    switch (consoleLevel) {
+      case "debug":
+        return "debug";
+      case "info":
+      case "log":
+        return "info";
+      case "warn":
+        return "warning";
+      case "error":
+        return "error";
+      default:
+        return "info";
+    }
+  }
+};
+
+// src/client.ts
+var SDK_NAME = "@statly/observe-sdk";
+var SDK_VERSION = "0.1.0";
+var StatlyClient = class {
+  constructor(options) {
+    this.user = null;
+    this.initialized = false;
+    this.options = this.mergeOptions(options);
+    this.transport = new Transport({
+      dsn: this.options.dsn,
+      debug: this.options.debug
+    });
+    this.breadcrumbs = new BreadcrumbManager(this.options.maxBreadcrumbs);
+    this.globalHandlers = new GlobalHandlers();
+    this.consoleIntegration = new ConsoleIntegration();
+  }
+  mergeOptions(options) {
+    return {
+      dsn: options.dsn,
+      release: options.release ?? "",
+      environment: options.environment ?? this.detectEnvironment(),
+      debug: options.debug ?? false,
+      sampleRate: options.sampleRate ?? 1,
+      maxBreadcrumbs: options.maxBreadcrumbs ?? 100,
+      autoCapture: options.autoCapture !== false,
+      captureConsole: options.captureConsole !== false,
+      captureNetwork: options.captureNetwork ?? false,
+      tags: options.tags ?? {},
+      beforeSend: options.beforeSend ?? ((e) => e)
+    };
+  }
+  detectEnvironment() {
+    if (typeof window !== "undefined") {
+      if (window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1") {
+        return "development";
+      }
+      if (window.location.hostname.includes("staging") || window.location.hostname.includes("stage")) {
+        return "staging";
+      }
+    }
+    return "production";
+  }
+  /**
+   * Initialize the SDK
+   */
+  init() {
+    if (this.initialized) {
+      if (this.options.debug) {
+        console.warn("[Statly] SDK already initialized");
+      }
+      return;
+    }
+    this.initialized = true;
+    if (this.options.autoCapture) {
+      this.globalHandlers.install((error, context) => {
+        this.captureError(error, context);
+      });
+    }
+    if (this.options.captureConsole) {
+      this.consoleIntegration.install((breadcrumb) => {
+        this.breadcrumbs.add(breadcrumb);
+      });
+    }
+    this.addBreadcrumb({
+      category: "navigation",
+      message: "SDK initialized",
+      level: "info"
+    });
+    if (this.options.debug) {
+      console.log("[Statly] SDK initialized", {
+        environment: this.options.environment,
+        release: this.options.release
+      });
+    }
+  }
+  /**
+   * Capture an exception/error
+   */
+  captureException(error, context) {
+    let errorObj;
+    if (error instanceof Error) {
+      errorObj = error;
+    } else if (typeof error === "string") {
+      errorObj = new Error(error);
+    } else {
+      errorObj = new Error("Unknown error");
+      errorObj.originalError = error;
+    }
+    return this.captureError(errorObj, context);
+  }
+  /**
+   * Capture a message
+   */
+  captureMessage(message, level = "info") {
+    const event = this.buildEvent({
+      message,
+      level
+    });
+    return this.sendEvent(event);
+  }
+  /**
+   * Internal method to capture an error
+   */
+  captureError(error, context) {
+    if (Math.random() > this.options.sampleRate) {
+      return "";
+    }
+    const event = this.buildEvent({
+      message: error.message,
+      level: "error",
+      stack: error.stack,
+      exception: {
+        type: error.name,
+        value: error.message,
+        stacktrace: this.parseStackTrace(error.stack)
+      },
+      extra: context
+    });
+    return this.sendEvent(event);
+  }
+  /**
+   * Build a complete event from partial data
+   */
+  buildEvent(partial) {
+    const event = {
+      message: partial.message || "Unknown error",
+      timestamp: Date.now(),
+      level: partial.level || "error",
+      environment: this.options.environment,
+      release: this.options.release || void 0,
+      url: typeof window !== "undefined" ? window.location.href : void 0,
+      user: this.user || void 0,
+      tags: { ...this.options.tags, ...partial.tags },
+      extra: partial.extra,
+      breadcrumbs: this.breadcrumbs.getAll(),
+      browser: this.getBrowserInfo(),
+      os: this.getOSInfo(),
+      sdk: {
+        name: SDK_NAME,
+        version: SDK_VERSION
+      },
+      ...partial
+    };
+    return event;
+  }
+  /**
+   * Parse a stack trace string into structured frames
+   */
+  parseStackTrace(stack) {
+    if (!stack) {
+      return void 0;
+    }
+    const frames = [];
+    const lines = stack.split("\n");
+    for (const line of lines) {
+      const chromeMatch = line.match(/^\s*at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?$/);
+      if (chromeMatch) {
+        frames.push({
+          function: chromeMatch[1] || "<anonymous>",
+          filename: chromeMatch[2],
+          lineno: parseInt(chromeMatch[3], 10),
+          colno: parseInt(chromeMatch[4], 10)
+        });
+        continue;
+      }
+      const firefoxMatch = line.match(/^(.+?)@(.+?):(\d+):(\d+)$/);
+      if (firefoxMatch) {
+        frames.push({
+          function: firefoxMatch[1] || "<anonymous>",
+          filename: firefoxMatch[2],
+          lineno: parseInt(firefoxMatch[3], 10),
+          colno: parseInt(firefoxMatch[4], 10)
+        });
+      }
+    }
+    return frames.length > 0 ? { frames } : void 0;
+  }
+  /**
+   * Send an event to the server
+   */
+  sendEvent(event) {
+    const processed = this.options.beforeSend(event);
+    if (!processed) {
+      if (this.options.debug) {
+        console.log("[Statly] Event dropped by beforeSend");
+      }
+      return "";
+    }
+    const eventId = this.generateEventId();
+    this.breadcrumbs.add({
+      category: "statly",
+      message: `Captured ${event.level}: ${event.message.slice(0, 50)}`,
+      level: "info"
+    });
+    this.transport.enqueue(processed);
+    if (this.options.debug) {
+      console.log("[Statly] Event captured:", eventId, event.message);
+    }
+    return eventId;
+  }
+  generateEventId() {
+    return crypto.randomUUID?.() || "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);
+    });
+  }
+  /**
+   * Set user context
+   */
+  setUser(user) {
+    this.user = user;
+    if (this.options.debug && user) {
+      console.log("[Statly] User set:", user.id || user.email);
+    }
+  }
+  /**
+   * Set a single tag
+   */
+  setTag(key, value) {
+    this.options.tags[key] = value;
+  }
+  /**
+   * Set multiple tags
+   */
+  setTags(tags) {
+    Object.assign(this.options.tags, tags);
+  }
+  /**
+   * Add a breadcrumb
+   */
+  addBreadcrumb(breadcrumb) {
+    this.breadcrumbs.add(breadcrumb);
+  }
+  /**
+   * Get browser info
+   */
+  getBrowserInfo() {
+    if (typeof navigator === "undefined") {
+      return void 0;
+    }
+    const ua = navigator.userAgent;
+    let name = "Unknown";
+    let version = "";
+    if (ua.includes("Firefox/")) {
+      name = "Firefox";
+      version = ua.split("Firefox/")[1]?.split(" ")[0] || "";
+    } else if (ua.includes("Chrome/")) {
+      name = "Chrome";
+      version = ua.split("Chrome/")[1]?.split(" ")[0] || "";
+    } else if (ua.includes("Safari/") && !ua.includes("Chrome")) {
+      name = "Safari";
+      version = ua.split("Version/")[1]?.split(" ")[0] || "";
+    } else if (ua.includes("Edge/") || ua.includes("Edg/")) {
+      name = "Edge";
+      version = ua.split(/Edg?e?\//)[1]?.split(" ")[0] || "";
+    }
+    return { name, version };
+  }
+  /**
+   * Get OS info
+   */
+  getOSInfo() {
+    if (typeof navigator === "undefined") {
+      return void 0;
+    }
+    const ua = navigator.userAgent;
+    let name = "Unknown";
+    let version = "";
+    if (ua.includes("Windows")) {
+      name = "Windows";
+      const match = ua.match(/Windows NT (\d+\.\d+)/);
+      if (match) version = match[1];
+    } else if (ua.includes("Mac OS X")) {
+      name = "macOS";
+      const match = ua.match(/Mac OS X (\d+[._]\d+)/);
+      if (match) version = match[1].replace("_", ".");
+    } else if (ua.includes("Linux")) {
+      name = "Linux";
+    } else if (ua.includes("Android")) {
+      name = "Android";
+      const match = ua.match(/Android (\d+\.\d+)/);
+      if (match) version = match[1];
+    } else if (ua.includes("iOS") || ua.includes("iPhone") || ua.includes("iPad")) {
+      name = "iOS";
+      const match = ua.match(/OS (\d+_\d+)/);
+      if (match) version = match[1].replace("_", ".");
+    }
+    return { name, version };
+  }
+  /**
+   * Flush pending events and clean up
+   */
+  async close() {
+    this.globalHandlers.uninstall();
+    this.consoleIntegration.uninstall();
+    await this.transport.flush();
+    this.transport.destroy();
+    this.initialized = false;
+  }
+  /**
+   * Force flush pending events
+   */
+  async flush() {
+    await this.transport.flush();
+  }
+};
+
+// src/integrations/nextjs.ts
+function withStatlyPagesApi(handler) {
+  return async (req, res) => {
+    Statly.addBreadcrumb({
+      category: "http",
+      message: `${req.method} ${req.url}`,
+      level: "info",
+      data: {
+        method: req.method,
+        url: req.url
+      }
+    });
+    try {
+      return await handler(req, res);
+    } catch (error) {
+      const context = {
+        request: {
+          method: req.method,
+          url: req.url,
+          headers: sanitizeHeaders(req.headers),
+          query: req.query
+        }
+      };
+      Statly.captureException(error, context);
+      throw error;
+    }
+  };
+}
+function withStatly(handler) {
+  const wrappedHandler = async (request, context) => {
+    Statly.addBreadcrumb({
+      category: "http",
+      message: `${request.method} ${request.nextUrl?.pathname || request.url}`,
+      level: "info",
+      data: {
+        method: request.method,
+        url: request.nextUrl?.pathname || request.url
+      }
+    });
+    try {
+      return await handler(request, context);
+    } catch (error) {
+      const headers = {};
+      request.headers.forEach((value, key) => {
+        headers[key] = value;
+      });
+      const errorContext = {
+        request: {
+          method: request.method,
+          url: request.nextUrl?.pathname || request.url,
+          headers: sanitizeHeaders(headers),
+          searchParams: request.nextUrl?.searchParams?.toString()
+        }
+      };
+      if (context?.params) {
+        try {
+          errorContext.params = await context.params;
+        } catch {
+        }
+      }
+      Statly.captureException(error, errorContext);
+      throw error;
+    }
+  };
+  return wrappedHandler;
+}
+function captureNextJsError(error, context) {
+  return Statly.captureException(error, {
+    ...context,
+    digest: error.digest,
+    source: "nextjs-error-boundary"
+  });
+}
+function withStatlyGetServerSideProps(handler) {
+  return async (context) => {
+    try {
+      return await handler(context);
+    } catch (error) {
+      Statly.captureException(error, {
+        source: "getServerSideProps",
+        url: context.req?.url || context.resolvedUrl
+      });
+      throw error;
+    }
+  };
+}
+function withStatlyGetStaticProps(handler) {
+  return async (context) => {
+    try {
+      return await handler(context);
+    } catch (error) {
+      Statly.captureException(error, {
+        source: "getStaticProps",
+        params: context.params
+      });
+      throw error;
+    }
+  };
+}
+function withStatlyServerAction(action, actionName) {
+  return async (...args) => {
+    Statly.addBreadcrumb({
+      category: "action",
+      message: `Server action: ${actionName || "unknown"}`,
+      level: "info"
+    });
+    try {
+      return await action(...args);
+    } catch (error) {
+      Statly.captureException(error, {
+        source: "server-action",
+        actionName
+      });
+      throw error;
+    }
+  };
+}
+function sanitizeHeaders(headers) {
+  const sensitiveHeaders = ["authorization", "cookie", "x-api-key", "x-auth-token"];
+  const sanitized = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (sensitiveHeaders.includes(key.toLowerCase())) {
+      sanitized[key] = "[Filtered]";
+    } else {
+      sanitized[key] = value;
+    }
+  }
+  return sanitized;
+}
+
+// src/integrations/fastify.ts
+function statlyFastifyPlugin(fastify, options, done) {
+  const {
+    captureValidationErrors = true,
+    shouldCapture,
+    skipStatusCodes = [400, 401, 403, 404]
+  } = options;
+  fastify.addHook("onRequest", (request, _reply, hookDone) => {
+    request.statlyStartTime = Date.now();
+    Statly.addBreadcrumb({
+      category: "http",
+      message: `${request.method} ${request.routerPath || request.url}`,
+      level: "info",
+      data: {
+        method: request.method,
+        url: request.url,
+        routerPath: request.routerPath,
+        requestId: request.id
+      }
+    });
+    hookDone();
+  });
+  fastify.addHook("onResponse", (request, reply, hookDone) => {
+    const startTime = request.statlyStartTime;
+    const duration = startTime ? Date.now() - startTime : void 0;
+    Statly.addBreadcrumb({
+      category: "http",
+      message: `Response ${reply.statusCode}`,
+      level: reply.statusCode >= 400 ? "error" : "info",
+      data: {
+        statusCode: reply.statusCode,
+        duration,
+        requestId: request.id
+      }
+    });
+    hookDone();
+  });
+  fastify.setErrorHandler((error, request, reply) => {
+    const statusCode = error.statusCode || 500;
+    if (skipStatusCodes.includes(statusCode)) {
+      throw error;
+    }
+    if (!captureValidationErrors && error.validation) {
+      throw error;
+    }
+    if (shouldCapture && !shouldCapture(error)) {
+      throw error;
+    }
+    const context = {
+      request: {
+        id: request.id,
+        method: request.method,
+        url: request.url,
+        routerPath: request.routerPath,
+        headers: sanitizeHeaders2(request.headers),
+        query: request.query,
+        params: request.params
+      },
+      error: {
+        statusCode: error.statusCode,
+        code: error.code
+      }
+    };
+    if (request.ip) {
+      context.ip = request.ip;
+    }
+    if (error.validation) {
+      context.validation = error.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;
+  });
+  done();
+}
+var statlyPlugin = statlyFastifyPlugin;
+function createRequestCapture(request) {
+  return (error, additionalContext) => {
+    const context = {
+      request: {
+        id: request.id,
+        method: request.method,
+        url: request.url,
+        routerPath: request.routerPath
+      },
+      ...additionalContext
+    };
+    return Statly.captureException(error, context);
+  };
+}
+function sanitizeHeaders2(headers) {
+  const sensitiveHeaders = ["authorization", "cookie", "x-api-key", "x-auth-token"];
+  const sanitized = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (sensitiveHeaders.includes(key.toLowerCase())) {
+      sanitized[key] = "[Filtered]";
+    } else {
+      sanitized[key] = value;
+    }
+  }
+  return sanitized;
+}
+
+// src/index.ts
+var client = null;
+function init(options) {
+  if (client) {
+    console.warn("[Statly] SDK already initialized. Call close() first to reinitialize.");
+    return;
+  }
+  client = new StatlyClient(options);
+  client.init();
+}
+function captureException(error, context) {
+  if (!client) {
+    console.warn("[Statly] SDK not initialized. Call Statly.init() first.");
+    return "";
+  }
+  return client.captureException(error, context);
+}
+function captureMessage(message, level = "info") {
+  if (!client) {
+    console.warn("[Statly] SDK not initialized. Call Statly.init() first.");
+    return "";
+  }
+  return client.captureMessage(message, level);
+}
+function setUser(user) {
+  if (!client) {
+    console.warn("[Statly] SDK not initialized. Call Statly.init() first.");
+    return;
+  }
+  client.setUser(user);
+}
+function setTag(key, value) {
+  if (!client) {
+    console.warn("[Statly] SDK not initialized. Call Statly.init() first.");
+    return;
+  }
+  client.setTag(key, value);
+}
+function setTags(tags) {
+  if (!client) {
+    console.warn("[Statly] SDK not initialized. Call Statly.init() first.");
+    return;
+  }
+  client.setTags(tags);
+}
+function addBreadcrumb(breadcrumb) {
+  if (!client) {
+    console.warn("[Statly] SDK not initialized. Call Statly.init() first.");
+    return;
+  }
+  client.addBreadcrumb(breadcrumb);
+}
+async function flush() {
+  if (!client) {
+    return;
+  }
+  await client.flush();
+}
+async function close() {
+  if (!client) {
+    return;
+  }
+  await client.close();
+  client = null;
+}
+function getClient() {
+  return client;
+}
+var Statly = {
+  init,
+  captureException,
+  captureMessage,
+  setUser,
+  setTag,
+  setTags,
+  addBreadcrumb,
+  flush,
+  close,
+  getClient
+};
+
+// src/integrations/express.ts
+function requestHandler() {
+  return (req, res, next) => {
+    req.statlyContext = {
+      transactionName: `${req.method} ${req.path || req.url}`,
+      startTime: Date.now()
+    };
+    Statly.addBreadcrumb({
+      category: "http",
+      message: `${req.method} ${req.originalUrl || req.url}`,
+      level: "info",
+      data: {
+        method: req.method,
+        url: req.originalUrl || req.url
+      }
+    });
+    if (req.user) {
+      Statly.setUser({
+        id: req.user.id?.toString(),
+        email: req.user.email?.toString()
+      });
+    }
+    res.on("finish", () => {
+      const duration = req.statlyContext?.startTime ? Date.now() - req.statlyContext.startTime : void 0;
+      Statly.addBreadcrumb({
+        category: "http",
+        message: `Response ${res.statusCode}`,
+        level: res.statusCode >= 400 ? "error" : "info",
+        data: {
+          statusCode: res.statusCode,
+          duration
+        }
+      });
+    });
+    next();
+  };
+}
+function expressErrorHandler(options = {}) {
+  return (err, req, res, next) => {
+    const error = err instanceof Error ? err : new Error(String(err));
+    if (options.shouldHandleError && !options.shouldHandleError(error)) {
+      return next(err);
+    }
+    const context = {
+      request: {
+        method: req.method,
+        url: req.originalUrl || req.url,
+        headers: sanitizeHeaders3(req.headers),
+        query: req.query,
+        data: sanitizeBody(req.body)
+      }
+    };
+    if (req.ip) {
+      context.ip = req.ip;
+    }
+    if (req.user) {
+      Statly.setUser({
+        id: req.user.id?.toString(),
+        email: req.user.email?.toString()
+      });
+    }
+    if (req.statlyContext?.transactionName) {
+      Statly.setTag("transaction", req.statlyContext.transactionName);
+    }
+    Statly.captureException(error, context);
+    next(err);
+  };
+}
+function sanitizeHeaders3(headers) {
+  const sensitiveHeaders = ["authorization", "cookie", "x-api-key", "x-auth-token"];
+  const sanitized = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (sensitiveHeaders.includes(key.toLowerCase())) {
+      sanitized[key] = "[Filtered]";
+    } else {
+      sanitized[key] = value;
+    }
+  }
+  return sanitized;
+}
+function sanitizeBody(body) {
+  if (!body || typeof body !== "object") {
+    return body;
+  }
+  const sensitiveFields = ["password", "secret", "token", "apiKey", "api_key", "credit_card", "creditCard", "ssn"];
+  const sanitized = {};
+  for (const [key, value] of Object.entries(body)) {
+    if (sensitiveFields.some((field) => key.toLowerCase().includes(field.toLowerCase()))) {
+      sanitized[key] = "[Filtered]";
+    } else if (typeof value === "object" && value !== null) {
+      sanitized[key] = sanitizeBody(value);
+    } else {
+      sanitized[key] = value;
+    }
+  }
+  return sanitized;
+}
+
+export {
+  StatlyClient,
+  requestHandler,
+  expressErrorHandler,
+  withStatlyPagesApi,
+  withStatly,
+  captureNextJsError,
+  withStatlyGetServerSideProps,
+  withStatlyGetStaticProps,
+  withStatlyServerAction,
+  statlyFastifyPlugin,
+  statlyPlugin,
+  createRequestCapture,
+  init,
+  captureException,
+  captureMessage,
+  setUser,
+  setTag,
+  setTags,
+  addBreadcrumb,
+  flush,
+  close,
+  getClient,
+  Statly
+};