@aigc-kino/logger-sdk 1.3.0

package/dist/index.cjs

@@ -0,0 +1,841 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  LogType: () => LogType,
+  Logger: () => Logger,
+  VuePlugin: () => VuePlugin,
+  attachAxios: () => attachAxios,
+  captureError: () => captureError,
+  captureMessage: () => captureMessage,
+  clearUser: () => clearUser,
+  destroy: () => destroy,
+  flush: () => flush,
+  getSessionId: () => getSessionId,
+  getTraceId: () => getTraceId,
+  init: () => init,
+  scrubUrl: () => scrubUrl,
+  setTag: () => setTag,
+  setUser: () => setUser,
+  track: () => track
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types/log-types.ts
+var LogType = /* @__PURE__ */ ((LogType2) => {
+  LogType2["JsError"] = "js-error";
+  LogType2["PromiseError"] = "promise-error";
+  LogType2["VueError"] = "vue-error";
+  LogType2["Network"] = "network";
+  LogType2["Resource"] = "resource";
+  LogType2["Performance"] = "performance";
+  LogType2["Behavior"] = "behavior";
+  LogType2["Page"] = "page";
+  LogType2["Business"] = "business";
+  LogType2["Console"] = "console";
+  LogType2["Custom"] = "custom";
+  return LogType2;
+})(LogType || {});
+
+// src/storage.ts
+var DB_NAME = "kino-log-platfrom-logger-sdk";
+var STORE = "pending-logs";
+var MAX_CACHE = 2e3;
+function openDb() {
+  return new Promise((resolve) => {
+    if (typeof indexedDB === "undefined") return resolve(null);
+    const req = indexedDB.open(DB_NAME, 1);
+    req.onupgradeneeded = () => {
+      if (!req.result.objectStoreNames.contains(STORE)) {
+        req.result.createObjectStore(STORE, { autoIncrement: true });
+      }
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => resolve(null);
+  });
+}
+var LogStorage = class {
+  constructor() {
+    this.dbPromise = openDb();
+  }
+  async save(logs) {
+    const db = await this.dbPromise;
+    if (!db || logs.length === 0) return;
+    await new Promise((resolve) => {
+      const tx = db.transaction(STORE, "readwrite");
+      const store = tx.objectStore(STORE);
+      for (const log of logs) store.add(log);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => resolve();
+    });
+    await this.trim();
+  }
+  async drain() {
+    const db = await this.dbPromise;
+    if (!db) return [];
+    return new Promise((resolve) => {
+      const tx = db.transaction(STORE, "readwrite");
+      const store = tx.objectStore(STORE);
+      const req = store.getAll();
+      req.onsuccess = () => {
+        const logs = req.result ?? [];
+        store.clear();
+        resolve(logs);
+      };
+      req.onerror = () => resolve([]);
+    });
+  }
+  async trim() {
+    const db = await this.dbPromise;
+    if (!db) return;
+    await new Promise((resolve) => {
+      const tx = db.transaction(STORE, "readwrite");
+      const store = tx.objectStore(STORE);
+      const countReq = store.count();
+      countReq.onsuccess = () => {
+        let excess = countReq.result - MAX_CACHE;
+        if (excess <= 0) return resolve();
+        const cursorReq = store.openCursor();
+        cursorReq.onsuccess = () => {
+          const cursor = cursorReq.result;
+          if (cursor && excess > 0) {
+            cursor.delete();
+            excess--;
+            cursor.continue();
+          } else {
+            resolve();
+          }
+        };
+        cursorReq.onerror = () => resolve();
+      };
+      countReq.onerror = () => resolve();
+    });
+  }
+};
+
+// src/transport.ts
+var Transport = class {
+  constructor(options) {
+    this.options = options;
+    this.queue = [];
+    this.storage = new LogStorage();
+    this.timer = null;
+    this.uploading = false;
+    this.timer = setInterval(() => void this.flush(), options.uploadInterval);
+    window.addEventListener("online", () => void this.flush());
+    document.addEventListener("visibilitychange", () => {
+      if (document.visibilityState === "hidden") this.flushWithBeacon();
+    });
+    window.addEventListener("pagehide", () => this.flushWithBeacon());
+    void this.recover();
+  }
+  get uploadUrl() {
+    return `${this.options.serverUrl.replace(/\/$/, "")}/api/log/upload?token=${encodeURIComponent(this.options.token)}`;
+  }
+  add(log) {
+    this.queue.push(log);
+    if (this.queue.length >= this.options.batchSize) void this.flush();
+  }
+  async flush() {
+    if (this.uploading || this.queue.length === 0) return;
+    const batch = this.queue.splice(0, this.options.batchSize);
+    this.uploading = true;
+    try {
+      const ok = await this.send(batch);
+      if (!ok) await this.storage.save(batch);
+    } finally {
+      this.uploading = false;
+    }
+    if (this.queue.length >= this.options.batchSize) void this.flush();
+  }
+  flushWithBeacon() {
+    if (this.queue.length === 0) return;
+    const batch = this.queue.splice(0, this.queue.length);
+    const payload = { projectId: this.options.projectId, logs: batch };
+    const body = JSON.stringify(payload);
+    let sent = false;
+    if (navigator.sendBeacon) {
+      sent = navigator.sendBeacon(this.uploadUrl, new Blob([body], { type: "application/json" }));
+    }
+    if (!sent) {
+      void fetch(this.uploadUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body,
+        keepalive: true
+      }).catch(() => void this.storage.save(batch));
+    }
+  }
+  destroy() {
+    if (this.timer) clearInterval(this.timer);
+    this.flushWithBeacon();
+  }
+  async recover() {
+    const cached = await this.storage.drain();
+    if (cached.length > 0) this.queue.unshift(...cached);
+  }
+  async send(logs, attempt = 0) {
+    const payload = { projectId: this.options.projectId, logs };
+    try {
+      const res = await fetch(this.uploadUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+        keepalive: true
+      });
+      if (res.ok) return true;
+      if (res.status >= 400 && res.status < 500) return true;
+    } catch {
+    }
+    if (attempt < this.options.maxRetry) {
+      await new Promise((r) => setTimeout(r, 1e3 * 2 ** attempt));
+      return this.send(logs, attempt + 1);
+    }
+    return false;
+  }
+};
+
+// src/utils.ts
+function uuid() {
+  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);
+  });
+}
+function getBrowser(ua) {
+  if (/Edg\//.test(ua)) return "Edge";
+  if (/Chrome\//.test(ua)) return "Chrome";
+  if (/Firefox\//.test(ua)) return "Firefox";
+  if (/Safari\//.test(ua)) return "Safari";
+  return "Unknown";
+}
+function getDevice(ua) {
+  return /Mobile|Android|iPhone|iPad/.test(ua) ? "Mobile" : "Desktop";
+}
+function getNetworkType() {
+  const nav = navigator;
+  return nav.connection?.effectiveType ?? "unknown";
+}
+function matchAny(value, patterns) {
+  return patterns.some((p) => typeof p === "string" ? value.includes(p) : p.test(value));
+}
+var SENSITIVE_PARAM_RE = /^(authorization|token|password|passwd|pwd|secret|cookie|phone|mobile|idcard|id-card)$/i;
+function maskSensitiveParams(params) {
+  const sensitiveKeys = [];
+  params.forEach((_value, key) => {
+    if (SENSITIVE_PARAM_RE.test(key)) sensitiveKeys.push(key);
+  });
+  for (const key of sensitiveKeys) params.set(key, "***");
+}
+function scrubUrl(url) {
+  try {
+    const u = new URL(url, location.href);
+    maskSensitiveParams(u.searchParams);
+    const qi = u.hash.indexOf("?");
+    if (qi >= 0) {
+      const hashParams = new URLSearchParams(u.hash.slice(qi + 1));
+      maskSensitiveParams(hashParams);
+      u.hash = `${u.hash.slice(0, qi)}?${hashParams.toString()}`;
+    }
+    return u.toString();
+  } catch {
+    return url;
+  }
+}
+
+// src/core/logger.ts
+var SESSION_KEY = "logger-sdk-session-id";
+var Logger = class {
+  constructor(options) {
+    this.tags = {};
+    this.cleanups = [];
+    this.destroyed = false;
+    this.options = {
+      env: "production",
+      version: "0.0.0",
+      enableError: true,
+      enablePerformance: true,
+      enableBehavior: true,
+      enableNetwork: true,
+      enableConsole: false,
+      sampleRate: 1,
+      batchSize: 50,
+      uploadInterval: 5e3,
+      maxRetry: 3,
+      ignoreErrors: [],
+      ignoreUrls: [],
+      remoteConfig: true,
+      debug: false,
+      ...options
+    };
+    this.sessionId = this.resolveSessionId();
+    this.traceId = this.resolveTraceId();
+    this.transport = new Transport(this.options);
+    if (this.options.remoteConfig) void this.pullRemoteConfig();
+  }
+  isUploadUrl(url) {
+    return url.includes("/api/log/upload") || url.includes("/api/users/profile");
+  }
+  shouldIgnoreUrl(url) {
+    return this.isUploadUrl(url) || matchAny(url, this.options.ignoreUrls);
+  }
+  setUser(userId, profile) {
+    this.options.userId = userId;
+    if (profile !== void 0) {
+      void this.uploadUserProfile(userId, profile).catch((error) => {
+        if (this.options.debug) console.warn("[logger-sdk] user profile upload failed", error);
+      });
+    }
+  }
+  /** 退出登录时调用，解除当前用户关联，后续日志不再携带 userId */
+  clearUser() {
+    this.options.userId = void 0;
+  }
+  setTag(key, value) {
+    this.tags[key] = value;
+  }
+  report(raw) {
+    if (this.destroyed) return;
+    if (Math.random() > this.options.sampleRate) return;
+    if (raw.message && matchAny(raw.message, this.options.ignoreErrors)) return;
+    const ua = navigator.userAgent;
+    let log = {
+      projectId: this.options.projectId,
+      env: this.options.env,
+      version: this.options.version,
+      type: raw.type,
+      level: raw.level,
+      message: String(raw.message).slice(0, 5e3),
+      stack: raw.stack?.slice(0, 1e4),
+      url: location.href,
+      userId: this.options.userId,
+      sessionId: this.sessionId,
+      traceId: this.traceId,
+      browser: getBrowser(ua),
+      device: getDevice(ua),
+      network: getNetworkType(),
+      timestamp: Date.now(),
+      extra: { ...this.tags, ...raw.extra },
+      ...this.options.microFrontend,
+      route: this.options.microFrontend ? location.pathname : void 0
+    };
+    if (this.options.beforeSend) {
+      const result = this.options.beforeSend(log);
+      if (result === false) return;
+      log = result;
+    }
+    this.transport.add(log);
+  }
+  track(event, data) {
+    this.report({ type: "business" /* Business */, level: "info", message: event, extra: data });
+  }
+  captureError(error, extra) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    this.report({ type: "js-error" /* JsError */, level: "error", message: err.message, stack: err.stack, extra });
+  }
+  captureMessage(message, level = "info") {
+    this.report({ type: "custom" /* Custom */, level, message });
+  }
+  flush() {
+    return this.transport.flush();
+  }
+  addCleanup(fn) {
+    this.cleanups.push(fn);
+  }
+  destroy() {
+    this.destroyed = true;
+    for (const fn of this.cleanups) fn();
+    this.cleanups = [];
+    this.transport.destroy();
+  }
+  resolveSessionId() {
+    try {
+      let id = sessionStorage.getItem(SESSION_KEY);
+      if (!id) {
+        id = uuid();
+        sessionStorage.setItem(SESSION_KEY, id);
+      }
+      return id;
+    } catch {
+      return uuid();
+    }
+  }
+  resolveTraceId() {
+    const w = window;
+    if (!w.__LOGGER_TRACE_ID__) w.__LOGGER_TRACE_ID__ = uuid();
+    return w.__LOGGER_TRACE_ID__;
+  }
+  async pullRemoteConfig() {
+    try {
+      const base = this.options.serverUrl.replace(/\/$/, "");
+      const res = await fetch(
+        `${base}/api/sdk/config?projectId=${encodeURIComponent(this.options.projectId)}&token=${encodeURIComponent(this.options.token)}`
+      );
+      if (!res.ok) return;
+      const config = await res.json();
+      if (typeof config.sampleRate === "number") this.options.sampleRate = config.sampleRate;
+      if (Array.isArray(config.ignoreErrors)) this.options.ignoreErrors = config.ignoreErrors;
+      if (typeof config.uploadInterval === "number") this.options.uploadInterval = config.uploadInterval;
+      if (typeof config.batchSize === "number") this.options.batchSize = config.batchSize;
+      if (typeof config.enablePerformance === "boolean") this.options.enablePerformance = config.enablePerformance;
+      if (typeof config.enableBehavior === "boolean") this.options.enableBehavior = config.enableBehavior;
+    } catch {
+    }
+  }
+  /** 上报用户资料；与日志队列隔离，避免资料重试或持久化到 IndexedDB。 */
+  async uploadUserProfile(userId, profile) {
+    const base = this.options.serverUrl.replace(/\/$/, "");
+    const res = await fetch(`${base}/api/users/profile?token=${encodeURIComponent(this.options.token)}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ projectId: this.options.projectId, userId, profile }),
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!res.ok) throw new Error(`[logger-sdk] user profile upload failed: HTTP ${res.status}`);
+  }
+};
+
+// src/plugins/error.ts
+function installErrorPlugins(logger) {
+  const onError = (event) => {
+    const target = event.target;
+    if (target && target !== window && !event.message) {
+      const el = target;
+      const src = el.src || el.href;
+      if (src) {
+        logger.report({
+          type: "resource" /* Resource */,
+          level: "error",
+          message: `Resource load failed: ${el.tagName.toLowerCase()}`,
+          extra: { resourceUrl: src }
+        });
+      }
+      return;
+    }
+    logger.report({
+      type: "js-error" /* JsError */,
+      level: "error",
+      message: event.message,
+      stack: event.error?.stack,
+      extra: { filename: event.filename, lineno: event.lineno, colno: event.colno }
+    });
+  };
+  const onRejection = (event) => {
+    const reason = event.reason;
+    logger.report({
+      type: "promise-error" /* PromiseError */,
+      level: "error",
+      message: reason instanceof Error ? reason.message : String(reason),
+      stack: reason instanceof Error ? reason.stack : void 0
+    });
+  };
+  window.addEventListener("error", onError, true);
+  window.addEventListener("unhandledrejection", onRejection);
+  logger.addCleanup(() => {
+    window.removeEventListener("error", onError, true);
+    window.removeEventListener("unhandledrejection", onRejection);
+  });
+}
+
+// src/plugins/network.ts
+var MAX_BODY_LENGTH = 10240;
+function extractRequestBody(body) {
+  if (body == null) return void 0;
+  if (typeof body === "string") return body.length > MAX_BODY_LENGTH ? body.slice(0, MAX_BODY_LENGTH) : body;
+  if (body instanceof URLSearchParams) {
+    const s = body.toString();
+    return s.length > MAX_BODY_LENGTH ? s.slice(0, MAX_BODY_LENGTH) : s;
+  }
+  return void 0;
+}
+function installFetchPlugin(logger) {
+  const originalFetch = window.fetch.bind(window);
+  window.fetch = async (input, init2) => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    if (logger.shouldIgnoreUrl(url)) return originalFetch(input, init2);
+    const method = init2?.method ?? (input instanceof Request ? input.method : "GET");
+    const requestBody = extractRequestBody(init2?.body);
+    const start = performance.now();
+    try {
+      const res = await originalFetch(input, init2);
+      const duration = Math.round(performance.now() - start);
+      logger.report({
+        type: "network" /* Network */,
+        level: res.ok ? "info" : "error",
+        message: `${method} ${url} ${res.status}`,
+        extra: { requestUrl: url, method, status: res.status, duration, success: res.ok, requestBody }
+      });
+      return res;
+    } catch (err) {
+      const duration = Math.round(performance.now() - start);
+      logger.report({
+        type: "network" /* Network */,
+        level: "error",
+        message: `${method} ${url} failed: ${err instanceof Error ? err.message : String(err)}`,
+        extra: { requestUrl: url, method, status: 0, duration, success: false, requestBody }
+      });
+      throw err;
+    }
+  };
+  logger.addCleanup(() => {
+    window.fetch = originalFetch;
+  });
+}
+function installXhrPlugin(logger) {
+  const OriginalXHR = window.XMLHttpRequest;
+  const originalOpen = OriginalXHR.prototype.open;
+  const originalSend = OriginalXHR.prototype.send;
+  OriginalXHR.prototype.open = function(method, url, ...rest) {
+    this.__logger = {
+      method: String(method).toUpperCase(),
+      url: typeof url === "string" ? url : url.href
+    };
+    return originalOpen.call(this, method, url, ...rest);
+  };
+  OriginalXHR.prototype.send = function(body) {
+    const meta = this.__logger;
+    if (!meta || logger.shouldIgnoreUrl(meta.url)) {
+      return originalSend.call(this, body);
+    }
+    meta.requestBody = extractRequestBody(body);
+    const start = performance.now();
+    const onLoadEnd = () => {
+      const duration = Math.round(performance.now() - start);
+      const status = this.status;
+      const success = status >= 200 && status < 300;
+      logger.report({
+        type: "network" /* Network */,
+        level: success ? "info" : "error",
+        message: `${meta.method} ${meta.url} ${status || "failed"}`,
+        extra: { requestUrl: meta.url, method: meta.method, status, duration, success, requestBody: meta.requestBody }
+      });
+    };
+    const onError = () => {
+      const duration = Math.round(performance.now() - start);
+      logger.report({
+        type: "network" /* Network */,
+        level: "error",
+        message: `${meta.method} ${meta.url} failed: network error`,
+        extra: { requestUrl: meta.url, method: meta.method, status: 0, duration, success: false, requestBody: meta.requestBody }
+      });
+    };
+    this.addEventListener("loadend", onLoadEnd);
+    this.addEventListener("error", onError);
+    return originalSend.call(this, body);
+  };
+  logger.addCleanup(() => {
+    OriginalXHR.prototype.open = originalOpen;
+    OriginalXHR.prototype.send = originalSend;
+  });
+}
+function attachAxiosTo(logger, axios) {
+  axios.interceptors.request.use((config) => {
+    config.metadata = { start: performance.now(), requestBody: config.data != null ? extractRequestBody(config.data) : void 0 };
+    return config;
+  });
+  axios.interceptors.response.use(
+    (res) => {
+      const url = res.config.url ?? "";
+      if (!logger.shouldIgnoreUrl(url)) {
+        const duration = Math.round(performance.now() - (res.config.metadata?.start ?? performance.now()));
+        logger.report({
+          type: "network" /* Network */,
+          level: "info",
+          message: `${res.config.method?.toUpperCase()} ${url} ${res.status}`,
+          extra: { requestUrl: url, method: res.config.method, status: res.status, duration, success: true, requestBody: res.config.metadata?.requestBody }
+        });
+      }
+      return res;
+    },
+    (err) => {
+      const url = err.config?.url ?? "";
+      if (!logger.shouldIgnoreUrl(url)) {
+        const duration = Math.round(performance.now() - (err.config?.metadata?.start ?? performance.now()));
+        logger.report({
+          type: "network" /* Network */,
+          level: "error",
+          message: `${err.config?.method?.toUpperCase()} ${url} failed: ${err.message}`,
+          extra: { requestUrl: url, method: err.config?.method, status: err.response?.status ?? 0, duration, success: false, requestBody: err.config?.metadata?.requestBody }
+        });
+      }
+      return Promise.reject(err);
+    }
+  );
+}
+
+// src/plugins/performance.ts
+function installPerformancePlugin(logger) {
+  if (!logger.options.enablePerformance || typeof PerformanceObserver === "undefined") return;
+  const metrics = {};
+  const observers = [];
+  const observe = (type, cb) => {
+    try {
+      const ob = new PerformanceObserver((list) => cb(list.getEntries()));
+      ob.observe({ type, buffered: true });
+      observers.push(ob);
+    } catch {
+    }
+  };
+  observe("largest-contentful-paint", (entries) => {
+    const last = entries[entries.length - 1];
+    if (last) metrics.lcp = Math.round(last.startTime);
+  });
+  observe("paint", (entries) => {
+    for (const e of entries) {
+      if (e.name === "first-contentful-paint") metrics.fcp = Math.round(e.startTime);
+    }
+  });
+  observe("first-input", (entries) => {
+    const first = entries[0];
+    if (first) metrics.fid = Math.round(first.processingStart - first.startTime);
+  });
+  const reportOnce = /* @__PURE__ */ (() => {
+    let reported = false;
+    return () => {
+      if (reported) return;
+      reported = true;
+      const nav = performance.getEntriesByType("navigation")[0];
+      if (nav) metrics.ttfb = Math.round(nav.responseStart - nav.requestStart);
+      logger.report({
+        type: "performance" /* Performance */,
+        level: "info",
+        message: "page-performance",
+        extra: { ...metrics }
+      });
+    };
+  })();
+  const onHidden = () => {
+    if (document.visibilityState === "hidden") reportOnce();
+  };
+  document.addEventListener("visibilitychange", onHidden);
+  const timer = setTimeout(reportOnce, 1e4);
+  logger.addCleanup(() => {
+    observers.forEach((o) => o.disconnect());
+    document.removeEventListener("visibilitychange", onHidden);
+    clearTimeout(timer);
+  });
+}
+
+// src/plugins/behavior.ts
+var MAX_PATH_DEPTH = 6;
+function buildDomPath(el) {
+  const parts = [];
+  let node = el;
+  while (node && node !== document.body && parts.length < MAX_PATH_DEPTH) {
+    const tag = node.tagName.toLowerCase();
+    const id = node.id ? `#${node.id}` : "";
+    const cls = node.className && typeof node.className === "string" ? `.${node.className.split(/\s+/).slice(0, 2).join(".")}` : "";
+    parts.unshift(`${tag}${id}${cls}`);
+    node = node.parentElement;
+  }
+  parts.unshift("body");
+  return parts.join(" > ");
+}
+function installBehaviorPlugin(logger) {
+  if (!logger.options.enableBehavior) return;
+  const onClick = (event) => {
+    const target = event.target;
+    if (!target) return;
+    const text = (target.innerText ?? "").trim().slice(0, 50);
+    const selector = [
+      target.tagName.toLowerCase(),
+      target.id ? `#${target.id}` : "",
+      target.className && typeof target.className === "string" ? `.${target.className.split(/\s+/).slice(0, 2).join(".")}` : ""
+    ].join("");
+    logger.report({
+      type: "behavior" /* Behavior */,
+      level: "info",
+      message: `click ${selector}`,
+      extra: { selector, path: buildDomPath(target), text }
+    });
+  };
+  document.addEventListener("click", onClick, true);
+  logger.addCleanup(() => document.removeEventListener("click", onClick, true));
+}
+function installPagePlugin(logger) {
+  const reportPv = (from) => {
+    logger.report({
+      type: "page" /* Page */,
+      level: "info",
+      message: "pv",
+      extra: { from, referrer: document.referrer }
+    });
+  };
+  reportPv();
+  const originalPushState = history.pushState.bind(history);
+  const originalReplaceState = history.replaceState.bind(history);
+  let lastUrl = location.href;
+  const onRouteChange = () => {
+    if (location.href === lastUrl) return;
+    const from = lastUrl;
+    lastUrl = location.href;
+    reportPv(from);
+  };
+  history.pushState = (...args) => {
+    originalPushState(...args);
+    onRouteChange();
+  };
+  history.replaceState = (...args) => {
+    originalReplaceState(...args);
+    onRouteChange();
+  };
+  window.addEventListener("popstate", onRouteChange);
+  window.addEventListener("hashchange", onRouteChange);
+  logger.addCleanup(() => {
+    history.pushState = originalPushState;
+    history.replaceState = originalReplaceState;
+    window.removeEventListener("popstate", onRouteChange);
+    window.removeEventListener("hashchange", onRouteChange);
+  });
+}
+function installConsolePlugin(logger) {
+  if (!logger.options.enableConsole) return;
+  const levels = ["error", "warn"];
+  const originals = /* @__PURE__ */ new Map();
+  for (const level of levels) {
+    const original = console[level].bind(console);
+    originals.set(level, original);
+    console[level] = (...args) => {
+      original(...args);
+      logger.report({
+        type: "console" /* Console */,
+        level,
+        message: args.map((a) => typeof a === "object" ? safeStringify(a) : String(a)).join(" ").slice(0, 2e3)
+      });
+    };
+  }
+  logger.addCleanup(() => {
+    for (const level of levels) {
+      const original = originals.get(level);
+      if (original) console[level] = original;
+    }
+  });
+}
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+// src/plugins/vue.ts
+function createVuePlugin(logger) {
+  return {
+    install(app) {
+      const previous = app.config.errorHandler;
+      app.config.errorHandler = (err, instance2, info) => {
+        const comp = instance2;
+        const componentName = comp?.$options?.name ?? comp?.$options?.__name ?? comp?.$?.type?.name ?? comp?.$?.type?.__name ?? "anonymous";
+        const error = err instanceof Error ? err : new Error(String(err));
+        logger.report({
+          type: "vue-error" /* VueError */,
+          level: "error",
+          message: error.message,
+          stack: error.stack,
+          extra: { componentName, lifecycleHook: info }
+        });
+        if (previous) previous(err, instance2, info);
+      };
+    }
+  };
+}
+
+// src/index.ts
+var instance = null;
+function init(options) {
+  if (instance) return instance;
+  instance = new Logger(options);
+  if (instance.options.enableError) installErrorPlugins(instance);
+  if (instance.options.enableNetwork) {
+    installFetchPlugin(instance);
+    installXhrPlugin(instance);
+  }
+  if (instance.options.enablePerformance) installPerformancePlugin(instance);
+  if (instance.options.enableBehavior) installBehaviorPlugin(instance);
+  if (instance.options.enableConsole) installConsolePlugin(instance);
+  installPagePlugin(instance);
+  return instance;
+}
+function required() {
+  if (!instance) throw new Error("[logger-sdk] init() must be called first");
+  return instance;
+}
+function setUser(userId, profile) {
+  required().setUser(userId, profile);
+}
+function clearUser() {
+  required().clearUser();
+}
+function setTag(key, value) {
+  required().setTag(key, value);
+}
+function track(event, data) {
+  required().track(event, data);
+}
+function captureError(error, extra) {
+  required().captureError(error, extra);
+}
+function captureMessage(message, level) {
+  required().captureMessage(message, level);
+}
+function getSessionId() {
+  return required().sessionId;
+}
+function getTraceId() {
+  return required().traceId;
+}
+function flush() {
+  return required().flush();
+}
+function destroy() {
+  instance?.destroy();
+  instance = null;
+}
+function attachAxios(axios) {
+  attachAxiosTo(required(), axios);
+}
+var VuePlugin = {
+  install(app) {
+    createVuePlugin(required()).install(app);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LogType,
+  Logger,
+  VuePlugin,
+  attachAxios,
+  captureError,
+  captureMessage,
+  clearUser,
+  destroy,
+  flush,
+  getSessionId,
+  getTraceId,
+  init,
+  scrubUrl,
+  setTag,
+  setUser,
+  track
+});