sentry-miniapp 1.3.0 → 1.4.0

package/src/integrations/httpcontext.ts

@@ -0,0 +1,140 @@
+import { getCurrentScope } from '@sentry/core';
+import type { Event, Integration, IntegrationFn } from '@sentry/core';
+
+import { sdk, getSystemInfo } from '../crossPlatform';
+
+/** Add node request data to the event */
+export class HttpContext implements Integration {
+  /**
+   * @inheritDoc
+   */
+  public static id: string = 'HttpContext';
+
+  /**
+   * @inheritDoc
+   */
+  public name: string = HttpContext.id;
+
+  /**
+   * @inheritDoc
+   */
+  public setupOnce(): void {
+    // This integration adds context during event processing
+  }
+
+  /**
+   * @inheritDoc
+   */
+  public processEvent(event: Event): Event {
+    const scope = getCurrentScope();
+
+    // Add miniapp specific context
+    const context = {
+      runtime: {
+        name: 'miniapp',
+        version: this._getMiniappVersion(),
+      },
+      app: {
+        name: this._getAppName(),
+        version: this._getAppVersion(),
+      },
+      device: this._getDeviceInfo(),
+      network: this._getNetworkInfo(),
+    };
+
+    scope.setContext('runtime', context.runtime);
+    scope.setContext('app', context.app);
+    scope.setContext('device', context.device);
+    scope.setContext('network', context.network);
+
+    return event;
+  }
+
+  /**
+   * Get miniapp version
+   */
+  private _getMiniappVersion(): string {
+    const sys = getSystemInfo();
+    return sys?.version || sys?.SDKVersion || 'unknown';
+  }
+
+  /**
+   * Get app name
+   */
+  private _getAppName(): string {
+    try {
+      if (sdk().getAccountInfoSync) {
+        const accountInfo = sdk().getAccountInfoSync?.();
+        return accountInfo.miniProgram?.appId || 'unknown';
+      }
+    } catch (e) {
+      // Ignore errors
+    }
+    return 'unknown';
+  }
+
+  /**
+   * Get app version
+   */
+  private _getAppVersion(): string {
+    try {
+      if (sdk().getAccountInfoSync) {
+        const accountInfo = sdk().getAccountInfoSync?.();
+        return accountInfo?.miniProgram?.version || 'unknown';
+      }
+    } catch (e) {
+      // Ignore errors
+    }
+    return 'unknown';
+  }
+
+  /**
+   * Get device information
+   */
+  private _getDeviceInfo(): Record<string, any> {
+    const sys = getSystemInfo();
+    if (!sys) return {};
+
+    return {
+      brand: sys.brand,
+      model: sys.model,
+      system: sys.system,
+      platform: sys.platform,
+      screenWidth: sys.screenWidth,
+      screenHeight: sys.screenHeight,
+      windowWidth: sys.windowWidth,
+      windowHeight: sys.windowHeight,
+      pixelRatio: sys.pixelRatio,
+      language: sys.language,
+    };
+  }
+
+  /**
+   * Get network information
+   */
+  private _getNetworkInfo(): Record<string, any> {
+    try {
+      if ((sdk() as any).getNetworkType) {
+        (sdk() as any).getNetworkType({
+          success: (res: { networkType: string }) => {
+            const scope = getCurrentScope();
+            scope.setTag('network.type', res.networkType);
+            scope.setContext('network', {
+              type: res.networkType,
+            });
+          },
+        });
+      }
+    } catch (e) {
+      // Ignore errors
+    }
+    return {};
+  }
+}
+
+/**
+ * HttpContext integration
+ */
+export const httpContextIntegration: IntegrationFn = () => {
+  return new HttpContext();
+};

package/src/integrations/index.ts

@@ -0,0 +1,10 @@
+export { GlobalHandlers } from './globalhandlers';
+export { TryCatch } from './trycatch';
+export { LinkedErrors } from './linkederrors';
+export { HttpContext } from './httpcontext';
+export { Dedupe } from './dedupe';
+export { System } from './system';
+export { Router } from './router';
+export { PerformanceIntegration, performanceIntegration } from './performance';
+export { RewriteFrames } from './rewriteframes';
+export { NetworkBreadcrumbs } from './networkbreadcrumbs';

