polyv-rum-sdk 0.1.13 → 0.1.16

package/dist/index.js

@@ -34,28 +34,44 @@ __export(src_exports, {
   RUMPluginVue2: () => RUMPluginVue2,
   RUM_ENV: () => RUM_ENV,
   SLSWebTrackingAdapter: () => SLSWebTrackingAdapter,
+  clearRUMUserReact: () => clearUser,
   createRUMPluginVue3: () => createRUMPluginVue3,
+  destroyRUMReact: () => destroyRUM2,
   destroyRUMVue2: () => destroyRUM,
+  disableRUMReact: () => disableRUM2,
   disableRUMVue2: () => disableRUM,
+  enableRUMReact: () => enableRUM2,
   enableRUMVue2: () => enableRUM,
+  getBreadcrumbsReact: () => getBreadcrumbs2,
   getBreadcrumbsVue2: () => getBreadcrumbs,
   getMitoAdapter: () => getMitoAdapter,
+  getRUMConfigReact: () => getRUMConfig2,
   getRUMConfigVue2: () => getRUMConfig,
   getRUMCoreInstance: () => getRUMCoreInstance,
   getRUMEnv: () => getRUMEnv,
+  getRUMManagerReact: () => getRUMManager2,
   getRUMManagerVue2: () => getRUMManager,
   getUserInfo: () => getUserInfo,
+  handleRouteChange: () => handleRouteChange,
   initRUMCore: () => initRUMCore,
+  initRUMSystemReact: () => initRUMSystem2,
   initRUMSystemVue2: () => initRUMSystem,
   mitoConfig: () => mitoConfig,
+  react: () => plugin_react_exports,
+  setRUMUserReact: () => setUser,
   shouldReport: () => shouldReport,
   slsConfig: () => slsConfig,
+  trackActionReact: () => trackAction2,
   trackActionVue2: () => trackAction,
+  trackEventReact: () => trackEvent2,
   trackEventVue2: () => trackEvent,
+  trackMetricReact: () => trackMetric2,
   trackMetricVue2: () => trackMetric,
+  trackPerformanceReact: () => trackPerformance2,
   trackPerformanceVue2: () => trackPerformance,
   transformDataForSLS: () => transformDataForSLS,
   useRUM: () => useRUM,
+  useRUMReact: () => useRUM2,
   vue2: () => plugin_vue2_exports,
   vue3: () => plugin_vue3_exports
 });
@@ -517,6 +533,8 @@ var SLSWebTrackingAdapter = class {
       this.addApiFields(logData, data);
     } else if (logData.event_type === "click") {
       this.addClickFields(logData, data);
+    } else if (logData.event_type === "custom") {
+      this.addCustomFields(logData, data);
     }
     try {
       let hash = "";
@@ -593,6 +611,56 @@ var SLSWebTrackingAdapter = class {
       logData.click_y = Number(data.y);
     }
   }
