sentry-miniapp 1.1.0 → 1.2.0

package/dist/sentry-miniapp.umd.js

@@ -249,7 +249,7 @@ var __yieldStar = (value) => {
   ensurePolyfills();
   const DEBUG_BUILD = typeof __SENTRY_DEBUG__ === "undefined" || __SENTRY_DEBUG__;
   const GLOBAL_OBJ = globalThis;
-  const SDK_VERSION$1 = "10.39.0";
+  const SDK_VERSION$1 = "10.45.0";
   function getMainCarrier() {
     getSentryCarrier(GLOBAL_OBJ);
     return GLOBAL_OBJ;
@@ -466,8 +466,7 @@ var __yieldStar = (value) => {
         }
       }
     }
-    const allowedAttrs = ["aria-label", "type", "name", "title", "alt"];
-    for (const k of allowedAttrs) {
+    for (const k of ["aria-label", "type", "name", "title", "alt"]) {
       const attr = elem.getAttribute(k);
       if (attr) {
         out.push(`[${k}="${attr}"]`);
@@ -517,16 +516,9 @@ var __yieldStar = (value) => {
   }
   function getOwnProperties(obj) {
     if (typeof obj === "object" && obj !== null) {
-      const extractedProps = {};
-      for (const property in obj) {
-        if (Object.prototype.hasOwnProperty.call(obj, property)) {
-          extractedProps[property] = obj[property];
-        }
-      }
-      return extractedProps;
-    } else {
-      return {};
+      return Object.fromEntries(Object.entries(obj));
     }
+    return {};
   }
   let RESOLVED_RUNNER;
   function withRandomSafeContext(cb) {
@@ -1557,14 +1549,13 @@ var __yieldStar = (value) => {
     };
   }
   const SENTRY_BAGGAGE_KEY_PREFIX = "sentry-";
-  const SENTRY_BAGGAGE_KEY_PREFIX_REGEX = /^sentry-/;
   function baggageHeaderToDynamicSamplingContext(baggageHeader) {
     const baggageObject = parseBaggageHeader(baggageHeader);
     if (!baggageObject) {
       return void 0;
     }
     const dynamicSamplingContext = Object.entries(baggageObject).reduce((acc, [key, value]) => {
-      if (key.match(SENTRY_BAGGAGE_KEY_PREFIX_REGEX)) {
+      if (key.startsWith(SENTRY_BAGGAGE_KEY_PREFIX)) {
         const nonPrefixedKey = key.slice(SENTRY_BAGGAGE_KEY_PREFIX.length);
         acc[nonPrefixedKey] = value;
       }
@@ -2244,28 +2235,24 @@ ${JSON.stringify(itemHeaders)}
       buffer
     ];
   }
-  const ITEM_TYPE_TO_DATA_CATEGORY_MAP = {
-    session: "session",
+  const DATA_CATEGORY_OVERRIDES = {
     sessions: "session",
-    attachment: "attachment",
-    transaction: "transaction",
     event: "error",
     client_report: "internal",
     user_report: "default",
-    profile: "profile",
     profile_chunk: "profile",
     replay_event: "replay",
     replay_recording: "replay",
     check_in: "monitor",
-    feedback: "feedback",
-    span: "span",
     raw_security: "security",
     log: "log_item",
-    metric: "metric",
     trace_metric: "metric"
   };
+  function _isOverriddenType(type) {
+    return type in DATA_CATEGORY_OVERRIDES;
+  }
   function envelopeItemTypeToDataCategory(type) {
-    return ITEM_TYPE_TO_DATA_CATEGORY_MAP[type];
+    return _isOverriddenType(type) ? DATA_CATEGORY_OVERRIDES[type] : type;
   }
   function getSdkMetadataForEnvelopeHeader(metadataOrEvent) {
     if (!(metadataOrEvent == null ? void 0 : metadataOrEvent.sdk)) {
@@ -3557,10 +3544,10 @@ ${JSON.stringify(itemHeaders)}
   }
   function startSession(context) {
     const isolationScope = getIsolationScope();
-    const currentScope = getCurrentScope();
+    const { user } = getCombinedScopeData(isolationScope, getCurrentScope());
     const { userAgent } = GLOBAL_OBJ.navigator || {};
     const session = makeSession(__spreadValues(__spreadValues({
-      user: currentScope.getUser() || isolationScope.getUser()
+      user
     }, userAgent && { userAgent }), context));
     const currentSession = isolationScope.getSession();
     if ((currentSession == null ? void 0 : currentSession.status) === "ok") {
@@ -4227,6 +4214,7 @@ ${JSON.stringify(itemHeaders)}
     // @ts-expect-error - PromiseLike is a subset of Promise
     close(timeout) {
       return __async(this, null, function* () {
+        _INTERNAL_flushLogsBuffer(this);
         const result = yield this.flush(timeout);
         this.getOptions().enabled = false;
         this.emit("close");
@@ -4374,6 +4362,14 @@ ${JSON.stringify(itemHeaders)}
         return {};
       });
     }
+    /**
+     * Disposes of the client and releases all resources.
+     *
+     * Subclasses should override this method to clean up their own resources.
+     * After calling dispose(), the client should not be used anymore.
+     */
+    dispose() {
+    }
     /* eslint-enable @typescript-eslint/unified-signatures */
     /** Setup integrations for this client. */
     _setupIntegrations() {
@@ -4458,12 +4454,13 @@ ${JSON.stringify(itemHeaders)}
         isolationScope.setLastEventId(event.event_id || hint.event_id);
       }
       return prepareEvent(options, event, hint, currentScope, this, isolationScope).then((evt) => {
+        var _a;
         if (evt === null) {
           return evt;
         }
         this.emit("postprocessEvent", evt, hint);
         evt.contexts = __spreadValues({
-          trace: getTraceContextFromScope(currentScope)
+          trace: __spreadValues(__spreadValues({}, (_a = evt.contexts) == null ? void 0 : _a.trace), getTraceContextFromScope(currentScope))
         }, evt.contexts);
         const dynamicSamplingContext = getDynamicSamplingContextFromScope(this, currentScope);
         evt.sdkProcessingMetadata = __spreadValues({
@@ -4531,11 +4528,12 @@ ${JSON.stringify(itemHeaders)}
       }
       const dataCategory = getDataCategoryByType(event.type);
       return this._prepareEvent(event, hint, currentScope, isolationScope).then((prepared) => {
+        var _a;
         if (prepared === null) {
           this.recordDroppedEvent("event_processor", dataCategory);
           throw _makeDoNotSendEventError("An event processor returned `null`, will not send event.");
         }
-        const isInternalException = hint.data && hint.data.__sentry__ === true;
+        const isInternalException = ((_a = hint.data) == null ? void 0 : _a.__sentry__) === true;
         if (isInternalException) {
           return prepared;
         }
@@ -4820,6 +4818,112 @@ Reason: ${reason}`
   function setCurrentClient(client) {
     getCurrentScope().setClient(client);
   }
+  const MIN_DELAY = 100;
+  const START_DELAY = 5e3;
+  const MAX_DELAY = 36e5;
+  function makeOfflineTransport(createTransport2) {
+    function log2(...args) {
+      DEBUG_BUILD && debug.log("[Offline]:", ...args);
+    }
+    return (options) => {
+      const transport = createTransport2(options);
+      if (!options.createStore) {
+        throw new Error("No `createStore` function was provided");
+      }
+      const store = options.createStore(options);
+      let retryDelay = START_DELAY;
+      let flushTimer;
+      function shouldQueue(env, error2, retryDelay2) {
+        if (envelopeContainsItemType(env, ["client_report"])) {
+          return false;
+        }
+        if (options.shouldStore) {
+          return options.shouldStore(env, error2, retryDelay2);
+        }
+        return true;
+      }
+      function flushIn(delay) {
+        if (flushTimer) {
+          clearTimeout(flushTimer);
+        }
+        flushTimer = safeUnref(
+          setTimeout(() => __async(null, null, function* () {
+            flushTimer = void 0;
+            const found = yield store.shift();
+            if (found) {
+              log2("Attempting to send previously queued event");
+              found[0].sent_at = (/* @__PURE__ */ new Date()).toISOString();
+              void send(found, true).catch((e) => {
+                log2("Failed to retry sending", e);
+              });
+            }
+          }), delay)
+        );
+      }
+      function flushWithBackOff() {
+        if (flushTimer) {
+          return;
+        }
+        flushIn(retryDelay);
+        retryDelay = Math.min(retryDelay * 2, MAX_DELAY);
+      }
+      function send(envelope, isRetry = false) {
+        return __async(this, null, function* () {
+          var _a, _b;
+          if (!isRetry && envelopeContainsItemType(envelope, ["replay_event", "replay_recording"])) {
+            yield store.push(envelope);
+            flushIn(MIN_DELAY);
+            return {};
+          }
+          try {
+            if (options.shouldSend && (yield options.shouldSend(envelope)) === false) {
+              throw new Error("Envelope not sent because `shouldSend` callback returned false");
+            }
+            const result = yield transport.send(envelope);
+            let delay = MIN_DELAY;
+            if (result) {
+              if ((_a = result.headers) == null ? void 0 : _a["retry-after"]) {
+                delay = parseRetryAfterHeader(result.headers["retry-after"]);
+              } else if ((_b = result.headers) == null ? void 0 : _b["x-sentry-rate-limits"]) {
+                delay = 6e4;
+              } else if ((result.statusCode || 0) >= 400) {
+                return result;
+              }
+            }
+            flushIn(delay);
+            retryDelay = START_DELAY;
+            return result;
+          } catch (e) {
+            if (yield shouldQueue(envelope, e, retryDelay)) {
+              if (isRetry) {
+                yield store.unshift(envelope);
+              } else {
+                yield store.push(envelope);
+              }
+              flushWithBackOff();
+              log2("Error sending. Event queued.", e);
+              return {};
+            } else {
+              throw e;
+            }
+          }
+        });
+      }
+      if (options.flushAtStartup) {
+        flushWithBackOff();
+      }
+      return {
+        send,
+        flush: (timeout) => {
+          if (timeout === void 0) {
+            retryDelay = START_DELAY;
+            flushIn(MIN_DELAY);
+          }
+          return transport.flush(timeout);
+        }
+      };
+    };
+  }
   const DEFAULT_BREADCRUMBS = 100;
   function addBreadcrumb(breadcrumb, hint) {
     const client = getClient();
@@ -4836,7 +4940,7 @@ Reason: ${reason}`
     }
     isolationScope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);
   }
-  const SDK_VERSION = "1.0.0-beta.1";
+  const SDK_VERSION = "1.2.0";
   const SDK_NAME = "sentry.javascript.miniapp";
   const getSDK = () => {
     let currentSdk = {
@@ -4864,9 +4968,35 @@ Reason: ${reason}`
       currentSdk = qq;
     } else if (typeof swan === "object" && swan !== null) {
       currentSdk = swan;
+    } else if (typeof ks === "object" && ks !== null) {
+      currentSdk = ks;
     } else {
       throw new Error("sentry-miniapp 暂不支持此平台");
     }
+    if (typeof my === "object" && my !== null && currentSdk === my && !currentSdk.request && currentSdk.httpRequest) {
+      currentSdk.request = currentSdk.httpRequest;
+    }
+    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) => {
+          const res = originalGet.call(currentSdk, { key });
+          return res ? res.data : null;
+        };
+      }
+      if (currentSdk.setStorageSync) {
+        const originalSet = currentSdk.setStorageSync;
+        currentSdk.setStorageSync = (key, data) => {
+          originalSet.call(currentSdk, { key, data });
+        };
+      }
+      if (currentSdk.removeStorageSync) {
+        const originalRemove = currentSdk.removeStorageSync;
+        currentSdk.removeStorageSync = (key) => {
+          originalRemove.call(currentSdk, { key });
+        };
+      }
+    }
     return currentSdk;
   };
   const getAppName = () => {
@@ -4883,6 +5013,8 @@ Reason: ${reason}`
       currentAppName = "qq";
     } else if (typeof swan === "object" && swan !== null) {
       currentAppName = "swan";
+    } else if (typeof ks === "object" && ks !== null) {
+      currentAppName = "kuaishou";
     }
     return currentAppName;
   };
@@ -4922,7 +5054,11 @@ Reason: ${reason}`
         return result;
       }
       if (currentSdk.getSystemInfoSync) {
-        return currentSdk.getSystemInfoSync();
+        const syncInfo = currentSdk.getSystemInfoSync();
+        if (!syncInfo.SDKVersion && syncInfo.version) {
+          syncInfo.SDKVersion = syncInfo.version;
+        }
+        return syncInfo;
       }
       return null;
     } catch (error2) {
@@ -4975,20 +5111,24 @@ Reason: ${reason}`
           header: __spreadValues({
             "Content-Type": "application/json"
           }, request.headers),
+          // Alipay uses `headers` instead of `header`
+          headers: __spreadValues({
+            "Content-Type": "application/json"
+          }, request.headers),
           timeout: 1e4,
           success: (res) => {
-            var _a2, _b2;
-            const status = res.statusCode;
+            const status = res.statusCode || res.status;
+            const resHeaders = res.header || res.headers || {};
             resolve({
               statusCode: status,
               headers: {
-                "x-sentry-rate-limits": (_a2 = res.header) == null ? void 0 : _a2["x-sentry-rate-limits"],
-                "retry-after": (_b2 = res.header) == null ? void 0 : _b2["retry-after"]
+                "x-sentry-rate-limits": resHeaders["x-sentry-rate-limits"],
+                "retry-after": resHeaders["retry-after"]
               }
             });
           },
           fail: (error2) => {
-            reject(new Error(`Network request failed: ${error2.errMsg || error2.message || "Unknown error"}`));
+            reject(new Error(`Network request failed: ${error2.errMsg || error2.errorMessage || error2.message || "Unknown error"}`));
           }
         };
         if (sdk().request) {
@@ -5002,8 +5142,75 @@ Reason: ${reason}`
     }
     return createTransport(options, makeRequest);
   }
+  const MAX_OFFLINE_CACHE_SIZE = 30;
+  const OFFLINE_STORE_KEY = "sentry_offline_store";
+  function createMiniappOfflineStore(_options) {
+    return {
+      push: (env) => __async(null, null, function* () {
+        try {
+          const store = getStore();
+          store.push(env);
+          if (store.length > MAX_OFFLINE_CACHE_SIZE) {
+            store.shift();
+          }
+          setStore(store);
+        } catch (e) {
+          console.warn("[Sentry] Failed to push to offline store", e);
+        }
+      }),
+      unshift: (env) => __async(null, null, function* () {
+        try {
+          const store = getStore();
+          store.unshift(env);
+          if (store.length > MAX_OFFLINE_CACHE_SIZE) {
+            store.pop();
+          }
+          setStore(store);
+        } catch (e) {
+          console.warn("[Sentry] Failed to unshift to offline store", e);
+        }
+      }),
+      shift: () => __async(null, null, function* () {
+        try {
+          const store = getStore();
+          if (store.length === 0) {
+            return void 0;
+          }
+          const env = store.shift();
+          setStore(store);
+          return env;
+        } catch (e) {
+          console.warn("[Sentry] Failed to shift from offline store", e);
+          return void 0;
+        }
+      })
+    };
+  }
+  function getStore() {
+    try {
+      const storageApi = sdk().getStorageSync;
+      if (storageApi) {
+        const storedStr = storageApi(OFFLINE_STORE_KEY);
+        if (storedStr) {
+          return typeof storedStr === "string" ? JSON.parse(storedStr) : storedStr;
+        }
+      }
+    } catch (e) {
+    }
+    return [];
+  }
+  function setStore(store) {
+    try {
+      const storageApi = sdk().setStorageSync;
+      if (storageApi) {
+        storageApi(OFFLINE_STORE_KEY, JSON.stringify(store));
+      }
+    } catch (e) {
+    }
+  }
   const index$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
     __proto__: null,
+    createMiniappOfflineStore,
     createMiniappTransport
   }, Symbol.toStringTag, { value: "Module" }));
   class MiniappClient extends Client {
@@ -5015,9 +5222,17 @@ Reason: ${reason}`
     constructor(options = {}) {
       super(__spreadProps(__spreadValues({}, options), {
         transport: options.transport || ((transportOptions) => {
-          return createMiniappTransport(__spreadProps(__spreadValues({}, transportOptions), {
+          const baseTransport = createMiniappTransport(__spreadProps(__spreadValues({}, transportOptions), {
             headers: {}
           }));
+          if (options.enableOfflineCache !== false) {
+            return makeOfflineTransport(() => baseTransport)(__spreadProps(__spreadValues({}, transportOptions), {
+              createStore: createMiniappOfflineStore,
+              flushAtStartup: true
+              // 启动时自动重试发送
+            }));
+          }
+          return baseTransport;
         })
       }));
     }
@@ -5303,7 +5518,6 @@ Reason: ${reason}`
   const _TryCatch = class _TryCatch {
     constructor() {
       this.name = _TryCatch.id;
-      this._ignoreOnError = 0;
     }
     /** JSDoc */
     _wrapTimeFunction(original) {
@@ -5341,7 +5555,6 @@ Reason: ${reason}`
      * and provide better metadata.
      */
     setupOnce() {
-      this._ignoreOnError = this._ignoreOnError;
       const global2 = globalThis;
       if (global2.setTimeout) {
         fill(global2, "setTimeout", this._wrapTimeFunction.bind(this));