@arms/rum-core 0.1.6 → 0.1.8

package/es/utils/disposable.js

@@ -0,0 +1,20 @@
+/**
+ * 资源清理组：统一管理多个清理函数的生命周期
+ *
+ * 用于收敛采集器中常见的 cleanup 数组模式，
+ * 避免每个采集器重复实现 push + forEach 逻辑
+ */
+export function createDisposableGroup() {
+  var cleanups = [];
+  return {
+    /** 注册一个或多个清理函数 */add: function add() {
+      cleanups.push.apply(cleanups, arguments);
+    },
+    /** 执行所有清理函数并重置 */dispose: function dispose() {
+      cleanups.forEach(function (fn) {
+        return fn();
+      });
+      cleanups.length = 0;
+    }
+  };
+}

package/es/utils/throttle.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 带 cancel 的 leading + trailing 节流函数
+ *
+ * - leading：连续调用时立即触发首次
+ * - trailing：保证最后一次在 wait 内补发
+ * - cancel：丢弃尾调用并重置节流窗口，防止跨 view 串数据
+ *
+ * @param fn 需要节流的函数
+ * @param wait 节流间隔（毫秒）
+ */
+export declare function throttle(fn: () => void, wait: number): {
+    (): void;
+    cancel: () => void;
+};

package/es/utils/throttle.js

@@ -0,0 +1,40 @@
+/**
+ * 带 cancel 的 leading + trailing 节流函数
+ *
+ * - leading：连续调用时立即触发首次
+ * - trailing：保证最后一次在 wait 内补发
+ * - cancel：丢弃尾调用并重置节流窗口，防止跨 view 串数据
+ *
+ * @param fn 需要节流的函数
+ * @param wait 节流间隔（毫秒）
+ */
+export function throttle(fn, wait) {
+  var lastInvoke = 0;
+  var timer = null;
+  var invoke = function invoke() {
+    lastInvoke = Date.now();
+    timer = null;
+    fn();
+  };
+  var wrapped = function wrapped() {
+    var remaining = wait - (Date.now() - lastInvoke);
+    if (remaining <= 0) {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      invoke();
+    } else if (!timer) {
+      timer = setTimeout(invoke, remaining);
+    }
+  };
+  wrapped.cancel = function () {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    // 重置 leading 窗口，让下次调用立刻触发，避免跨 view 共享上次的节流窗口
+    lastInvoke = 0;
+  };
+  return wrapped;
+}

package/lib/index.d.ts

@@ -19,5 +19,7 @@ export * from './utils/trace';
 export * from './utils/verify';
 export * from './utils/url';
 export * from './utils/events';
+export * from './utils/throttle';
+export * from './utils/disposable';
 export * from './monitor';
 export { Client, Context, Reporter, Shell };

package/lib/index.js

@@ -135,6 +135,20 @@ Object.keys(_events).forEach(function (key) {
   if (key in exports && exports[key] === _events[key]) return;
   exports[key] = _events[key];
 });
+var _throttle = require("./utils/throttle");
+Object.keys(_throttle).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _throttle[key]) return;
+  exports[key] = _throttle[key];
+});
+var _disposable = require("./utils/disposable");
+Object.keys(_disposable).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _disposable[key]) return;
+  exports[key] = _disposable[key];
+});
 var _monitor = require("./monitor");
 Object.keys(_monitor).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/lib/model/client.d.ts

@@ -1,6 +1,6 @@
 import { IClient, IConfiguration, IContext, IRumSession } from '../types/client';
-import { IConfigManager } from "../types/config";
-import { RumEvent } from '../types/rum-event';
+import { IConfigManager } from '../types/config';
+import { RumEvent, SendEventOptions } from '../types/rum-event';
 import { IProcessor } from '../types/processor';
 import { ICollector } from '../types/collector';
 import { IReporter } from '../types/reporter';
