@arms/rum-reactnative 0.1.1 → 0.1.3-beta.0

package/lib/commonjs/collector/action/index.js

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _rumCore = require("@arms/rum-core");
+var _view = require("../../utils/view");
+var _action = require("../../utils/action");
+class ActionCollector {
+  name = 'action-collector';
+  DELAY_TIME = 300;
+  events = ['tap'];
+  setup(ctx, sendEvent) {
+    const {
+      collectors = {}
+    } = ctx.getConfig();
+    if (collectors.action === false) {
+      return;
+    }
+    this.ctx = ctx;
+    this.sendEvent = sendEvent;
+    // 开启 React Native 触摸自动采集，并监听标准化的 tap 事件
+    (0, _action.startTrackingActions)();
+    (0, _action.addActionListener)(this.onEvent);
+  }
+  onEvent = e => {
+    if (e && this.events.includes(e.type) && e.target) {
+      const {
+        target,
+        currentTarget,
+        type
+      } = e;
+      const {
+        dataset,
+        id
+      } = target;
+      if (!id) return;
+      if (currentTarget && id !== currentTarget.id) return;
+      let view;
+      if (this.ctx) {
+        view = (0, _view.getCurView)(this.ctx);
+      }
+      const event = {
+        event_type: _rumCore.RumEventType.ACTION,
+        type,
+        name: e.name || id,
+        target_name: e.targetName,
+        duration: e.duration,
+        position: e.position,
+        target: this.buildTarget(target),
+        snapshots: dataset && Object.keys(dataset).length ? JSON.stringify(dataset).slice(0, 1000) : undefined,
+        times: 1,
+        view
+      };
+      clearTimeout(this.timer);
+      if (this.lastEvent && this.lastActionId === id) {
+        // 同一元素的连续点击：仅累加次数
+        // @ts-ignore
+        this.lastEvent.times += 1;
+      } else {
+        // 切换到不同元素：立即上报上一个，再记录新事件
+        if (this.lastEvent) {
+          this.sendAction();
+        }
+        this.lastEvent = event;
+        this.lastActionId = id;
+      }
+      this.timer = setTimeout(this.sendAction, this.DELAY_TIME);
+    }
+  };
+
+  /**
+   * 组装热力图相关的 target 信息（selector/宽高/可交互性/可信度）。
+   * 当没有任何字段时返回 undefined，避免上报空对象。
+   */
+  buildTarget(target) {
+    const {
+      selector,
+      width,
+      height,
+      reaction,
+      trust
+    } = target;
+    if (selector === undefined && width === undefined && height === undefined && reaction === undefined && trust === undefined) {
+      return undefined;
+    }
+    return {
+      selector,
+      width,
+      height,
+      reaction,
+      trust
+    };
+  }
+  sendAction = () => {
+    // @ts-ignore
+    this.sendEvent(this.lastEvent);
+    this.lastEvent = undefined;
+    this.lastActionId = undefined;
+  };
+  destroy() {
+    (0, _action.removeActionListener)(this.onEvent);
+    (0, _action.stopTrackingActions)();
+  }
+}
+exports.default = ActionCollector;
+//# sourceMappingURL=index.js.map

package/lib/commonjs/collector/exception/crash.js

