@arms/rum-core 0.1.5 → 0.1.6

package/es/utils/protobuf.js

@@ -0,0 +1,123 @@
+/**
+ * SLS LogGroup Protobuf 编码器（最小化实现，零外部依赖）
+ *
+ * Schema:
+ *   message Log {
+ *     required uint32 Time = 1;
+ *     message Content { required string Key = 1; required string Value = 2; }
+ *     repeated Content Contents = 2;
+ *   }
+ *   message LogTag { required string Key = 1; required string Value = 2; }
+ *   message LogGroup {
+ *     repeated Log Logs = 1;
+ *     optional string Topic = 3;
+ *     optional string Source = 4;
+ *     repeated LogTag LogTags = 6;
+ *   }
+ */
+
+var WIRE_TYPE_VARINT = 0;
+var WIRE_TYPE_LEN = 2;
+
+/**
+ * UTF-8 编码 fallback（当 TextEncoder 不可用时使用，如部分小程序环境）
+ */
+function encodeUtf8Fallback(str) {
+  var bytes = [];
+  for (var i = 0; i < str.length; i++) {
+    var charCode = str.charCodeAt(i);
+    if (charCode < 0x80) {
+      bytes.push(charCode);
+    } else if (charCode < 0x800) {
+      bytes.push(0xc0 | charCode >> 6);
+      bytes.push(0x80 | charCode & 0x3f);
+    } else if (charCode >= 0xd800 && charCode <= 0xdbff) {
+      // 代理对处理
+      i++;
+      var low = str.charCodeAt(i);
+      charCode = 0x10000 + (charCode - 0xd800 << 10) + (low - 0xdc00);
+      bytes.push(0xf0 | charCode >> 18);
+      bytes.push(0x80 | charCode >> 12 & 0x3f);
+      bytes.push(0x80 | charCode >> 6 & 0x3f);
+      bytes.push(0x80 | charCode & 0x3f);
+    } else {
+      bytes.push(0xe0 | charCode >> 12);
+      bytes.push(0x80 | charCode >> 6 & 0x3f);
+      bytes.push(0x80 | charCode & 0x3f);
+    }
+  }
+  return new Uint8Array(bytes);
+}
+var utf8Encoder = typeof TextEncoder !== 'undefined' ? new TextEncoder() : {
+  encode: encodeUtf8Fallback
+};
+var ProtobufWriter = /*#__PURE__*/function () {
+  function ProtobufWriter() {
+    this.buf = [];
+  }
+  var _proto = ProtobufWriter.prototype;
+  _proto.writeVarint = function writeVarint(value) {
+    // Base-128 可变长整数编码（仅处理非负整数）
+    var v = value >>> 0;
+    while (v > 0x7f) {
+      this.buf.push(v & 0x7f | 0x80);
+      v = v >>> 7;
+    }
+    this.buf.push(v & 0x7f);
+  };
+  _proto.writeTag = function writeTag(fieldNumber, wireType) {
+    this.writeVarint(fieldNumber << 3 | wireType);
+  };
+  _proto.writeString = function writeString(fieldNumber, value) {
+    var bytes = utf8Encoder.encode(value);
+    this.writeTag(fieldNumber, WIRE_TYPE_LEN);
+    this.writeVarint(bytes.length);
+    for (var i = 0; i < bytes.length; i++) {
+      this.buf.push(bytes[i]);
+    }
+  };
+  _proto.writeUint32 = function writeUint32(fieldNumber, value) {
+    this.writeTag(fieldNumber, WIRE_TYPE_VARINT);
+    this.writeVarint(value);
+  };
+  _proto.writeBytes = function writeBytes(fieldNumber, data) {
+    this.writeTag(fieldNumber, WIRE_TYPE_LEN);
+    this.writeVarint(data.length);
+    for (var i = 0; i < data.length; i++) {
+      this.buf.push(data[i]);
+    }
+  };
+  _proto.finish = function finish() {
+    return new Uint8Array(this.buf);
+  };
+  return ProtobufWriter;
+}();
+function encodeContent(key, value) {
+  var w = new ProtobufWriter();
+  w.writeString(1, key);
+  w.writeString(2, value);
+  return w.finish();
+}
+function encodeLog(time, contents) {
+  var w = new ProtobufWriter();
+  w.writeUint32(1, time);
+  for (var i = 0; i < contents.length; i++) {
+    var c = contents[i];
+    w.writeBytes(2, encodeContent(c.key, c.value));
+  }
+  return w.finish();
+}
+export function encodeLogGroup(logs, topic, source) {
+  var w = new ProtobufWriter();
+  for (var i = 0; i < logs.length; i++) {
+    var log = logs[i];
+    w.writeBytes(1, encodeLog(log.time, log.contents));
+  }
+  if (topic !== undefined) {
+    w.writeString(3, topic);
+  }
+  if (source !== undefined) {
+    w.writeString(4, source);
+  }
+  return w.finish();
+}

