@arms/rum-reactnative 0.1.2 → 0.1.3-beta.1

package/lib/commonjs/utils/view.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addNavigateListener = addNavigateListener;
+exports.getCurView = getCurView;
+exports.removeNavigateListener = removeNavigateListener;
+exports.startTrackingViews = startTrackingViews;
+exports.stopTrackingViews = stopTrackingViews;
+var _rumCore = require("@arms/rum-core");
+// import { IPage } from "../types/client";
+
+// export const PAGE_ID = '__rum_view_id';
+//
+// /**
+//  * 获取 RUM 内置的view_id标识
+//  * @param page
+//  * @param session
+//  * @returns
+//  */
+// export async function getRumViewId(page: IPage, session?: IRumSession): Promise<string> {
+//   if (!page) return;
+//   if (page.id) {
+//     return page.id;
+//   }
+//   if (!session) return;
+//   return page.id = session.getViewId();
+// }
+//
+// /**
+//  * 获取当前 view
+//  * @param viewId
+//  * @param ctx
+//  * @returns
+//  */
+// export function getViewById(viewId: string, ctx: IContext): IViewData {
+//   if (!viewId || !ctx) return;
+//   return ctx.getViews().find(view => view.id === viewId);
+// }
+
+/**
+ * 获取当前 view
+ * @param ctx
+ * @returns
+ */
+function getCurView(ctx) {
+  if (!ctx) return;
+  const views = ctx.getViews();
+  if (views && views.length) {
+    return views[views.length - 1];
+  }
+  return null;
+}
+let currentNavigationRef;
+const navigateListeners = [];
+function addNavigateListener(listener) {
+  if ((0, _rumCore.isFunction)(listener)) {
+    navigateListeners.push(listener);
+  }
+}
+function removeNavigateListener(listener) {
+  navigateListeners.splice(navigateListeners.indexOf(listener), 1);
+}
+function triggerNavigateChange(event) {
+  if (!currentNavigationRef) return;
+  let route = event;
+  if ((0, _rumCore.isFunction)(currentNavigationRef.getCurrentRoute)) {
+    route = currentNavigationRef.getCurrentRoute();
+  }
+  if (!route) return;
+  navigateListeners.forEach(listener => {
+    listener(route);
+  });
+}
+function startTrackingViews(nav) {
+  if (!nav || currentNavigationRef) return;
+  currentNavigationRef = nav;
+  if ((0, _rumCore.isFunction)(nav.events)) {
+    // react-native-navigation
+    nav.events().registerComponentDidAppearListener(triggerNavigateChange);
+  } else {
+    // @react-native/navigation
+    nav.addListener('state', triggerNavigateChange);
+  }
+  triggerNavigateChange({});
+}
+function stopTrackingViews() {
+  if (!currentNavigationRef) return;
+  currentNavigationRef.removeListener('state', triggerNavigateChange);
+  currentNavigationRef = undefined;
+}
+//# sourceMappingURL=view.js.map

package/lib/module/NativeRumSdkReactnative.js