@@ -12,7 +12,7 @@ declare class Client implements IClient {
     private reporter;
     private ctx;
     init(config: IConfiguration, rumSession?: IRumSession, configManager?: IConfigManager, monitorReporter?: IMonitorReporter): void;
-    sendEvent: (payload: RumEvent) => void;
+    sendEvent: (payload: RumEvent, options?: SendEventOptions) => void;
     setContext(ctx: IContext): void;
     getContext(): IContext;
     useCollectors(collectors: ICollector[]): void;

package/lib/model/client.js

@@ -19,8 +19,8 @@ var Client = /*#__PURE__*/function () {
     this.processors = void 0;
     this.reporter = void 0;
     this.ctx = void 0;
-    this.sendEvent = function (payload) {
-      _this.emitter.emit(_client.EventType.collect, payload);
+    this.sendEvent = function (payload, options) {
+      _this.emitter.emit(_client.EventType.collect, payload, options);
     };
   }
   var _proto = Client.prototype;
@@ -61,7 +61,7 @@ var Client = /*#__PURE__*/function () {
     });
 
     // collector 收集数据统一 push 到各匹配 processor
-    this.emitter.on(_client.EventType.collect, function (payload) {
+    this.emitter.on(_client.EventType.collect, function (payload, options) {
       ctx.setRumEvent(payload);
       for (var _iterator = _createForOfIteratorHelperLoose(processors), _step; !(_step = _iterator()).done;) {
         var processor = _step.value;
@@ -73,12 +73,12 @@ var Client = /*#__PURE__*/function () {
         }
         if (processor.match(ctx)) {
           var res = processor.process(ctx);
-          if (res) {
-            ctx.setRumEvent(res);
-          }
+          // 无论返回值是否为 falsy 都写回 context，
+          // 确保 processor 返回 null/undefined（丢弃事件）时能正确生效
+          ctx.setRumEvent(res);
         }
       }
-      reporter.report(ctx);
+      reporter.report(ctx, options);
     });
     collectors.forEach(function (collector) {
       collector.setup(ctx, _this2.sendEvent);

package/lib/model/reporter.d.ts

@@ -1,23 +1,46 @@
 import { IContext } from '../types/client';
-import { RumEvent, IViewData, RumEventBundle } from '../types/rum-event';
+import { RumEvent, IViewData, RumEventBundle, SendEventOptions } from '../types/rum-event';
+/**
+ * 抽象上报器，负责事件排队、批量打包与发送。
+ *
+ * 上报模式（通过 SendEventOptions 控制）：
+ * - 默认：事件进入队列，等待定时器或队列满后批量 flush
+ * - immediate：事件进入队列后立即 flush 整个队列
+ * - single：事件不进队列，独立打包立即上报
+ */
 export default abstract class Reporter {
     name: string;
-    /**
-     * 新上报事件优先检测队列是否超过 50 条，如果超过立即 report。
-     * 如果没超过则检测 FlushTime 内有无新上报事件，如果有新事件，重置 timer，无则 report
-     */
     protected eventQueue: RumEvent[];
     protected ctx: IContext;
     private timer;
     private _init;
     getReportCfg(): import("../types/client").IReportConfig;
-    report(ctx: IContext): void;
+    /**
+     * 上报入口，根据 options 决定上报策略：
+     * - single: 当前事件独立打包立即发送，不影响队列
+     * - immediate: 当前事件入队后立即 flush 整个队列
+     * - 默认: 当前事件入队，等待定时器或队列满后批量 flush
+     */
+    report(ctx: IContext, options?: SendEventOptions): void;
+    /**
+     * 当前事件独立打包上报，不进入批量队列，不重置队列定时器
+     */
+    private flushSingleEvent;
     private pushToQueue;
     /**
      * eventQueue 提取最新 View 作为公共 View，event 中不同 View Event 保留 View id
      */
     protected flushEventQueue(): void;
-    mergeEvent(ctx: IContext, events: RumEvent[], view: IViewData): void;
+    /**
+     * 按 session_id 分组事件并分别打包上报：
+     * - 当前 session 的事件统一打包
+     * - 非当前 session 的事件按各自 session_id 单独打包
+     */
+    protected dispatchEvents(ctx: IContext, events: RumEvent[], view: IViewData): void;
+    /**
+     * 构建 bundle 并发送请求
+     */
+    private buildAndSend;
     private tryRequest;
     /**
      * 接口请求由各平台 sdk reporter 实现

package/lib/model/reporter.js

@@ -15,13 +15,18 @@ var _url = require("../utils/url");
 var FLUSH_TIME = 3000;
 var MAX_EVENT_COUNT = 20;
 var attrs = ['app', 'user', 'device', 'os', 'geo', 'isp', 'net', 'properties'];
+
+/**
+ * 抽象上报器，负责事件排队、批量打包与发送。
+ *
+ * 上报模式（通过 SendEventOptions 控制）：
+ * - 默认：事件进入队列，等待定时器或队列满后批量 flush
+ * - immediate：事件进入队列后立即 flush 整个队列
+ * - single：事件不进队列，独立打包立即上报
+ */
 var Reporter = exports["default"] = /*#__PURE__*/function () {
   function Reporter() {
     this.name = 'reporter';
-    /**
-     * 新上报事件优先检测队列是否超过 50 条，如果超过立即 report。
-     * 如果没超过则检测 FlushTime 内有无新上报事件，如果有新事件，重置 timer，无则 report
-     */
     this.eventQueue = [];
     this.ctx = void 0;
     this.timer = void 0;
@@ -40,30 +45,62 @@ var Reporter = exports["default"] = /*#__PURE__*/function () {
       cfg.maxEventCount = MAX_EVENT_COUNT;
     }
     return cfg;
-  };
-  _proto.report = function report(ctx) {
+  }
+
+  /**
+   * 上报入口，根据 options 决定上报策略：
+   * - single: 当前事件独立打包立即发送，不影响队列
+   * - immediate: 当前事件入队后立即 flush 整个队列
+   * - 默认: 当前事件入队，等待定时器或队列满后批量 flush
+   */;
+  _proto.report = function report(ctx, options) {
     var _this = this;
     this.ctx = ctx;
     if (!this._init) {
       this.init(ctx);
       this._init = true;
     }
+
+    // single 优先级最高：当前事件单独上报，不影响队列
+    if (options && options.single) {
+      this.flushSingleEvent(ctx);
+      return;
+    }
     clearTimeout(this.timer);
     this.pushToQueue();
     var reportConfig = this.getReportCfg();
-    // 超过 MaxCount 直接 flush，否则延迟发送
-    if (this.eventQueue.length >= reportConfig.maxEventCount) {
+    if (options && options.immediate || this.eventQueue.length >= reportConfig.maxEventCount) {
       this.flushEventQueue();
     } else {
       this.timer = setTimeout(function () {
         _this.flushEventQueue();
       }, reportConfig.flushTime);
     }
+  }
+
+  /**
+   * 当前事件独立打包上报，不进入批量队列，不重置队列定时器
+   */;
+  _proto.flushSingleEvent = function flushSingleEvent(ctx) {
+    var _event$view;
+    var session = ctx.session;
+    var sampled = session ? session.getSampled() : true;
+    if (!sampled) return;
+    var event = ctx.getRumEvent();
+    if (!event) return;
+    var views = ctx.getViews();
+    var curView = views[views.length - 1];
+    if (((_event$view = event.view) === null || _event$view === void 0 ? void 0 : _event$view.id) === curView.id) {
+      delete event.view;
+    }
+    this.dispatchEvents(ctx, [event], curView);
   };
   _proto.pushToQueue = function pushToQueue() {
     var ctx = this.ctx,
       eventQueue = this.eventQueue;
     var event = ctx.getRumEvent();
+    // processor 返回 null/undefined 表示丢弃事件，直接跳过
+    if (!event) return;
 
     // 针对相同 event，做 times 合并
     // todo，支持其他类型 event 合并
@@ -121,8 +158,8 @@ var Reporter = exports["default"] = /*#__PURE__*/function () {
     views.forEach(function (view) {
       if (view.id === curView.id) {
         var events = eventQueue.filter(function (event) {
-          var _event$view;
-          return ((_event$view = event.view) === null || _event$view === void 0 ? void 0 : _event$view.id) === view.id;
+          var _event$view2;
+          return ((_event$view2 = event.view) === null || _event$view2 === void 0 ? void 0 : _event$view2.id) === view.id;
         });
         events.forEach(function (event) {
           delete event.view;
@@ -131,28 +168,49 @@ var Reporter = exports["default"] = /*#__PURE__*/function () {
     });
     var session = ctx.session;
     var sampled = session ? session.getSampled() : true;
-    sampled && this.mergeEvent(ctx, eventQueue, curView);
+    sampled && this.dispatchEvents(ctx, eventQueue, curView);
     this.eventQueue = [];
-  };
-  _proto.mergeEvent = function mergeEvent(ctx, events, view) {
+  }
+
+  /**
+   * 按 session_id 分组事件并分别打包上报：
+   * - 当前 session 的事件统一打包
+   * - 非当前 session 的事件按各自 session_id 单独打包
+   */;
+  _proto.dispatchEvents = function dispatchEvents(ctx, events, view) {
     var config = ctx.getConfig();
     var session = ctx.session;
     var sessionId = session.getSessionId();
-    // events.forEach(event => {
-    //   if (event.session_id === sessionId) {
-    //     delete event.session_id;
-    //   }
-    // });
+    var currentSessionEvents = [];
+    var otherSessionEventsMap = {};
     for (var i = 0; i < events.length; i++) {
       var e = events[i];
-      if (e.session_id === sessionId) {
+      if (!e.session_id || e.session_id === sessionId) {
         delete e.session_id;
+        currentSessionEvents.push(e);
       } else {
-        events.splice(i, 1);
-        i--;
+        var sid = e.session_id;
+        if (!otherSessionEventsMap[sid]) {
+          otherSessionEventsMap[sid] = [];
+        }
+        delete e.session_id;
+        otherSessionEventsMap[sid].push(e);
       }
     }
-    if (events.length === 0) return;
+    if (currentSessionEvents.length > 0) {
+      this.buildAndSend(ctx, config, session, sessionId, currentSessionEvents, view);
+    }
+    var otherSessionIds = Object.keys(otherSessionEventsMap);
+    for (var _i = 0; _i < otherSessionIds.length; _i++) {
+      var _sid = otherSessionIds[_i];
+      this.buildAndSend(ctx, config, session, _sid, otherSessionEventsMap[_sid], view);
+    }
+  }
+
+  /**
+   * 构建 bundle 并发送请求
+   */;
+  _proto.buildAndSend = function buildAndSend(ctx, config, session, sessionId, events, view) {
     var extend = (0, _url.getUrlParams)(config.endpoint);
     var bundle = (0, _extends2["default"])({
       app: {

package/lib/model/shell.d.ts

@@ -1,6 +1,6 @@
-import { IClient, IConfiguration } from "../types/client";
-import { RumCustomEvent, RumEvent, RumExceptionEvent, RumResourceEvent, RumViewEvent } from "../types/rum-event";
-import { IShell } from "../types/shell";
+import { IClient, IConfiguration } from '../types/client';
+import { RumCustomEvent, RumEvent, RumExceptionEvent, RumResourceEvent, RumViewEvent, SendEventOptions } from '../types/rum-event';
+import { IShell } from '../types/shell';
 export default abstract class Shell implements IShell {
     client: IClient;
     constructor(config?: IConfiguration);
@@ -8,7 +8,7 @@ export default abstract class Shell implements IShell {
      * 初始化
      */
     abstract init(configuration: IConfiguration): Promise<Shell> | Shell;
-    sendEvent(payload: RumEvent): void;
+    sendEvent(payload: RumEvent, options?: SendEventOptions): void;
     /**
      * get config
      */

package/lib/model/shell.js

@@ -40,9 +40,9 @@ var Shell = exports["default"] = /*#__PURE__*/function () {
    * 初始化
    */
   var _proto = Shell.prototype;
-  _proto.sendEvent = function sendEvent(payload) {
+  _proto.sendEvent = function sendEvent(payload, options) {
     if (this.client) {
-      this.client.sendEvent(payload);
+      this.client.sendEvent(payload, options);
     }
   }
 
@@ -69,10 +69,11 @@ var Shell = exports["default"] = /*#__PURE__*/function () {
       event_type: _rumEvent.RumEventType.CUSTOM
     });
     this.sendEvent(data);
-  };
+  }
+
   /**
    * 自定义视图上报
-   */
+   */;
   _proto.sendView = function sendView(payload) {
     if (!(0, _is.isObject)(payload)) {
       return;
@@ -94,10 +95,11 @@ var Shell = exports["default"] = /*#__PURE__*/function () {
       event_type: _rumEvent.RumEventType.VIEW
     });
     this.sendEvent(data);
-  };
+  }
+
   /**
    * 自定义异常上报
-   */
+   */;
   _proto.sendException = function sendException(payload) {
     if (!payload.name || !payload.message) {
       return;
@@ -116,10 +118,11 @@ var Shell = exports["default"] = /*#__PURE__*/function () {
       source: 'custom'
     });
     this.sendEvent(data);
-  };
+  }
+
   /**
    * 自定义资源上报
-   */
+   */;
   _proto.sendResource = function sendResource(payload) {
     if (!payload.name || !payload.type || !(0, _is.isNumber)(payload.duration)) {
       return;

package/lib/types/client.d.ts

@@ -1,7 +1,7 @@
 import { ICollector } from './collector';
 import { IProcessor } from './processor';
 import { IReporter } from './reporter';
-import { RumEvent, RumEventBundle, IViewData } from './rum-event';
+import { RumEvent, RumEventBundle, IViewData, SendEventOptions } from './rum-event';
 import { MatchOption } from '../utils/match';
 import { IConfigManager } from './config';
 import { EventEmitter } from '../utils/events';
@@ -119,7 +119,7 @@ export interface IClient {
     /**
      * 业务自定义上传数据
      */
-    sendEvent(payload: RumEvent): void;
+    sendEvent(payload: RumEvent, options?: SendEventOptions): void;
     /**
      * 修改运行时上下文
      */

package/lib/types/collector.d.ts

@@ -1,7 +1,7 @@
 import { IContext } from './client';
-import { RumEvent } from './rum-event';
+import { SendEventFn } from './rum-event';
 export interface ICollector {
     name: string;
-    setup(ctx: IContext, sendEvent: (payload: RumEvent) => void): void;
+    setup(ctx: IContext, sendEvent: SendEventFn): void;
     destroy?(): void;
 }

package/lib/types/reporter.d.ts

@@ -1,8 +1,8 @@
 import { IContext } from './client';
-import { RumEventBundle } from './rum-event';
+import { RumEventBundle, SendEventOptions } from './rum-event';
 export interface IReporter {
     name: string;
     init(ctx: IContext): void;
     request(ctx: IContext, bundle: RumEventBundle): void;
-    report(ctx: IContext): void;
+    report(ctx: IContext, options?: SendEventOptions): void;
 }

package/lib/types/rum-event.d.ts

@@ -7,6 +7,15 @@ export declare enum RumEventType {
     CUSTOM = "custom",
     APPLICATION = "application"
 }
+/** sendEvent 方法的可选配置 */
+export interface SendEventOptions {
+    /** 是否立即上报，将当前事件加入队列后立即 flush 整个队列 */
+    immediate?: boolean;
+    /** 是否单独上报，当前事件不入队列，独立打包发送 */
+    single?: boolean;
+}
+/** 采集器向上层发送事件的统一回调签名 */
+export type SendEventFn = (payload: RumEvent, options?: SendEventOptions) => void;
 export interface BaseObject {
     [key: string]: BaseObjectValue;
 }

package/lib/types/rum-event.js

@@ -12,6 +12,8 @@ var RumEventType = exports.RumEventType = /*#__PURE__*/function (RumEventType) {
   RumEventType["APPLICATION"] = "application";
   return RumEventType;
 }({});
+/** sendEvent 方法的可选配置 */
+/** 采集器向上层发送事件的统一回调签名 */
 /** 电池信息 */
 /** 设备信息 */
 /** 内存信息 */

package/lib/types/shell.d.ts

@@ -1,5 +1,5 @@
-import { IConfiguration } from "./client";
-import { RumEvent } from "./rum-event";
+import { IConfiguration } from './client';
+import { RumEvent, SendEventOptions } from './rum-event';
 /**
  * 每个 sdk shell 导出固定需要实现的基础 api
  * 对外导出 shell 层, 所有 shell 层模型的 API 设计约定：
@@ -15,7 +15,7 @@ export interface IShell {
     /**
      * 自定义上传数据
      */
-    sendEvent(payload: RumEvent): void;
+    sendEvent(payload: RumEvent, options?: SendEventOptions): void;
     /**
      * get config
      */