sentry-miniapp 1.3.0 → 1.4.0

package/src/integrations/router.ts

@@ -0,0 +1,180 @@
+import { addBreadcrumb, getCurrentScope } from '@sentry/core';
+import type { Integration, IntegrationFn } from '@sentry/core';
+
+/** Router integration for miniapp navigation */
+export class Router implements Integration {
+  /**
+   * @inheritDoc
+   */
+  public static id: string = 'Router';
+
+  /**
+   * @inheritDoc
+   */
+  public name: string = Router.id;
+
+  /**
+   * @inheritDoc
+   */
+  private _lastRoute: string = '';
+
+  /**
+   * @inheritDoc
+   */
+  public setupOnce(): void {
+    this._instrumentNavigation();
+    this._startRouteMonitoring();
+  }
+
+  /**
+   * Instrument navigation functions
+   */
+  private _instrumentNavigation(): void {
+    const global = globalThis as any;
+    
+    // Instrument wx.navigateTo
+    if (global.wx && global.wx.navigateTo) {
+      const originalNavigateTo = global.wx.navigateTo;
+      global.wx.navigateTo = (options: any) => {
+        this._recordNavigation('navigateTo', options.url, this._getCurrentRoute());
+        return originalNavigateTo.call(global.wx, options);
+      };
+    }
+
+    // Instrument wx.redirectTo
+    if (global.wx && global.wx.redirectTo) {
+      const originalRedirectTo = global.wx.redirectTo;
+      global.wx.redirectTo = (options: any) => {
+        this._recordNavigation('redirectTo', options.url, this._getCurrentRoute());
+        return originalRedirectTo.call(global.wx, options);
+      };
+    }
+
+    // Instrument wx.switchTab
+    if (global.wx && global.wx.switchTab) {
+      const originalSwitchTab = global.wx.switchTab;
+      global.wx.switchTab = (options: any) => {
+        this._recordNavigation('switchTab', options.url, this._getCurrentRoute());
+        return originalSwitchTab.call(global.wx, options);
+      };
+    }
+
+    // Instrument wx.navigateBack
+    if (global.wx && global.wx.navigateBack) {
+      const originalNavigateBack = global.wx.navigateBack;
+      global.wx.navigateBack = (options: any = {}) => {
+        this._recordNavigation('navigateBack', 'back', this._getCurrentRoute(), options.delta);
+        return originalNavigateBack.call(global.wx, options);
+      };
+    }
+
+    // Instrument wx.reLaunch
+    if (global.wx && global.wx.reLaunch) {
+      const originalReLaunch = global.wx.reLaunch;
+      global.wx.reLaunch = (options: any) => {
+        this._recordNavigation('reLaunch', options.url, this._getCurrentRoute());
+        return originalReLaunch.call(global.wx, options);
+      };
+    }
+  }
+
+  /**
+   * Start monitoring route changes
+   */
+  private _startRouteMonitoring(): void {
+    // Monitor route changes by checking current pages periodically
+    setInterval(() => {
+      const currentRoute = this._getCurrentRoute();
+      if (currentRoute && currentRoute !== this._lastRoute) {
+        this._recordRouteChange(this._lastRoute, currentRoute);
+        this._lastRoute = currentRoute;
+      }
+    }, 1000);
+  }
+
+  /**
+   * Get current route
+   */
+  private _getCurrentRoute(): string {
+    try {
+      const global = globalThis as any;
+      if (global.getCurrentPages) {
+        const pages = global.getCurrentPages();
+        if (pages && pages.length > 0) {
+          const currentPage = pages[pages.length - 1];
+          return currentPage.route || currentPage.__route__ || '';
+        }
+      }
+    } catch (e) {
+      // Ignore errors
+    }
+    return '';
+  }
+
+  /**
+   * Record navigation action
+   */
+  private _recordNavigation(action: string, to: string, from: string, delta?: number): void {
+    const scope = getCurrentScope();
+    
+    // Add breadcrumb
+    addBreadcrumb({
+      category: 'navigation',
+      data: {
+        action,
+        from,
+        to,
+        delta,
+      },
+      message: `Navigation ${action}: ${from} -> ${to}`,
+      type: 'navigation',
+    });
+
+    // Set current route tag
+    scope.setTag('route', to === 'back' ? from : to);
+    
+    // Set navigation context
+    scope.setContext('navigation', {
+      action,
+      from,
+      to,
+      delta,
+      timestamp: Date.now(),
+    });
+  }
+
+  /**
+   * Record route change
+   */
+  private _recordRouteChange(from: string, to: string): void {
+    const scope = getCurrentScope();
+    
+    // Add breadcrumb
+    addBreadcrumb({
+      category: 'navigation',
+      data: {
+        from,
+        to,
+      },
+      message: `Route changed: ${from} -> ${to}`,
+      type: 'navigation',
+    });
+
+    // Update route tag
+    scope.setTag('route', to);
+    
+    // Update route context
+    scope.setContext('route', {
+      current: to,
+      previous: from,
+      timestamp: Date.now(),
+    });
+  }
+}
+
+/**
+ * Router integration
+ */
+export const routerIntegration: IntegrationFn = () => {
+  return new Router();
+};

