@sentry/browser 6.17.0 → 6.17.1

package/build/bundle.es6.js

@@ -1,4 +1,4 @@
-/*! @sentry/browser 6.17.0 (ad2f4ad) | https://github.com/getsentry/sentry-javascript */
+/*! @sentry/browser 6.17.1 (97cf273) | https://github.com/getsentry/sentry-javascript */
 var Sentry = (function (exports) {
   /**
    * TODO(v7): Remove this enum and replace with SeverityLevel
@@ -3861,10 +3861,7 @@ var Sentry = (function (exports) {
               // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
               normalized.contexts.trace = event.contexts.trace;
           }
-          const { _experiments = {} } = this.getOptions();
-          if (_experiments.ensureNoCircularStructures) {
-              return normalize(normalized);
-          }
+          event.sdkProcessingMetadata = Object.assign(Object.assign({}, event.sdkProcessingMetadata), { baseClientNormalized: true });
           return normalized;
       }
       /**
@@ -4165,10 +4162,56 @@ var Sentry = (function (exports) {
       const useEnvelope = eventType === 'transaction' || !!api.tunnel;
       const { transactionSampling } = event.sdkProcessingMetadata || {};
       const { method: samplingMethod, rate: sampleRate } = transactionSampling || {};
+      // TODO: Below is a temporary hack in order to debug a serialization error - see
+      // https://github.com/getsentry/sentry-javascript/issues/2809 and
+      // https://github.com/getsentry/sentry-javascript/pull/4425. TL;DR: even though we normalize all events (which should
+      // prevent this), something is causing `JSON.stringify` to throw a circular reference error.
+      //
+      // When it's time to remove it:
+      // 1. Delete everything between here and where the request object `req` is created, EXCEPT the line deleting
+      //    `sdkProcessingMetadata`
+      // 2. Restore the original version of the request body, which is commented out
+      // 3. Search for `skippedNormalization` and pull out the companion hack in the browser playwright tests
+      enhanceEventWithSdkInfo(event, api.metadata.sdk);
+      event.tags = event.tags || {};
+      event.extra = event.extra || {};
+      // In theory, all events should be marked as having gone through normalization and so
+      // we should never set this tag
+      if (!(event.sdkProcessingMetadata && event.sdkProcessingMetadata.baseClientNormalized)) {
+          event.tags.skippedNormalization = true;
+      }
       // prevent this data from being sent to sentry
+      // TODO: This is NOT part of the hack - DO NOT DELETE
       delete event.sdkProcessingMetadata;
+      let body;
+      try {
+          // 99.9% of events should get through just fine - no change in behavior for them
+          body = JSON.stringify(event);
+      }
+      catch (err) {
+          // Record data about the error without replacing original event data, then force renormalization
+          event.tags.JSONStringifyError = true;
+          event.extra.JSONStringifyError = err;
+          try {
+              body = JSON.stringify(normalize(event));
+          }
+          catch (newErr) {
+              // At this point even renormalization hasn't worked, meaning something about the event data has gone very wrong.
+              // Time to cut our losses and record only the new error. With luck, even in the problematic cases we're trying to
+              // debug with this hack, we won't ever land here.
+              const innerErr = newErr;
+              body = JSON.stringify({
+                  message: 'JSON.stringify error after renormalization',
+                  // setting `extra: { innerErr }` here for some reason results in an empty object, so unpack manually
+                  extra: { message: innerErr.message, stack: innerErr.stack },
+              });
+          }
+      }
       const req = {
-          body: JSON.stringify(sdkInfo ? enhanceEventWithSdkInfo(event, api.metadata.sdk) : event),
+          // this is the relevant line of code before the hack was added, to make it easy to undo said hack once we've solved
+          // the mystery
+          // body: JSON.stringify(sdkInfo ? enhanceEventWithSdkInfo(event, api.metadata.sdk) : event),
+          body,
           type: eventType,
           url: useEnvelope
               ? getEnvelopeEndpointWithUrlEncodedAuth(api.dsn, api.tunnel)
@@ -4217,7 +4260,7 @@ var Sentry = (function (exports) {
       hub.bindClient(client);
   }
 
-  const SDK_VERSION = '6.17.0';
+  const SDK_VERSION = '6.17.1';
 
   let originalFunctionToString;
   /** Patch toString calls to return proper name for wrapped functions */