+  addCustomFields(logData, data) {
+    if (data.name) {
+      logData.custom_event_name = String(data.name);
+    }
+    if (data.action) {
+      logData.custom_event_action = String(data.action);
+    }
+    const customFields = {};
+    let fieldCount = 0;
+    const maxFields = 10;
+    const reservedKeys = [
+      "type",
+      "timestamp",
+      "name",
+      "action",
+      "eventType",
+      "category",
+      "level",
+      "userId",
+      "userName",
+      "userEmail",
+      "accountId",
+      "roles",
+      "pageTitle",
+      "path",
+      "search",
+      "hash",
+      "url",
+      "referrer",
+      "userAgent",
+      "rawData",
+      "dimensions"
+    ];
+    for (const [key, value] of Object.entries(data)) {
+      if (reservedKeys.includes(key))
+        continue;
+      if (fieldCount >= maxFields)
+        break;
+      if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        customFields[key] = value;
+        fieldCount++;
+      }
+    }
+    if (Object.keys(customFields).length > 0) {
+      logData.custom_event_fields = JSON.stringify(customFields);
+    }
+    if (data.detail !== void 0) {
+      logData.custom_event_detail = String(data.detail);
+    }
+  }
   filterSensitiveData(data) {
     const sensitivePatterns = [
       /password/i,
@@ -824,9 +892,9 @@ var MitoSLSAdapter = class {
         debug: this.options.debug,
         maxBreadcrumbs: this.options.maxBreadcrumbs,
         Vue: context.Vue || ((_a = this.options.vue) == null ? void 0 : _a.Vue),
-        framework: {
-          vue: true
-        },
+        // 根据 framework 配置决定是否设置 Vue 框架
+        // 如果未指定且没有 Vue 实例，则不设置 framework，使用原生 DOM 监听
+        ...this.options.framework === "vue" || this.options.framework === void 0 && context.Vue ? { framework: { vue: true } } : {},
         beforeDataReport: this.handleDataReport,
         silent: !this.options.debug,
         silentConsole: !this.options.debug,
@@ -1667,34 +1735,461 @@ function createRUMPluginVue3(options) {
 function useRUM() {
   return Vue.inject("rum");
 }
+
+// src/react/plugin.react.ts
+var plugin_react_exports = {};
+__export(plugin_react_exports, {
+  clearUser: () => clearUser,
+  destroyRUM: () => destroyRUM2,
+  disableRUM: () => disableRUM2,
+  enableRUM: () => enableRUM2,
+  getBreadcrumbs: () => getBreadcrumbs2,
+  getRUMConfig: () => getRUMConfig2,
+  getRUMManager: () => getRUMManager2,
+  handleRouteChange: () => handleRouteChange,
+  initRUMSystem: () => initRUMSystem2,
+  setUser: () => setUser,
+  trackAction: () => trackAction2,
+  trackEvent: () => trackEvent2,
+  trackMetric: () => trackMetric2,
+  trackPerformance: () => trackPerformance2,
+  useRUM: () => useRUM2
+});
+
+// src/react/RUMManager.react.ts
+var RUMManagerReact = class {
+  constructor() {
+    this.adapter = null;
+    this.isInitialized = false;
+    this.isEnabled = true;
+    this.context = {};
+    this.previousLocation = null;
+  }
+  async init(context = {}, options = {}) {
+    try {
+      if (!this.shouldEnableRUM()) {
+        if (mitoConfig.debug) {
+          console.log("[RUM] RUM system is disabled");
+        }
+        return;
+      }
+      if (this.isInitialized) {
+        if (mitoConfig.debug) {
+          console.log("[RUM] RUM system already initialized");
+        }
+        return;
+      }
+      this.context = {
+        store: context.store,
+        router: context.router,
+        ...context
+      };
+      const mergedOptions = {
+        ...mitoConfig,
+        ...options,
+        // React 项目不设置 Vue 框架配置
+        ...options.framework === "react" ? { framework: "react" } : {}
+      };
+      this.adapter = await initRUMCore(
+        {
+          store: this.context.store,
+          router: this.context.router
+        },
+        mergedOptions
+      );
+      this.setupUserInteractionTracking();
+      this.isInitialized = true;
+      if (mitoConfig.debug) {
+        console.log("[RUM] RUM system initialized successfully");
+      }
+    } catch (error) {
+      console.error("[RUM] Failed to initialize RUM system:", error);
+    }
+  }
+  shouldEnableRUM() {
+    if (!this.isEnabled) {
+      return false;
+    }
+    const env = getRUMEnv();
+    const rumEnabled = env.VUE_APP_RUM_ENABLED || env.VITE_RUM_ENABLED;
+    if (rumEnabled !== void 0) {
+      return rumEnabled === "true";
+    }
+    const mode = env.MODE || env.NODE_ENV;
+    const isProdEnv = mode === "prod" || mode === "production";
+    return !isProdEnv;
+  }
+  /**
+   * 设置 React Router 路由监听
+   * 在路由变化时调用此方法
+   */
+  handleRouteChange(location) {
+    if (!this.adapter || !this.previousLocation) {
+      this.previousLocation = location;
+      return;
+    }
+    if (location.pathname !== this.previousLocation.pathname) {
+      if (typeof this.adapter.handleRouteChange === "function") {
+        this.adapter.handleRouteChange(
+          { path: location.pathname, search: location.search, hash: location.hash },
+          { path: this.previousLocation.pathname, search: this.previousLocation.search, hash: this.previousLocation.hash }
+        );
+      }
+    }
+    this.previousLocation = location;
+  }
+  setupUserInteractionTracking() {
+    if (typeof window === "undefined" || typeof document === "undefined") {
+      return;
+    }
+    document.addEventListener(
+      "click",
+      (event) => {
+        var _a;
+        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 routeKey = window.location.pathname || "unknown_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: ((_a = target.textContent) == null ? void 0 : _a.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("[RUM] Failed to track click event:", error);
+        }
+      },
+      true
+    );
+    if (mitoConfig.debug) {
+      console.log("[RUM] 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("[RUM] Failed to track event:", error);
+    }
+  }
+  trackPerformance(performanceData) {
+    if (!this.checkRUMAvailable()) {
+      return;
+    }
+    try {
+      this.adapter.trackEvent({
+        name: "performance",
+        type: "performance",
+        ...performanceData
+      });
+    } catch (error) {
+      console.error("[RUM] 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("[RUM] 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("[RUM] Failed to track metric:", error);
+    }
+  }
+  /**
+   * 设置用户信息
+   * 在用户登录后调用
+   */
+  setUser(userInfo) {
+    if (!this.adapter) {
+      return;
+    }
+    try {
+      this.adapter.setUser(userInfo);
+      if (mitoConfig.debug) {
+        console.log("[RUM] User info set:", userInfo);
+      }
+    } catch (error) {
+      console.error("[RUM] Failed to set user info:", error);
+    }
+  }
+  /**
+   * 清除用户信息
+   * 在用户登出后调用
+   */
+  clearUser() {
+    if (!this.adapter) {
+      return;
+    }
+    try {
+      this.adapter.setUser({});
+      if (mitoConfig.debug) {
+        console.log("[RUM] User info cleared");
+      }
+    } catch (error) {
+      console.error("[RUM] Failed to clear user info:", error);
+    }
+  }
+  getBreadcrumbs() {
+    if (!this.checkRUMAvailable()) {
+      return [];
+    }
+    try {
+      return this.adapter.getBreadcrumbs();
+    } catch (error) {
+      console.error("[RUM] Failed to get breadcrumbs:", error);
+      return [];
+    }
+  }
+  enable() {
+    this.isEnabled = true;
+    if (mitoConfig.debug) {
+      console.log("[RUM] RUM system enabled");
+    }
+  }
+  disable() {
+    this.isEnabled = false;
+    if (mitoConfig.debug) {
+      console.log("[RUM] 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 = {};
+      this.previousLocation = null;
+      if (mitoConfig.debug) {
+        console.log("[RUM] RUM system destroyed");
+      }
+    } catch (error) {
+      console.error("[RUM] Failed to destroy RUM system:", error);
+    }
+  }
+};
+
+// src/react/plugin.react.ts
+var rumManagerReact = new RUMManagerReact();
+var initRUMSystem2 = (context = {}, options = {}) => rumManagerReact.init(context, options);
+var handleRouteChange = (location) => rumManagerReact.handleRouteChange(location);
+var setUser = (userInfo) => rumManagerReact.setUser(userInfo);
+var clearUser = () => rumManagerReact.clearUser();
+var trackEvent2 = (eventName, eventData) => rumManagerReact.trackEvent(eventName, eventData || {});
+var trackPerformance2 = (performanceData) => rumManagerReact.trackPerformance(performanceData);
+var trackAction2 = (action, actionData) => rumManagerReact.trackAction(action, actionData || {});
+var trackMetric2 = (metricName, value, dimensions) => rumManagerReact.trackMetric(metricName, value, dimensions || {});
+var getBreadcrumbs2 = () => rumManagerReact.getBreadcrumbs();
+var enableRUM2 = () => rumManagerReact.enable();
+var disableRUM2 = () => rumManagerReact.disable();
+var getRUMConfig2 = () => rumManagerReact.getConfig();
+var destroyRUM2 = () => rumManagerReact.destroy();
+var getRUMManager2 = () => rumManagerReact;
+var useRUM2 = () => ({
+  trackEvent: trackEvent2,
+  trackPerformance: trackPerformance2,
+  trackAction: trackAction2,
+  trackMetric: trackMetric2,
+  getBreadcrumbs: getBreadcrumbs2,
+  setUser,
+  clearUser,
+  enable: enableRUM2,
+  disable: disableRUM2,
+  getConfig: getRUMConfig2
+});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   MitoSLSAdapter,
   RUMPluginVue2,
   RUM_ENV,
   SLSWebTrackingAdapter,
+  clearRUMUserReact,
   createRUMPluginVue3,
+  destroyRUMReact,
   destroyRUMVue2,
+  disableRUMReact,
   disableRUMVue2,
+  enableRUMReact,
   enableRUMVue2,
+  getBreadcrumbsReact,
   getBreadcrumbsVue2,
   getMitoAdapter,
+  getRUMConfigReact,
   getRUMConfigVue2,
   getRUMCoreInstance,
   getRUMEnv,
+  getRUMManagerReact,
   getRUMManagerVue2,
   getUserInfo,
+  handleRouteChange,
   initRUMCore,
+  initRUMSystemReact,
   initRUMSystemVue2,
   mitoConfig,
+  react,
+  setRUMUserReact,
   shouldReport,
   slsConfig,
+  trackActionReact,
   trackActionVue2,
+  trackEventReact,
   trackEventVue2,
+  trackMetricReact,
   trackMetricVue2,
+  trackPerformanceReact,
   trackPerformanceVue2,
   transformDataForSLS,
   useRUM,
+  useRUMReact,
   vue2,
   vue3
 });