sentry-miniapp 1.3.0 → 1.4.0

package/src/polyfills.ts

@@ -0,0 +1,242 @@
+/**
+ * Polyfills for miniapp environment
+ * 小程序环境的 polyfill 实现
+ */
+
+/**
+ * URLSearchParams polyfill for miniapp environment
+ * 小程序环境的 URLSearchParams polyfill
+ */
+class URLSearchParamsPolyfill {
+  private params: Record<string, string> = {};
+
+  constructor(init?: string | Record<string, string> | URLSearchParamsPolyfill | string[][]) {
+    if (typeof init === 'string') {
+      this.parseString(init);
+    } else if (Array.isArray(init)) {
+      // Handle string[][] format
+      for (const pair of init) {
+        if (Array.isArray(pair) && pair.length >= 2) {
+           this.append(pair[0] || '', pair[1] || '');
+         }
+      }
+    } else if (init && typeof init === 'object') {
+      if (init instanceof URLSearchParamsPolyfill) {
+        this.params = { ...init.params };
+      } else {
+        this.params = { ...init };
+      }
+    }
+  }
+
+  get size(): number {
+    return Object.keys(this.params).length;
+  }
+
+  private parseString(str: string): void {
+    if (str.startsWith('?')) {
+      str = str.slice(1);
+    }
+    
+    if (!str) {
+      return;
+    }
+
+    const pairs = str.split('&');
+    for (const pair of pairs) {
+      const [key, value = ''] = pair.split('=');
+      if (key) {
+        this.params[decodeURIComponent(key)] = decodeURIComponent(value);
+      }
+    }
+  }
+
+  append(name: string, value: string): void {
+    // URLSearchParams.append should add to existing values, not replace
+    const existing = this.params[name];
+    if (existing) {
+      this.params[name] = existing + ',' + value;
+    } else {
+      this.params[name] = value;
+    }
+  }
+
+  delete(name: string): void {
+    delete this.params[name];
+  }
+
+  get(name: string): string | null {
+    return this.params[name] ?? null;
+  }
+
+  getAll(name: string): string[] {
+    // For simplicity, we only store one value per key
+    // In a full implementation, this would return an array of all values
+    const value = this.params[name];
+    return value ? [value] : [];
+  }
+
+  has(name: string): boolean {
+    return name in this.params;
+  }
+
+  set(name: string, value: string): void {
+    this.params[name] = String(value);
+  }
+
+  sort(): void {
+    const sortedKeys = Object.keys(this.params).sort();
+    const sortedParams: Record<string, string> = {};
+    for (const key of sortedKeys) {
+       sortedParams[key] = this.params[key] || '';
+     }
+    this.params = sortedParams;
+  }
+
+  toString(): string {
+    const pairs: string[] = [];
+    for (const [key, value] of Object.entries(this.params)) {
+      pairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+    }
+    return pairs.join('&');
+  }
+
+  forEach(callback: (value: string, key: string, parent: URLSearchParamsPolyfill) => void): void {
+    for (const [key, value] of Object.entries(this.params)) {
+      callback(value, key, this);
+    }
+  }
+
+  *keys(): IterableIterator<string> {
+    for (const key of Object.keys(this.params)) {
+      yield key;
+    }
+  }
+
+  *values(): IterableIterator<string> {
+    for (const value of Object.values(this.params)) {
+      yield value;
+    }
+  }
+
+  *entries(): IterableIterator<[string, string]> {
+    for (const [key, value] of Object.entries(this.params)) {
+      yield [key, value];
+    }
+  }
+
+  // Symbol.iterator to make it iterable
+  *[Symbol.iterator](): IterableIterator<[string, string]> {
+    yield* this.entries();
+  }
+}
+
+/**
+ * Get the global object for the current environment
+ * 获取当前环境的全局对象
+ */
+function getGlobalObject(): any {
+  // 尝试获取全局对象
+  const globalScope = Function('return this')();
+  
+  // 微信小程序环境
+  if (globalScope && typeof globalScope.wx !== 'undefined' && globalScope.wx) {
+    return globalScope.wx;
+  }
+  // 支付宝小程序环境
+  if (globalScope && typeof globalScope.my !== 'undefined' && globalScope.my) {
+    return globalScope.my;
+  }
+  // 百度小程序环境
+  if (globalScope && typeof globalScope.swan !== 'undefined' && globalScope.swan) {
+    return globalScope.swan;
+  }
+  // 字节跳动小程序环境
+  if (globalScope && typeof globalScope.tt !== 'undefined' && globalScope.tt) {
+    return globalScope.tt;
+  }
+  // QQ小程序环境
+  if (globalScope && typeof globalScope.qq !== 'undefined' && globalScope.qq) {
+    return globalScope.qq;
+  }
+  // 通用全局对象检测
+  if (typeof globalThis !== 'undefined') {
+    return globalThis;
+  }
+  // 浏览器环境
+  if (typeof window !== 'undefined') {
+    return window;
+  }
+  // Node.js 环境
+  if (typeof global !== 'undefined') {
+    return global;
+  }
+  // Web Worker 环境
+  if (typeof self !== 'undefined') {
+    return self;
+  }
+  // 返回全局作用域
+  return globalScope;
+}
+
+/**
+ * Install polyfills for miniapp environment
+ * 为小程序环境安装 polyfill
+ */
+export function installPolyfills(): void {
+  try {
+    const globalObj = getGlobalObject();
+    
+    if (!globalObj) {
+      console.warn('[Sentry] Unable to detect global object, polyfills may not work correctly');
+      return;
+    }
+    
+    // Install URLSearchParams polyfill if not available
+    if (typeof globalObj.URLSearchParams === 'undefined') {
+      globalObj.URLSearchParams = URLSearchParamsPolyfill;
+    }
+    
+    // Also install to the global scope for direct access
+    // 同时安装到全局作用域以便直接访问
+    const globalScope = Function('return this')();
+    if (globalScope && typeof globalScope.URLSearchParams === 'undefined') {
+      globalScope.URLSearchParams = URLSearchParamsPolyfill as any;
+    }
+    
+    // For environments where Function('return this')() doesn't work
+    // 对于 Function('return this')() 不起作用的环境
+    if (typeof globalThis !== 'undefined' && typeof globalThis.URLSearchParams === 'undefined') {
+      (globalThis as any).URLSearchParams = URLSearchParamsPolyfill;
+    }
+  } catch (error) {
+    console.warn('[Sentry] Failed to install polyfills:', error);
+  }
+}
+
+/**
+ * Check if we're in a miniapp environment and install polyfills
+ * 检查是否在小程序环境中并安装 polyfill
+ */
+export function ensurePolyfills(): void {
+  // Always install polyfills regardless of environment to ensure compatibility
+  // This ensures URLSearchParams is always available when needed
+  installPolyfills();
+}
+
+/**
+ * Check if URLSearchParams is available in the current environment
+ * 检查当前环境是否支持 URLSearchParams
+ */
+export function isURLSearchParamsSupported(): boolean {
+  try {
+    const globalObj = getGlobalObject();
+    return globalObj && typeof globalObj.URLSearchParams !== 'undefined';
+  } catch {
+    return false;
+  }
+}
+
+// Auto-install polyfills immediately when this module is loaded
+// This runs before any other SDK functionality
+ensurePolyfills();