package/src/integrations/linkederrors.ts

@@ -0,0 +1,107 @@
+import type { Event, EventHint, Exception, ExtendedError, Integration, IntegrationFn } from '@sentry/core';
+import { exceptionFromError, getCurrentScope } from '@sentry/core';
+
+const DEFAULT_KEY = 'cause';
+const DEFAULT_LIMIT = 5;
+
+/** Adds SDK info to the event */
+export class LinkedErrors implements Integration {
+  /**
+   * @inheritDoc
+   */
+  public static id: string = 'LinkedErrors';
+
+  /**
+   * @inheritDoc
+   */
+  public name: string = LinkedErrors.id;
+
+  /**
+   * @inheritDoc
+   */
+  private readonly _key: string;
+
+  /**
+   * @inheritDoc
+   */
+  private readonly _limit: number;
+
+  /**
+   * @inheritDoc
+   */
+  public constructor(options: { key?: string; limit?: number } = {}) {
+    this._key = options.key || DEFAULT_KEY;
+    this._limit = options.limit || DEFAULT_LIMIT;
+  }
+
+  /**
+   * @inheritDoc
+   */
+  public setupOnce(): void {
+    // This integration doesn't need setup
+  }
+
+  /**
+   * @inheritDoc
+   */
+  public processEvent(event: Event, hint?: EventHint): Event {
+    const client = getCurrentScope().getClient();
+    if (!client) {
+      return event;
+    }
+
+    // const options = client.getOptions();
+    // Note: getCurrentScope() doesn't have getIntegration method, so we'll process directly
+    return this._handler(event, hint);
+  }
+
+  /**
+   * @inheritDoc
+   */
+  private _handler(event: Event, hint?: EventHint): Event {
+    if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {
+      return event;
+    }
+
+    const linkedErrors = this._walkErrorTree(hint.originalException as ExtendedError, this._key);
+    event.exception.values = [...linkedErrors, ...event.exception.values];
+
+    return event;
+  }
+
+  /**
+   * @inheritDoc
+   */
+  private _walkErrorTree(error: ExtendedError, key: string, stack: Exception[] = []): Exception[] {
+    if (!isInstanceOf(error[key], Error) || stack.length + 1 >= this._limit) {
+      return stack;
+    }
+
+    const exception = exceptionFromError(() => [], error[key]);
+    return this._walkErrorTree(error[key], key, [exception, ...stack]);
+  }
+}
+
+/**
+ * Checks whether given value's type is one of a few Error or Error-like
+ * {@link isError}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isInstanceOf(wat: any, base: any): boolean {
+  try {
+    return wat instanceof base;
+  } catch (_e) {
+    return false;
+  }
+}
+
+
+
+/**
+ * LinkedErrors integration
+ */
+export const linkedErrorsIntegration: IntegrationFn = (options?: { key?: string; limit?: number }) => {
+  return new LinkedErrors(options);
+};

package/src/integrations/networkbreadcrumbs.ts

