sentry-miniapp 1.2.0 → 1.4.0

package/src/crossPlatform.ts

@@ -0,0 +1,407 @@
+declare const wx: any; // 微信小程序、微信小游戏
+declare const my: any; // 支付宝小程序
+declare const tt: any; // 字节跳动小程序
+declare const dd: any; // 钉钉小程序
+declare const qq: any; // QQ 小程序、QQ 小游戏
+declare const swan: any; // 百度小程序
+declare const ks: any; // 快手小程序
+
+/**
+ * 小程序平台 SDK 接口
+ */
+interface SDK {
+  request: Function;
+  httpRequest?: Function; // 针对钉钉小程序
+  getSystemInfoSync?: Function; // 已弃用，保留兼容性
+  canIUse?: Function; // 检查API是否可用
+  getSystemSetting?: Function; // 新 API
+  getAppAuthorizeSetting?: Function; // 新 API
+  getDeviceInfo?: Function; // 新 API
+  getWindowInfo?: Function; // 新 API
+  getAppBaseInfo?: Function; // 新 API
+  onError?: Function;
+  onUnhandledRejection?: Function;
+  onPageNotFound?: Function;
+  onMemoryWarning?: Function;
+  getLaunchOptionsSync?: Function;
+  getAccountInfoSync?: Function;
+  getUpdateManager?: Function;
+  showModal?: Function;
+  URLSearchParams?: Function;
+  // Performance API
+  getPerformance?: Function; // 获取性能管理器
+  reportPerformance?: Function; // 上报性能数据
+  // Storage API
+  setStorageSync?: Function;
+  getStorageSync?: Function;
+  getStorageInfoSync?: Function;
+  removeStorageSync?: Function;
+}
+
+/**
+ * 小程序平台类型
+ */
+export type AppName =
+  | 'wechat'
+  | 'alipay'
+  | 'bytedance'
+  | 'dingtalk'
+  | 'qq'
+  | 'swan'
+  | 'kuaishou'
+  | 'unknown';
+
+/**
+ * 系统信息接口
+ */
+export interface SystemInfo {
+  brand: string;
+  model: string;
+  pixelRatio: number;
+  screenWidth: number;
+  screenHeight: number;
+  windowWidth: number;
+  windowHeight: number;
+  statusBarHeight: number;
+  language: string;
+  version: string;
+  system: string;
+  platform: string;
+  fontSizeSetting: number;
+  SDKVersion: string;
+  benchmarkLevel?: number;
+  albumAuthorized?: boolean;
+  cameraAuthorized?: boolean;
+  locationAuthorized?: boolean;
+  microphoneAuthorized?: boolean;
+  notificationAuthorized?: boolean;
+  bluetoothEnabled?: boolean;
+  locationEnabled?: boolean;
+  wifiEnabled?: boolean;
+  safeArea?: {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    width: number;
+    height: number;
+  };
+}
+
+/**
+ * 获取跨平台的 SDK
+ */
+const getSDK = (): SDK => {
+  let currentSdk: SDK = {
+    // tslint:disable-next-line: no-empty
+    request: () => { },
+    // tslint:disable-next-line: no-empty
+    httpRequest: () => { },
+    // tslint:disable-next-line: no-empty
+    getSystemInfoSync: () => ({}),
+    // tslint:disable-next-line: no-empty
+    URLSearchParams: () => { }
+  };
+
+  if (typeof wx === 'object' && wx !== null) {
+    // tslint:disable-next-line: no-unsafe-any
+    currentSdk = wx;
+  } else if (typeof my === 'object' && my !== null) {
+    // tslint:disable-next-line: no-unsafe-any
+    currentSdk = my;
+  } else if (typeof tt === 'object' && tt !== null) {
+    // tslint:disable-next-line: no-unsafe-any
+    currentSdk = tt;
+  } else if (typeof dd === 'object' && dd !== null) {
+    // tslint:disable-next-line: no-unsafe-any
+    currentSdk = dd;
+  } else if (typeof qq === 'object' && qq !== null) {
+    // tslint:disable-next-line: no-unsafe-any
+    currentSdk = qq;
+  } else if (typeof swan === 'object' && swan !== null) {
+    // tslint:disable-next-line: no-unsafe-any
+    currentSdk = swan;
+  } else if (typeof ks === 'object' && ks !== null) {
+    // tslint:disable-next-line: no-unsafe-any
+    currentSdk = ks;
+  } else {
+    throw new Error('sentry-miniapp 暂不支持此平台');
+  }
+
+  // 支付宝小程序的网络请求 API 是 my.httpRequest
+  if (typeof my === 'object' && my !== null && currentSdk === my && !currentSdk.request && currentSdk.httpRequest) {
+    currentSdk.request = currentSdk.httpRequest;
+  }
+
+  // 支付宝和钉钉的 Storage API 参数是对象形式，这里做一层抹平包装
+  if ((typeof my === 'object' && my !== null && currentSdk === my) ||
+    (typeof dd === 'object' && dd !== null && currentSdk === dd)) {
+    if (currentSdk.getStorageSync) {
+      const originalGet = currentSdk.getStorageSync;
+      currentSdk.getStorageSync = (key: string) => {
+        const res = originalGet.call(currentSdk, { key });
+        return res ? res.data : null;
+      };
+    }
+    if (currentSdk.setStorageSync) {
+      const originalSet = currentSdk.setStorageSync;
+      currentSdk.setStorageSync = (key: string, data: any) => {
+        originalSet.call(currentSdk, { key, data });
+      };
+    }
+    if (currentSdk.removeStorageSync) {
+      const originalRemove = currentSdk.removeStorageSync;
+      currentSdk.removeStorageSync = (key: string) => {
+        originalRemove.call(currentSdk, { key });
+      };
+    }
+  }
+
+  return currentSdk;
+};
+
+/**
+ * 获取平台名称
+ */
+const getAppName = (): AppName => {
+  let currentAppName: AppName = 'unknown';
+
+  if (typeof wx === 'object' && wx !== null) {
+    currentAppName = 'wechat';
+  } else if (typeof my === 'object' && my !== null) {
+    currentAppName = 'alipay';
+  } else if (typeof tt === 'object' && tt !== null) {
+    currentAppName = 'bytedance';
+  } else if (typeof dd === 'object' && dd !== null) {
+    currentAppName = 'dingtalk';
+  } else if (typeof qq === 'object' && qq !== null) {
+    currentAppName = 'qq';
+  } else if (typeof swan === 'object' && swan !== null) {
+    currentAppName = 'swan';
+  } else if (typeof ks === 'object' && ks !== null) {
+    currentAppName = 'kuaishou';
+  }
+
+  return currentAppName;
+};
+
+/**
+ * 获取系统信息
+ * 优先使用新的 API，保持向后兼容性
+ */
+const getSystemInfo = (): SystemInfo | null => {
+  try {
+    const currentSdk = getSDK();
+    const result: any = {};
+    let hasNewApi = false;
+
+    // 1. 基础信息
+    if (currentSdk.getAppBaseInfo) {
+      const baseInfo = currentSdk.getAppBaseInfo();
+      Object.assign(result, baseInfo);
+      hasNewApi = true;
+    }
+
+    // 2. 窗口信息
+    if (currentSdk.getWindowInfo) {
+      const windowInfo = currentSdk.getWindowInfo();
+      Object.assign(result, windowInfo);
+      hasNewApi = true;
+    }
+
+    // 3. 设备信息
+    if (currentSdk.getDeviceInfo) {
+      const deviceInfo = currentSdk.getDeviceInfo();
+      Object.assign(result, deviceInfo);
+      hasNewApi = true;
+    }
+
+    // 4. 授权设置 (需要转换类型)
+    if (currentSdk.getAppAuthorizeSetting) {
+      const authSetting = currentSdk.getAppAuthorizeSetting();
+      result.albumAuthorized = authSetting.albumAuthorized === 'authorized';
+      result.cameraAuthorized = authSetting.cameraAuthorized === 'authorized';
+      result.locationAuthorized = authSetting.locationAuthorized === 'authorized';
+      result.microphoneAuthorized = authSetting.microphoneAuthorized === 'authorized';
+      result.notificationAuthorized = authSetting.notificationAuthorized === 'authorized';
+    }
+
+    // 5. 系统设置
+    if (currentSdk.getSystemSetting) {
+      const sysSetting = currentSdk.getSystemSetting();
+      Object.assign(result, sysSetting);
+    }
+
+    // 如果成功获取了主要信息，则返回结果
+    if (hasNewApi) {
+      return result as SystemInfo;
+    }
+
+    // 兜底使用旧的 API（已弃用但保持兼容性）
+    if (currentSdk.getSystemInfoSync) {
+      const syncInfo = currentSdk.getSystemInfoSync();
+      // 支付宝小程序等平台，版本信息可能叫 version 而不是 SDKVersion
+      if (!syncInfo.SDKVersion && syncInfo.version) {
+        syncInfo.SDKVersion = syncInfo.version;
+      }
+      return syncInfo as SystemInfo;
+    }
+
+    return null;
+  } catch (error) {
+    console.warn('[Sentry] Failed to get system info:', error);
+    return null;
+  }
+};
+
+/**
+ * 检查是否在小程序环境中
+ */
+const isMiniappEnvironment = (): boolean => {
+  try {
+    getSDK();
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+// 懒加载 SDK 和 appName，避免在模块导入时就执行平台检测
+export let _sdk: SDK | null = null;
+let _appName: string | null = null;
+
+export const sdk = (): SDK => {
+  if (_sdk === null) {
+    _sdk = getSDK();
+  }
+  return _sdk;
+};
+
+export const appName = (): string => {
+  if (_appName === null) {
+    _appName = getAppName();
+  }
+  return _appName;
+};
+
+/**
+ * 性能指标类型
+ */
+export interface PerformanceEntry {
+  name: string;
+  entryType: string;
+  startTime: number;
+  duration: number;
+}
+
+/**
+ * 导航性能指标
+ */
+export interface NavigationPerformanceEntry extends PerformanceEntry {
+  entryType: 'navigation';
+  // 小程序启动相关
+  appLaunchTime?: number;
+  pageReadyTime?: number;
+  firstRenderTime?: number;
+  // 页面导航相关
+  navigationStart?: number;
+  navigationEnd?: number;
+  loadEventStart?: number;
+  loadEventEnd?: number;
+}
+
+/**
+ * 渲染性能指标
+ */
+export interface RenderPerformanceEntry extends PerformanceEntry {
+  entryType: 'render';
+  // 渲染相关
+  renderStart?: number;
+  renderEnd?: number;
+  // 脚本执行
+  scriptStart?: number;
+  scriptEnd?: number;
+}
+
+/**
+ * 资源加载性能指标
+ */
+export interface ResourcePerformanceEntry extends PerformanceEntry {
+  entryType: 'resource';
+  // 资源类型
+  initiatorType?: string;
+  // 网络时序
+  fetchStart?: number;
+  domainLookupStart?: number;
+  domainLookupEnd?: number;
+  connectStart?: number;
+  connectEnd?: number;
+  requestStart?: number;
+  responseStart?: number;
+  responseEnd?: number;
+  // 资源大小
+  transferSize?: number;
+  encodedBodySize?: number;
+  decodedBodySize?: number;
+}
+
+/**
+ * 用户交互性能指标
+ */
+export interface UserTimingPerformanceEntry extends PerformanceEntry {
+  entryType: 'measure' | 'mark';
+  detail?: any;
+}
+
+/**
+ * Performance Observer 回调
+ */
+export interface PerformanceObserverCallback {
+  (entries: PerformanceEntry[]): void;
+}
+
+/**
+ * Performance API 管理器接口
+ */
+export interface PerformanceManager {
+  // 获取性能条目
+  getEntries(): PerformanceEntry[];
+  getEntriesByType(type: string): PerformanceEntry[];
+  getEntriesByName(name: string, type?: string): PerformanceEntry[];
+
+  // 标记和测量
+  mark(name: string): void;
+  measure(name: string, startMark?: string, endMark?: string): void;
+
+  // 清除
+  clearMarks(name?: string): void;
+  clearMeasures(name?: string): void;
+
+  // 观察者
+  createObserver(callback: PerformanceObserverCallback): PerformanceObserver;
+}
+
+/**
+ * Performance Observer 接口
+ */
+export interface PerformanceObserver {
+  observe(options: { entryTypes: string[] }): void;
+  disconnect(): void;
+}
+
+/**
+ * 获取性能管理器
+ */
+export const getPerformanceManager = (): PerformanceManager | null => {
+  try {
+    const currentSdk = sdk();
+    if (currentSdk.getPerformance && typeof currentSdk.getPerformance === 'function') {
+      return currentSdk.getPerformance();
+    }
+  } catch (error) {
+    console.warn('Failed to get performance manager:', error);
+  }
+  return null;
+};
+
+export { getSDK, getSystemInfo, isMiniappEnvironment };

package/src/eventbuilder.ts

@@ -0,0 +1,291 @@
+// Note: eventFromException and eventFromMessage are now handled by the client
+import type { Event, EventHint, SeverityLevel } from '@sentry/core';
+
+// 为小程序环境定义 ErrorEvent 接口
+interface ErrorEvent {
+  error: Error;
+  message: string;
+  filename?: string;
+  lineno?: number;
+  colno?: number;
+  constructor: { name: string };
+}
+
+// Simple implementations for compatibility
+export function eventFromException(existingEvent: any, exception: any, _hint?: EventHint): Event {
+  return {
+    ...existingEvent,
+    exception: {
+      values: [{
+        type: (exception && exception.name) || 'Error',
+        value: (exception && exception.message) || String(exception),
+      }]
+    },
+    level: 'error',
+  } as Event;
+}
+
+export function eventFromMessage(existingEvent: any, message: string, level: any = 'info', _hint?: EventHint): Event {
+  return {
+    ...existingEvent,
+    message: message,
+    level,
+  } as Event;
+}
+
+import { isError, isPlainObject } from './helpers';
+
+/**
+ * Builds and Event from a Exception
+ * @hidden
+ */
+export function eventFromUnknownInput(
+  stackParser: any,
+  exception: unknown,
+  hint?: EventHint,
+): Event {
+  let event: Event;
+
+  if (isErrorEvent(exception) && (exception as ErrorEvent).error) {
+    // If it is an ErrorEvent with `error` property, extract it to get actual Error
+    const errorEvent = exception as ErrorEvent;
+    return eventFromException(stackParser, errorEvent.error, hint);
+  }
+
+  // If it is a `DOMError` (which is a legacy API, but still supported in some browsers) or `DOMException`
+  if (isDOMError(exception) || isDOMException(exception)) {
+    const domException = exception as DOMException;
+
+    if ('stack' in exception) {
+      event = eventFromException(stackParser, exception as Error, hint);
+    } else {
+      const name = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');
+      const message = domException.message ? `${name}: ${domException.message}` : name;
+      event = eventFromMessage(stackParser, message, 'error', hint);
+      event.exception = {
+        values: [
+          {
+            type: name,
+            value: domException.message,
+          },
+        ],
+      };
+    }
+    return event;
+  }
+
+  if (isError(exception)) {
+    // we have a real Error object, do nothing
+    return eventFromException(stackParser, exception, hint);
+  }
+
+  if (isPlainObject(exception) && hint && hint.syntheticException) {
+    // If it is plain Object, serialize it manually and extract options
+    // This will allow us to group events based on top-level keys
+    // which is much better than creating new group when any key/value change
+    const message = `Non-Error exception captured with keys: ${extractExceptionKeysForMessage(exception)}`;
+    const syntheticException = hint.syntheticException;
+    event = eventFromException(stackParser, syntheticException, hint);
+    event.message = message;
+    event.exception!.values![0] = {
+      ...event.exception!.values![0],
+      type: 'Object',
+      value: message,
+    };
+    event.extra = {
+      ...event.extra,
+      __serialized__: normalizeToSize(exception),
+    };
+
+    return event;
+  }
+
+  // If none of previous checks were valid, then it means that it's not:
+  // - an instance of DOMError
+  // - an instance of DOMException
+  // - an instance of Event
+  // - an instance of Error
+  // - a valid ErrorEvent (one with an error property)
+  // - a plain Object
+  //
+  // So bail out and capture it as a simple message:
+  const stringException = exception as string;
+  event = eventFromMessage(stackParser, stringException, undefined, hint);
+  event.exception = {
+    values: [
+      {
+        type: 'UnhandledException',
+        value: `Non-Error exception captured: ${stringException}`,
+      },
+    ],
+  };
+
+  return event;
+}
+
+/**
+ * @hidden
+ */
+export function eventFromString(
+  stackParser: any,
+  input: string,
+  level: SeverityLevel = 'info',
+  hint?: EventHint,
+): Event {
+  const event = eventFromMessage(stackParser, input, level, hint);
+  event.level = level;
+  return event;
+}
+
+/**
+ * Checks whether given value's type is ErrorEvent
+ * {@link isErrorEvent}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isErrorEvent(wat: any): wat is ErrorEvent {
+  return wat && wat.constructor && wat.constructor.name === 'ErrorEvent';
+}
+
+/**
+ * Checks whether given value's type is DOMError
+ * {@link isDOMError}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isDOMError(wat: any): wat is Error {
+  return wat && wat.constructor && wat.constructor.name === 'DOMError';
+}
+
+/**
+ * Checks whether given value's type is DOMException
+ * {@link isDOMException}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isDOMException(wat: any): wat is DOMException {
+  return wat && wat.constructor && wat.constructor.name === 'DOMException';
+}
+
+/**
+ * @hidden
+ */
+function extractExceptionKeysForMessage(exception: Record<string, unknown>, maxLength: number = 40): string {
+  const keys = Object.keys(exception);
+  keys.sort();
+
+  if (!keys.length) {
+    return '[object has no keys]';
+  }
+
+  if (keys[0] && keys[0].length >= maxLength) {
+    return keys[0];
+  }
+
+  for (let includedKeys = keys.length; includedKeys > 0; includedKeys--) {
+    const serialized = keys.slice(0, includedKeys).join(', ');
+    if (serialized.length > maxLength) {
+      continue;
+    }
+    if (includedKeys === keys.length) {
+      return serialized;
+    }
+    return `${serialized}\u2026`;
+  }
+
+  return '';
+}
+
+/**
+ * Normalize any value to a reasonable size for serialization
+ */
+function normalizeToSize(object: any, depth: number = 3, maxProperties: number = 1000): any {
+  const normalized = normalizeValue(object, depth, maxProperties);
+
+  // truncate the object
+  if (normalized && typeof normalized === 'object' && Object.keys(normalized).length > maxProperties) {
+    return '[Object too large]';
+  }
+
+  return normalized;
+}
+
+/**
+ * Normalize a value
+ */
+function normalizeValue(value: any, depth: number, maxProperties: number): any {
+  if (depth === 0) {
+    return '[Object]';
+  }
+
+  if (value === null || (['number', 'boolean', 'string'].includes(typeof value) && !isNaN(value))) {
+    return value;
+  }
+
+  const stringified = stringifyValue(value);
+  if (!stringified.startsWith('[object ')) {
+    return stringified;
+  }
+
+  if (value['__sentry_skip_normalization__']) {
+    return value;
+  }
+
+  if (typeof value === 'function') {
+    return `[Function: ${value.name || '<anonymous>'}]`;
+  }
+
+  if (typeof value === 'symbol') {
+    return `[${String(value)}]`;
+  }
+
+  if (typeof value !== 'object') {
+    return value;
+  }
+
+  if (isError(value)) {
+    return {
+      message: value.message,
+      name: value.name,
+      stack: value.stack,
+    };
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((v) => normalizeValue(v, depth - 1, maxProperties));
+  }
+
+  const normalized: Record<string, any> = {};
+  let numAdded = 0;
+
+  for (const key in value) {
+    if (!Object.prototype.hasOwnProperty.call(value, key)) {
+      continue;
+    }
+
+    if (numAdded >= maxProperties) {
+      normalized['[...]'] = '[Object too large]';
+      break;
+    }
+
+    const normalizedKey = typeof key === 'symbol' ? `[${String(key)}]` : key;
+    normalized[normalizedKey] = normalizeValue(value[key], depth - 1, maxProperties);
+    numAdded += 1;
+  }
+
+  return normalized;
+}
+
+/**
+ * Stringify a value
+ */
+function stringifyValue(value: any): string {
+  try {
+    return JSON.stringify(value);
+  } catch (_oO) {
+    return '[Object]';
+  }
+}