@@ -0,0 +1,148 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _rumCore = require("@arms/rum-core");
+var _NativeRumSdkReactnative = _interopRequireDefault(require("../../NativeRumSdkReactnative"));
+var _crash = require("../../types/crash");
+var _crash2 = require("../../utils/crash");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * 崩溃采集器（Exception 的子类型）：
+ * 1. 初始化时读取上次运行写入的原生崩溃文件，转换为 RumEvent 通过标准管线上报；
+ * 2. 通过 ctx.emitter 订阅上下文变更事件，同步到原生侧
+ *    （用于下一次启动时崩溃报告携带正确上下文）。
+ */
+
+class CrashCollector {
+  name = 'crash-collector';
+  initialized = false;
+  /** 已上报待确认（ack）的 crash_id，成功后才删文件 */
+  pendingAckIds = new Set();
+  setup(ctx, sendEvent) {
+    const {
+      collectors = {}
+    } = ctx.getConfig();
+    if (collectors.crash === false) {
+      return;
+    }
+    this.ctx = ctx;
+    this.sendEvent = sendEvent;
+
+    // 订阅上下文变更事件，同步到原生侧
+    ctx.emitter.on(_crash.CRASH_CONTEXT_EVENT, this.onCrashContextChange);
+    // 订阅上报确认事件：reporter 上报成功后回 ack，再删除对应崩溃文件
+    ctx.emitter.on(_crash.CRASH_REPORT_ACK_EVENT, this.onCrashReportAck);
+
+    // 顺序执行：先处理待上报崩溃，再清理旧文件（避免竞态）
+    this.processPendingCrashes().then(() => this.cleanupOldCrashes()).catch(e => {
+      _rumCore.logger.error('crash-collector', 'Failed to process crash reports', e);
+    });
+  }
+  async processPendingCrashes() {
+    if (this.initialized) return;
+    this.initialized = true;
+
+    // 不以 crashedLastRun 作为 gating：KSCrash 的 crashedLastLaunch 只在崩溃后的下一次
+    // 启动为 true，再下一次正常启动就清零，会导致遗留崩溃文件永远不被处理。
+    // 只要磁盘上有 pending 文件就读取并上报。
+    await (0, _crash2.safeNativeCall)(() => _NativeRumSdkReactnative.default.crashedLastRun(), 'crashedLastRun');
+    const crashesJson = await (0, _crash2.safeNativeCall)(() => _NativeRumSdkReactnative.default.getPendingCrashes(), 'getPendingCrashes');
+    if (!crashesJson) return;
+    let crashes = [];
+    try {
+      crashes = JSON.parse(crashesJson) || [];
+    } catch (e) {
+      _rumCore.logger.error('crash-collector', 'Failed to parse crashes JSON', e);
+      // 清理损坏的文件，避免每次启动重复尝试解析
+      await (0, _crash2.safeNativeCall)(() => _NativeRumSdkReactnative.default.clearAllCrashReports(), 'clearAllCrashReports');
+      return;
+    }
+    if (!Array.isArray(crashes) || crashes.length === 0) return;
+    const crashIds = [];
+    const hasFilesWithoutId = crashes.some(c => !c.crash_id);
+    for (let i = 0; i < crashes.length; i++) {
+      try {
+        const event = (0, _crash2.convertCrashToRumEvent)(crashes[i]);
+        const cid = crashes[i].crash_id;
+        // 将瞬态 crash_id 注入 snapshots（而非根级），reporter 上报前从中提取
+        // 用于 ack，并在序列化前从 snapshots 中剥离，不会发送到后端
+        if (cid) {
+          try {
+            const snapshotsObj = JSON.parse(event.snapshots);
+            snapshotsObj[_crash.CRASH_ID_FIELD] = cid;
+            event.snapshots = JSON.stringify(snapshotsObj);
+          } catch {
+            // snapshots 解析失败时降级：仍挂载到根级以保证 ack 机制可用
+            event[_crash.CRASH_ID_FIELD] = cid;
+          }
+          this.pendingAckIds.add(cid);
+          crashIds.push(cid);
+        }
+        // 最后一个崩溃事件使用 immediate 立即 flush 整个队列
+        const isLast = i === crashes.length - 1;
+        this.sendEvent?.(event, isLast ? {
+          immediate: true
+        } : undefined);
+      } catch (e) {
+        _rumCore.logger.warn('crash-collector', 'Failed to convert crash', e);
+      }
+    }
+
+    // 有 crash_id 的文件：不在此处删除，等 reporter 上报成功后由 onCrashReportAck
+    // 删除；上报失败则保留，下次启动重试（cleanupOldCrashes 兜底防止无限增长）。
+
+    // 无 crash_id 的旧版 NDK 崩溃文件无法 ack：仅当本次没有待 ack 的带 id 文件时
+    // 才安全清理（clearAllCrashReports 会删除全部文件，避免误删 ack-pending）。
+    if (hasFilesWithoutId && crashIds.length === 0) {
+      await (0, _crash2.safeNativeCall)(() => _NativeRumSdkReactnative.default.clearAllCrashReports(), 'clearAllCrashReports');
+    }
+  }
+
+  /** 兜底清理：删除过期和超限的崩溃文件，防止存储耗尽 */
+  async cleanupOldCrashes() {
+    // 最多保留 10 个崩溃文件，7 天过期
+    const MAX_FILES = 10;
+    const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+    await (0, _crash2.safeNativeCall)(() => _NativeRumSdkReactnative.default.cleanupOldCrashes(MAX_FILES, MAX_AGE_MS), 'cleanupOldCrashes');
+  }
+  onCrashContextChange = context => {
+    try {
+      _NativeRumSdkReactnative.default.updateCrashContext(JSON.stringify(context));
+    } catch {
+      //
+    }
+  };
+
+  /**
+   * reporter 上报确认回调：
+   * - 成功：删除对应 crash_id 的崩溃文件（确保上报成功后才删，不丢数据）；
+   * - 失败：保留文件，下次启动重试，仅从内存待确认集合中移除。
+   */
+  onCrashReportAck = ack => {
+    if (!ack || !Array.isArray(ack.crashIds) || ack.crashIds.length === 0) {
+      return;
+    }
+    // 只处理本采集器登记过的 id
+    const toClear = ack.crashIds.filter(id => this.pendingAckIds.has(id));
+    if (toClear.length === 0) return;
+    if (!ack.success) {
+      // 上报失败：文件保留，从待确认集合移除（下次启动重新登记与上报）
+      for (const id of toClear) this.pendingAckIds.delete(id);
+      return;
+    }
+    (0, _crash2.safeNativeCall)(() => _NativeRumSdkReactnative.default.clearCrashReports(JSON.stringify(toClear)), 'clearCrashReports').finally(() => {
+      for (const id of toClear) this.pendingAckIds.delete(id);
+    });
+  };
+  destroy() {
+    this.ctx?.emitter.off(_crash.CRASH_CONTEXT_EVENT, this.onCrashContextChange);
+    this.ctx?.emitter.off(_crash.CRASH_REPORT_ACK_EVENT, this.onCrashReportAck);
+    this.pendingAckIds.clear();
+    this.sendEvent = undefined;
+  }
+}
+exports.default = CrashCollector;
+//# sourceMappingURL=crash.js.map