package/src/sdk.ts

@@ -0,0 +1,182 @@
+import {
+  getCurrentScope,
+  initAndBind,
+  setContext,
+  withScope,
+} from '@sentry/core';
+import type {
+  Integration,
+} from '@sentry/core';
+
+import { MiniappClient } from './client';
+import { appName, getSystemInfo, isMiniappEnvironment } from './crossPlatform';
+import {
+  GlobalHandlers,
+  TryCatch,
+  LinkedErrors,
+  HttpContext,
+  Dedupe,
+  performanceIntegration,
+  RewriteFrames,
+  NetworkBreadcrumbs,
+} from './integrations/index';
+import type { MiniappOptions, ReportDialogOptions, SendFeedbackParams } from './types';
+
+/**
+ * Default integrations for the miniapp SDK
+ */
+export const defaultIntegrations: Integration[] = [
+  // Core integrations
+  new HttpContext(),
+  new Dedupe(),
+  new GlobalHandlers(),
+  new TryCatch(),
+  new LinkedErrors(),
+  // Performance monitoring
+  performanceIntegration({
+    enableNavigation: true,
+    enableRender: true,
+    enableResource: true,
+    enableUserTiming: true,
+    sampleRate: 1.0,
+    reportInterval: 30000,
+  }),
+];
+
+/**
+ * Get default integrations for the miniapp SDK
+ * @returns Array of default integrations
+ */
+export function getDefaultIntegrations(): Integration[] {
+  return [...defaultIntegrations];
+}
+
+/**
+ * Initialize the Sentry Miniapp SDK
+ * @param options Configuration options for the SDK
+ */
+export function init(options: MiniappOptions = {} as any): MiniappClient | undefined {
+  if (!isMiniappEnvironment()) {
+    console.warn('sentry-miniapp: Not running in a supported miniapp environment');
+    return undefined;
+  }
+
+  const opts = {
+    ...options,
+    integrations: options.integrations || defaultIntegrations,
+    stackParser: () => [],
+    transport: options.transport,
+  };
+
+  if (opts.enableSourceMap !== false) {
+    opts.integrations.push(new RewriteFrames());
+  }
+
+  opts.integrations.push(new NetworkBreadcrumbs({ traceNetworkBody: opts.traceNetworkBody }));
+
+  // Set platform context
+  setContext('miniapp', {
+    platform: appName,
+    environment: 'miniapp',
+  });
+
+  // Add system information
+  const systemInfo = getSystemInfo();
+  if (systemInfo) {
+    setContext('device', {
+      brand: systemInfo.brand,
+      model: systemInfo.model,
+      language: systemInfo.language,
+      system: systemInfo.system,
+      platform: systemInfo.platform,
+      screen_resolution: `${systemInfo.screenWidth}x${systemInfo.screenHeight}`,
+    });
+
+    setContext('app', {
+      sdk_version: systemInfo.SDKVersion,
+      version: systemInfo.version,
+    });
+  }
+
+  initAndBind(MiniappClient as any, opts as any);
+  return getCurrentScope().getClient() as MiniappClient;
+}
+
+/**
+ * @deprecated Miniapp environment does not support Sentry's default HTML report dialog.
+ * Please implement your own UI form to collect user feedback (name, email, comments)
+ * and use `Sentry.captureFeedback()` to submit it to Sentry.
+ * 
+ * 小程序环境不支持 Sentry 官方的 HTML 反馈弹窗。
+ * 请自行实现 UI 表单收集用户反馈，并调用 `Sentry.captureFeedback()` 进行上报。
+ */
+export function showReportDialog(_options: ReportDialogOptions = {}): void {
+  console.warn(
+    '[sentry-miniapp] showReportDialog is deprecated and does nothing. ' +
+    'Please build your own UI and use `Sentry.captureFeedback()` instead.'
+  );
+}
+
+/**
+ * Get the last event ID
+ */
+export function lastEventId(): string | undefined {
+  return getCurrentScope().lastEventId();
+}
+
+/**
+ * Flush pending events
+ */
+export function flush(timeout?: number): PromiseLike<boolean> {
+  const client = getCurrentScope().getClient();
+  if (client) {
+    return client.flush(timeout);
+  }
+  return Promise.resolve(false);
+}
+
+/**
+ * Close the SDK
+ */
+export function close(timeout?: number): PromiseLike<boolean> {
+  const client = getCurrentScope().getClient();
+  if (client) {
+    return client.close(timeout);
+  }
+  return Promise.resolve(false);
+}
+
+/**
+ * Wrap a function to capture exceptions
+ */
+export function wrap<T extends (...args: any[]) => any>(fn: T): T {
+  return (function (this: any, ...args: Parameters<T>) {
+    return withScope(() => {
+      try {
+        return fn.apply(this, args);
+      } catch (error) {
+        getCurrentScope().captureException(error);
+        throw error;
+      }
+    });
+  }) as T;
+}
+
+
+
+/**
+ * Capture feedback using the new feedback API.
+ * 使用新的反馈 API 捕获反馈
+ *
+ * @param params Feedback parameters
+ * @returns Event ID
+ */
+export function captureFeedback(params: SendFeedbackParams): string {
+  const client = getCurrentScope().getClient() as MiniappClient | undefined;
+  if (client) {
+    return client.captureFeedback(params);
+  } else {
+    console.warn('sentry-miniapp: No client available for captureFeedback');
+    return '';
+  }
+}