package/src/integrations/system.ts

@@ -0,0 +1,135 @@
+import { getCurrentScope } from '@sentry/core';
+import type { Integration, IntegrationFn } from '@sentry/core';
+
+import { getSystemInfo, sdk } from '../crossPlatform';
+
+/** System information integration */
+export class System implements Integration {
+  /**
+   * @inheritDoc
+   */
+  public static id: string = 'System';
+
+  /**
+   * @inheritDoc
+   */
+  public name: string = System.id;
+
+  /**
+   * @inheritDoc
+   */
+  public setupOnce(): void {
+    this._addSystemContext();
+    this._addNetworkContext();
+    this._addLocationContext();
+  }
+
+  /**
+   * Add system information to context
+   */
+  private _addSystemContext(): void {
+    try {
+      const systemInfo = getSystemInfo();
+      if (systemInfo) {
+        const scope = getCurrentScope();
+        
+        // Set device context
+        scope.setContext('device', {
+          name: systemInfo.model,
+          model: systemInfo.model,
+          brand: systemInfo.brand,
+          family: systemInfo.platform,
+          arch: systemInfo.platform,
+        });
+
+        // Set OS context
+        scope.setContext('os', {
+          name: systemInfo.system?.split(' ')[0] || 'unknown',
+          version: systemInfo.system?.split(' ')[1] || 'unknown',
+          kernel_version: systemInfo.version,
+        });
+
+        // Set app context
+        scope.setContext('app', {
+          app_name: (systemInfo as any).appName || 'unknown',
+          app_version: systemInfo.version,
+        });
+
+        // Set screen context
+        scope.setContext('screen', {
+          screen_width: systemInfo.screenWidth,
+          screen_height: systemInfo.screenHeight,
+          screen_density: systemInfo.pixelRatio,
+        });
+
+        // Set tags
+        scope.setTag('device.model', systemInfo.model);
+        scope.setTag('device.brand', systemInfo.brand);
+        scope.setTag('os.name', systemInfo.system?.split(' ')[0] || 'unknown');
+        scope.setTag('os.version', systemInfo.system?.split(' ')[1] || 'unknown');
+        scope.setTag('app.version', systemInfo.version);
+        scope.setTag('language', systemInfo.language);
+      }
+    } catch (e) {
+      // Ignore errors when getting system info
+    }
+  }
+
+  /**
+   * Add network information to context
+   */
+  private _addNetworkContext(): void {
+    try {
+      if ((sdk() as any).getNetworkType) {
+      (sdk() as any).getNetworkType({
+          success: (res: { networkType: string; isConnected?: boolean }) => {
+            const scope = getCurrentScope();
+            scope.setContext('network', {
+              type: res.networkType,
+              connected: res.isConnected !== false,
+            });
+            scope.setTag('network.type', res.networkType);
+          },
+          fail: () => {
+            // Ignore network type fetch errors
+          },
+        });
+      }
+    } catch (e) {
+      // Ignore errors when getting network info
+    }
+  }
+
+  /**
+   * Add location information to context (if available)
+   */
+  private _addLocationContext(): void {
+    try {
+      if ((sdk() as any).getLocation) {
+      (sdk() as any).getLocation({
+          type: 'gcj02',
+          success: (res: { latitude: number; longitude: number; accuracy: number }) => {
+            const scope = getCurrentScope();
+            scope.setContext('location', {
+              latitude: res.latitude,
+              longitude: res.longitude,
+              accuracy: res.accuracy,
+            });
+          },
+          fail: () => {
+            // Ignore location fetch errors (user might not grant permission)
+          },
+        });
+      }
+    } catch (e) {
+      // Ignore errors when getting location info
+    }
+  }
+}
+
+/**
+ * System integration
+ */
+export const systemIntegration: IntegrationFn = () => {
+  return new System();
+};

package/src/integrations/trycatch.ts