@@ -0,0 +1,47 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+
+/**
+ * 原生设备信息，对应存储模型中的公共属性：
+ * - device.* （id / type / brand / model / name）
+ * - os.*     （type / version / container / container_version）
+ * - app.package
+ * - viewport.width / viewport.height
+ */
+
+/**
+ * 获取原生模块。
+ *
+ * 使用非强制的 `TurboModuleRegistry.get`（而非 `getEnforcing`），避免在原生
+ * 二进制未注册该模块时于「模块加载阶段」直接抛异常——那会连锁导致整个 JS
+ * bundle 评估失败（表现为所有路由丢失 default export、App 白屏）。
+ *
+ * 当原生模块缺失时（通常是新增原生代码后未重新编译原生 App，只重跑了 Metro），
+ * 返回一组空实现兜底：崩溃采集与原生设备信息降级为不可用，但 PV / 行为 / API /
+ * JS 异常等纯 JS 能力不受影响。需重新构建原生工程（如 `expo run:ios` /
+ * `pod install` + 重新编译）后崩溃采集才会真正生效。
+ */
+const nativeModule = TurboModuleRegistry.get('RumSdkReactnative');
+if (!nativeModule) {
+  console.warn("[rum] Native module 'RumSdkReactnative' not found in the native binary. " + 'Crash reporting and native device info are disabled. ' + 'Rebuild the native app (e.g. `expo run:ios` / `expo run:android`, ' + 'or `pod install` + rebuild) so the module gets registered.');
+}
+
+/** 原生模块缺失时的空实现，保证调用方不会因缺方法而抛错。 */
+const fallback = {
+  getItem: async () => null,
+  setItem: async () => {},
+  removeItem: async () => {},
+  clear: async () => {},
+  getAllKeys: async () => [],
+  getDeviceInfo: async () => ({}),
+  getPendingCrashes: async () => '[]',
+  clearCrashReports: async () => {},
+  clearAllCrashReports: async () => {},
+  cleanupOldCrashes: async () => {},
+  crashedLastRun: async () => false,
+  updateCrashContext: () => {},
+  triggerTestCrash: () => {}
+};
+export default nativeModule ?? fallback;
+//# sourceMappingURL=NativeRumSdkReactnative.js.map

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

@@ -2,6 +2,7 @@
 
 import { RumEventType } from '@arms/rum-core';
 import { getCurView } from "../../utils/view.js";