package/lib/commonjs/collector/exception/index.js

@@ -0,0 +1,238 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _rumCore = require("@arms/rum-core");
+class ExceptionCollector {
+  name = 'exception-collector';
+  installed = false;
+  /** fatal 去重保护：防止连续 fatal error 重复上报 */
+  handlingFatal = false;
+  /** 防止 errorHandle 内部 console.error 形成循环 */
+  inErrorHandle = false;
+  origin = {
+    consoleError: console.error,
+    originalOnError: null,
+    originalOnUnhandledRejection: null
+  };
+  setup(ctx, sendEvent) {
+    this.ctx = ctx;
+    this.sendEvent = sendEvent;
+    this.hackOrigin();
+  }
+  hackOrigin() {
+    // 防止重复安装覆盖 originalOnError
+    if (this.installed) return;
+    this.installed = true;
+    const self = this;
+    const {
+      collectors = {}
+    } = this.ctx.getConfig();
+    if (collectors.jsError !== false) {
+      if (ErrorUtils) {
+        this.origin.originalOnError = ErrorUtils.getGlobalHandler?.();
+        ErrorUtils.setGlobalHandler(this.onError);
+      }
+      // Promise rejection: 优先 Hermes，JSC 兜底
+      if (HermesInternal?.enablePromiseRejectionTracker && HermesInternal?.hasPromise?.()) {
+        HermesInternal.enablePromiseRejectionTracker({
+          allRejections: true,
+          onUnhandled: this.onUnhandled
+        });
+      } else {
+        // JSC / 其他引擎：监听 unhandledrejection 事件
+        this.setupJSCPromiseRejection();
+      }
+    }
+    if (collectors.consoleError !== false) {
+      (0, _rumCore.interceptFunction)(console, 'error', function (error) {
+        if (self.inErrorHandle) return; // 防止循环
+        self.errorHandle(error, 'console.error');
+      });
+    }
+  }
+
+  /** JSC 引擎 Promise rejection 兜底方案 */
+  setupJSCPromiseRejection() {
+    try {
+      if (typeof globalThis !== 'undefined') {
+        const self = this;
+        this.origin.originalOnUnhandledRejection = globalThis.onunhandledrejection || null;
+        globalThis.onunhandledrejection = function (event) {
+          if (event?.reason) {
+            self.errorHandle(event.reason, 'onUnhandled');
+          }
+          if (typeof self.origin.originalOnUnhandledRejection === 'function') {
+            self.origin.originalOnUnhandledRejection.call(this, event);
+          }
+        };
+      }
+    } catch {
+      // JSC 不支持时不影响主流程
+    }
+  }
+  onError = (e, isFatal) => {
+    // fatal 去重保护：防止连续 fatal error 重复上报或死循环
+    if (isFatal) {
+      if (this.handlingFatal) return;
+      this.handlingFatal = true;
+    }
+
+    // 先采集（确保数据不丢）
+    this.errorHandle(e, 'onError');
+
+    // fatal error：确保事件落盘后再终止进程
+    if (isFatal && this.ctx) {
+      try {
+        const reporter = this.ctx.reporter;
+        if (reporter && typeof reporter.flush === 'function') {
+          // 使用超时兜底，避免永久阻塞
+          Promise.race([reporter.flush(), new Promise(resolve => setTimeout(resolve, 2000))]).finally(() => {
+            if (this.origin.originalOnError) {
+              this.origin.originalOnError(e, isFatal);
+            }
+          });
+          return;
+        }
+      } catch {
+        // ignore flush error
+      }
+    }
+
+    // 非 fatal 或 flush 不可用时直接链式调用
+    if (this.origin.originalOnError) {
+      this.origin.originalOnError(e, isFatal);
+    }
+    if (!isFatal) {
+      this.handlingFatal = false;
+    }
+  };
+  onUnhandled = (_id, error) => {
+    this.errorHandle(error, 'onUnhandled');
+  };
+  errorHandle = (error, source = '') => {
+    if (this.inErrorHandle) return; // 防止循环
+    if (error == null) return; // null/undefined 直接跳过
+
+    this.inErrorHandle = true;
+    try {
+      let name = '';
+      let message = '';
+      let file = '';
+      let stack = '';
+      let line = 0;
+      let column = 0;
+      if (error instanceof Object) {
+        name = String(error.name || error.constructor?.name || 'Error');
+        message = String(error.message || '');
+        file = String(error.filename || error.fileName || '');
+        // stack 可能在 error.stack 或 error.componentStack（React 渲染错误）
+        stack = String(error.stack || '');
+        if (!stack && error.componentStack) {
+          stack = String(error.componentStack);
+        }
+        line = Number(error.lineno || error.lineNumber || 0);
+        column = Number(error.colno || error.columnNumber || 0);
+      } else if (typeof error === 'string') {
+        stack = error;
+        const err = this.getErrorByStack(error);
+        if (err) {
+          name = err.name || 'Error';
+          message = err.message || '';
+        } else {
+          name = 'Error';
+          message = error.substring(0, 200);
+        }
+      } else if (typeof error === 'number' || typeof error === 'boolean') {
+        name = 'Error';
+        message = String(error);
+      }
+      if (!name || !message && !stack || this.errorFilter(error)) {
+        return;
+      }
+      if (this.ctx && this.sendEvent) {
+        const baseRumEvent = this.ctx.session.getBaseEvent();
+        const normalizedSource = source === 'console.error' ? 'console' : 'event';
+        this.sendEvent({
+          ...baseRumEvent,
+          event_type: _rumCore.RumEventType.EXCEPTION,
+          source: normalizedSource,
+          type: 'error',
+          name,
+          message,
+          file,
+          stack,
+          line,
+          column,
+          times: 1
+        });
+      }
+    } finally {
+      this.inErrorHandle = false;
+    }
+  };
+
+  /**
+   * 根据stack获取Error信息
+   * TODO: 增加基于Stack解析filename和lineNumber的能力
+   * @param stack
+   * @returns
+   */
+  getErrorByStack(stack = '') {
+    const res = stack.split('\n');
+    const prefix = 'at ';
+    if (res.length < 2) return;
+    for (let i = 1; i < res.length; i++) {
+      const str = res[i] || '';
+      if (str.trim().startsWith(prefix)) {
+        const line = res[i - 1] || '';
+        const index = line.indexOf(': ');
+        return {
+          name: line.substring(0, index),
+          message: line.substring(index + 2)
+        };
+      }
+    }
+    return;
+  }
+  errorFilter(err) {
+    let {
+      exception: filters
+    } = this.ctx.getConfig().filters || {};
+    if (!filters) {
+      return false;
+    }
+    if (!(0, _rumCore.isArray)(filters)) {
+      filters = [filters];
+    }
+    return (0, _rumCore.matchList)(filters, err.name, true, err) || (0, _rumCore.matchList)(filters, err.message, true, err) || (0, _rumCore.matchList)(filters, err.stack || '', true, err);
+  }
+  destroy() {
+    if (!this.installed) return;
+    // 恢复 console.error
+    if (this.origin.consoleError) {
+      console.error = this.origin.consoleError;
+    }
+    // 恢复 ErrorUtils.setGlobalHandler
+    if (ErrorUtils && this.origin.originalOnError) {
+      try {
+        ErrorUtils.setGlobalHandler(this.origin.originalOnError);
+      } catch {
+        // ignore
+      }
+    }
+    // 恢复 onunhandledrejection
+    if (typeof globalThis !== 'undefined' && this.origin.originalOnUnhandledRejection !== null) {
+      try {
+        globalThis.onunhandledrejection = this.origin.originalOnUnhandledRejection;
+      } catch {
+        // ignore
+      }
+    }
+    this.installed = false;
+  }
+}
+exports.default = ExceptionCollector;
+//# sourceMappingURL=index.js.map

package/lib/commonjs/collector/index.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ActionCollector", {
+  enumerable: true,
+  get: function () {
+    return _index2.default;
+  }
+});
+Object.defineProperty(exports, "ApiCollector", {
+  enumerable: true,
+  get: function () {
+    return _api.default;
+  }
+});
+Object.defineProperty(exports, "CrashCollector", {
+  enumerable: true,
+  get: function () {
+    return _crash.default;
+  }
+});
+Object.defineProperty(exports, "ExceptionCollector", {
+  enumerable: true,
+  get: function () {
+    return _index.default;
+  }
+});
+Object.defineProperty(exports, "PvCollector", {
+  enumerable: true,
+  get: function () {
+    return _pv.default;
+  }
+});
+var _pv = _interopRequireDefault(require("./view/pv"));
+var _index = _interopRequireDefault(require("./exception/index"));
+var _crash = _interopRequireDefault(require("./exception/crash"));
+var _api = _interopRequireDefault(require("./resource/api"));
+var _index2 = _interopRequireDefault(require("./action/index"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+//# sourceMappingURL=index.js.map