package/src/transports/index.ts

@@ -0,0 +1,3 @@
+export { createMiniappTransport } from './xhr';
+export type { MiniappTransportOptions } from './xhr';
+export { createMiniappOfflineStore } from './offlineStore';

package/src/transports/offlineStore.ts

@@ -0,0 +1,85 @@
+import type { Envelope } from '@sentry/core';
+import type { OfflineStore, OfflineTransportOptions } from '@sentry/core/build/types/transports/offline';
+import { sdk } from '../crossPlatform';
+
+const DEFAULT_OFFLINE_CACHE_SIZE = 30; // 默认最大缓存数量
+const OFFLINE_STORE_KEY = 'sentry_offline_store';
+
+export interface MiniappOfflineStoreOptions extends OfflineTransportOptions {
+  offlineCacheLimit?: number;
+}
+
+/**
+ * Creates an offline store using miniapp storage API
+ */
+export function createMiniappOfflineStore(options: MiniappOfflineStoreOptions): OfflineStore {
+  const maxCacheSize = options.offlineCacheLimit || DEFAULT_OFFLINE_CACHE_SIZE;
+
+  return {
+    push: async (env: Envelope): Promise<void> => {
+      try {
+        const store = getStore();
+        store.push(env);
+        if (store.length > maxCacheSize) {
+          store.shift(); // 移除最早的缓存以限制大小
+        }
+        setStore(store);
+      } catch (e) {
+        console.warn('[Sentry] Failed to push to offline store', e);
+      }
+    },
+    unshift: async (env: Envelope): Promise<void> => {
+      try {
+        const store = getStore();
+        store.unshift(env);
+        if (store.length > maxCacheSize) {
+          store.pop(); // 移除最旧的缓存以限制大小
+        }
+        setStore(store);
+      } catch (e) {
+        console.warn('[Sentry] Failed to unshift to offline store', e);
+      }
+    },
+    shift: async (): Promise<Envelope | undefined> => {
+      try {
+        const store = getStore();
+        if (store.length === 0) {
+          return undefined;
+        }
+        const env = store.shift();
+        setStore(store);
+        return env;
+      } catch (e) {
+        console.warn('[Sentry] Failed to shift from offline store', e);
+        return undefined;
+      }
+    },
+  };
+}
+
+function getStore(): Envelope[] {
+  try {
+    const storageApi = sdk().getStorageSync;
+    if (storageApi) {
+      const storedStr = storageApi(OFFLINE_STORE_KEY);
+      if (storedStr) {
+        // storage API may return string or parsed object directly depending on platform
+        return typeof storedStr === 'string' ? JSON.parse(storedStr) : storedStr;
+      }
+    }
+  } catch (e) {
+    // ignore
+  }
+  return [];
+}
+
+function setStore(store: Envelope[]): void {
+  try {
+    const storageApi = sdk().setStorageSync;
+    if (storageApi) {
+      storageApi(OFFLINE_STORE_KEY, JSON.stringify(store));
+    }
+  } catch (e) {
+    // ignore
+  }
+}