@@ -0,0 +1,233 @@
+import { captureException, getCurrentScope } from '@sentry/core';
+import type { Integration, IntegrationFn, WrappedFunction } from '@sentry/core';
+
+/** Wrap timer functions and event targets to catch errors and provide better meta data */
+export class TryCatch implements Integration {
+  /**
+   * @inheritDoc
+   */
+  public static id: string = 'TryCatch';
+
+  /**
+   * @inheritDoc
+   */
+  public name: string = TryCatch.id;
+
+  /** JSDoc */
+  private _wrapTimeFunction(original: (...args: any[]) => any): (...args: any[]) => any {
+    return function (this: any, ...args: any[]): any {
+      const originalCallback = args[0];
+      args[0] = wrap(originalCallback, {
+        mechanism: {
+          data: { function: getFunctionName(original) },
+          handled: true,
+          type: 'instrument',
+        },
+      });
+      return original.apply(this, args);
+    };
+  }
+
+  /** JSDoc */
+  private _wrapRAF(original: any): (callback: () => void) => any {
+    return function (this: any, callback: () => void): any {
+      return original(
+        wrap(callback, {
+          mechanism: {
+            data: {
+              function: 'requestAnimationFrame',
+              handler: getFunctionName(original),
+            },
+            handled: true,
+            type: 'instrument',
+          },
+        }),
+      );
+    };
+  }
+
+  /**
+   * Wrap timer functions and event targets to catch errors
+   * and provide better metadata.
+   */
+  public setupOnce(): void {
+
+    // In miniapp environment, we mainly focus on wrapping common async functions
+    const global = globalThis as any;
+
+    if (global.setTimeout) {
+      fill(global, 'setTimeout', this._wrapTimeFunction.bind(this));
+    }
+    if (global.setInterval) {
+      fill(global, 'setInterval', this._wrapTimeFunction.bind(this));
+    }
+    if (global.requestAnimationFrame) {
+      fill(global, 'requestAnimationFrame', this._wrapRAF.bind(this));
+    }
+  }
+}
+
+/**
+ * Wrap a function to capture exceptions
+ */
+export function wrap(
+  fn: WrappedFunction,
+  options: {
+    mechanism?: {
+      data?: Record<string, any>;
+      handled?: boolean;
+      type?: string;
+    };
+    capture?: boolean;
+  } = {},
+  before?: WrappedFunction,
+): any {
+  // tslint:disable-next-line:strict-type-predicates
+  if (typeof fn !== 'function') {
+    return fn;
+  }
+
+  try {
+    // We don't wanna wrap it twice
+    if ((fn as any).__sentry__) {
+      return fn;
+    }
+
+    // If this has already been wrapped in the past, return that wrapped function
+    if (fn.__sentry_wrapped__) {
+      return fn.__sentry_wrapped__;
+    }
+  } catch (e) {
+    // Just accessing custom props in some environments
+    // can cause a "Permission denied" exception.
+    // Bail on wrapping and return the function as-is.
+    return fn;
+  }
+
+  const sentryWrapped: WrappedFunction = function (this: any, ...args: any[]): any {
+    // tslint:disable-next-line:strict-type-predicates
+    if (before && typeof before === 'function') {
+      before.apply(this, args);
+    }
+
+    try {
+      const wrappedArguments = args.map((arg: any) => wrap(arg, options));
+
+      if ((fn as any).handleEvent) {
+        return (fn as any).handleEvent.apply(this, wrappedArguments);
+      }
+
+      return fn.apply(this, wrappedArguments);
+    } catch (ex) {
+      const scope = getCurrentScope();
+
+      scope.addEventProcessor((event) => {
+        const processedEvent = { ...event };
+
+        if (options.mechanism) {
+          processedEvent.exception = processedEvent.exception || {};
+          (processedEvent.exception as any).mechanism = options.mechanism;
+        }
+
+        processedEvent.extra = {
+          ...processedEvent.extra,
+          arguments: args,
+        };
+
+        return processedEvent;
+      });
+
+      captureException(ex);
+      throw ex;
+    }
+  };
+
+  // Accessing some objects may throw
+  try {
+    // tslint:disable-next-line: no-for-in
+    for (const property in fn) {
+      if (Object.prototype.hasOwnProperty.call(fn, property)) {
+        (sentryWrapped as any)[property] = (fn as any)[property];
+      }
+    }
+  } catch (_oO) {
+    // no-empty
+  }
+
+  fn.prototype = fn.prototype || {};
+  sentryWrapped.prototype = fn.prototype;
+
+  Object.defineProperty(fn, '__sentry_wrapped__', {
+    enumerable: false,
+    value: sentryWrapped,
+  });
+
+  // Signal that this function has been wrapped/filled already
+  Object.defineProperties(sentryWrapped, {
+    __sentry__: {
+      enumerable: false,
+      value: true,
+    },
+    __sentry_original__: {
+      enumerable: false,
+      value: fn,
+    },
+  });
+
+  // Restore original function name
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name') as PropertyDescriptor;
+    if (descriptor.configurable) {
+      Object.defineProperty(sentryWrapped, 'name', {
+        get(): string {
+          return fn.name;
+        },
+      });
+    }
+  } catch (_oO) {
+    // no-empty
+  }
+
+  return sentryWrapped;
+}
+
+/**
+ * Fill an object with a new value, keeping a reference to the original
+ */
+function fill(source: { [key: string]: any }, name: string, replacementFactory: (...args: any[]) => any): void {
+  if (!(name in source)) {
+    return;
+  }
+
+  const original = source[name] as () => any;
+  const wrapped = replacementFactory(original);
+
+  if (typeof wrapped === 'function') {
+    try {
+      wrapped.prototype = wrapped.prototype || {};
+      wrapped.prototype.constructor = wrapped;
+    } catch (_Oo) {
+      // This can throw in some funky environments
+    }
+  }
+
+  source[name] = wrapped;
+}
+
+/**
+ * Safely extract function name from itself
+ */
+function getFunctionName(fn: any): string {
+  try {
+    return (fn && fn.name) || '<anonymous>';
+  } catch (e) {
+    return '<anonymous>';
+  }
+}
+
+/**
+ * TryCatch integration
+ */
+export const tryCatchIntegration: IntegrationFn = () => {
+  return new TryCatch();
+};