@arms/rum-core 0.1.5 → 0.1.7

package/lib/model/client.d.ts

@@ -1,17 +1,18 @@
 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';
+import { IMonitorReporter } from '../monitor/types';
 declare class Client implements IClient {
     private emitter;
     private collectors;
     private processors;
     private reporter;
     private ctx;
-    init(config: IConfiguration, rumSession?: IRumSession, configManager?: IConfigManager): void;
-    sendEvent: (payload: RumEvent) => void;
+    init(config: IConfiguration, rumSession?: IRumSession, configManager?: IConfigManager, monitorReporter?: IMonitorReporter): void;
+    sendEvent: (payload: RumEvent, options?: SendEventOptions) => void;
     setContext(ctx: IContext): void;
     getContext(): IContext;
     useCollectors(collectors: ICollector[]): void;

package/lib/model/client.js

@@ -5,6 +5,7 @@ exports.__esModule = true;
 exports["default"] = void 0;
 var _client = require("../types/client");
 var _events = require("../utils/events");
+var _telemetry = require("../monitor/telemetry");
 var _context = _interopRequireDefault(require("./context"));
 var _is = require("../utils/is");
 function _createForOfIteratorHelperLoose(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (t) return (t = t.call(r)).next.bind(t); if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var o = 0; return function () { return o >= r.length ? { done: !0 } : { done: !1, value: r[o++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
@@ -18,14 +19,39 @@ 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;
-  _proto.init = function init(config, rumSession, configManager) {
+  _proto.init = function init(config, rumSession, configManager, monitorReporter) {
     var _this2 = this;
     this.ctx = new _context["default"](config, rumSession, configManager);
+
+    // Telemetry 初始化 —— 统一在 Core 中完成，各平台仅需传入 reporter
+    if (monitorReporter) {
+      var telemetryConfig = {
+        appType: (rumSession === null || rumSession === void 0 ? void 0 : rumSession.appType) || '',
+        sdkVersion: (rumSession === null || rumSession === void 0 ? void 0 : rumSession.sdkVersion) || '',
+        endpoint: config.endpoint,
+        getSessionId: rumSession ? function () {
+          return rumSession.getSessionId();
+        } : undefined,
+        getSessionSampled: rumSession ? function () {
+          return rumSession.getSampled();
+        } : undefined,
+        getViewId: function getViewId() {
+          var _this2$ctx;
+          var views = (_this2$ctx = _this2.ctx) === null || _this2$ctx === void 0 ? void 0 : _this2$ctx.getViews();
+          return views && views.length ? views[views.length - 1].id : undefined;
+        },
+        selfMonitor: config.selfMonitor
+      };
+      if (config.pid) {
+        telemetryConfig['app.id'] = config.pid;
+      }
+      _telemetry.Telemetry.init(telemetryConfig, monitorReporter);
+    }
     var ctx = this.ctx,
       collectors = this.collectors,
       processors = this.processors,
@@ -35,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;
@@ -52,7 +78,7 @@ var Client = /*#__PURE__*/function () {
           }
         }
       }
-      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

@@ -6,6 +6,7 @@ exports["default"] = void 0;
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _logger = require("../monitor/logger");
 var _rumEvent = require("../types/rum-event");
 var _exception = require("../utils/exception");
 var _is = require("../utils/is");
@@ -14,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;
@@ -39,25 +45,54 @@ 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();
+    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,
@@ -120,8 +155,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;
@@ -130,28 +165,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: {
@@ -222,6 +278,8 @@ var Reporter = exports["default"] = /*#__PURE__*/function () {
               setTimeout(function () {
                 return _this2.tryRequest(bundle, retry + 1);
               }, retryDelay);
+            } else {
+              _logger.logger.error('reporter', "Request failed after " + (retry + 1) + " attempts", _t);
             }
           case 4:
           case "end":

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/monitor/index.d.ts

@@ -0,0 +1,6 @@
+export { logger, callMonitored } from './logger';
+export type { ILogger } from './logger';
+export { Telemetry, convertBundlesToLogGroup } from './telemetry';
+export type { TelemetryContext } from './telemetry';
+export type { MonitorLogEvent, MonitorLogLevel, MonitorEventBundle, IMonitorReporter, ISelfMonitorConfig } from './types';
+export { encodeLogGroup } from '../utils/protobuf';

package/lib/monitor/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+exports.__esModule = true;
+exports.logger = exports.encodeLogGroup = exports.convertBundlesToLogGroup = exports.callMonitored = exports.Telemetry = void 0;
+var _logger = require("./logger");
+exports.logger = _logger.logger;
+exports.callMonitored = _logger.callMonitored;
+var _telemetry = require("./telemetry");
+exports.Telemetry = _telemetry.Telemetry;
+exports.convertBundlesToLogGroup = _telemetry.convertBundlesToLogGroup;
+var _protobuf = require("../utils/protobuf");
+exports.encodeLogGroup = _protobuf.encodeLogGroup;

package/lib/monitor/logger.d.ts

@@ -0,0 +1,34 @@
+import { MonitorLogEvent, MonitorLogLevel } from './types';
+type LogArgs = [module: string, message: string, error?: unknown, context?: Record<string, unknown>];
+export interface ILogger {
+    debug(...args: LogArgs): void;
+    info(...args: LogArgs): void;
+    warn(...args: LogArgs): void;
+    error(...args: LogArgs): void;
+    crash(...args: LogArgs): void;
+}
+declare class Logger implements ILogger {
+    private console;
+    private reportLevels;
+    private onError?;
+    setConsole(enabled: boolean): void;
+    setReportLevels(levels: MonitorLogLevel[]): void;
+    setOnError(handler?: (event: MonitorLogEvent) => void): void;
+    debug(...args: LogArgs): void;
+    info(...args: LogArgs): void;
+    warn(...args: LogArgs): void;
+    error(...args: LogArgs): void;
+    crash(...args: LogArgs): void;
+    private log;
+    /**
+     * 函数包装器 — 用于箭头函数属性
+     * 用法: private handler = logger.wrap((e) => {...}, 'module', 'message?')
+     */
+    wrap<T extends (...args: any[]) => unknown>(fn: T, module: string, message?: string): T;
+}
+export declare const logger: Logger;
+/**
+ * 执行被监控函数，异常时自动上报
+ */
+export declare function callMonitored<T extends (...args: any[]) => unknown>(fn: T, context?: any, args?: any, module?: string, message?: string): ReturnType<T> | undefined;
+export {};

package/lib/monitor/logger.js

@@ -0,0 +1,117 @@
+"use strict";
+
+exports.__esModule = true;
+exports.callMonitored = callMonitored;
+exports.logger = void 0;
+var DEFAULT_REPORT_LEVELS = ['debug', 'error', 'crash'];
+var Logger = /*#__PURE__*/function () {
+  function Logger() {
+    this.console = false;
+    this.reportLevels = DEFAULT_REPORT_LEVELS;
+    this.onError = void 0;
+  }
+  var _proto = Logger.prototype;
+  _proto.setConsole = function setConsole(enabled) {
+    this.console = enabled;
+  };
+  _proto.setReportLevels = function setReportLevels(levels) {
+    this.reportLevels = levels;
+  };
+  _proto.setOnError = function setOnError(handler) {
+    this.onError = handler;
+  };
+  _proto.debug = function debug() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    this.log('debug', args);
+  };
+  _proto.info = function info() {
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    this.log('info', args);
+  };
+  _proto.warn = function warn() {
+    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+      args[_key3] = arguments[_key3];
+    }
+    this.log('warn', args);
+  };
+  _proto.error = function error() {
+    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+      args[_key4] = arguments[_key4];
+    }
+    this.log('error', args);
+  };
+  _proto.crash = function crash() {
+    for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+      args[_key5] = arguments[_key5];
+    }
+    this.log('crash', args);
+  };
+  _proto.log = function log(level, _ref) {
+    var _this$onError;
+    var module = _ref[0],
+      message = _ref[1],
+      error = _ref[2],
+      context = _ref[3];
+    if (this.console) {
+      var consoleFn = level === 'crash' ? 'error' : level === 'debug' ? 'log' : level;
+      console[consoleFn]("[RUM-SDK][" + module + "]", message, error || '');
+    }
+
+    // 仅上报配置中指定的级别
+    if (!this.reportLevels.includes(level)) return;
+    var stack;
+    if (error instanceof Error) {
+      stack = error.stack;
+    } else if (error && typeof error === 'object' && 'stack' in error) {
+      stack = String(error.stack);
+    }
+
+    // 截断过长的 stack（与 content 同等 12KB 上限）
+    if (stack && stack.length > 12288) {
+      stack = stack.slice(0, 12288);
+    }
+    (_this$onError = this.onError) === null || _this$onError === void 0 ? void 0 : _this$onError.call(this, Object.assign({
+      level: level,
+      content: message,
+      type: module,
+      stack: stack
+    }, context));
+  }
+
+  /**
+   * 函数包装器 — 用于箭头函数属性
+   * 用法: private handler = logger.wrap((e) => {...}, 'module', 'message?')
+   */;
+  _proto.wrap = function wrap(fn, module, message) {
+    return function () {
+      for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
+        args[_key6] = arguments[_key6];
+      }
+      return callMonitored(fn, this, args, module, message);
+    };
+  };
+  return Logger;
+}();
+var logger = exports.logger = new Logger();
+
+/**
+ * 执行被监控函数，异常时自动上报
+ */
+function callMonitored(fn, context, args, module, message) {
+  try {
+    var result = fn.apply(context, args);
+    // 检测 async 函数返回的 Promise，附加 .catch 处理
+    if (result && typeof result["catch"] === 'function') {
+      result["catch"](function (e) {
+        logger.error(module || 'unknown', message || (e instanceof Error ? e.message : String(e)), e);
+      });
+    }
+    return result;
+  } catch (e) {
+    logger.error(module || 'unknown', message || (e instanceof Error ? e.message : String(e)), e);
+  }
+}

package/lib/monitor/telemetry.d.ts

@@ -0,0 +1,42 @@
+import { MonitorLogEvent, MonitorEventBundle, IMonitorReporter, ISelfMonitorConfig } from './types';
+export interface TelemetryContext {
+    appType: string;
+    sdkVersion: string;
+    endpoint: string;
+    getSessionId?: () => string | undefined;
+    getViewId?: () => string | undefined;
+    getSessionSampled?: () => boolean;
+    /** 自监控配置 */
+    selfMonitor?: ISelfMonitorConfig | boolean;
+    [key: string]: unknown;
+}
+export declare class Telemetry {
+    private static instance;
+    static init(context: TelemetryContext, reporter?: IMonitorReporter): Telemetry;
+    static get(): Telemetry | undefined;
+    private buffer;
+    private queue;
+    private sentEvents;
+    private started;
+    private enabled;
+    private sampled;
+    private timer;
+    private reporter?;
+    private context;
+    private isReporting;
+    private endpointParams;
+    constructor(context: TelemetryContext, reporter?: IMonitorReporter);
+    private start;
+    addEvent(event: MonitorLogEvent): void;
+    flush(): void;
+    setReporter(reporter: IMonitorReporter): void;
+    private flushBuffer;
+    private processSnapshot;
+    private shouldSend;
+    private buildBundle;
+    private sendBatch;
+}
+/**
+ * 将 MonitorEventBundle 数组转换并编码为 SLS LogGroup Protobuf 格式
+ */
+export declare function convertBundlesToLogGroup(data: MonitorEventBundle[]): Uint8Array;