package/src/transports/xhr.ts

@@ -0,0 +1,68 @@
+import type { BaseTransportOptions, Transport, TransportMakeRequestResponse } from '@sentry/core';
+import { createTransport } from '@sentry/core';
+
+import { sdk } from '../crossPlatform';
+
+export interface MiniappTransportOptions extends BaseTransportOptions {
+  /** Custom headers for the request */
+  headers?: Record<string, string>;
+}
+
+/**
+ * Creates a Transport that uses the miniapp request API to send events to Sentry.
+ */
+export function createMiniappTransport(options: MiniappTransportOptions): Transport {
+  // 保存 URL 到局部变量
+  const transportUrl = options.url;
+
+  /**
+   * Make a request using miniapp request API
+   */
+  function makeRequest(request: any): Promise<TransportMakeRequestResponse> {
+
+    return new Promise((resolve, reject) => {
+      const requestOptions = {
+        url: transportUrl,
+        method: 'POST' as const,
+        data: request.body,
+        header: {
+          'Content-Type': 'application/json',
+          ...request.headers,
+        },
+        // Alipay uses `headers` instead of `header`
+        headers: {
+          'Content-Type': 'application/json',
+          ...request.headers,
+        },
+        timeout: 10000,
+        success: (res: any) => {
+          // Alipay uses `status` instead of `statusCode`, and `headers` instead of `header`
+          const status = res.statusCode || res.status;
+          const resHeaders = res.header || res.headers || {};
+
+          resolve({
+            statusCode: status,
+            headers: {
+              'x-sentry-rate-limits': resHeaders['x-sentry-rate-limits'],
+              'retry-after': resHeaders['retry-after'],
+            },
+          });
+        },
+        fail: (error: any) => {
+          reject(new Error(`Network request failed: ${error.errMsg || error.errorMessage || error.message || 'Unknown error'}`));
+        },
+      };
+
+      // Use the appropriate request method based on the platform
+      if (sdk().request) {
+        sdk().request?.(requestOptions);
+      } else if (sdk().httpRequest) {
+        sdk().httpRequest?.(requestOptions);
+      } else {
+        reject(new Error('No request method available in current miniapp environment'));
+      }
+    });
+  }
+
+  return createTransport(options, makeRequest);
+}