+import { addActionListener, removeActionListener, startTrackingActions, stopTrackingActions } from "../../utils/action.js";
 export default class ActionCollector {
   name = 'action-collector';
   DELAY_TIME = 300;
@@ -15,7 +16,9 @@ export default class ActionCollector {
     }
     this.ctx = ctx;
     this.sendEvent = sendEvent;
-    // addPageListener('*', this.onEvent)
+    // 开启 React Native 触摸自动采集，并监听标准化的 tap 事件
+    startTrackingActions();
+    addActionListener(this.onEvent);
   }
   onEvent = e => {
     if (e && this.events.includes(e.type) && e.target) {
@@ -37,32 +40,64 @@ export default class ActionCollector {
       const event = {
         event_type: RumEventType.ACTION,
         type,
-        name: id,
-        snapshots: Object.keys(dataset).length ? JSON.stringify(dataset) : undefined,
+        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) {
-        if (this.lastEvent.name !== event.name) {
+      if (this.lastEvent && this.lastActionId === id) {
+        // 同一元素的连续点击：仅累加次数
+        // @ts-ignore
+        this.lastEvent.times += 1;
+      } else {
+        // 切换到不同元素：立即上报上一个，再记录新事件
+        if (this.lastEvent) {
           this.sendAction();
-        } else {
-          // @ts-ignore
-          this.lastEvent.times += 1;
         }
-      } else {
         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() {
-    // removePageListener('*', this.onEvent);
+    removeActionListener(this.onEvent);
+    stopTrackingActions();
   }
 }
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,143 @@
+"use strict";
+
+import { logger } from '@arms/rum-core';
+import NativeRumSdkReactnative from "../../NativeRumSdkReactnative.js";
+import { CRASH_CONTEXT_EVENT, CRASH_ID_FIELD, CRASH_REPORT_ACK_EVENT } from "../../types/crash.js";
+import { convertCrashToRumEvent, safeNativeCall } from "../../utils/crash.js";
+
+/**
+ * 崩溃采集器（Exception 的子类型）：
+ * 1. 初始化时读取上次运行写入的原生崩溃文件，转换为 RumEvent 通过标准管线上报；
+ * 2. 通过 ctx.emitter 订阅上下文变更事件，同步到原生侧
+ *    （用于下一次启动时崩溃报告携带正确上下文）。
+ */
+
+export default 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_CONTEXT_EVENT, this.onCrashContextChange);
+    // 订阅上报确认事件：reporter 上报成功后回 ack，再删除对应崩溃文件
+    ctx.emitter.on(CRASH_REPORT_ACK_EVENT, this.onCrashReportAck);
+
+    // 顺序执行：先处理待上报崩溃，再清理旧文件（避免竞态）
+    this.processPendingCrashes().then(() => this.cleanupOldCrashes()).catch(e => {
+      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 safeNativeCall(() => NativeRumSdkReactnative.crashedLastRun(), 'crashedLastRun');
+    const crashesJson = await safeNativeCall(() => NativeRumSdkReactnative.getPendingCrashes(), 'getPendingCrashes');
+    if (!crashesJson) return;
+    let crashes = [];
+    try {
+      crashes = JSON.parse(crashesJson) || [];
+    } catch (e) {
+      logger.error('crash-collector', 'Failed to parse crashes JSON', e);
+      // 清理损坏的文件，避免每次启动重复尝试解析
+      await safeNativeCall(() => NativeRumSdkReactnative.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 = 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_ID_FIELD] = cid;
+            event.snapshots = JSON.stringify(snapshotsObj);
+          } catch {
+            // snapshots 解析失败时降级：仍挂载到根级以保证 ack 机制可用
+            event[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) {
+        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 safeNativeCall(() => NativeRumSdkReactnative.clearAllCrashReports(), 'clearAllCrashReports');
+    }
+  }
+
+  /** 兜底清理：删除过期和超限的崩溃文件，防止存储耗尽 */
+  async cleanupOldCrashes() {
+    // 最多保留 10 个崩溃文件，7 天过期
+    const MAX_FILES = 10;
+    const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+    await safeNativeCall(() => NativeRumSdkReactnative.cleanupOldCrashes(MAX_FILES, MAX_AGE_MS), 'cleanupOldCrashes');
+  }
+  onCrashContextChange = context => {
+    try {
+      NativeRumSdkReactnative.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;
+    }
+    safeNativeCall(() => NativeRumSdkReactnative.clearCrashReports(JSON.stringify(toClear)), 'clearCrashReports').finally(() => {
+      for (const id of toClear) this.pendingAckIds.delete(id);
+    });
+  };
+  destroy() {
+    this.ctx?.emitter.off(CRASH_CONTEXT_EVENT, this.onCrashContextChange);
+    this.ctx?.emitter.off(CRASH_REPORT_ACK_EVENT, this.onCrashReportAck);
+    this.pendingAckIds.clear();
+    this.sendEvent = undefined;
+  }
+}
+//# sourceMappingURL=crash.js.map

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

@@ -3,9 +3,15 @@
 import { isArray, interceptFunction, matchList, RumEventType } from '@arms/rum-core';
 export default class ExceptionCollector {
   name = 'exception-collector';
+  installed = false;
+  /** fatal 去重保护：防止连续 fatal error 重复上报 */
+  handlingFatal = false;
+  /** 防止 errorHandle 内部 console.error 形成循环 */
+  inErrorHandle = false;
   origin = {
     consoleError: console.error,
-    originalOnError: null
+    originalOnError: null,
+    originalOnUnhandledRejection: null
   };
   setup(ctx, sendEvent) {
     this.ctx = ctx;
@@ -13,6 +19,9 @@ export default class ExceptionCollector {
     this.hackOrigin();
   }
   hackOrigin() {
+    // 防止重复安装覆盖 originalOnError
+    if (this.installed) return;
+    this.installed = true;
     const self = this;
     const {
       collectors = {}
@@ -22,68 +31,142 @@ export default class ExceptionCollector {
         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) {
       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) {
-      // @ts-ignore
       this.origin.originalOnError(e, isFatal);
     }
-    this.errorHandle(e, 'onError');
+    if (!isFatal) {
+      this.handlingFatal = false;
+    }
   };
   onUnhandled = (_id, error) => {
     this.errorHandle(error, 'onUnhandled');
   };
   errorHandle = (error, source = '') => {
-    let name = '';
-    let message = '';
-    let file = '';
-    let stack = '';
-    let line = '';
-    let column = '';
-    if (error instanceof Object) {
-      name = error.name;
-      message = error.message;
-      file = error.filename || error.fileName;
-      stack = error.stack;
-      line = error.lineno || error.lineNumber;
-      column = error.colno || error.columnNumber;
-    } else if (typeof error === 'string') {
-      stack = error;
-      const err = this.getErrorByStack(error);
-      if (err) {
-        name = err.name;
-        message = err.message;
+    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 || this.errorFilter(error)) {
-      return;
-    }
-    if (this.ctx && this.sendEvent) {
-      const baseRumEvent = this.ctx.session.getBaseEvent();
-      this.sendEvent({
-        ...baseRumEvent,
-        event_type: RumEventType.EXCEPTION,
-        source,
-        type: 'error',
-        name,
-        message,
-        file,
-        stack,
-        line,
-        column
-      });
+      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: RumEventType.EXCEPTION,
+          source: normalizedSource,
+          type: 'error',
+          name,
+          message,
+          file,
+          stack,
+          line,
+          column,
+          times: 1
+        });
+      }
+    } finally {
+      this.inErrorHandle = false;
     }
   };
 
@@ -123,13 +206,28 @@ export default class ExceptionCollector {
     return matchList(filters, err.name, true, err) || matchList(filters, err.message, true, err) || matchList(filters, err.stack || '', true, err);
   }
   destroy() {
-    const origin = this.origin;
-    if (origin.consoleError) {
-      console.error = origin.consoleError;
+    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
+      }
     }
-    // if (isFunction(sdk.offError)) {
-    //   sdk.offError(this.onError);
-    // }
+    this.installed = false;
   }
 }
 //# sourceMappingURL=index.js.map

package/lib/module/collector/index.js

@@ -0,0 +1,8 @@
+"use strict";
+
+export { default as PvCollector } from "./view/pv.js";
+export { default as ExceptionCollector } from "./exception/index.js";
+export { default as CrashCollector } from "./exception/crash.js";
+export { default as ApiCollector } from "./resource/api.js";
+export { default as ActionCollector } from "./action/index.js";
+//# sourceMappingURL=index.js.map

package/lib/module/collector/resource/api.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { find, generateGUID, generateSpanId, generateTraceId, isString, interceptFunction, restoreFunction, isFunction, makeTracingHeaders, matchList, parseTracingOptions, performDraw, RumEventType, ResourceStatus, urlMatch } from '@arms/rum-core';
+import { find, generateGUID, generateSpanId, generateTraceId, isString, interceptFunction, restoreFunction, isFunction, makeTracingHeaders, matchList, parseTracingOptions, performDraw, RumEventType, ResourceStatus, urlMatch, logger } from '@arms/rum-core';
 import { getCurrentTime } from "../../utils/base.js";
 import { ApiType, reviseApiAttr, getResourceName, getResourceSuccessByCode } from "../../utils/api.js";
 export default class ApiCollector {
@@ -32,9 +32,9 @@ export default class ApiCollector {
     } = parseTracingOptions(tracing);
     if (!enable) return;
     // @ts-ignore
-    const traceOption = find(allowedUrls, traceOption => matchList([traceOption.match], apiAttr.url || ''));
-    if (!traceOption) return;
-    let pTypes = traceOption.propagatorTypes;
+    const resolvedTraceOption = find(allowedUrls, item => matchList([item.match], apiAttr.url || ''));
+    if (!resolvedTraceOption) return;
+    let pTypes = resolvedTraceOption.propagatorTypes;
     if (pTypes && pTypes.length === 0) {
       pTypes = propagatorTypes;
     }
@@ -141,7 +141,7 @@ export default class ApiCollector {
               ...reviseApiAttr(attrs)
             };
           } catch (e) {
-            //
+            logger.warn('api-collector', 'evaluateApi failed for XHR', e);
           }
         }
         self.sendAPI(apiAttr, entry);
@@ -211,7 +211,7 @@ export default class ApiCollector {
               ...reviseApiAttr(attrs)
             };
           } catch (e) {
-            //
+            logger.warn('api-collector', 'evaluateApi failed for fetch', e);
           }
         }
         self.sendAPI(apiAttr, entry);