sentry-miniapp 1.1.0 → 1.2.0

package/dist/sentry-miniapp.esm.js

@@ -245,7 +245,7 @@ function ensurePolyfills() {
 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;
@@ -462,8 +462,7 @@ function _htmlElementAsString(el, keyAttrs) {
       }
     }
   }
-  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}"]`);
@@ -513,16 +512,9 @@ function serializeEventTarget(target) {
 }
 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) {
@@ -1553,14 +1545,13 @@ function getCapturedScopesOnSpan(span) {
   };
 }
 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;
     }
@@ -2240,28 +2231,24 @@ function createAttachmentEnvelopeItem(attachment) {
     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)) {
@@ -3553,10 +3540,10 @@ function addEventProcessor(callback) {
 }
 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") {
@@ -4223,6 +4210,7 @@ class Client {
   // @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");
@@ -4370,6 +4358,14 @@ class Client {
       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() {
@@ -4454,12 +4450,13 @@ class Client {
       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({
@@ -4527,11 +4524,12 @@ class Client {
     }
     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;
       }
@@ -4816,6 +4814,112 @@ function initAndBind(clientClass, options) {
 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();
@@ -4832,7 +4936,7 @@ function addBreadcrumb(breadcrumb, hint) {
   }
   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 = {
@@ -4860,9 +4964,35 @@ const getSDK = () => {
     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 = () => {
@@ -4879,6 +5009,8 @@ const getAppName = () => {
     currentAppName = "qq";
   } else if (typeof swan === "object" && swan !== null) {
     currentAppName = "swan";
+  } else if (typeof ks === "object" && ks !== null) {
+    currentAppName = "kuaishou";
   }
   return currentAppName;
 };
@@ -4918,7 +5050,11 @@ const getSystemInfo = () => {
       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) {
@@ -4971,20 +5107,24 @@ function createMiniappTransport(options) {
         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) {
@@ -4998,8 +5138,75 @@ function createMiniappTransport(options) {
   }
   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 {
@@ -5011,9 +5218,17 @@ class MiniappClient extends Client {
   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;
       })
     }));
   }
@@ -5299,7 +5514,6 @@ let GlobalHandlers = _GlobalHandlers;
 const _TryCatch = class _TryCatch {
   constructor() {
     this.name = _TryCatch.id;
-    this._ignoreOnError = 0;
   }
   /** JSDoc */
   _wrapTimeFunction(original) {
@@ -5337,7 +5551,6 @@ const _TryCatch = class _TryCatch {
    * and provide better metadata.
    */
   setupOnce() {
-    this._ignoreOnError = this._ignoreOnError;
     const global2 = globalThis;
     if (global2.setTimeout) {
       fill(global2, "setTimeout", this._wrapTimeFunction.bind(this));