package/lib/index.d.ts

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

package/lib/index.js

@@ -134,4 +134,11 @@ Object.keys(_events).forEach(function (key) {
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   if (key in exports && exports[key] === _events[key]) return;
   exports[key] = _events[key];
+});
+var _monitor = require("./monitor");
+Object.keys(_monitor).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _monitor[key]) return;
+  exports[key] = _monitor[key];
 });

package/lib/model/client.d.ts

@@ -4,13 +4,14 @@ import { RumEvent } 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;
+    init(config: IConfiguration, rumSession?: IRumSession, configManager?: IConfigManager, monitorReporter?: IMonitorReporter): void;
     sendEvent: (payload: RumEvent) => void;
     setContext(ctx: IContext): void;
     getContext(): IContext;

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."); }
@@ -23,9 +24,34 @@ var Client = /*#__PURE__*/function () {
     };
   }
   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,

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");
@@ -222,6 +223,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/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;

package/lib/monitor/telemetry.js

@@ -0,0 +1,214 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.Telemetry = void 0;
+exports.convertBundlesToLogGroup = convertBundlesToLogGroup;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _logger = require("./logger");
+var _url = require("../utils/url");
+var _protobuf = require("../utils/protobuf");
+var _number = require("../utils/number");
+var _Telemetry;
+var MAX_EVENTS_PER_PAGE = 15;
+var BUFFER_SIZE = 100;
+var LOG_CONTENT_MAX_SIZE = 12288;
+var FLUSH_TIME = 5000;
+var MAX_BATCH_SIZE = 10;
+var DEFAULT_SAMPLE_RATE = 100;
+
+/** 事件快照：在事件产生时就捕获上下文 */
+var Telemetry = exports.Telemetry = /*#__PURE__*/function () {
+  function Telemetry(context, reporter) {
+    this.buffer = [];
+    this.queue = [];
+    this.sentEvents = new Set();
+    this.started = false;
+    this.enabled = true;
+    this.sampled = void 0;
+    this.timer = null;
+    this.reporter = void 0;
+    this.context = void 0;
+    this.isReporting = false;
+    this.endpointParams = void 0;
+    this.context = context;
+    this.reporter = reporter;
+    this.endpointParams = (0, _url.getUrlParams)(context.endpoint);
+
+    // 解析自监控配置
+    var selfMonitor = context.selfMonitor;
+    if (typeof selfMonitor === 'boolean') {
+      this.enabled = selfMonitor;
+      this.sampled = (0, _number.performDraw)(DEFAULT_SAMPLE_RATE);
+    } else if (selfMonitor && typeof selfMonitor === 'object') {
+      this.enabled = selfMonitor.enable !== false;
+      var rate = selfMonitor.sampling;
+      this.sampled = (0, _number.performDraw)(typeof rate === 'number' && rate >= 0 && rate <= 100 ? rate : DEFAULT_SAMPLE_RATE);
+      if (selfMonitor.console) {
+        _logger.logger.setConsole(true);
+      }
+      if (selfMonitor.reportLevels) {
+        _logger.logger.setReportLevels(selfMonitor.reportLevels);
+      }
+    } else {
+      this.enabled = true;
+      this.sampled = (0, _number.performDraw)(DEFAULT_SAMPLE_RATE);
+    }
+  }
+  Telemetry.init = function init(context, reporter) {
+    if (Telemetry.instance) {
+      Telemetry.instance.flush();
+    }
+    Telemetry.instance = new Telemetry(context, reporter);
+    Telemetry.instance.start();
+    return Telemetry.instance;
+  };
+  Telemetry.get = function get() {
+    return Telemetry.instance;
+  };
+  var _proto = Telemetry.prototype;
+  _proto.start = function start() {
+    var _this = this;
+    if (this.started) return;
+    this.started = true;
+    _logger.logger.setOnError(function (event) {
+      return _this.addEvent(event);
+    });
+    this.flushBuffer();
+  };
+  _proto.addEvent = function addEvent(event) {
+    var _this$context$getSess, _this$context, _this$context$getView, _this$context2;
+    if (!this.enabled || !event) return;
+    if (event.content && event.content.length > LOG_CONTENT_MAX_SIZE) {
+      event = (0, _extends2["default"])({}, event, {
+        content: event.content.slice(0, LOG_CONTENT_MAX_SIZE)
+      });
+    }
+    if (event.stack && event.stack.length > LOG_CONTENT_MAX_SIZE) {
+      event = (0, _extends2["default"])({}, event, {
+        stack: event.stack.slice(0, LOG_CONTENT_MAX_SIZE)
+      });
+    }
+
+    // 在事件产生时就捕获快照
+    var snapshot = {
+      event: event,
+      sessionId: (_this$context$getSess = (_this$context = this.context).getSessionId) === null || _this$context$getSess === void 0 ? void 0 : _this$context$getSess.call(_this$context),
+      viewId: (_this$context$getView = (_this$context2 = this.context).getViewId) === null || _this$context$getView === void 0 ? void 0 : _this$context$getView.call(_this$context2),
+      timestamp: Date.now()
+    };
+    if (!this.started || !this.reporter) {
+      if (this.buffer.length < BUFFER_SIZE) {
+        this.buffer.push(snapshot);
+      }
+      return;
+    }
+    this.processSnapshot(snapshot);
+  };
+  _proto.flush = function flush() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.sendBatch();
+  };
+  _proto.setReporter = function setReporter(reporter) {
+    this.reporter = reporter;
+    if (this.started) {
+      this.flushBuffer();
+    }
+  };
+  _proto.flushBuffer = function flushBuffer() {
+    var _this2 = this;
+    var buffered = this.buffer.splice(0);
+    buffered.forEach(function (snapshot) {
+      return _this2.processSnapshot(snapshot);
+    });
+  };
+  _proto.processSnapshot = function processSnapshot(snapshot) {
+    var _this3 = this;
+    if (!this.shouldSend(snapshot.event)) return;
+    var bundle = this.buildBundle(snapshot);
+    this.queue.push(bundle);
+    if (this.queue.length >= MAX_BATCH_SIZE) {
+      this.flush();
+    } else if (!this.timer) {
+      this.timer = setTimeout(function () {
+        return _this3.flush();
+      }, FLUSH_TIME);
+    }
+  };
+  _proto.shouldSend = function shouldSend(event) {
+    // 先检查 Session 采样，未命中则不上报
+    if (this.context.getSessionSampled && !this.context.getSessionSampled()) return false;
+    // 再检查自监控自身采样
+    if (!this.sampled) return false;
+    if (this.sentEvents.size >= MAX_EVENTS_PER_PAGE) return false;
+    var key = (event.content || '') + (event.stack || '');
+    if (this.sentEvents.has(key)) return false;
+    this.sentEvents.add(key);
+    return true;
+  };
+  _proto.buildBundle = function buildBundle(snapshot) {
+    var _this$context3 = this.context,
+      appType = _this$context3.appType,
+      sdkVersion = _this$context3.sdkVersion,
+      endpoint = _this$context3.endpoint;
+    return (0, _extends2["default"])({
+      'app.type': appType,
+      _v: sdkVersion,
+      endpoint: endpoint,
+      'session.id': snapshot.sessionId,
+      'view.id': snapshot.viewId,
+      timestamp: snapshot.timestamp,
+      event_type: 'log',
+      log: snapshot.event
+    }, this.endpointParams);
+  };
+  _proto.sendBatch = function sendBatch() {
+    if (this.queue.length === 0 || !this.reporter) return;
+    if (this.isReporting) return;
+    var batch = this.queue.splice(0);
+    this.isReporting = true;
+    try {
+      this.reporter.send(batch);
+    } catch (e) {
+      // 不通过 logger（避免反馈循环），直接 console 仅供开发调试
+      try {
+        console.warn('[RUM-Telemetry] send failed:', e);
+      } catch (_) {}
+    } finally {
+      this.isReporting = false;
+    }
+  };
+  return Telemetry;
+}();
+/**
+ * 将 MonitorEventBundle 数组转换并编码为 SLS LogGroup Protobuf 格式
+ */
+_Telemetry = Telemetry;
+Telemetry.instance = void 0;
+function convertBundlesToLogGroup(data) {
+  var logs = data.map(function (bundle) {
+    var contents = [];
+
+    // 遍历 bundle 顶层字段，跳过 timestamp（映射到 time），对象类型整体序列化
+    for (var _i = 0, _Object$entries = Object.entries(bundle); _i < _Object$entries.length; _i++) {
+      var _Object$entries$_i = _Object$entries[_i],
+        _key = _Object$entries$_i[0],
+        val = _Object$entries$_i[1];
+      if (_key === 'timestamp') continue;
+      if (val !== undefined && val !== null) {
+        contents.push({
+          key: _key,
+          value: typeof val === 'object' ? JSON.stringify(val) : String(val)
+        });
+      }
+    }
+    return {
+      time: Math.floor(bundle.timestamp / 1000),
+      contents: contents
+    };
+  });
+  return (0, _protobuf.encodeLogGroup)(logs);
+}