sentry-miniapp 1.2.0 → 1.4.0

package/src/helpers.ts

@@ -0,0 +1,214 @@
+import { captureException, getCurrentScope } from '@sentry/core';
+import type { WrappedFunction } from '@sentry/core';
+
+/**
+ * Wrap a function to capture exceptions
+ */
+export function wrap(
+  fn: WrappedFunction,
+  options: {
+    mechanism?: {
+      data?: Record<string, any>;
+      handled?: boolean;
+      type?: string;
+    };
+  } = {},
+  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 {
+      return fn.apply(this, args);
+    } 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;
+}
+
+/**
+ * Check if we should ignore the next onError event
+ */
+let ignoreNextOnError = 0;
+
+/**
+ * Check if we should ignore onError
+ */
+export function shouldIgnoreOnError(): boolean {
+  return ignoreNextOnError > 0;
+}
+
+/**
+ * Ignore next onError
+ */
+export function ignoreNextOnErrorCall(): void {
+  ignoreNextOnError += 1;
+  setTimeout(() => {
+    ignoreNextOnError -= 1;
+  });
+}
+
+/**
+ * Safely extract function name from itself
+ */
+export function getFunctionName(fn: any): string {
+  try {
+    return (fn && fn.name) || '<anonymous>';
+  } catch (e) {
+    return '<anonymous>';
+  }
+}
+
+/**
+ * Fill an object with a new value, keeping a reference to the original
+ */
+export 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;
+}
+
+/**
+ * Check if value is an instance of Error
+ */
+export function isError(wat: any): wat is Error {
+  switch (Object.prototype.toString.call(wat)) {
+    case '[object Error]':
+    case '[object Exception]':
+    case '[object DOMException]':
+      return true;
+    default:
+      return isInstanceOf(wat, Error);
+  }
+}
+
+/**
+ * Check if value is an instance of the given constructor
+ */
+export function isInstanceOf(wat: any, base: any): boolean {
+  try {
+    return wat instanceof base;
+  } catch (_e) {
+    return false;
+  }
+}
+
+/**
+ * Check if value is a string
+ */
+export function isString(wat: any): wat is string {
+  return Object.prototype.toString.call(wat) === '[object String]';
+}
+
+/**
+ * Check if value is a plain object
+ */
+export function isPlainObject(wat: any): wat is Record<string, any> {
+  return Object.prototype.toString.call(wat) === '[object Object]';
+}

package/src/index.ts

@@ -0,0 +1,86 @@
+// Sentry Miniapp SDK for WeChat Mini Program
+// Based on @sentry/core 9.38.0
+// Development Mode: Auto-rebuild enabled
+
+// Install polyfills for miniapp environment
+import { ensurePolyfills } from './polyfills';
+ensurePolyfills();
+
+// Export types from @sentry/core (v9 moved types from @sentry/types to @sentry/core)
+export type {
+  Breadcrumb,
+  BreadcrumbHint,
+  Event,
+  EventHint,
+  Exception,
+  SdkInfo,
+  Session,
+  SeverityLevel,
+  StackFrame,
+  Stacktrace,
+  Thread,
+  User,
+  Integration,
+  Options,
+  Client,
+  Scope,
+  Transport,
+  BaseTransportOptions,
+} from '@sentry/core';
+
+// Export core functions from @sentry/core
+export {
+  addEventProcessor,
+  addIntegration,
+  captureException,
+  captureEvent,
+  captureMessage,
+  getClient,
+  getCurrentScope,
+  getIsolationScope,
+  withScope,
+  startSpan,
+  startInactiveSpan,
+  setContext,
+  setExtra,
+  setExtras,
+  setTag,
+  setTags,
+  setUser,
+  addBreadcrumb,
+  flush,
+  close,
+  lastEventId,
+  isEnabled,
+  // Session management APIs
+  startSession,
+  endSession,
+  captureSession,
+} from '@sentry/core';
+
+// Export SDK specific exports
+export { SDK_NAME, SDK_VERSION } from './version';
+export { init, showReportDialog, wrap, captureFeedback } from './sdk';
+export type { MiniappOptions, SendFeedbackParams } from './types';
+export { MiniappClient } from './client';
+export * as Integrations from './integrations/index';
+export * as Transports from './transports/index';
+
+// Performance API exports
+export {
+  getPerformanceManager,
+  type PerformanceEntry,
+  type NavigationPerformanceEntry,
+  type RenderPerformanceEntry,
+  type ResourcePerformanceEntry,
+  type UserTimingPerformanceEntry,
+  type PerformanceManager,
+  type PerformanceObserver,
+} from './crossPlatform';
+export { performanceIntegration, type PerformanceIntegrationOptions } from './integrations/performance';
+
+// Export Session utility functions from @sentry/core
+export { makeSession, closeSession, updateSession } from '@sentry/core';
+
+// Export default integrations
+export { defaultIntegrations, getDefaultIntegrations } from './sdk';

