polyv-rum-sdk 0.1.2

package/dist/index.mjs

@@ -0,0 +1,1599 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/env.ts
+var getRUMEnv = () => {
+  if (typeof window !== "undefined" && window.VUE_APP_ENV) {
+    return window.VUE_APP_ENV;
+  }
+  if (typeof process !== "undefined" && process.env) {
+    return process.env;
+  }
+  return {};
+};
+var RUM_ENV = getRUMEnv();
+
+// src/core/config.ts
+var getEnv = (key, defaultValue = "") => {
+  const env = getRUMEnv();
+  if (env && Object.prototype.hasOwnProperty.call(env, key)) {
+    return env[key] || defaultValue;
+  }
+  return defaultValue;
+};
+var isProduction = getEnv("NODE_ENV") === "production";
+var isDebugEnabled = getEnv("VUE_APP_RUM_DEBUG", "false") === "true";
+var getSessionId = () => {
+  if (typeof sessionStorage === "undefined") {
+    return `session_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+  }
+  let sessionId = sessionStorage.getItem("rum_session_id");
+  if (!sessionId) {
+    sessionId = `session_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    sessionStorage.setItem("rum_session_id", sessionId);
+  }
+  return sessionId;
+};
+var getMetricType = (data) => {
+  switch (data.type) {
+    case "performance":
+      return "duration";
+    case "xhr":
+      return "xhr";
+    case "fetch":
+      return "fetch";
+    case "click":
+      return "click";
+    case "route":
+      return "route";
+    case "error":
+      return "error";
+    default:
+      return "unknown";
+  }
+};
+var extractValue = (data) => {
+  switch (data.type) {
+    case "performance":
+      return data.duration || 0;
+    case "xhr":
+    case "fetch":
+      return data.duration || data.status || 0;
+    case "click":
+    case "error":
+      return 1;
+    default:
+      return 1;
+  }
+};
+var slsConfig = {
+  host: getEnv("VUE_APP_SLS_HOST", "cn-shenzhen.log.aliyuncs.com"),
+  project: getEnv("VUE_APP_SLS_PROJECT", "live-admin-rum"),
+  logstore: getEnv("VUE_APP_SLS_LOGSTORE", "rum-traces-dev"),
+  time: 10,
+  count: 10,
+  topic: "rum-monitor",
+  source: "web",
+  enabled: getEnv("VUE_APP_SLS_ENABLED", "true") !== "false",
+  debug: isDebugEnabled,
+  appName: "live-admin-v3",
+  appVersion: getEnv("PACKAGE_VERSION", "1.0.0"),
+  retryCount: 3,
+  retryInterval: 2e3
+};
+if (typeof console !== "undefined" && isDebugEnabled) {
+  console.log("\u{1F527} SLS Config:", {
+    enabled: slsConfig.enabled,
+    debug: slsConfig.debug,
+    host: slsConfig.host,
+    project: slsConfig.project,
+    logstore: slsConfig.logstore,
+    envCheck: {
+      VUE_APP_SLS_ENABLED: getEnv("VUE_APP_SLS_ENABLED"),
+      VUE_APP_RUM_DEBUG: getEnv("VUE_APP_RUM_DEBUG")
+    }
+  });
+}
+var mitoConfig = {
+  dsn: getEnv("VUE_APP_RUM_DSN", "") || null,
+  appName: "live-admin-v3",
+  appVersion: getEnv("PACKAGE_VERSION", "1.0.0"),
+  environment: getEnv("NODE_ENV", "development"),
+  debug: isDebugEnabled,
+  maxBreadcrumbs: 20,
+  sampleRate: {
+    error: 1,
+    click: isProduction ? 0.1 : 1,
+    route: 1,
+    custom: 1,
+    xhr: isProduction ? 0.5 : 1
+  },
+  vue: {
+    Vue: void 0,
+    lifecycle: true,
+    performance: true
+  },
+  network: {
+    xhr: true,
+    fetch: true,
+    ignoreUrls: [/sls\.aliyuncs\.com/, /file:\/\//],
+    responseSizeLimit: 500
+  },
+  error: {
+    javascript: true,
+    promise: true,
+    resource: true,
+    ignoreErrors: [/third-party/, /Network timeout/]
+  },
+  user: {
+    click: true,
+    route: true,
+    performance: true,
+    sensitiveSelectors: [
+      'input[type="password"]',
+      'input[name*="password"]',
+      'input[name*="token"]',
+      'textarea[name*="secret"]'
+    ]
+  },
+  breadcrumb: {
+    console: isDebugEnabled,
+    dom: true,
+    navigation: true,
+    customTypes: ["vue", "vuex", "axios"]
+  },
+  transport: {
+    type: "xhr",
+    batch: {
+      size: 10,
+      interval: 5e3,
+      immediateOnError: true
+    },
+    retry: {
+      times: 3,
+      interval: 2e3
+    }
+  }
+};
+var getUserInfo = (store) => {
+  try {
+    if (!store || !store.state) {
+      return {};
+    }
+    const userModule = store.state.user || {};
+    const userInfo = userModule.userInfo || userModule || {};
+    const getters = store.getters || {};
+    return {
+      userId: userInfo.userId || userInfo.id || getters["user/userId"],
+      userName: userInfo.userName || userInfo.contact || userInfo.name,
+      accountId: userInfo.accountId,
+      email: userInfo.email,
+      roles: userInfo.roles || [],
+      permissions: getters["user/permissions"] || userInfo.permissions || []
+    };
+  } catch (error) {
+    console.warn("Failed to get user info from store:", error);
+    return {};
+  }
+};
+var transformDataForSLS = (data, context = {}) => {
+  var _a;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const userInfo = getUserInfo(context.store);
+  const dimensions = {
+    pageTitle: typeof document !== "undefined" ? document.title : "",
+    path: typeof window !== "undefined" ? window.location.pathname : "",
+    search: typeof window !== "undefined" ? window.location.search : "",
+    hash: typeof window !== "undefined" ? window.location.hash : "",
+    ...userInfo && {
+      userId: userInfo.userId,
+      userName: userInfo.userName,
+      accountId: userInfo.accountId,
+      userEmail: userInfo.email,
+      userRoles: (userInfo.roles || []).join(","),
+      userPermissions: (userInfo.permissions || []).join(",")
+    },
+    ...data.customData
+  };
+  if (data.type === "click") {
+    const target = data.target || {};
+    const page = data.page || {};
+    dimensions.clickBizId = data.bizId;
+    dimensions.clickTargetTag = target.tagName;
+    dimensions.clickTargetId = target.id;
+    dimensions.clickTargetClass = target.className;
+    dimensions.clickTargetSelector = target.selector;
+    dimensions.clickTargetText = target.textContent;
+    dimensions.clickPageUrl = page.url;
+    dimensions.clickPagePath = page.path;
+    dimensions.clickPageTitle = page.title;
+    dimensions.clickX = data.x;
+    dimensions.clickY = data.y;
+  }
+  return {
+    __time__: Math.floor(Date.now() / 1e3),
+    __source__: "live-admin-v3",
+    timestamp,
+    environment: mitoConfig.environment,
+    sessionId: getSessionId(),
+    user: userInfo,
+    dataType: data.type || "unknown",
+    metricType: getMetricType(data),
+    value: extractValue(data),
+    event: {
+      type: data.type,
+      url: typeof window !== "undefined" && window.location ? window.location.href : "",
+      userAgent: typeof navigator !== "undefined" ? navigator.userAgent : "unknown",
+      referrer: typeof document !== "undefined" ? document.referrer : void 0
+    },
+    techStack: {
+      vue: ((_a = context.Vue) == null ? void 0 : _a.version) || "unknown",
+      platform: typeof navigator !== "undefined" ? navigator.platform : "unknown",
+      language: typeof navigator !== "undefined" ? navigator.language : "unknown"
+    },
+    rawData: isDebugEnabled ? data : void 0,
+    dimensions
+  };
+};
+var shouldReport = (data) => {
+  const dataType = data.type;
+  const sampleRate = mitoConfig.sampleRate[dataType] || 0;
+  if (sampleRate === 0)
+    return false;
+  if (sampleRate === 1)
+    return true;
+  return Math.random() < sampleRate;
+};
+
+// src/core/MitoSLSAdapter.ts
+import { init } from "@mitojs/browser";
+
+// src/transport/SLSWebTrackingAdapter.ts
+import SlsTracker from "@aliyun-sls/web-track-browser";
+var getEnv2 = (key, defaultValue = "") => {
+  const env = getRUMEnv();
+  if (env && Object.prototype.hasOwnProperty.call(env, key)) {
+    return env[key] || defaultValue;
+  }
+  return defaultValue;
+};
+var SLSWebTrackingAdapter = class {
+  constructor(config = {}) {
+    this.slsTracker = null;
+    this.isInitialized = false;
+    this.isDestroyed = false;
+    this.pendingLogs = [];
+    this.retryQueue = [];
+    var _a, _b, _c, _d, _e, _f, _g;
+    this.config = {
+      host: config.host || getEnv2("VUE_APP_SLS_HOST", "cn-shenzhen.log.aliyuncs.com"),
+      project: config.project || getEnv2("VUE_APP_SLS_PROJECT", "live-admin-rum"),
+      logstore: config.logstore || "rum-traces-dev",
+      time: (_a = config.time) != null ? _a : 10,
+      count: (_b = config.count) != null ? _b : 10,
+      topic: config.topic || "rum-monitor",
+      source: config.source || "web",
+      environment: config.environment || getEnv2("NODE_ENV", "development"),
+      debug: (_c = config.debug) != null ? _c : getEnv2("VUE_APP_RUM_DEBUG", "false") === "true",
+      enabled: (_d = config.enabled) != null ? _d : true,
+      userId: (_e = config.userId) != null ? _e : null,
+      sessionId: config.sessionId || this.generateSessionId(),
+      appName: config.appName || "live-admin-v3",
+      appVersion: config.appVersion || getEnv2("PACKAGE_VERSION", "1.0.0"),
+      retryCount: (_f = config.retryCount) != null ? _f : 3,
+      retryInterval: (_g = config.retryInterval) != null ? _g : 2e3
+    };
+    this.handleBeforeSend = this.handleBeforeSend.bind(this);
+    this.handleError = this.handleError.bind(this);
+  }
+  async init() {
+    if (this.isInitialized) {
+      console.warn("SLSWebTrackingAdapter already initialized");
+      return;
+    }
+    if (this.isDestroyed) {
+      throw new Error(
+        "SLSWebTrackingAdapter has been destroyed, cannot reinitialize"
+      );
+    }
+    if (!this.config.enabled) {
+      if (this.config.debug) {
+        console.log("SLSWebTrackingAdapter is disabled");
+      }
+      return;
+    }
+    if (this.config.debug) {
+      console.log("\u{1F680} Initializing SLSWebTrackingAdapter...", {
+        config: this.config,
+        SlsTracker: typeof SlsTracker
+      });
+    }
+    try {
+      this.slsTracker = new SlsTracker({
+        host: this.config.host,
+        project: this.config.project,
+        logstore: this.config.logstore,
+        time: this.config.time,
+        count: this.config.count,
+        topic: this.config.topic,
+        source: this.config.source,
+        autoPopulateFields: false,
+        beforeSend: this.handleBeforeSend
+      });
+      this.isInitialized = true;
+      if (this.config.debug) {
+        console.log("\u2705 SLSWebTrackingAdapter initialized successfully", {
+          project: this.config.project,
+          logstore: this.config.logstore,
+          host: this.config.host,
+          trackerInstance: !!this.slsTracker
+        });
+      }
+      await this.sendLog({
+        type: "system",
+        category: "init",
+        message: "SLS WebTracking adapter initialized successfully",
+        level: "info",
+        timestamp: Date.now()
+      });
+    } catch (error) {
+      console.error("\u274C Failed to initialize SLSWebTrackingAdapter:", error);
+      this.handleError(error);
+      throw error;
+    }
+  }
+  async sendLog(data) {
+    if (this.config.debug) {
+      console.log("\u{1F4E4} Sending log to SLS...", {
+        originalData: data,
+        isReady: this.checkReady(),
+        hasTracker: !!this.slsTracker,
+        isInitialized: this.isInitialized
+      });
+    }
+    if (!this.checkReady()) {
+      if (this.config.debug) {
+        console.log("\u274C SLS adapter not ready, skipping log send");
+      }
+      return;
+    }
+    try {
+      const logData = await this.transformLogData(data);
+      if (this.config.debug) {
+        console.log("\u{1F527} Transformed SLS Log Data:", logData);
+      }
+      await this.slsTracker.send(logData);
+      if (this.config.debug) {
+        console.log("\u2705 Log sent to SLS successfully");
+      }
+    } catch (error) {
+      console.error("\u274C Failed to send log to SLS:", error);
+      await this.handleSendError(data, error);
+    }
+  }
+  async sendBatchLogs(logs) {
+    if (!this.checkReady()) {
+      return;
+    }
+    if (!Array.isArray(logs) || logs.length === 0) {
+      return;
+    }
+    try {
+      const transformedLogs = await Promise.all(
+        logs.map((log) => this.transformLogData(log))
+      );
+      for (const logData of transformedLogs) {
+        await this.slsTracker.send(logData);
+      }
+      if (this.config.debug) {
+        console.log(
+          `Batch sent ${transformedLogs.length} logs to SLS successfully`
+        );
+      }
+    } catch (error) {
+      console.error("Failed to send batch logs to SLS:", error);
+      for (const log of logs) {
+        await this.handleSendError(log, error);
+      }
+    }
+  }
+  async transformLogData(data) {
+    const timestamp = Math.floor(Date.now() / 1e3);
+    const logData = {
+      __time__: timestamp,
+      __source__: this.config.source,
+      // 基础信息
+      event_type: data.eventType || data.type || "unknown",
+      category: data.category || "general",
+      level: data.level || "info",
+      client_timestamp: Date.now(),
+      // 应用信息
+      app_name: this.config.appName,
+      // app_version: this.config.appVersion,
+      environment: this.config.environment,
+      // 会话信息
+      session_id: this.config.sessionId,
+      // 页面信息
+      page_url: typeof window !== "undefined" && window.location ? window.location.href : "",
+      page_title: typeof document !== "undefined" ? document.title : void 0,
+      page_path: typeof window !== "undefined" && window.location ? window.location.pathname : "",
+      // 用户代理信息
+      user_agent: typeof navigator !== "undefined" ? navigator.userAgent : void 0,
+      language: typeof navigator !== "undefined" ? navigator.language : void 0
+    };
+    if (this.config.userId) {
+      logData.user_id = this.config.userId;
+    }
+    if (data.userId) {
+      logData.user_id = data.userId;
+    }
+    if (data.userName) {
+      logData.user_name = data.userName;
+    }
+    if (data.userEmail) {
+      logData.user_email = data.userEmail;
+    }
+    if (logData.event_type === "error") {
+      this.addErrorFields(logData, data);
+    } else if (logData.event_type === "xhr" || logData.event_type === "fetch") {
+      this.addApiFields(logData, data);
+    } else if (logData.event_type === "click") {
+      this.addClickFields(logData, data);
+    }
+    try {
+      let hash = "";
+      if (data && typeof data.hash === "string") {
+        hash = data.hash;
+      } else if (data && data.dimensions && typeof data.dimensions.hash === "string") {
+        hash = data.dimensions.hash;
+      } else if (typeof window !== "undefined" && typeof window.location !== "undefined") {
+        hash = window.location.hash || "";
+      }
+      logData.detail_json = JSON.stringify({ hash });
+    } catch (error) {
+      console.warn("Failed to serialize detail data:", error);
+      logData.detail_json = JSON.stringify({
+        error: "Failed to serialize data"
+      });
+    }
+    return logData;
+  }
+  addErrorFields(logData, data) {
+    if (data.message) {
+      logData.error_message = String(data.message);
+    }
+    if (data.stack) {
+      logData.error_stack = String(data.stack);
+    }
+    if (data.filename) {
+      logData.error_filename = data.filename;
+    }
+    if (data.lineno) {
+      logData.error_lineno = String(data.lineno);
+    }
+    if (data.colno) {
+      logData.error_colno = String(data.colno);
+    }
+    if (data.name) {
+      logData.error_name = data.name;
+    }
+  }
+  addApiFields(logData, data) {
+    if (data.url) {
+      logData.api_url = data.url;
+    }
+    if (data.method) {
+      logData.api_method = data.method;
+    }
+    if (data.status !== void 0) {
+      logData.api_status = Number(data.status);
+    }
+    if (data.duration !== void 0) {
+      logData.api_duration = Number(data.duration);
+    }
+    if (data.responseSize !== void 0) {
+      logData.api_response_size = Number(data.responseSize);
+    }
+  }
+  addClickFields(logData, data) {
+    if (data.clickBizId || data.bizId) {
+      logData.click_biz_id = data.clickBizId || data.bizId;
+    }
+    if (data.target) {
+      logData.click_target = data.target;
+    }
+    if (data.selector) {
+      logData.click_selector = data.selector;
+    }
+    if (data.text) {
+      logData.click_text = data.text;
+    }
+    if (data.x !== void 0) {
+      logData.click_x = Number(data.x);
+    }
+    if (data.y !== void 0) {
+      logData.click_y = Number(data.y);
+    }
+  }
+  filterSensitiveData(data) {
+    const sensitivePatterns = [
+      /password/i,
+      /token/i,
+      /secret/i,
+      /key/i,
+      /auth/i,
+      /credential/i
+    ];
+    const filtered = { ...data };
+    Object.keys(filtered).forEach((key) => {
+      const value = filtered[key];
+      if (typeof value === "string") {
+        if (sensitivePatterns.some((pattern) => pattern.test(key))) {
+          filtered[key] = "[FILTERED]";
+        }
+        if (filtered[key].length > 500) {
+          filtered[key] = `${filtered[key].substring(0, 500)}...`;
+        }
+      }
+    });
+    return filtered;
+  }
+  async handleSendError(data, error) {
+    const retryItem = {
+      data,
+      error,
+      timestamp: Date.now(),
+      retryCount: 0
+    };
+    this.retryQueue.push(retryItem);
+    if (this.shouldRetry(error)) {
+      setTimeout(() => {
+        this.retryFailedLogs();
+      }, this.config.retryInterval);
+    }
+  }
+  async retryFailedLogs() {
+    if (this.retryQueue.length === 0) {
+      return;
+    }
+    const itemsToRetry = this.retryQueue.filter(
+      (item) => item.retryCount < this.config.retryCount
+    );
+    this.retryQueue = this.retryQueue.filter(
+      (item) => item.retryCount >= this.config.retryCount
+    );
+    for (const item of itemsToRetry) {
+      try {
+        item.retryCount++;
+        await this.sendLog(item.data);
+        const index = this.retryQueue.indexOf(item);
+        if (index > -1) {
+          this.retryQueue.splice(index, 1);
+        }
+      } catch (error) {
+        console.warn(
+          `Retry failed for log (attempt ${item.retryCount}):`,
+          error
+        );
+        if (item.retryCount < this.config.retryCount) {
+          setTimeout(() => {
+            this.retryFailedLogs();
+          }, this.config.retryInterval * item.retryCount);
+        } else {
+          console.error("Max retry attempts reached, dropping log:", item.data);
+        }
+      }
+    }
+  }
+  shouldRetry(error) {
+    const retryableErrors = [
+      "Network timeout",
+      "Connection failed",
+      "Service unavailable",
+      "Rate limit exceeded"
+    ];
+    return retryableErrors.some(
+      (pattern) => error.message && error.message.includes(pattern)
+    );
+  }
+  handleError(error) {
+    console.error("SLSWebTrackingAdapter Error:", error);
+  }
+  checkReady() {
+    if (!this.config.enabled) {
+      return false;
+    }
+    if (!this.isInitialized) {
+      console.warn("SLSWebTrackingAdapter not initialized");
+      return false;
+    }
+    if (!this.slsTracker) {
+      console.warn("SLS Tracker not available");
+      return false;
+    }
+    return true;
+  }
+  generateSessionId() {
+    if (typeof sessionStorage !== "undefined") {
+      let sessionId = sessionStorage.getItem("sls_session_id");
+      if (!sessionId) {
+        sessionId = `session_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+        sessionStorage.setItem("sls_session_id", sessionId);
+      }
+      return sessionId;
+    }
+    return `session_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+  }
+  handleBeforeSend(logData) {
+    try {
+      const dataSize = JSON.stringify(logData).length;
+      const maxSize = 1024 * 1024;
+      if (dataSize > maxSize) {
+        console.warn("Log data too large, skipping:", dataSize);
+        return false;
+      }
+      const filteredData = this.filterSensitiveData(logData);
+      if (this.config.debug) {
+        console.log("Log before send:", filteredData);
+      }
+      return filteredData;
+    } catch (error) {
+      console.error("Error in beforeSend handler:", error);
+      return false;
+    }
+  }
+  setUserId(userId) {
+    this.config.userId = userId;
+  }
+  updateConfig(newConfig) {
+    this.config = { ...this.config, ...newConfig };
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  getStats() {
+    return {
+      isInitialized: this.isInitialized,
+      isDestroyed: this.isDestroyed,
+      pendingLogsCount: this.pendingLogs.length,
+      retryQueueCount: this.retryQueue.length,
+      config: {
+        project: this.config.project,
+        logstore: this.config.logstore,
+        enabled: this.config.enabled
+      }
+    };
+  }
+  destroy() {
+    if (this.isDestroyed) {
+      return;
+    }
+    try {
+      if (this.retryQueue.length > 0 && this.config.debug) {
+        console.warn(
+          `Destroying adapter with ${this.retryQueue.length} items in retry queue`
+        );
+      }
+      if (this.slsTracker && this.slsTracker.destroy) {
+        this.slsTracker.destroy();
+      }
+      this.isDestroyed = true;
+      this.isInitialized = false;
+      this.slsTracker = null;
+      this.pendingLogs = [];
+      this.retryQueue = [];
+      if (this.config.debug) {
+        console.log("SLSWebTrackingAdapter destroyed");
+      }
+    } catch (error) {
+      console.error("Error destroying SLSWebTrackingAdapter:", error);
+    }
+  }
+};
+
+// src/core/MitoSLSAdapter.ts
+var MitoSLSAdapter = class {
+  constructor(options = {}) {
+    this.mitoInstance = null;
+    this.slsAdapter = null;
+    this.store = null;
+    this.router = null;
+    this.isInitialized = false;
+    this.options = {
+      ...mitoConfig,
+      ...options
+    };
+    this.handleDataReport = this.handleDataReport.bind(this);
+    this.handleRouteChange = this.handleRouteChange.bind(this);
+    this.handleError = this.handleError.bind(this);
+    this.addBreadcrumb = this.addBreadcrumb.bind(this);
+  }
+  addBreadcrumb(payload) {
+    if (!this.mitoInstance || !this.mitoInstance.breadcrumb) {
+      return;
+    }
+    const breadcrumb = this.mitoInstance.breadcrumb;
+    if (typeof breadcrumb.add === "function") {
+      breadcrumb.add(payload);
+      return;
+    }
+    if (typeof breadcrumb.push === "function") {
+      breadcrumb.push(payload);
+    }
+  }
+  async init(context = {}) {
+    var _a;
+    if (this.isInitialized) {
+      console.warn("MitoSLSAdapter already initialized");
+      return;
+    }
+    this.store = context.store;
+    this.router = context.router;
+    if (!this.options.dsn) {
+      console.warn(
+        "MitoSLSAdapter: DSN not configured, RUM system will run in simulation mode"
+      );
+    }
+    try {
+      const slsConfigOverride = this.options.slsConfigOverride || {};
+      this.slsAdapter = new SLSWebTrackingAdapter({
+        ...slsConfig,
+        ...slsConfigOverride
+      });
+      await this.slsAdapter.init();
+      this.mitoInstance = init({
+        dsn: this.options.dsn || void 0,
+        debug: this.options.debug,
+        maxBreadcrumbs: this.options.maxBreadcrumbs,
+        Vue: context.Vue || ((_a = this.options.vue) == null ? void 0 : _a.Vue),
+        framework: {
+          vue: true
+        },
+        beforeDataReport: this.handleDataReport,
+        silent: !this.options.debug,
+        enableUrlHash: true,
+        enableUserAgent: true,
+        enableHistory: true,
+        performance: {
+          enable: this.options.user.performance,
+          sampleRate: this.options.sampleRate.performance || 1
+        },
+        user: {
+          enableClickTrack: this.options.user.click,
+          clickTrackSampleRate: this.options.sampleRate.click,
+          ignoreSelector: this.options.user.sensitiveSelectors.join(", ")
+        },
+        api: {
+          enableApiMonitor: this.options.network.xhr,
+          apiMonitorSampleRate: this.options.sampleRate.xhr,
+          ignoreUrls: this.options.network.ignoreUrls,
+          requestSizeLimit: this.options.network.responseSizeLimit * 1024
+        }
+      });
+      this.setupVueIntegration();
+      this.setupRouterIntegration();
+      this.setupErrorHandling();
+      this.isInitialized = true;
+      if (this.options.debug) {
+        console.log("MitoSLSAdapter initialized successfully");
+      }
+    } catch (error) {
+      console.error("Failed to initialize MitoSLSAdapter:", error);
+      this.handleError(error);
+    }
+  }
+  setupVueIntegration() {
+    if (!this.store) {
+      console.warn("Vuex store not provided, some features may be limited");
+      return;
+    }
+    this.store.subscribe((mutation) => {
+      try {
+        if (this.shouldTrackMutation(mutation)) {
+          this.addBreadcrumb({
+            type: "vuex",
+            message: `Vuex: ${mutation.type}`,
+            category: "vuex",
+            data: {
+              mutation: mutation.type,
+              payload: mutation.payload
+            }
+          });
+        }
+      } catch (error) {
+        console.warn("Failed to track Vuex mutation:", error);
+      }
+    });
+    if (this.options.debug) {
+      console.log("Vue integration configured");
+    }
+  }
+  setupRouterIntegration() {
+    if (!this.router) {
+      console.warn("Vue router not provided, route tracking disabled");
+      return;
+    }
+    this.router.afterEach((to, from) => {
+      try {
+        this.handleRouteChange(to, from);
+      } catch (error) {
+        console.warn("Failed to handle route change:", error);
+      }
+    });
+    if (this.options.debug) {
+      console.log("Router integration configured");
+    }
+  }
+  setupErrorHandling() {
+    if (this.options.debug) {
+      console.log("Error handling configured");
+    }
+  }
+  handleDataReport(data) {
+    try {
+      if (this.options.debug) {
+        console.log("\u{1F50D} MitoJS Data Report:", {
+          type: data.type,
+          timestamp: data.t || Date.now(),
+          data
+        });
+      }
+      if (!shouldReport(data)) {
+        if (this.options.debug) {
+          console.log("\u23ED\uFE0F Data filtered by sampling rate:", data.type);
+        }
+        return false;
+      }
+      const slsData = transformDataForSLS(data, {
+        store: this.store,
+        router: this.router
+      });
+      this.sendToSLS(slsData);
+      return false;
+    } catch (error) {
+      console.error("Failed to handle data report:", error);
+      return false;
+    }
+  }
+  handleRouteChange(to, from) {
+    try {
+      const routeData = {
+        type: "route",
+        from: {
+          path: from.fullPath,
+          name: from.name,
+          params: from.params,
+          query: from.query
+        },
+        to: {
+          path: to.fullPath,
+          name: to.name,
+          params: to.params,
+          query: to.query
+        },
+        timestamp: Date.now()
+      };
+      this.addBreadcrumb({
+        type: "route",
+        message: `Route: ${from.fullPath} -> ${to.fullPath}`,
+        category: "navigation",
+        data: routeData
+      });
+      if (shouldReport(routeData)) {
+        const slsData = transformDataForSLS(routeData, {
+          store: this.store,
+          router: this.router
+        });
+        this.sendToSLS(slsData);
+      }
+    } catch (error) {
+      console.error("Failed to handle route change:", error);
+    }
+  }
+  handleError(error) {
+    try {
+      const errorData = {
+        type: "error",
+        message: (error == null ? void 0 : error.message) || "Unknown error",
+        stack: error == null ? void 0 : error.stack,
+        name: error == null ? void 0 : error.name,
+        timestamp: Date.now()
+      };
+      this.addBreadcrumb({
+        type: "error",
+        message: errorData.message,
+        category: "error",
+        data: errorData
+      });
+      if (shouldReport(errorData)) {
+        const slsData = transformDataForSLS(errorData, {
+          store: this.store,
+          router: this.router
+        });
+        this.sendToSLS(slsData);
+      }
+    } catch (e) {
+      console.error("Failed to handle error:", e);
+    }
+  }
+  async sendToSLS(data) {
+    try {
+      if (!this.slsAdapter) {
+        if (this.options.debug) {
+          console.log("\u{1F4DD} RUM Data [SIMULATION MODE]:", data);
+        }
+        return;
+      }
+      const slsLogData = this.transformDataForSLSLog(data);
+      if (this.options.debug) {
+        console.log("\u{1F527} Transformed SLS Log Data:", slsLogData);
+      }
+      await this.slsAdapter.sendLog(slsLogData);
+      if (this.options.debug) {
+        console.log("\u2705 RUM Data sent to SLS successfully");
+      }
+    } catch (error) {
+      console.error("\u274C Failed to send data to SLS:", error);
+      if (this.options.debug) {
+        console.log("\u{1F504} RUM Data [FALLBACK MODE]:", data);
+      }
+    }
+  }
+  transformDataForSLSLog(data) {
+    var _a;
+    return {
+      eventType: data.dataType || ((_a = data.event) == null ? void 0 : _a.type) || "unknown",
+      category: this.getEventCategory(data.dataType),
+      level: this.getEventLevel(data.dataType),
+      ...data.event,
+      ...data.dimensions,
+      ...data.rawData
+    };
+  }
+  getEventCategory(dataType) {
+    switch (dataType) {
+      case "error":
+        return "error";
+      case "performance":
+        return "performance";
+      case "click":
+      case "route":
+        return "user";
+      case "xhr":
+        return "general";
+      default:
+        return "general";
+    }
+  }
+  getEventLevel(dataType) {
+    switch (dataType) {
+      case "error":
+        return "error";
+      case "xhr":
+        return "warn";
+      default:
+        return "info";
+    }
+  }
+  getUserInfoFromStore() {
+    var _a, _b;
+    try {
+      const user = ((_b = (_a = this.store) == null ? void 0 : _a.state) == null ? void 0 : _b.user) || {};
+      return {
+        userId: user.userId || user.id,
+        userName: user.userName || user.name,
+        accountId: user.accountId
+      };
+    } catch (error) {
+      console.warn("Failed to get user info from store:", error);
+      return {};
+    }
+  }
+  shouldTrackMutation(mutation) {
+    const ignoredMutations = ["SET_LOADING", "SET_CURRENT_PAGE", "UPDATE_MOUSE_POSITION"];
+    return !ignoredMutations.includes(mutation.type);
+  }
+  trackEvent(eventData) {
+    try {
+      const customData = {
+        type: "custom",
+        timestamp: Date.now(),
+        ...eventData
+      };
+      this.addBreadcrumb({
+        type: "custom",
+        message: `Custom Event: ${eventData.name || "unknown"}`,
+        category: "custom",
+        data: customData
+      });
+      if (shouldReport(customData)) {
+        const slsData = transformDataForSLS(customData, {
+          store: this.store,
+          router: this.router
+        });
+        this.sendToSLS(slsData);
+      }
+    } catch (error) {
+      console.error("Failed to track custom event:", error);
+    }
+  }
+  setUser(userInfo) {
+    try {
+      if (this.mitoInstance && this.mitoInstance.setUser) {
+        this.mitoInstance.setUser({
+          id: userInfo.userId,
+          username: userInfo.userName,
+          email: userInfo.email
+        });
+      }
+      if (this.slsAdapter && userInfo.userId) {
+        this.slsAdapter.setUserId(userInfo.userId);
+      }
+    } catch (error) {
+      console.error("Failed to set user info:", error);
+    }
+  }
+  getBreadcrumbs() {
+    var _a, _b;
+    try {
+      return ((_b = (_a = this.mitoInstance) == null ? void 0 : _a.getBreadcrumbs) == null ? void 0 : _b.call(_a)) || [];
+    } catch (error) {
+      console.error("Failed to get breadcrumbs:", error);
+      return [];
+    }
+  }
+  destroy() {
+    try {
+      if (typeof window !== "undefined") {
+        window.removeEventListener("error", this.handleError);
+        window.removeEventListener(
+          "unhandledrejection",
+          this.handleError
+        );
+      }
+      if (this.mitoInstance && this.mitoInstance.destroy) {
+        this.mitoInstance.destroy();
+      }
+      if (this.slsAdapter) {
+        this.slsAdapter.destroy();
+      }
+      this.isInitialized = false;
+      if (this.options.debug) {
+        console.log("MitoSLSAdapter destroyed");
+      }
+    } catch (error) {
+      console.error("Failed to destroy MitoSLSAdapter:", error);
+    }
+  }
+};
+var instance = null;
+var getMitoAdapter = (options = {}) => {
+  if (!instance) {
+    instance = new MitoSLSAdapter(options);
+  }
+  return instance;
+};
+var initRUMCore = async (context, options = {}) => {
+  const adapter = getMitoAdapter(options);
+  await adapter.init(context);
+  return adapter;
+};
+var getRUMCoreInstance = () => instance;
+
+// src/vue2/plugin.vue2.ts
+var plugin_vue2_exports = {};
+__export(plugin_vue2_exports, {
+  RUMPluginVue2: () => RUMPluginVue2,
+  destroyRUM: () => destroyRUM,
+  disableRUM: () => disableRUM,
+  enableRUM: () => enableRUM,
+  getBreadcrumbs: () => getBreadcrumbs,
+  getRUMConfig: () => getRUMConfig,
+  getRUMManager: () => getRUMManager,
+  initRUMSystem: () => initRUMSystem,
+  trackAction: () => trackAction,
+  trackEvent: () => trackEvent,
+  trackMetric: () => trackMetric,
+  trackPerformance: () => trackPerformance
+});
+
+// src/vue2/RUMManager.vue2.ts
+var RUMManagerVue2 = class {
+  constructor() {
+    this.adapter = null;
+    this.isInitialized = false;
+    this.isEnabled = true;
+    this.context = {};
+  }
+  async init(context, options = {}) {
+    try {
+      if (!this.shouldEnableRUM()) {
+        if (mitoConfig.debug) {
+          console.log("RUM system is disabled");
+        }
+        return;
+      }
+      if (this.isInitialized) {
+        if (mitoConfig.debug) {
+          console.log("RUM system already initialized");
+        }
+        return;
+      }
+      this.context = {
+        store: context.store,
+        router: context.router,
+        Vue: context.Vue,
+        ...context
+      };
+      const mergedOptions = {
+        ...mitoConfig,
+        ...options,
+        vue: {
+          ...mitoConfig.vue,
+          ...options.vue
+        }
+      };
+      this.adapter = await initRUMCore(
+        {
+          store: this.context.store,
+          router: this.context.router,
+          Vue: this.context.Vue
+        },
+        mergedOptions
+      );
+      this.setUserInfo();
+      this.setupUserStateListener();
+      this.setupUserInteractionTracking();
+      this.isInitialized = true;
+      if (mitoConfig.debug) {
+        console.log("RUM system initialized successfully");
+      }
+    } catch (error) {
+      console.error("Failed to initialize RUM system:", error);
+    }
+  }
+  shouldEnableRUM() {
+    if (!this.isEnabled) {
+      return false;
+    }
+    const env = getRUMEnv();
+    const rumEnabled = env.VUE_APP_RUM_ENABLED;
+    if (rumEnabled !== void 0) {
+      return rumEnabled === "true";
+    }
+    const mode = env.MODE;
+    const isProdEnv = mode === "prod" || mode === "production";
+    return !isProdEnv;
+  }
+  setUserInfo() {
+    if (!this.context.store) {
+      return;
+    }
+    try {
+      const userModule = this.context.store.state.user || {};
+      const user = userModule.userInfo || userModule || {};
+      if (this.adapter && user.userId) {
+        this.adapter.setUser({
+          userId: user.userId,
+          userName: user.userName,
+          accountId: user.accountId,
+          roles: user.roles,
+          email: user.email
+        });
+      }
+    } catch (error) {
+      console.warn("Failed to set user info:", error);
+    }
+  }
+  setupUserStateListener() {
+    if (!this.context.store) {
+      return;
+    }
+    this.context.store.subscribe((mutation) => {
+      if (mutation.type.includes("user")) {
+        this.setUserInfo();
+      }
+    });
+  }
+  setupUserInteractionTracking() {
+    if (typeof window === "undefined" || typeof document === "undefined") {
+      return;
+    }
+    document.addEventListener(
+      "click",
+      (event) => {
+        var _a, _b, _c;
+        try {
+          const originalTarget = event.target;
+          const findClosest = (el, selector) => el && typeof el.closest === "function" ? el.closest(selector) : null;
+          let target = findClosest(originalTarget, "[rum-id],[rum-name]");
+          if (!target) {
+            target = findClosest(
+              originalTarget,
+              'button, a, [role="button"], [role="link"]'
+            );
+          }
+          if (!target && originalTarget && window.getComputedStyle) {
+            const style = window.getComputedStyle(originalTarget);
+            if (style.cursor === "pointer") {
+              target = originalTarget;
+            }
+          }
+          if (!target) {
+            return;
+          }
+          const getAttr = (el, name) => el && typeof el.getAttribute === "function" ? el.getAttribute(name) : null;
+          let bizId = getAttr(target, "rum-id") || getAttr(target, "rum-name") || "";
+          if (!bizId) {
+            const tagName = target.tagName ? target.tagName.toLowerCase() : "element";
+            const classList = (target.className || "").toString().split(/\s+/).filter((c) => c.trim());
+            const primaryClass = classList[0] || "no-class";
+            const getLabel = (el) => {
+              if (!el)
+                return "";
+              const text = (el.textContent || "").trim();
+              if (text)
+                return text;
+              const ariaLabel = getAttr(el, "aria-label");
+              if (ariaLabel)
+                return ariaLabel;
+              const title = getAttr(el, "title");
+              if (title)
+                return title;
+              const alt = getAttr(el, "alt");
+              if (alt)
+                return alt;
+              const placeholder = getAttr(el, "placeholder");
+              if (placeholder)
+                return placeholder;
+              const value = typeof el.value === "string" ? el.value.trim() : "";
+              if (value)
+                return value;
+              return "";
+            };
+            const label = getLabel(target);
+            const safeLabel = (label || primaryClass).replace(/\s+/g, "_").slice(0, 32) || "no_label";
+            const route = ((_b = (_a = this.context) == null ? void 0 : _a.router) == null ? void 0 : _b.currentRoute) || {};
+            const buildRouteKey = (r) => {
+              try {
+                if (!r)
+                  return "unknown_route";
+                if (r.name) {
+                  return String(r.name);
+                }
+                if (Array.isArray(r.matched) && r.matched.length > 0) {
+                  const record = r.matched[r.matched.length - 1];
+                  if (record && record.path) {
+                    return record.path;
+                  }
+                }
+                if (r.path) {
+                  return r.path;
+                }
+              } catch {
+              }
+              return window.location.pathname || "unknown_route";
+            };
+            const routeKey = buildRouteKey(route);
+            let indexSuffix = "";
+            try {
+              const parent = target.parentNode;
+              if (parent && parent.children && parent.children.length) {
+                const siblings = Array.from(parent.children).filter(
+                  (el) => el.tagName === target.tagName && el.className === target.className
+                );
+                const index = siblings.indexOf(target);
+                if (index >= 0) {
+                  indexSuffix = `[${index}]`;
+                }
+              }
+            } catch {
+            }
+            bizId = `${routeKey}|${tagName}.${primaryClass}${indexSuffix}|${safeLabel}`;
+          }
+          const targetInfo = {
+            tagName: target.tagName,
+            className: target.className,
+            id: target.id,
+            textContent: ((_c = target.textContent) == null ? void 0 : _c.substring(0, 50)) || "",
+            selector: this.getCSSSelector(target)
+          };
+          this.trackAction("click", {
+            type: "click",
+            bizId,
+            x: event.clientX,
+            y: event.clientY,
+            target: targetInfo,
+            page: {
+              url: window.location.href,
+              title: document.title,
+              path: window.location.pathname
+            },
+            timestamp: Date.now()
+          });
+        } catch (error) {
+          console.warn("Failed to track click event:", error);
+        }
+      },
+      true
+    );
+    document.addEventListener("visibilitychange", () => {
+    });
+    if (mitoConfig.debug) {
+      console.log("User interaction tracking configured");
+    }
+  }
+  getCSSSelector(element) {
+    if (!element || element.nodeType !== Node.ELEMENT_NODE) {
+      return "";
+    }
+    const path = [];
+    let current = element;
+    while (current && current.nodeType === Node.ELEMENT_NODE) {
+      let selector = current.tagName.toLowerCase();
+      if (current.id) {
+        selector += `#${current.id}`;
+        path.unshift(selector);
+        break;
+      }
+      if (current.className) {
+        const classes = current.className.split(" ").filter((c) => c.trim());
+        if (classes.length > 0) {
+          selector += `.${classes[0]}`;
+        }
+      }
+      path.unshift(selector);
+      current = current.parentElement;
+      if (path.length > 5) {
+        break;
+      }
+    }
+    return path.join(" > ");
+  }
+  trackEvent(eventName, eventData = {}) {
+    if (!this.checkRUMAvailable()) {
+      return;
+    }
+    try {
+      this.adapter.trackEvent({
+        name: eventName,
+        ...eventData
+      });
+    } catch (error) {
+      console.error("Failed to track event:", error);
+    }
+  }
+  trackPerformance(performanceData) {
+    if (!this.checkRUMAvailable()) {
+      return;
+    }
+    try {
+      this.adapter.trackEvent({
+        name: "performance",
+        type: "performance",
+        ...performanceData
+      });
+    } catch (error) {
+      console.error("Failed to track performance:", error);
+    }
+  }
+  trackAction(action, actionData = {}) {
+    if (!this.checkRUMAvailable()) {
+      return;
+    }
+    try {
+      this.adapter.trackEvent({
+        name: "user_action",
+        action,
+        ...actionData
+      });
+    } catch (error) {
+      console.error("Failed to track action:", error);
+    }
+  }
+  trackMetric(metricName, value, dimensions = {}) {
+    if (!this.checkRUMAvailable()) {
+      return;
+    }
+    try {
+      this.adapter.trackEvent({
+        name: "metric",
+        metricName,
+        value,
+        dimensions
+      });
+    } catch (error) {
+      console.error("Failed to track metric:", error);
+    }
+  }
+  getBreadcrumbs() {
+    if (!this.checkRUMAvailable()) {
+      return [];
+    }
+    try {
+      return this.adapter.getBreadcrumbs();
+    } catch (error) {
+      console.error("Failed to get breadcrumbs:", error);
+      return [];
+    }
+  }
+  enable() {
+    this.isEnabled = true;
+    if (mitoConfig.debug) {
+      console.log("RUM system enabled");
+    }
+  }
+  disable() {
+    this.isEnabled = false;
+    if (mitoConfig.debug) {
+      console.log("RUM system disabled");
+    }
+  }
+  checkRUMAvailable() {
+    return this.isEnabled && this.isInitialized && !!this.adapter;
+  }
+  getConfig() {
+    return {
+      isInitialized: this.isInitialized,
+      isEnabled: this.isEnabled,
+      environment: mitoConfig.environment,
+      debug: mitoConfig.debug,
+      sls: {
+        enabled: slsConfig.enabled,
+        configured: true,
+        project: slsConfig.project,
+        logstore: slsConfig.logstore
+      }
+    };
+  }
+  destroy() {
+    try {
+      if (this.adapter) {
+        this.adapter.destroy();
+        this.adapter = null;
+      }
+      this.isInitialized = false;
+      this.context = {};
+      if (mitoConfig.debug) {
+        console.log("RUM system destroyed");
+      }
+    } catch (error) {
+      console.error("Failed to destroy RUM system:", error);
+    }
+  }
+};
+
+// src/vue2/plugin.vue2.ts
+var rumManagerVue2 = new RUMManagerVue2();
+var initRUMSystem = (context, options = {}) => rumManagerVue2.init(context, options);
+var trackEvent = (eventName, eventData) => rumManagerVue2.trackEvent(eventName, eventData || {});
+var trackPerformance = (performanceData) => rumManagerVue2.trackPerformance(performanceData);
+var trackAction = (action, actionData) => rumManagerVue2.trackAction(action, actionData || {});
+var trackMetric = (metricName, value, dimensions) => rumManagerVue2.trackMetric(metricName, value, dimensions || {});
+var getBreadcrumbs = () => rumManagerVue2.getBreadcrumbs();
+var enableRUM = () => rumManagerVue2.enable();
+var disableRUM = () => rumManagerVue2.disable();
+var getRUMConfig = () => rumManagerVue2.getConfig();
+var destroyRUM = () => rumManagerVue2.destroy();
+var getRUMManager = () => rumManagerVue2;
+var RUMPluginVue2 = {
+  install(Vue) {
+    Vue.prototype.$rum = {
+      trackEvent,
+      trackPerformance,
+      trackAction,
+      trackMetric,
+      getBreadcrumbs,
+      enable: enableRUM,
+      disable: disableRUM,
+      getConfig: getRUMConfig
+    };
+    Vue.$rumManager = rumManagerVue2;
+  }
+};
+
+// src/vue3/plugin.vue3.ts
+var plugin_vue3_exports = {};
+__export(plugin_vue3_exports, {
+  createRUMPluginVue3: () => createRUMPluginVue3,
+  useRUM: () => useRUM
+});
+import { inject } from "vue";
+
+// src/vue3/RUMManager.vue3.ts
+var RUMManagerVue3 = class {
+  constructor() {
+    this.inner = new RUMManagerVue2();
+  }
+  init(context, options = {}) {
+    return this.inner.init(context, options);
+  }
+  trackEvent(eventName, eventData = {}) {
+    this.inner.trackEvent(eventName, eventData);
+  }
+  trackPerformance(performanceData) {
+    this.inner.trackPerformance(performanceData);
+  }
+  trackAction(action, actionData = {}) {
+    this.inner.trackAction(action, actionData);
+  }
+  trackMetric(metricName, value, dimensions = {}) {
+    this.inner.trackMetric(metricName, value, dimensions);
+  }
+  getBreadcrumbs() {
+    return this.inner.getBreadcrumbs();
+  }
+  enable() {
+    this.inner.enable();
+  }
+  disable() {
+    this.inner.disable();
+  }
+  getConfig() {
+    return this.inner.getConfig();
+  }
+  destroy() {
+    this.inner.destroy();
+  }
+};
+
+// src/vue3/plugin.vue3.ts
+function createRUMPluginVue3(options) {
+  const manager = new RUMManagerVue3();
+  return {
+    install(app) {
+      manager.init(
+        { store: options.store, router: options.router },
+        options.coreOptions || {}
+      );
+      app.config.globalProperties.$rum = {
+        trackEvent: manager.trackEvent.bind(manager),
+        trackPerformance: manager.trackPerformance.bind(manager),
+        trackAction: manager.trackAction.bind(manager),
+        trackMetric: manager.trackMetric.bind(manager),
+        getBreadcrumbs: manager.getBreadcrumbs.bind(manager),
+        enable: manager.enable.bind(manager),
+        disable: manager.disable.bind(manager),
+        getConfig: manager.getConfig.bind(manager)
+      };
+      app.provide("rum", manager);
+    }
+  };
+}
+function useRUM() {
+  return inject("rum");
+}
+export {
+  MitoSLSAdapter,
+  RUMPluginVue2,
+  RUM_ENV,
+  SLSWebTrackingAdapter,
+  createRUMPluginVue3,
+  destroyRUM as destroyRUMVue2,
+  disableRUM as disableRUMVue2,
+  enableRUM as enableRUMVue2,
+  getBreadcrumbs as getBreadcrumbsVue2,
+  getMitoAdapter,
+  getRUMConfig as getRUMConfigVue2,
+  getRUMCoreInstance,
+  getRUMEnv,
+  getRUMManager as getRUMManagerVue2,
+  getUserInfo,
+  initRUMCore,
+  initRUMSystem as initRUMSystemVue2,
+  mitoConfig,
+  shouldReport,
+  slsConfig,
+  trackAction as trackActionVue2,
+  trackEvent as trackEventVue2,
+  trackMetric as trackMetricVue2,
+  trackPerformance as trackPerformanceVue2,
+  transformDataForSLS,
+  useRUM,
+  plugin_vue2_exports as vue2,
+  plugin_vue3_exports as vue3
+};
+//# sourceMappingURL=index.mjs.map