@arms/rum-core 0.1.4 → 0.1.6

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":
@@ -237,7 +240,7 @@ var Reporter = exports["default"] = /*#__PURE__*/function () {
   /**
    * 接口请求由各平台 sdk reporter 实现
    */
-  ;
+;
   /**
    * 初始化时
    */

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);
+}

package/lib/monitor/types.d.ts

@@ -0,0 +1,46 @@
+export type MonitorLogLevel = 'debug' | 'info' | 'warn' | 'error' | 'crash';
+export interface MonitorLogEvent {
+    level: MonitorLogLevel;
+    content: string;
+    stack?: string;
+    type?: string;
+    [key: string]: unknown;
+}
+export interface MonitorEventBundle {
+    'app.type': string;
+    _v: string;
+    endpoint: string;
+    'session.id'?: string;
+    'view.id'?: string;
+    timestamp: number;
+    event_type: 'log';
+    log?: MonitorLogEvent;
+    [key: string]: unknown;
+}
+export interface IMonitorReporter {
+    send(data: MonitorEventBundle[]): void;
+}
+/**
+ * 自监控配置
+ */
+export interface ISelfMonitorConfig {
+    /**
+     * 是否启用自监控，默认 true
+     */
+    enable?: boolean;
+    /**
+     * 采样率，取值范围 0 - 100，支持小数（如 50.5 表示 50.5%）
+     * 所有级别日志统一受采样率控制
+     */
+    sampling?: number;
+    /**
+     * 是否在浏览器控制台输出自监控日志，默认 false
+     * 设为 true 时，所有级别日志会同时输出到控制台
+     */
+    console?: boolean;
+    /**
+     * 需要上报到 Telemetry 的日志级别列表
+     * 默认值: ['debug', 'error', 'crash']
+     */
+    reportLevels?: MonitorLogLevel[];
+}

package/lib/monitor/types.js

@@ -0,0 +1,3 @@
+"use strict";
+
+exports.__esModule = true;

package/lib/types/client.d.ts

@@ -5,6 +5,7 @@ import { RumEvent, RumEventBundle, IViewData } from './rum-event';
 import { MatchOption } from '../utils/match';
 import { IConfigManager } from './config';
 import { EventEmitter } from '../utils/events';
+import { ISelfMonitorConfig, IMonitorReporter } from '../monitor/types';
 export declare enum EventType {
     /**
      * 收集数据
@@ -33,7 +34,15 @@ export interface IContext {
     [key: string]: any;
 }
 export interface SessionConfig {
+    /**
+     * Session 采样率，取值范围 0 - 1 的小数
+     * @deprecated 该字段将在未来版本下线，请使用 {@link SessionConfig.sampling} 替代
+     */
     sampleRate?: number;
+    /**
+     * Session 采样率，取值范围 0 - 100，支持小数（如 50.5 表示 50.5%）
+     */
+    sampling?: number;
     maxDuration?: number;
     overtime?: number;
     storage?: string;
@@ -46,6 +55,10 @@ export interface IReportConfig {
 }
 export interface IRumSession {
     init(ctx: IContext): void;
+    /** 平台类型标识，如 'browser'/'miniapp' */
+    appType: string;
+    /** SDK 版本号 */
+    sdkVersion: string;
     sessionConfig: SessionConfig;
     getSessionId: () => string;
     getSampled: () => boolean;
@@ -102,7 +115,7 @@ export interface IClient {
     /**
      * 初始化
      */
-    init: (configuration: IConfiguration, rumSession?: IRumSession, configManager?: IConfigManager) => void;
+    init: (configuration: IConfiguration, rumSession?: IRumSession, configManager?: IConfigManager, monitorReporter?: IMonitorReporter) => void;
     /**
      * 业务自定义上传数据
      */
@@ -227,5 +240,13 @@ export interface IConfiguration {
         attributeName: string;
         attributeValue?: Array<string | RegExp> | null;
     }>;
+    /**
+     * 自监控（Self-Monitor）配置
+     * 用于控制 SDK 内部异常和错误的自动上报行为
+     * - `boolean`: 简单启用/禁用自监控
+     * - `ISelfMonitorConfig`: 详细配置，可指定采样率等
+     * @default true
+     */
+    selfMonitor?: boolean | ISelfMonitorConfig;
     [key: string]: unknown;
 }