package/src/integrations/dedupe.ts

@@ -0,0 +1,215 @@
+import type { Event, EventHint, Integration, IntegrationFn } from '@sentry/core';
+
+/** Deduplication filter */
+export class Dedupe implements Integration {
+  /**
+   * @inheritDoc
+   */
+  public static id: string = 'Dedupe';
+
+  /**
+   * @inheritDoc
+   */
+  public name: string = Dedupe.id;
+
+  /**
+   * @inheritDoc
+   */
+  private _previousEvent?: Event;
+
+  /**
+   * @inheritDoc
+   */
+  public setupOnce(): void {
+    // This integration doesn't need setup
+  }
+
+  /**
+   * @inheritDoc
+   */
+  public processEvent(currentEvent: Event, _hint?: EventHint): Event | null {
+    // We want to ignore any non-error type events, e.g. transactions or replays
+    // These should never be deduped, and also not be compared against as _previousEvent.
+    if (currentEvent.type) {
+      return currentEvent;
+    }
+
+    // Juuust in case something goes wrong
+    try {
+      if (this._shouldDropEvent(currentEvent, this._previousEvent)) {
+        return null;
+      }
+    } catch (_oO) {
+      return (this._previousEvent = currentEvent);
+    }
+
+    return (this._previousEvent = currentEvent);
+  }
+
+  /** JSDoc */
+  private _shouldDropEvent(currentEvent: Event, previousEvent?: Event): boolean {
+    if (!previousEvent) {
+      return false;
+    }
+
+    if (this._isSameMessageEvent(currentEvent, previousEvent)) {
+      return true;
+    }
+
+    if (this._isSameExceptionEvent(currentEvent, previousEvent)) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /** JSDoc */
+  private _isSameMessageEvent(currentEvent: Event, previousEvent: Event): boolean {
+    const currentMessage = currentEvent.message;
+    const previousMessage = previousEvent.message;
+
+    // If neither event has a message property, they were both exceptions, so bail out
+    if (!currentMessage && !previousMessage) {
+      return false;
+    }
+
+    // If only one event has a message property, the events are not the same
+    if ((currentMessage && !previousMessage) || (!currentMessage && previousMessage)) {
+      return false;
+    }
+
+    if (currentMessage !== previousMessage) {
+      return false;
+    }
+
+    if (!this._isSameFingerprint(currentEvent, previousEvent)) {
+      return false;
+    }
+
+    if (!this._isSameStacktrace(currentEvent, previousEvent)) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /** JSDoc */
+  private _isSameExceptionEvent(currentEvent: Event, previousEvent: Event): boolean {
+    const currentException = this._getExceptionFromEvent(currentEvent);
+    const previousException = this._getExceptionFromEvent(previousEvent);
+
+    if (!currentException || !previousException) {
+      return false;
+    }
+
+    if (currentException.type !== previousException.type || currentException.value !== previousException.value) {
+      return false;
+    }
+
+    if (!this._isSameFingerprint(currentEvent, previousEvent)) {
+      return false;
+    }
+
+    if (!this._isSameStacktrace(currentEvent, previousEvent)) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /** JSDoc */
+  private _isSameStacktrace(currentEvent: Event, previousEvent: Event): boolean {
+    let currentFrames = this._getFramesFromEvent(currentEvent);
+    let previousFrames = this._getFramesFromEvent(previousEvent);
+
+    // If neither event has a stacktrace, they are assumed to be the same
+    if (!currentFrames && !previousFrames) {
+      return true;
+    }
+
+    // If only one event has a stacktrace, but not the other one, they are not the same
+    if ((currentFrames && !previousFrames) || (!currentFrames && previousFrames)) {
+      return false;
+    }
+
+    currentFrames = currentFrames as any[];
+    previousFrames = previousFrames as any[];
+
+    // If number of frames differ, they are not the same
+    if (previousFrames.length !== currentFrames.length) {
+      return false;
+    }
+
+    // Otherwise, compare the frames
+    for (let i = 0; i < previousFrames.length; i++) {
+      const frameA = previousFrames[i];
+      const frameB = currentFrames[i];
+
+      if (
+        frameA.filename !== frameB.filename ||
+        frameA.lineno !== frameB.lineno ||
+        frameA.colno !== frameB.colno ||
+        frameA.function !== frameB.function
+      ) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  /** JSDoc */
+  private _isSameFingerprint(currentEvent: Event, previousEvent: Event): boolean {
+    let currentFingerprint = currentEvent.fingerprint;
+    let previousFingerprint = previousEvent.fingerprint;
+
+    // If neither event has a fingerprint, they are assumed to be the same
+    if (!currentFingerprint && !previousFingerprint) {
+      return true;
+    }
+
+    // If only one event has a fingerprint, but not the other one, they are not the same
+    if ((currentFingerprint && !previousFingerprint) || (!currentFingerprint && previousFingerprint)) {
+      return false;
+    }
+
+    currentFingerprint = currentFingerprint as string[];
+    previousFingerprint = previousFingerprint as string[];
+
+    // Otherwise, compare the fingerprints
+    try {
+      return !!(currentFingerprint.join('') === previousFingerprint.join(''));
+    } catch (_oO) {
+      return false;
+    }
+  }
+
+  /** JSDoc */
+  private _getExceptionFromEvent(event: Event): any {
+    return event.exception && event.exception.values && event.exception.values[0];
+  }
+
+  /** JSDoc */
+  private _getFramesFromEvent(event: Event): any[] | undefined {
+    const exception = event.exception;
+
+    if (exception) {
+      try {
+        // @ts-expect-error Object could be undefined
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        return exception.values[0].stacktrace.frames;
+      } catch (_oO) {
+        // ignore
+      }
+    }
+
+    return undefined;
+  }
+}
+
+/**
+ * Dedupe integration
+ */
+export const dedupeIntegration: IntegrationFn = () => {
+  return new Dedupe();
+};

package/src/integrations/globalhandlers.ts

@@ -0,0 +1,209 @@
+import { captureException, getCurrentScope } from '@sentry/core';
+import type { Integration, IntegrationFn } from '@sentry/core';
+
+import { sdk } from '../crossPlatform';
+
+/** JSDoc */
+interface GlobalHandlersIntegrations {
+  onerror: boolean;
+  onunhandledrejection: boolean;
+  onpagenotfound: boolean;
+  onmemorywarning: boolean;
+}
+
+/** Global handlers */
+export class GlobalHandlers implements Integration {
+  /**
+   * @inheritDoc
+   */
+  public static id: string = 'GlobalHandlers';
+
+  /**
+   * @inheritDoc
+   */
+  public name: string = GlobalHandlers.id;
+
+  /** JSDoc */
+  private readonly _options: GlobalHandlersIntegrations;
+
+  /** JSDoc */
+  private _onErrorHandlerInstalled: boolean = false;
+
+  /** JSDoc */
+  private _onUnhandledRejectionHandlerInstalled: boolean = false;
+
+  /** JSDoc */
+  private _onPageNotFoundHandlerInstalled: boolean = false;
+
+  /** JSDoc */
+  private _onMemoryWarningHandlerInstalled: boolean = false;
+
+  /** JSDoc */
+  public constructor(options?: Partial<GlobalHandlersIntegrations>) {
+    this._options = {
+      onerror: true,
+      onunhandledrejection: true,
+      onpagenotfound: true,
+      onmemorywarning: true,
+      ...options,
+    };
+  }
+
+  /**
+   * @inheritDoc
+   */
+  public setupOnce(): void {
+    Error.stackTraceLimit = 50;
+
+    if (this._options.onerror) {
+      this._installGlobalOnErrorHandler();
+    }
+
+    if (this._options.onunhandledrejection) {
+      this._installGlobalOnUnhandledRejectionHandler();
+    }
+
+    if (this._options.onpagenotfound) {
+      this._installGlobalOnPageNotFoundHandler();
+    }
+
+    if (this._options.onmemorywarning) {
+      this._installGlobalOnMemoryWarningHandler();
+    }
+  }
+
+  /** JSDoc */
+  private _installGlobalOnErrorHandler(): void {
+    if (this._onErrorHandlerInstalled) {
+      return;
+    }
+
+    if (sdk().onError) {
+      // https://developers.weixin.qq.com/miniprogram/dev/api/base/app/app-event/wx.onError.html
+      sdk().onError?.((err: string | Error) => {
+        const error = typeof err === 'string' ? new Error(err) : err;
+        captureException(error, {
+          mechanism: {
+            type: 'onerror',
+            handled: false,
+          },
+        });
+      });
+    }
+
+    this._onErrorHandlerInstalled = true;
+  }
+
+  /** JSDoc */
+  private _installGlobalOnUnhandledRejectionHandler(): void {
+    if (this._onUnhandledRejectionHandlerInstalled) {
+      return;
+    }
+
+    if (sdk().onUnhandledRejection) {
+      /** JSDoc */
+      interface OnUnhandledRejectionRes {
+        reason: string | Error;
+        promise: Promise<any>;
+      }
+
+      // https://developers.weixin.qq.com/miniprogram/dev/api/base/app/app-event/wx.onUnhandledRejection.html
+      sdk().onUnhandledRejection?.(({ reason, promise }: OnUnhandledRejectionRes) => {
+        const error = typeof reason === 'string' ? new Error(reason) : reason;
+        (captureException as any)(error, {
+          mechanism: {
+            type: 'onunhandledrejection',
+            handled: false,
+          },
+          extra: {
+            promise,
+          },
+        });
+      });
+    }
+
+    this._onUnhandledRejectionHandlerInstalled = true;
+  }
+
+  /** JSDoc */
+  private _installGlobalOnPageNotFoundHandler(): void {
+    if (this._onPageNotFoundHandlerInstalled) {
+      return;
+    }
+
+    if (sdk().onPageNotFound) {
+      sdk().onPageNotFound?.((res: { path: string; query: Record<string, any>; isEntryPage: boolean }) => {
+        const scope = getCurrentScope();
+        const url = res.path.split('?')[0];
+
+        scope.setTag('pagenotfound', url);
+        scope.setContext('page_not_found', {
+          path: res.path,
+          query: res.query,
+          isEntryPage: res.isEntryPage,
+        });
+        
+        (captureException as any)(new Error(`页面无法找到: ${url}`), {
+          level: 'warning',
+          mechanism: {
+            type: 'onpagenotfound',
+            handled: true,
+          },
+        });
+      });
+    }
+
+    this._onPageNotFoundHandlerInstalled = true;
+  }
+
+  /** JSDoc */
+  private _installGlobalOnMemoryWarningHandler(): void {
+    if (this._onMemoryWarningHandlerInstalled) {
+      return;
+    }
+
+    if (sdk().onMemoryWarning) {
+      sdk().onMemoryWarning?.(({ level = -1 }: { level: number }) => {
+        let levelMessage = '没有获取到告警级别信息';
+
+        switch (level) {
+          case 5:
+            levelMessage = 'TRIM_MEMORY_RUNNING_MODERATE';
+            break;
+          case 10:
+            levelMessage = 'TRIM_MEMORY_RUNNING_LOW';
+            break;
+          case 15:
+            levelMessage = 'TRIM_MEMORY_RUNNING_CRITICAL';
+            break;
+          default:
+            return;
+        }
+
+        const scope = getCurrentScope();
+        scope.setTag('memory-warning', String(level));
+        scope.setContext('memory_warning', {
+          level,
+          message: levelMessage,
+        });
+        
+        (captureException as any)(new Error('内存不足告警'), {
+          level: 'warning',
+          mechanism: {
+            type: 'onmemorywarning',
+            handled: true,
+          },
+        });
+      });
+    }
+
+    this._onMemoryWarningHandlerInstalled = true;
+  }
+}
+
+/**
+ * Global handlers integration
+ */
+export const globalHandlersIntegration: IntegrationFn = (options?: Partial<GlobalHandlersIntegrations>) => {
+  return new GlobalHandlers(options);
+};