@sentry/browser 10.53.0 → 10.54.0

package/build/npm/cjs/dev/helpers.js

@@ -2,178 +2,100 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const browser = require('@sentry/core/browser');
 
-const WINDOW = browser.GLOBAL_OBJ ;
-
+const WINDOW = browser.GLOBAL_OBJ;
 let ignoreOnError = 0;
-
-/**
- * @hidden
- */
 function shouldIgnoreOnError() {
   return ignoreOnError > 0;
 }
-
-/**
- * @hidden
- */
 function ignoreNextOnError() {
-  // onerror should trigger before setTimeout
   ignoreOnError++;
   setTimeout(() => {
     ignoreOnError--;
   });
 }
-
-// eslint-disable-next-line @typescript-eslint/ban-types
-
-/**
- * Instruments the given function and sends an event to Sentry every time the
- * function throws an exception.
- *
- * @param fn A function to wrap. It is generally safe to pass an unbound function, because the returned wrapper always
- * has a correct `this` context.
- * @returns The wrapped function.
- * @hidden
- */
-function wrap(
-  fn,
-  options
-
- = {},
-) {
-  // for future readers what this does is wrap a function and then create
-  // a bi-directional wrapping between them.
-  //
-  // example: wrapped = wrap(original);
-  //  original.__sentry_wrapped__ -> wrapped
-  //  wrapped.__sentry_original__ -> original
-
-  function isFunction(fn) {
-    return typeof fn === 'function';
+function wrap(fn, options = {}) {
+  function isFunction(fn2) {
+    return typeof fn2 === "function";
   }
-
   if (!isFunction(fn)) {
     return fn;
   }
-
   try {
-    // if we're dealing with a function that was previously wrapped, return
-    // the original wrapper.
-    const wrapper = (fn ).__sentry_wrapped__;
+    const wrapper = fn.__sentry_wrapped__;
     if (wrapper) {
-      if (typeof wrapper === 'function') {
+      if (typeof wrapper === "function") {
         return wrapper;
       } else {
-        // If we find that the `__sentry_wrapped__` function is not a function at the time of accessing it, it means
-        // that something messed with it. In that case we want to return the originally passed function.
         return fn;
       }
     }
-
-    // We don't wanna wrap it twice
     if (browser.getOriginalFunction(fn)) {
       return fn;
     }
   } catch {
-    // Just accessing custom props in some Selenium environments
-    // can cause a "Permission denied" exception (see raven-js#495).
-    // Bail on wrapping and return the function as-is (defers to window.onerror).
     return fn;
   }
-
-  // Wrap the function itself
-  // It is important that `sentryWrapped` is not an arrow function to preserve the context of `this`
-  const sentryWrapped = function ( ...args) {
+  const sentryWrapped = function(...args) {
+    browser.GLOBAL_OBJ._sentryWrappedDepth = (browser.GLOBAL_OBJ._sentryWrappedDepth || 0) + 1;
     try {
-      // Also wrap arguments that are themselves functions
-      const wrappedArguments = args.map(arg => wrap(arg, options));
-
-      // Attempt to invoke user-land function
-      // NOTE: If you are a Sentry user, and you are seeing this stack frame, it
-      //       means the sentry.javascript SDK caught an error invoking your application code. This
-      //       is expected behavior and NOT indicative of a bug with sentry.javascript.
+      const wrappedArguments = args.map((arg) => wrap(arg, options));
       return fn.apply(this, wrappedArguments);
     } catch (ex) {
       ignoreNextOnError();
-
-      browser.withScope(scope => {
-        scope.addEventProcessor(event => {
+      browser.withScope((scope) => {
+        scope.addEventProcessor((event) => {
           if (options.mechanism) {
-            browser.addExceptionTypeValue(event, undefined, undefined);
+            browser.addExceptionTypeValue(event, void 0, void 0);
             browser.addExceptionMechanism(event, options.mechanism);
           }
-
           event.extra = {
             ...event.extra,
-            arguments: args,
+            arguments: args
           };
-
           return event;
         });
-
-        // no need to add a mechanism here, we already add it via an event processor above
         browser.captureException(ex);
       });
-
       throw ex;
+    } finally {
+      browser.GLOBAL_OBJ._sentryWrappedDepth = (browser.GLOBAL_OBJ._sentryWrappedDepth || 0) - 1;
     }
-  } ;
-
-  // Wrap the wrapped function in a proxy, to ensure any other properties of the original function remain available
+  };
   try {
     for (const property in fn) {
       if (Object.prototype.hasOwnProperty.call(fn, property)) {
-        sentryWrapped[property ] = fn[property ];
+        sentryWrapped[property] = fn[property];
       }
     }
   } catch {
-    // Accessing some objects may throw
-    // ref: https://github.com/getsentry/sentry-javascript/issues/1168
   }
-
-  // Signal that this function has been wrapped/filled already
-  // for both debugging and to prevent it to being wrapped/filled twice
   browser.markFunctionWrapped(sentryWrapped, fn);
-
-  browser.addNonEnumerableProperty(fn, '__sentry_wrapped__', sentryWrapped);
-
-  // Restore original function name (not all browsers allow that)
+  browser.addNonEnumerableProperty(fn, "__sentry_wrapped__", sentryWrapped);
   try {
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name');
+    const descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, "name");
     if (descriptor.configurable) {
-      Object.defineProperty(sentryWrapped, 'name', {
+      Object.defineProperty(sentryWrapped, "name", {
         get() {
           return fn.name;
-        },
+        }
       });
     }
   } catch {
-    // This may throw if e.g. the descriptor does not exist, or a browser does not allow redefining `name`.
-    // to save some bytes we simply try-catch this
   }
-
   return sentryWrapped;
 }
-
-/**
- * Get HTTP request data from the current page.
- */
 function getHttpRequestData() {
-  // grab as much info as exists and add it to the event
   const url = browser.getLocationHref();
   const { referrer } = WINDOW.document || {};
   const { userAgent } = WINDOW.navigator || {};
-
   const headers = {
-    ...(referrer && { Referer: referrer }),
-    ...(userAgent && { 'User-Agent': userAgent }),
+    ...referrer && { Referer: referrer },
+    ...userAgent && { "User-Agent": userAgent }
   };
   const request = {
     url,
-    headers,
+    headers
   };
-
   return request;
 }
 

package/build/npm/cjs/dev/helpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.js","sources":["../../../../src/helpers.ts"],"sourcesContent":["import type { Mechanism, WrappedFunction } from '@sentry/core/browser';\nimport {\n  addExceptionMechanism,\n  addExceptionTypeValue,\n  addNonEnumerableProperty,\n  captureException,\n  getLocationHref,\n  getOriginalFunction,\n  GLOBAL_OBJ,\n  markFunctionWrapped,\n  withScope,\n} from '@sentry/core/browser';\n\nexport const WINDOW = GLOBAL_OBJ as typeof GLOBAL_OBJ & Window;\n\nlet ignoreOnError: number = 0;\n\n/**\n * @hidden\n */\nexport function shouldIgnoreOnError(): boolean {\n  return ignoreOnError > 0;\n}\n\n/**\n * @hidden\n */\nexport function ignoreNextOnError(): void {\n  // onerror should trigger before setTimeout\n  ignoreOnError++;\n  setTimeout(() => {\n    ignoreOnError--;\n  });\n}\n\n// eslint-disable-next-line @typescript-eslint/ban-types\ntype WrappableFunction = Function;\n\nexport function wrap<T extends WrappableFunction>(\n  fn: T,\n  options?: {\n    mechanism?: Mechanism;\n  },\n): WrappedFunction<T>;\nexport function wrap<NonFunction>(\n  fn: NonFunction,\n  options?: {\n    mechanism?: Mechanism;\n  },\n): NonFunction;\n/**\n * Instruments the given function and sends an event to Sentry every time the\n * function throws an exception.\n *\n * @param fn A function to wrap. It is generally safe to pass an unbound function, because the returned wrapper always\n * has a correct `this` context.\n * @returns The wrapped function.\n * @hidden\n */\nexport function wrap<T extends WrappableFunction, NonFunction>(\n  fn: T | NonFunction,\n  options: {\n    mechanism?: Mechanism;\n  } = {},\n): NonFunction | WrappedFunction<T> {\n  // for future readers what this does is wrap a function and then create\n  // a bi-directional wrapping between them.\n  //\n  // example: wrapped = wrap(original);\n  //  original.__sentry_wrapped__ -> wrapped\n  //  wrapped.__sentry_original__ -> original\n\n  function isFunction(fn: T | NonFunction): fn is T {\n    return typeof fn === 'function';\n  }\n\n  if (!isFunction(fn)) {\n    return fn;\n  }\n\n  try {\n    // if we're dealing with a function that was previously wrapped, return\n    // the original wrapper.\n    const wrapper = (fn as WrappedFunction<T>).__sentry_wrapped__;\n    if (wrapper) {\n      if (typeof wrapper === 'function') {\n        return wrapper;\n      } else {\n        // If we find that the `__sentry_wrapped__` function is not a function at the time of accessing it, it means\n        // that something messed with it. In that case we want to return the originally passed function.\n        return fn;\n      }\n    }\n\n    // We don't wanna wrap it twice\n    if (getOriginalFunction(fn)) {\n      return fn;\n    }\n  } catch {\n    // Just accessing custom props in some Selenium environments\n    // can cause a \"Permission denied\" exception (see raven-js#495).\n    // Bail on wrapping and return the function as-is (defers to window.onerror).\n    return fn;\n  }\n\n  // Wrap the function itself\n  // It is important that `sentryWrapped` is not an arrow function to preserve the context of `this`\n  const sentryWrapped = function (this: unknown, ...args: unknown[]): unknown {\n    try {\n      // Also wrap arguments that are themselves functions\n      const wrappedArguments = args.map(arg => wrap(arg, options));\n\n      // Attempt to invoke user-land function\n      // NOTE: If you are a Sentry user, and you are seeing this stack frame, it\n      //       means the sentry.javascript SDK caught an error invoking your application code. This\n      //       is expected behavior and NOT indicative of a bug with sentry.javascript.\n      return fn.apply(this, wrappedArguments);\n    } catch (ex) {\n      ignoreNextOnError();\n\n      withScope(scope => {\n        scope.addEventProcessor(event => {\n          if (options.mechanism) {\n            addExceptionTypeValue(event, undefined, undefined);\n            addExceptionMechanism(event, options.mechanism);\n          }\n\n          event.extra = {\n            ...event.extra,\n            arguments: args,\n          };\n\n          return event;\n        });\n\n        // no need to add a mechanism here, we already add it via an event processor above\n        captureException(ex);\n      });\n\n      throw ex;\n    }\n  } as unknown as WrappedFunction<T>;\n\n  // Wrap the wrapped function in a proxy, to ensure any other properties of the original function remain available\n  try {\n    for (const property in fn) {\n      if (Object.prototype.hasOwnProperty.call(fn, property)) {\n        sentryWrapped[property as keyof T] = fn[property as keyof T];\n      }\n    }\n  } catch {\n    // Accessing some objects may throw\n    // ref: https://github.com/getsentry/sentry-javascript/issues/1168\n  }\n\n  // Signal that this function has been wrapped/filled already\n  // for both debugging and to prevent it to being wrapped/filled twice\n  markFunctionWrapped(sentryWrapped, fn);\n\n  addNonEnumerableProperty(fn, '__sentry_wrapped__', sentryWrapped);\n\n  // Restore original function name (not all browsers allow that)\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name')!;\n    if (descriptor.configurable) {\n      Object.defineProperty(sentryWrapped, 'name', {\n        get(): string {\n          return fn.name;\n        },\n      });\n    }\n  } catch {\n    // This may throw if e.g. the descriptor does not exist, or a browser does not allow redefining `name`.\n    // to save some bytes we simply try-catch this\n  }\n\n  return sentryWrapped;\n}\n\n/**\n * Get HTTP request data from the current page.\n */\nexport function getHttpRequestData(): { url: string; headers: Record<string, string> } {\n  // grab as much info as exists and add it to the event\n  const url = getLocationHref();\n  const { referrer } = WINDOW.document || {};\n  const { userAgent } = WINDOW.navigator || {};\n\n  const headers = {\n    ...(referrer && { Referer: referrer }),\n    ...(userAgent && { 'User-Agent': userAgent }),\n  };\n  const request = {\n    url,\n    headers,\n  };\n\n  return request;\n}\n"],"names":["GLOBAL_OBJ","getOriginalFunction","withScope","addExceptionTypeValue","addExceptionMechanism","captureException","markFunctionWrapped","addNonEnumerableProperty","getLocationHref"],"mappings":";;;;AAaO,MAAM,MAAA,GAASA,kBAAA;;AAEtB,IAAI,aAAa,GAAW,CAAC;;AAE7B;AACA;AACA;AACO,SAAS,mBAAmB,GAAY;AAC/C,EAAE,OAAO,aAAA,GAAgB,CAAC;AAC1B;;AAEA;AACA;AACA;AACO,SAAS,iBAAiB,GAAS;AAC1C;AACA,EAAE,aAAa,EAAE;AACjB,EAAE,UAAU,CAAC,MAAM;AACnB,IAAI,aAAa,EAAE;AACnB,EAAE,CAAC,CAAC;AACJ;;AAEA;;AAeA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,IAAI;AACpB,EAAE,EAAE;AACJ,EAAE;;AAEA,GAAI,EAAE;AACR,EAAoC;AACpC;AACA;AACA;AACA;AACA;AACA;;AAEA,EAAE,SAAS,UAAU,CAAC,EAAE,EAA4B;AACpD,IAAI,OAAO,OAAO,EAAA,KAAO,UAAU;AACnC,EAAE;;AAEF,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,EAAE;AACvB,IAAI,OAAO,EAAE;AACb,EAAE;;AAEF,EAAE,IAAI;AACN;AACA;AACA,IAAI,MAAM,OAAA,GAAU,CAAC,EAAA,GAA0B,kBAAkB;AACjE,IAAI,IAAI,OAAO,EAAE;AACjB,MAAM,IAAI,OAAO,OAAA,KAAY,UAAU,EAAE;AACzC,QAAQ,OAAO,OAAO;AACtB,MAAM,OAAO;AACb;AACA;AACA,QAAQ,OAAO,EAAE;AACjB,MAAM;AACN,IAAI;;AAEJ;AACA,IAAI,IAAIC,2BAAmB,CAAC,EAAE,CAAC,EAAE;AACjC,MAAM,OAAO,EAAE;AACf,IAAI;AACJ,EAAE,EAAE,MAAM;AACV;AACA;AACA;AACA,IAAI,OAAO,EAAE;AACb,EAAE;;AAEF;AACA;AACA,EAAE,MAAM,gBAAgB,WAAyB,GAAG,IAAI,EAAsB;AAC9E,IAAI,IAAI;AACR;AACA,MAAM,MAAM,gBAAA,GAAmB,IAAI,CAAC,GAAG,CAAC,GAAA,IAAO,IAAI,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;;AAElE;AACA;AACA;AACA;AACA,MAAM,OAAO,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,gBAAgB,CAAC;AAC7C,IAAI,CAAA,CAAE,OAAO,EAAE,EAAE;AACjB,MAAM,iBAAiB,EAAE;;AAEzB,MAAMC,iBAAS,CAAC,KAAA,IAAS;AACzB,QAAQ,KAAK,CAAC,iBAAiB,CAAC,SAAS;AACzC,UAAU,IAAI,OAAO,CAAC,SAAS,EAAE;AACjC,YAAYC,6BAAqB,CAAC,KAAK,EAAE,SAAS,EAAE,SAAS,CAAC;AAC9D,YAAYC,6BAAqB,CAAC,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC;AAC3D,UAAU;;AAEV,UAAU,KAAK,CAAC,KAAA,GAAQ;AACxB,YAAY,GAAG,KAAK,CAAC,KAAK;AAC1B,YAAY,SAAS,EAAE,IAAI;AAC3B,WAAW;;AAEX,UAAU,OAAO,KAAK;AACtB,QAAQ,CAAC,CAAC;;AAEV;AACA,QAAQC,wBAAgB,CAAC,EAAE,CAAC;AAC5B,MAAM,CAAC,CAAC;;AAER,MAAM,MAAM,EAAE;AACd,IAAI;AACJ,EAAE,CAAA;;AAEF;AACA,EAAE,IAAI;AACN,IAAI,KAAK,MAAM,QAAA,IAAY,EAAE,EAAE;AAC/B,MAAM,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,EAAE,QAAQ,CAAC,EAAE;AAC9D,QAAQ,aAAa,CAAC,QAAA,EAAS,GAAc,EAAE,CAAC,UAAoB;AACpE,MAAM;AACN,IAAI;AACJ,EAAE,EAAE,MAAM;AACV;AACA;AACA,EAAE;;AAEF;AACA;AACA,EAAEC,2BAAmB,CAAC,aAAa,EAAE,EAAE,CAAC;;AAExC,EAAEC,gCAAwB,CAAC,EAAE,EAAE,oBAAoB,EAAE,aAAa,CAAC;;AAEnE;AACA,EAAE,IAAI;AACN;AACA,IAAI,MAAM,UAAA,GAAa,MAAM,CAAC,wBAAwB,CAAC,aAAa,EAAE,MAAM,CAAC;AAC7E,IAAI,IAAI,UAAU,CAAC,YAAY,EAAE;AACjC,MAAM,MAAM,CAAC,cAAc,CAAC,aAAa,EAAE,MAAM,EAAE;AACnD,QAAQ,GAAG,GAAW;AACtB,UAAU,OAAO,EAAE,CAAC,IAAI;AACxB,QAAQ,CAAC;AACT,OAAO,CAAC;AACR,IAAI;AACJ,EAAE,EAAE,MAAM;AACV;AACA;AACA,EAAE;;AAEF,EAAE,OAAO,aAAa;AACtB;;AAEA;AACA;AACA;AACO,SAAS,kBAAkB,GAAqD;AACvF;AACA,EAAE,MAAM,GAAA,GAAMC,uBAAe,EAAE;AAC/B,EAAE,MAAM,EAAE,QAAA,EAAS,GAAI,MAAM,CAAC,QAAA,IAAY,EAAE;AAC5C,EAAE,MAAM,EAAE,SAAA,EAAU,GAAI,MAAM,CAAC,SAAA,IAAa,EAAE;;AAE9C,EAAE,MAAM,UAAU;AAClB,IAAI,IAAI,QAAA,IAAY,EAAE,OAAO,EAAE,QAAA,EAAU,CAAC;AAC1C,IAAI,IAAI,SAAA,IAAa,EAAE,YAAY,EAAE,SAAA,EAAW,CAAC;AACjD,GAAG;AACH,EAAE,MAAM,UAAU;AAClB,IAAI,GAAG;AACP,IAAI,OAAO;AACX,GAAG;;AAEH,EAAE,OAAO,OAAO;AAChB;;;;;;;;"}
+{"version":3,"file":"helpers.js","sources":["../../../../src/helpers.ts"],"sourcesContent":["import type { Mechanism, WrappedFunction } from '@sentry/core/browser';\nimport {\n  addExceptionMechanism,\n  addExceptionTypeValue,\n  addNonEnumerableProperty,\n  captureException,\n  getLocationHref,\n  getOriginalFunction,\n  GLOBAL_OBJ,\n  markFunctionWrapped,\n  withScope,\n} from '@sentry/core/browser';\n\nexport const WINDOW = GLOBAL_OBJ as typeof GLOBAL_OBJ & Window;\n\nlet ignoreOnError: number = 0;\n\n/**\n * @hidden\n */\nexport function shouldIgnoreOnError(): boolean {\n  return ignoreOnError > 0;\n}\n\n/**\n * @hidden\n */\nexport function ignoreNextOnError(): void {\n  // onerror should trigger before setTimeout\n  ignoreOnError++;\n  setTimeout(() => {\n    ignoreOnError--;\n  });\n}\n\n// eslint-disable-next-line @typescript-eslint/ban-types\ntype WrappableFunction = Function;\n\nexport function wrap<T extends WrappableFunction>(\n  fn: T,\n  options?: {\n    mechanism?: Mechanism;\n  },\n): WrappedFunction<T>;\nexport function wrap<NonFunction>(\n  fn: NonFunction,\n  options?: {\n    mechanism?: Mechanism;\n  },\n): NonFunction;\n/**\n * Instruments the given function and sends an event to Sentry every time the\n * function throws an exception.\n *\n * @param fn A function to wrap. It is generally safe to pass an unbound function, because the returned wrapper always\n * has a correct `this` context.\n * @returns The wrapped function.\n * @hidden\n */\nexport function wrap<T extends WrappableFunction, NonFunction>(\n  fn: T | NonFunction,\n  options: {\n    mechanism?: Mechanism;\n  } = {},\n): NonFunction | WrappedFunction<T> {\n  // for future readers what this does is wrap a function and then create\n  // a bi-directional wrapping between them.\n  //\n  // example: wrapped = wrap(original);\n  //  original.__sentry_wrapped__ -> wrapped\n  //  wrapped.__sentry_original__ -> original\n\n  function isFunction(fn: T | NonFunction): fn is T {\n    return typeof fn === 'function';\n  }\n\n  if (!isFunction(fn)) {\n    return fn;\n  }\n\n  try {\n    // if we're dealing with a function that was previously wrapped, return\n    // the original wrapper.\n    const wrapper = (fn as WrappedFunction<T>).__sentry_wrapped__;\n    if (wrapper) {\n      if (typeof wrapper === 'function') {\n        return wrapper;\n      } else {\n        // If we find that the `__sentry_wrapped__` function is not a function at the time of accessing it, it means\n        // that something messed with it. In that case we want to return the originally passed function.\n        return fn;\n      }\n    }\n\n    // We don't wanna wrap it twice\n    if (getOriginalFunction(fn)) {\n      return fn;\n    }\n  } catch {\n    // Just accessing custom props in some Selenium environments\n    // can cause a \"Permission denied\" exception (see raven-js#495).\n    // Bail on wrapping and return the function as-is (defers to window.onerror).\n    return fn;\n  }\n\n  // Wrap the function itself\n  // It is important that `sentryWrapped` is not an arrow function to preserve the context of `this`\n  const sentryWrapped = function (this: unknown, ...args: unknown[]): unknown {\n    // Track depth on GLOBAL_OBJ so the thirdPartyErrorFilterIntegration (in @sentry/core) can detect\n    // that processEvent is running inside a sentryWrapped call, even with minified/bundled code.\n    GLOBAL_OBJ._sentryWrappedDepth = (GLOBAL_OBJ._sentryWrappedDepth || 0) + 1;\n    try {\n      // Also wrap arguments that are themselves functions\n      const wrappedArguments = args.map(arg => wrap(arg, options));\n\n      // Attempt to invoke user-land function\n      // NOTE: If you are a Sentry user, and you are seeing this stack frame, it\n      //       means the sentry.javascript SDK caught an error invoking your application code. This\n      //       is expected behavior and NOT indicative of a bug with sentry.javascript.\n      return fn.apply(this, wrappedArguments);\n    } catch (ex) {\n      ignoreNextOnError();\n\n      withScope(scope => {\n        scope.addEventProcessor(event => {\n          if (options.mechanism) {\n            addExceptionTypeValue(event, undefined, undefined);\n            addExceptionMechanism(event, options.mechanism);\n          }\n\n          event.extra = {\n            ...event.extra,\n            arguments: args,\n          };\n\n          return event;\n        });\n\n        // no need to add a mechanism here, we already add it via an event processor above\n        captureException(ex);\n      });\n\n      throw ex;\n    } finally {\n      GLOBAL_OBJ._sentryWrappedDepth = (GLOBAL_OBJ._sentryWrappedDepth || 0) - 1;\n    }\n  } as unknown as WrappedFunction<T>;\n\n  // Wrap the wrapped function in a proxy, to ensure any other properties of the original function remain available\n  try {\n    for (const property in fn) {\n      if (Object.prototype.hasOwnProperty.call(fn, property)) {\n        sentryWrapped[property as keyof T] = fn[property as keyof T];\n      }\n    }\n  } catch {\n    // Accessing some objects may throw\n    // ref: https://github.com/getsentry/sentry-javascript/issues/1168\n  }\n\n  // Signal that this function has been wrapped/filled already\n  // for both debugging and to prevent it to being wrapped/filled twice\n  markFunctionWrapped(sentryWrapped, fn);\n\n  addNonEnumerableProperty(fn, '__sentry_wrapped__', sentryWrapped);\n\n  // Restore original function name (not all browsers allow that)\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name')!;\n    if (descriptor.configurable) {\n      Object.defineProperty(sentryWrapped, 'name', {\n        get(): string {\n          return fn.name;\n        },\n      });\n    }\n  } catch {\n    // This may throw if e.g. the descriptor does not exist, or a browser does not allow redefining `name`.\n    // to save some bytes we simply try-catch this\n  }\n\n  return sentryWrapped;\n}\n\n/**\n * Get HTTP request data from the current page.\n */\nexport function getHttpRequestData(): { url: string; headers: Record<string, string> } {\n  // grab as much info as exists and add it to the event\n  const url = getLocationHref();\n  const { referrer } = WINDOW.document || {};\n  const { userAgent } = WINDOW.navigator || {};\n\n  const headers = {\n    ...(referrer && { Referer: referrer }),\n    ...(userAgent && { 'User-Agent': userAgent }),\n  };\n  const request = {\n    url,\n    headers,\n  };\n\n  return request;\n}\n"],"names":["GLOBAL_OBJ","fn","getOriginalFunction","withScope","addExceptionTypeValue","addExceptionMechanism","captureException","markFunctionWrapped","addNonEnumerableProperty","getLocationHref"],"mappings":"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"}

package/build/npm/cjs/dev/index.js

@@ -33,6 +33,7 @@ const browserUtils = require('@sentry-internal/browser-utils');
 const reportPageLoaded = require('./tracing/reportPageLoaded.js');
 const setActiveSpan = require('./tracing/setActiveSpan.js');
 const spanstreaming = require('./integrations/spanstreaming.js');
+const fetchStreamPerformance = require('./integrations/fetchStreamPerformance.js');
 const offline = require('./transports/offline.js');
 const integration$1 = require('./profiling/integration.js');
 const spotlight = require('./integrations/spotlight.js');
@@ -180,6 +181,7 @@ exports.elementTimingIntegration = browserUtils.elementTimingIntegration;
 exports.reportPageLoaded = reportPageLoaded.reportPageLoaded;
 exports.setActiveSpanInBrowser = setActiveSpan.setActiveSpanInBrowser;
 exports.spanStreamingIntegration = spanstreaming.spanStreamingIntegration;
+exports.fetchStreamPerformanceIntegration = fetchStreamPerformance.fetchStreamPerformanceIntegration;
 exports.makeBrowserOfflineTransport = offline.makeBrowserOfflineTransport;
 exports.browserProfilingIntegration = integration$1.browserProfilingIntegration;
 exports.spotlightBrowserIntegration = spotlight.spotlightBrowserIntegration;

package/build/npm/cjs/dev/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/npm/cjs/dev/integrations/breadcrumbs.js

@@ -5,11 +5,8 @@ const browserUtils = require('@sentry-internal/browser-utils');
 const debugBuild = require('../debug-build.js');
 const helpers = require('../helpers.js');
 
-/** maxStringLength gets capped to prevent 100 breadcrumbs exceeding 1MB event payload size */
 const MAX_ALLOWED_STRING_LENGTH = 1024;
-
-const INTEGRATION_NAME = 'Breadcrumbs';
-
+const INTEGRATION_NAME = "Breadcrumbs";
 const _breadcrumbsIntegration = ((options = {}) => {
   const _options = {
     console: true,
@@ -18,13 +15,11 @@ const _breadcrumbsIntegration = ((options = {}) => {
     history: true,
     sentry: true,
     xhr: true,
-    ...options,
+    ...options
   };
-
   return {
     name: INTEGRATION_NAME,
     setup(client) {
-      // TODO(v11): Remove this functionality and use `consoleIntegration` from @sentry/core instead.
       if (_options.console) {
         browser.addConsoleInstrumentationHandler(_getConsoleBreadcrumbHandler(client));
       }
@@ -41,290 +36,213 @@ const _breadcrumbsIntegration = ((options = {}) => {
         browserUtils.addHistoryInstrumentationHandler(_getHistoryBreadcrumbHandler(client));
       }
       if (_options.sentry) {
-        client.on('beforeSendEvent', _getSentryBreadcrumbHandler(client));
+        client.on("beforeSendEvent", _getSentryBreadcrumbHandler(client));
       }
-    },
+    }
   };
-}) ;
-
+});
 const breadcrumbsIntegration = browser.defineIntegration(_breadcrumbsIntegration);
-
-/**
- * Adds a breadcrumb for Sentry events or transactions if this option is enabled.
- */
 function _getSentryBreadcrumbHandler(client) {
   return function addSentryBreadcrumb(event) {
     if (browser.getClient() !== client) {
       return;
     }
-
     browser.addBreadcrumb(
       {
-        category: `sentry.${event.type === 'transaction' ? 'transaction' : 'event'}`,
+        category: `sentry.${event.type === "transaction" ? "transaction" : "event"}`,
         event_id: event.event_id,
         level: event.level,
-        message: browser.getEventDescription(event),
+        message: browser.getEventDescription(event)
       },
       {
-        event,
-      },
+        event
+      }
     );
   };
 }
-
-/**
- * A HOC that creates a function that creates breadcrumbs from DOM API calls.
- * This is a HOC so that we get access to dom options in the closure.
- */
-function _getDomBreadcrumbHandler(
-  client,
-  dom,
-) {
+function _getDomBreadcrumbHandler(client, dom) {
   return function _innerDomBreadcrumb(handlerData) {
     if (browser.getClient() !== client) {
       return;
     }
-
     let target;
     let componentName;
-    let keyAttrs = typeof dom === 'object' ? dom.serializeAttribute : undefined;
-
-    let maxStringLength =
-      typeof dom === 'object' && typeof dom.maxStringLength === 'number' ? dom.maxStringLength : undefined;
+    let keyAttrs = typeof dom === "object" ? dom.serializeAttribute : void 0;
+    let maxStringLength = typeof dom === "object" && typeof dom.maxStringLength === "number" ? dom.maxStringLength : void 0;
     if (maxStringLength && maxStringLength > MAX_ALLOWED_STRING_LENGTH) {
-      debugBuild.DEBUG_BUILD &&
-        browser.debug.warn(
-          `\`dom.maxStringLength\` cannot exceed ${MAX_ALLOWED_STRING_LENGTH}, but a value of ${maxStringLength} was configured. Sentry will use ${MAX_ALLOWED_STRING_LENGTH} instead.`,
-        );
+      debugBuild.DEBUG_BUILD && browser.debug.warn(
+        `\`dom.maxStringLength\` cannot exceed ${MAX_ALLOWED_STRING_LENGTH}, but a value of ${maxStringLength} was configured. Sentry will use ${MAX_ALLOWED_STRING_LENGTH} instead.`
+      );
       maxStringLength = MAX_ALLOWED_STRING_LENGTH;
     }
-
-    if (typeof keyAttrs === 'string') {
+    if (typeof keyAttrs === "string") {
       keyAttrs = [keyAttrs];
     }
-
-    // Accessing event.target can throw (see getsentry/raven-js#838, #768)
     try {
-      const event = handlerData.event ;
+      const event = handlerData.event;
       const element = _isEvent(event) ? event.target : event;
-
       target = browser.htmlTreeAsString(element, { keyAttrs, maxStringLength });
       componentName = browser.getComponentName(element);
     } catch {
-      target = '<unknown>';
+      target = "<unknown>";
     }
-
     if (target.length === 0) {
       return;
     }
-
     const breadcrumb = {
       category: `ui.${handlerData.name}`,
-      message: target,
+      message: target
     };
-
     if (componentName) {
-      breadcrumb.data = { 'ui.component_name': componentName };
+      breadcrumb.data = { "ui.component_name": componentName };
     }
-
     browser.addBreadcrumb(breadcrumb, {
       event: handlerData.event,
       name: handlerData.name,
-      global: handlerData.global,
+      global: handlerData.global
     });
   };
 }
-
-/**
- * Creates breadcrumbs from console API calls
- */
 function _getConsoleBreadcrumbHandler(client) {
   return function _consoleBreadcrumb(handlerData) {
     if (browser.getClient() !== client) {
       return;
     }
-
     const breadcrumb = {
-      category: 'console',
+      category: "console",
       data: {
         arguments: handlerData.args,
-        logger: 'console',
+        logger: "console"
       },
       level: browser.severityLevelFromString(handlerData.level),
-      message: browser.safeJoin(handlerData.args, ' '),
+      message: browser.safeJoin(handlerData.args, " ")
     };
-
-    if (handlerData.level === 'assert') {
+    if (handlerData.level === "assert") {
       if (handlerData.args[0] === false) {
-        breadcrumb.message = `Assertion failed: ${browser.safeJoin(handlerData.args.slice(1), ' ') || 'console.assert'}`;
+        breadcrumb.message = `Assertion failed: ${browser.safeJoin(handlerData.args.slice(1), " ") || "console.assert"}`;
         breadcrumb.data.arguments = handlerData.args.slice(1);
       } else {
-        // Don't capture a breadcrumb for passed assertions
         return;
       }
     }
-
     browser.addBreadcrumb(breadcrumb, {
       input: handlerData.args,
-      level: handlerData.level,
+      level: handlerData.level
     });
   };
 }
-
-/**
- * Creates breadcrumbs from XHR API calls
- */
 function _getXhrBreadcrumbHandler(client) {
   return function _xhrBreadcrumb(handlerData) {
     if (browser.getClient() !== client) {
       return;
     }
-
     const { startTimestamp, endTimestamp } = handlerData;
-
     const sentryXhrData = handlerData.xhr[browserUtils.SENTRY_XHR_DATA_KEY];
-
-    // We only capture complete, non-sentry requests
     if (!startTimestamp || !endTimestamp || !sentryXhrData) {
       return;
     }
-
     const { method, url, status_code, body } = sentryXhrData;
-
     const data = {
       method,
       url,
-      status_code,
+      status_code
     };
-
     const hint = {
       xhr: handlerData.xhr,
       input: body,
       startTimestamp,
-      endTimestamp,
+      endTimestamp
     };
-
     const breadcrumb = {
-      category: 'xhr',
+      category: "xhr",
       data,
-      type: 'http',
-      level: browser.getBreadcrumbLogLevelFromHttpStatusCode(status_code),
+      type: "http",
+      level: browser.getBreadcrumbLogLevelFromHttpStatusCode(status_code)
     };
-
-    client.emit('beforeOutgoingRequestBreadcrumb', breadcrumb, hint );
-
+    client.emit("beforeOutgoingRequestBreadcrumb", breadcrumb, hint);
     browser.addBreadcrumb(breadcrumb, hint);
   };
 }
-
-/**
- * Creates breadcrumbs from fetch API calls
- */
 function _getFetchBreadcrumbHandler(client) {
   return function _fetchBreadcrumb(handlerData) {
     if (browser.getClient() !== client) {
       return;
     }
-
     const { startTimestamp, endTimestamp } = handlerData;
-
-    // We only capture complete fetch requests
     if (!endTimestamp) {
       return;
     }
-
-    if (handlerData.fetchData.url.match(/sentry_key/) && handlerData.fetchData.method === 'POST') {
-      // We will not create breadcrumbs for fetch requests that contain `sentry_key` (internal sentry requests)
+    if (handlerData.fetchData.url.match(/sentry_key/) && handlerData.fetchData.method === "POST") {
       return;
     }
-
     if (handlerData.error) {
       const hint = {
         data: handlerData.error,
         input: handlerData.args,
         startTimestamp,
-        endTimestamp,
+        endTimestamp
       };
-
       const breadcrumb = {
-        category: 'fetch',
+        category: "fetch",
         data: handlerData.fetchData,
-        level: 'error',
-        type: 'http',
-      } ;
-
-      client.emit('beforeOutgoingRequestBreadcrumb', breadcrumb, hint );
-
+        level: "error",
+        type: "http"
+      };
+      client.emit("beforeOutgoingRequestBreadcrumb", breadcrumb, hint);
       browser.addBreadcrumb(breadcrumb, hint);
     } else {
-      const response = handlerData.response ;
+      const response = handlerData.response;
       const data = {
         ...handlerData.fetchData,
-        status_code: response?.status,
+        status_code: response?.status
       };
-
       const hint = {
         input: handlerData.args,
         response,
         startTimestamp,
-        endTimestamp,
+        endTimestamp
       };
-
       const breadcrumb = {
-        category: 'fetch',
+        category: "fetch",
         data,
-        type: 'http',
-        level: browser.getBreadcrumbLogLevelFromHttpStatusCode(data.status_code),
+        type: "http",
+        level: browser.getBreadcrumbLogLevelFromHttpStatusCode(data.status_code)
       };
-
-      client.emit('beforeOutgoingRequestBreadcrumb', breadcrumb, hint );
-
+      client.emit("beforeOutgoingRequestBreadcrumb", breadcrumb, hint);
       browser.addBreadcrumb(breadcrumb, hint);
     }
   };
 }
-
-/**
- * Creates breadcrumbs from history API calls
- */
 function _getHistoryBreadcrumbHandler(client) {
   return function _historyBreadcrumb(handlerData) {
     if (browser.getClient() !== client) {
       return;
     }
-
     let from = handlerData.from;
     let to = handlerData.to;
     const parsedLoc = browser.parseUrl(helpers.WINDOW.location.href);
-    let parsedFrom = from ? browser.parseUrl(from) : undefined;
+    let parsedFrom = from ? browser.parseUrl(from) : void 0;
     const parsedTo = browser.parseUrl(to);
-
-    // Initial pushState doesn't provide `from` information
     if (!parsedFrom?.path) {
       parsedFrom = parsedLoc;
     }
-
-    // Use only the path component of the URL if the URL matches the current
-    // document (almost all the time when using pushState)
     if (parsedLoc.protocol === parsedTo.protocol && parsedLoc.host === parsedTo.host) {
       to = parsedTo.relative;
     }
     if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host) {
       from = parsedFrom.relative;
     }
-
     browser.addBreadcrumb({
-      category: 'navigation',
+      category: "navigation",
       data: {
         from,
-        to,
-      },
+        to
+      }
     });
   };
 }
-
 function _isEvent(event) {
-  return !!event && !!(event ).target;
+  return !!event && !!event.target;
 }
 
 exports.breadcrumbsIntegration = breadcrumbsIntegration;