@@ -0,0 +1,155 @@
+import { addBreadcrumb, getClient } from '@sentry/core';
+import type { Integration } from '@sentry/core';
+import { fill } from '../helpers';
+import { sdk } from '../crossPlatform';
+
+/**
+ * Network Breadcrumbs Integration.
+ * Monkey patches miniapp network API (e.g. wx.request, my.httpRequest)
+ * to record network breadcrumbs, including request and response body if configured.
+ */
+export class NetworkBreadcrumbs implements Integration {
+  /**
+   * @inheritDoc
+   */
+  public static id: string = 'NetworkBreadcrumbs';
+
+  /**
+   * @inheritDoc
+   */
+  public name: string = NetworkBreadcrumbs.id;
+
+  private readonly _traceNetworkBody: boolean;
+
+  public constructor(options: { traceNetworkBody?: boolean | undefined } = {}) {
+    this._traceNetworkBody = !!options.traceNetworkBody;
+  }
+
+  /**
+   * @inheritDoc
+   */
+  public setupOnce(): void {
+    const miniappSdk = sdk();
+
+    // Intercept standard request (WeChat, ByteDance, Swan, etc.)
+    if (miniappSdk && typeof miniappSdk.request === 'function') {
+      fill(miniappSdk, 'request', this._createRequestWrapper.bind(this));
+    }
+
+    // Intercept Alipay request
+    if (miniappSdk && typeof miniappSdk.httpRequest === 'function') {
+      fill(miniappSdk, 'httpRequest', this._createRequestWrapper.bind(this));
+    }
+  }
+
+  /**
+   * Wraps the miniapp request API to capture breadcrumbs
+   */
+  private _createRequestWrapper(originalRequest: Function): Function {
+    const traceNetworkBody = this._traceNetworkBody;
+
+    return function (this: any, options: any): any {
+      if (!options || typeof options !== 'object') {
+        return originalRequest.call(this, options);
+      }
+
+      const url = options.url || '';
+
+      // Get the configured DSN/Transport URL from the current client
+      const client = getClient();
+      let dsnUrl = '';
+      if (client) {
+        const dsn = client.getOptions().dsn;
+        if (dsn) {
+          // A DSN looks like https://key@sentry.io/123
+          // We extract just the host part to filter against
+          try {
+            const dsnMatch = dsn.match(/^(?:https?:\/\/)?(?:[^@\n]+@)?([^:/\n]+)/i);
+            if (dsnMatch && dsnMatch[1]) {
+              dsnUrl = dsnMatch[1];
+            }
+          } catch (e) {
+            // fallback
+          }
+        }
+      }
+
+      // Ignore Sentry's own requests to prevent infinite loops
+      // Fallback to 'sentry.io' if DSN extraction fails but it's the SaaS version
+      if (typeof url === 'string') {
+        const isSentryRequest = (dsnUrl && url.indexOf(dsnUrl) !== -1) || url.indexOf('sentry.io') !== -1;
+        if (isSentryRequest) {
+          return originalRequest.call(this, options);
+        }
+      }
+
+      const method = (options.method || 'GET').toUpperCase();
+      const requestData = options.data;
+
+      const breadcrumbData: Record<string, any> = {
+        url,
+        method,
+      };
+
+      if (traceNetworkBody && requestData) {
+        try {
+          breadcrumbData['request_body'] = typeof requestData === 'string'
+            ? requestData
+            : JSON.stringify(requestData);
+        } catch (e) {
+          breadcrumbData['request_body'] = '[Cannot serialize request body]';
+        }
+      }
+
+      const originalSuccess = options.success;
+      const originalFail = options.fail;
+
+      // Wrap success callback
+      options.success = function (this: any, ...args: any[]) {
+        const res = args[0] || {};
+        const statusCode = res.statusCode || res.status;
+        breadcrumbData['status_code'] = statusCode;
+
+        if (traceNetworkBody && res.data) {
+          try {
+            breadcrumbData['response_body'] = typeof res.data === 'string'
+              ? res.data
+              : JSON.stringify(res.data);
+          } catch (e) {
+            breadcrumbData['response_body'] = '[Cannot serialize response body]';
+          }
+        }
+
+        addBreadcrumb({
+          type: 'http',
+          category: 'xhr',
+          data: breadcrumbData,
+          level: statusCode >= 400 ? 'warning' : 'info',
+        });
+
+        if (typeof originalSuccess === 'function') {
+          return originalSuccess.apply(this, args);
+        }
+      };
+
+      // Wrap fail callback
+      options.fail = function (this: any, ...args: any[]) {
+        const err = args[0] || {};
+        breadcrumbData['error'] = err.errMsg || err.errorMessage || 'Network request failed';
+
+        addBreadcrumb({
+          type: 'http',
+          category: 'xhr',
+          data: breadcrumbData,
+          level: 'error',
+        });
+
+        if (typeof originalFail === 'function') {
+          return originalFail.apply(this, args);
+        }
+      };
+
+      return originalRequest.call(this, options);
+    };
+  }
+}