package/src/types.ts

@@ -0,0 +1,129 @@
+import type { ClientOptions, BaseTransportOptions, Integration } from '@sentry/core';
+
+/**
+ * Configuration options for the Sentry Miniapp SDK.
+ */
+export interface MiniappOptions {
+  /** Sentry DSN */
+  dsn?: string;
+
+  /** Environment */
+  environment?: string;
+
+  /** Debug mode */
+  debug?: boolean;
+
+  /** Sample rate */
+  sampleRate?: number;
+
+  /** Release version */
+  release?: string;
+
+  /** Maximum number of breadcrumbs */
+  maxBreadcrumbs?: number;
+
+  /** Traces sample rate */
+  tracesSampleRate?: number;
+
+  /** Transport function */
+  transport?: any;
+
+  /** Before send hook */
+  beforeSend?: any;
+
+  /** Before breadcrumb hook */
+  beforeBreadcrumb?: any;
+
+  /** Miniapp platform type */
+  platform?: 'wechat' | 'alipay' | 'bytedance' | 'qq' | 'baidu' | 'dingtalk';
+
+  /** Whether to enable system info collection */
+  enableSystemInfo?: boolean;
+
+  /** Whether to enable user interaction breadcrumbs */
+  enableUserInteractionBreadcrumbs?: boolean;
+
+  /** Whether to enable console breadcrumbs */
+  enableConsoleBreadcrumbs?: boolean;
+
+  /** Whether to enable navigation breadcrumbs */
+  enableNavigationBreadcrumbs?: boolean;
+
+  /** Whether to enable automatic source map path rewrite */
+  enableSourceMap?: boolean;
+
+  /** Whether to capture and record request and response body in network breadcrumbs */
+  traceNetworkBody?: boolean;
+
+  /** Whether to enable offline cache to retry sending events later */
+  enableOfflineCache?: boolean;
+
+  /** Maximum number of events to store in offline cache (default: 30) */
+  offlineCacheLimit?: number;
+
+  /** Array of strings or regexes that match error URLs which should be exclusively sent to Sentry */
+  allowUrls?: Array<string | RegExp>;
+
+  /** Array of strings or regexes that match error URLs which should not be sent to Sentry */
+  denyUrls?: Array<string | RegExp>;
+
+  /** Integrations */
+  integrations?: Integration[];
+
+  /** Default integrations */
+  defaultIntegrations?: Integration[];
+}
+
+/**
+ * Client options for the Miniapp SDK.
+ */
+export interface MiniappClientOptions extends ClientOptions<BaseTransportOptions> {
+  options?: MiniappOptions;
+}
+
+/**
+ * All properties the report dialog supports
+ */
+export interface ReportDialogOptions {
+  [key: string]: any;
+  eventId?: string;
+  dsn?: string;
+  user?: {
+    email?: string;
+    name?: string;
+  };
+  lang?: string;
+  title?: string;
+  subtitle?: string;
+  subtitle2?: string;
+  labelName?: string;
+  labelEmail?: string;
+  labelComments?: string;
+  labelClose?: string;
+  labelSubmit?: string;
+  errorGeneric?: string;
+  errorFormEntry?: string;
+  successMessage?: string;
+  /** Callback after reportDialog showed up */
+  onLoad?(): void;
+}
+
+
+
+/**
+ * Parameters for sending user feedback
+ */
+export interface SendFeedbackParams {
+  message: string;
+  name?: string;
+  email?: string;
+  url?: string;
+  source?: string;
+  associatedEventId?: string;
+  /**
+   * Set an object that will be merged sent as tags data with the event.
+   */
+  tags?: {
+    [key: string]: string | number | boolean;
+  };
+}