@sentry/browser-utils 10.58.0

package/build/cjs/instrument/xhr.js

@@ -0,0 +1,108 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+const types = require('../types.js');
+
+const SENTRY_XHR_DATA_KEY = "__sentry_xhr_v3__";
+function addXhrInstrumentationHandler(handler) {
+  const type = "xhr";
+  core.addHandler(type, handler);
+  core.maybeInstrument(type, instrumentXHR);
+}
+function instrumentXHR() {
+  if (!types.WINDOW.XMLHttpRequest) {
+    return;
+  }
+  const xhrproto = XMLHttpRequest.prototype;
+  xhrproto.open = new Proxy(xhrproto.open, {
+    apply(originalOpen, xhrOpenThisArg, xhrOpenArgArray) {
+      const virtualError = new Error();
+      const startTimestamp = core.timestampInSeconds() * 1e3;
+      const method = core.isString(xhrOpenArgArray[0]) ? xhrOpenArgArray[0].toUpperCase() : void 0;
+      const url = parseXhrUrlArg(xhrOpenArgArray[1]);
+      if (!method || !url) {
+        return originalOpen.apply(xhrOpenThisArg, xhrOpenArgArray);
+      }
+      xhrOpenThisArg[SENTRY_XHR_DATA_KEY] = {
+        method,
+        url,
+        request_headers: {}
+      };
+      if (method === "POST" && url.match(/sentry_key/)) {
+        xhrOpenThisArg.__sentry_own_request__ = true;
+      }
+      const onreadystatechangeHandler = () => {
+        const xhrInfo = xhrOpenThisArg[SENTRY_XHR_DATA_KEY];
+        if (!xhrInfo) {
+          return;
+        }
+        if (xhrOpenThisArg.readyState === 4) {
+          try {
+            xhrInfo.status_code = xhrOpenThisArg.status;
+          } catch {
+          }
+          const handlerData = {
+            endTimestamp: core.timestampInSeconds() * 1e3,
+            startTimestamp,
+            xhr: xhrOpenThisArg,
+            virtualError
+          };
+          core.triggerHandlers("xhr", handlerData);
+        }
+      };
+      if ("onreadystatechange" in xhrOpenThisArg && typeof xhrOpenThisArg.onreadystatechange === "function") {
+        xhrOpenThisArg.onreadystatechange = new Proxy(xhrOpenThisArg.onreadystatechange, {
+          apply(originalOnreadystatechange, onreadystatechangeThisArg, onreadystatechangeArgArray) {
+            onreadystatechangeHandler();
+            return originalOnreadystatechange.apply(onreadystatechangeThisArg, onreadystatechangeArgArray);
+          }
+        });
+      } else {
+        xhrOpenThisArg.addEventListener("readystatechange", onreadystatechangeHandler);
+      }
+      xhrOpenThisArg.setRequestHeader = new Proxy(xhrOpenThisArg.setRequestHeader, {
+        apply(originalSetRequestHeader, setRequestHeaderThisArg, setRequestHeaderArgArray) {
+          const [header, value] = setRequestHeaderArgArray;
+          const xhrInfo = setRequestHeaderThisArg[SENTRY_XHR_DATA_KEY];
+          if (xhrInfo && core.isString(header) && core.isString(value)) {
+            xhrInfo.request_headers[header.toLowerCase()] = value;
+          }
+          return originalSetRequestHeader.apply(setRequestHeaderThisArg, setRequestHeaderArgArray);
+        }
+      });
+      return originalOpen.apply(xhrOpenThisArg, xhrOpenArgArray);
+    }
+  });
+  xhrproto.send = new Proxy(xhrproto.send, {
+    apply(originalSend, sendThisArg, sendArgArray) {
+      const sentryXhrData = sendThisArg[SENTRY_XHR_DATA_KEY];
+      if (!sentryXhrData) {
+        return originalSend.apply(sendThisArg, sendArgArray);
+      }
+      if (sendArgArray[0] !== void 0) {
+        sentryXhrData.body = sendArgArray[0];
+      }
+      const handlerData = {
+        startTimestamp: core.timestampInSeconds() * 1e3,
+        xhr: sendThisArg
+      };
+      core.triggerHandlers("xhr", handlerData);
+      return originalSend.apply(sendThisArg, sendArgArray);
+    }
+  });
+}
+function parseXhrUrlArg(url) {
+  if (core.isString(url)) {
+    return url;
+  }
+  try {
+    return url.toString();
+  } catch {
+  }
+  return void 0;
+}
+
+exports.SENTRY_XHR_DATA_KEY = SENTRY_XHR_DATA_KEY;
+exports.addXhrInstrumentationHandler = addXhrInstrumentationHandler;
+exports.instrumentXHR = instrumentXHR;
+//# sourceMappingURL=xhr.js.map

package/build/cjs/instrument/xhr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"xhr.js","sources":["../../../src/instrument/xhr.ts"],"sourcesContent":["import type { HandlerDataXhr, SentryWrappedXMLHttpRequest } from '@sentry/core';\nimport { addHandler, isString, maybeInstrument, timestampInSeconds, triggerHandlers } from '@sentry/core';\nimport { WINDOW } from '../types';\n\nexport const SENTRY_XHR_DATA_KEY = '__sentry_xhr_v3__';\n\ntype WindowWithXhr = Window & { XMLHttpRequest?: typeof XMLHttpRequest };\n\n/**\n * Add an instrumentation handler for when an XHR request happens.\n * The handler function is called once when the request starts and once when it ends,\n * which can be identified by checking if it has an `endTimestamp`.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nexport function addXhrInstrumentationHandler(handler: (data: HandlerDataXhr) => void): void {\n  const type = 'xhr';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentXHR);\n}\n\n/** Exported only for tests. */\nexport function instrumentXHR(): void {\n  if (!(WINDOW as WindowWithXhr).XMLHttpRequest) {\n    return;\n  }\n\n  const xhrproto = XMLHttpRequest.prototype;\n\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  xhrproto.open = new Proxy(xhrproto.open, {\n    apply(\n      originalOpen,\n      xhrOpenThisArg: XMLHttpRequest & SentryWrappedXMLHttpRequest,\n      xhrOpenArgArray:\n        | [method: string, url: string | URL]\n        | [method: string, url: string | URL, async: boolean, username?: string | null, password?: string | null],\n    ) {\n      // NOTE: If you are a Sentry user, and you are seeing this stack frame,\n      //       it means the error, that was caused by your XHR call did not\n      //       have a stack trace. If you are using HttpClient integration,\n      //       this is the expected behavior, as we are using this virtual error to capture\n      //       the location of your XHR call, and group your HttpClient events accordingly.\n      const virtualError = new Error();\n\n      const startTimestamp = timestampInSeconds() * 1000;\n\n      // open() should always be called with two or more arguments\n      // But to be on the safe side, we actually validate this and bail out if we don't have a method & url\n      const method = isString(xhrOpenArgArray[0]) ? xhrOpenArgArray[0].toUpperCase() : undefined;\n      const url = parseXhrUrlArg(xhrOpenArgArray[1]);\n\n      if (!method || !url) {\n        return originalOpen.apply(xhrOpenThisArg, xhrOpenArgArray);\n      }\n\n      xhrOpenThisArg[SENTRY_XHR_DATA_KEY] = {\n        method,\n        url,\n        request_headers: {},\n      };\n\n      // if Sentry key appears in URL, don't capture it as a request\n      if (method === 'POST' && url.match(/sentry_key/)) {\n        xhrOpenThisArg.__sentry_own_request__ = true;\n      }\n\n      const onreadystatechangeHandler: () => void = () => {\n        // For whatever reason, this is not the same instance here as from the outer method\n        const xhrInfo = xhrOpenThisArg[SENTRY_XHR_DATA_KEY];\n\n        if (!xhrInfo) {\n          return;\n        }\n\n        if (xhrOpenThisArg.readyState === 4) {\n          try {\n            // touching statusCode in some platforms throws\n            // an exception\n            xhrInfo.status_code = xhrOpenThisArg.status;\n          } catch {\n            /* do nothing */\n          }\n\n          const handlerData: HandlerDataXhr = {\n            endTimestamp: timestampInSeconds() * 1000,\n            startTimestamp,\n            xhr: xhrOpenThisArg,\n            virtualError,\n          };\n          triggerHandlers('xhr', handlerData);\n        }\n      };\n\n      if ('onreadystatechange' in xhrOpenThisArg && typeof xhrOpenThisArg.onreadystatechange === 'function') {\n        xhrOpenThisArg.onreadystatechange = new Proxy(xhrOpenThisArg.onreadystatechange, {\n          apply(originalOnreadystatechange, onreadystatechangeThisArg, onreadystatechangeArgArray: unknown[]) {\n            onreadystatechangeHandler();\n            return originalOnreadystatechange.apply(onreadystatechangeThisArg, onreadystatechangeArgArray);\n          },\n        });\n      } else {\n        xhrOpenThisArg.addEventListener('readystatechange', onreadystatechangeHandler);\n      }\n\n      // Intercepting `setRequestHeader` to access the request headers of XHR instance.\n      // This will only work for user/library defined headers, not for the default/browser-assigned headers.\n      // Request cookies are also unavailable for XHR, as `Cookie` header can't be defined by `setRequestHeader`.\n      xhrOpenThisArg.setRequestHeader = new Proxy(xhrOpenThisArg.setRequestHeader, {\n        apply(\n          originalSetRequestHeader,\n          setRequestHeaderThisArg: SentryWrappedXMLHttpRequest,\n          setRequestHeaderArgArray: unknown[],\n        ) {\n          const [header, value] = setRequestHeaderArgArray;\n\n          const xhrInfo = setRequestHeaderThisArg[SENTRY_XHR_DATA_KEY];\n\n          if (xhrInfo && isString(header) && isString(value)) {\n            xhrInfo.request_headers[header.toLowerCase()] = value;\n          }\n\n          return originalSetRequestHeader.apply(setRequestHeaderThisArg, setRequestHeaderArgArray);\n        },\n      });\n\n      return originalOpen.apply(xhrOpenThisArg, xhrOpenArgArray);\n    },\n  });\n\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  xhrproto.send = new Proxy(xhrproto.send, {\n    apply(originalSend, sendThisArg: XMLHttpRequest & SentryWrappedXMLHttpRequest, sendArgArray: unknown[]) {\n      const sentryXhrData = sendThisArg[SENTRY_XHR_DATA_KEY];\n\n      if (!sentryXhrData) {\n        return originalSend.apply(sendThisArg, sendArgArray);\n      }\n\n      if (sendArgArray[0] !== undefined) {\n        sentryXhrData.body = sendArgArray[0];\n      }\n\n      const handlerData: HandlerDataXhr = {\n        startTimestamp: timestampInSeconds() * 1000,\n        xhr: sendThisArg,\n      };\n      triggerHandlers('xhr', handlerData);\n\n      return originalSend.apply(sendThisArg, sendArgArray);\n    },\n  });\n}\n\n/**\n * Parses the URL argument of a XHR method to a string.\n *\n * See: https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/open#url\n * url: A string or any other object with a stringifier — including a URL object — that provides the URL of the resource to send the request to.\n *\n * @param url - The URL argument of an XHR method\n * @returns The parsed URL string or undefined if the URL is invalid\n */\nfunction parseXhrUrlArg(url: unknown): string | undefined {\n  if (isString(url)) {\n    return url;\n  }\n\n  try {\n    // If the passed in argument is not a string, it should have a `toString` method as a stringifier.\n    // If that fails, we just return undefined (like in IE11 where URL is not available)\n    return (url as URL).toString();\n  } catch {} // eslint-disable-line no-empty\n\n  return undefined;\n}\n"],"names":["addHandler","maybeInstrument","WINDOW","timestampInSeconds","isString","triggerHandlers"],"mappings":"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"}

package/build/cjs/is.js

@@ -0,0 +1,15 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+function isElement(wat) {
+  if (typeof Element === "undefined") {
+    return false;
+  }
+  try {
+    return wat instanceof Element;
+  } catch {
+    return false;
+  }
+}
+
+exports.isElement = isElement;
+//# sourceMappingURL=is.js.map

package/build/cjs/is.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is.js","sources":["../../src/is.ts"],"sourcesContent":["/**\n * Checks whether given value's type is an Element instance.\n *\n * Returns false if `Element` is not available in the current runtime.\n */\nexport function isElement(wat: unknown): boolean {\n  if (typeof Element === 'undefined') {\n    return false;\n  }\n  try {\n    return wat instanceof Element;\n  } catch {\n    return false;\n  }\n}\n"],"names":[],"mappings":";;AAKO,SAAS,UAAU,GAAA,EAAuB;AAC/C,EAAA,IAAI,OAAO,YAAY,WAAA,EAAa;AAClC,IAAA,OAAO,KAAA;AAAA,EACT;AACA,EAAA,IAAI;AACF,IAAA,OAAO,GAAA,YAAe,OAAA;AAAA,EACxB,CAAA,CAAA,MAAQ;AACN,IAAA,OAAO,KAAA;AAAA,EACT;AACF;;;;"}

package/build/cjs/metrics/browserMetrics.js

@@ -0,0 +1,535 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+const htmlTreeAsString = require('../htmlTreeAsString.js');
+const types = require('../types.js');
+const cls = require('./cls.js');
+const instrument = require('./instrument.js');
+const lcp = require('./lcp.js');
+const resourceTiming = require('./resourceTiming.js');
+const utils = require('./utils.js');
+const getActivationStart = require('./web-vitals/lib/getActivationStart.js');
+const getNavigationEntry = require('./web-vitals/lib/getNavigationEntry.js');
+const getVisibilityWatcher = require('./web-vitals/lib/getVisibilityWatcher.js');
+const debugBuild = require('../debug-build.js');
+
+const MAX_INT_AS_BYTES = 2147483647;
+let _performanceCursor = 0;
+let _measurements = {};
+let _lcpEntry;
+let _clsEntry;
+function startTrackingWebVitals({
+  recordClsStandaloneSpans,
+  recordLcpStandaloneSpans,
+  client
+}) {
+  const performance = utils.getBrowserPerformanceAPI();
+  if (performance && core.browserPerformanceTimeOrigin()) {
+    if (performance.mark) {
+      types.WINDOW.performance.mark("sentry-tracing-init");
+    }
+    const lcpCleanupCallback = recordLcpStandaloneSpans ? lcp.trackLcpAsStandaloneSpan(client) : recordLcpStandaloneSpans === false ? _trackLCP() : void 0;
+    const clsCleanupCallback = recordClsStandaloneSpans ? cls.trackClsAsStandaloneSpan(client) : recordClsStandaloneSpans === false ? _trackCLS() : void 0;
+    const ttfbCleanupCallback = _trackTtfb();
+    const fpFcpCleanupCallback = _trackFpFcp();
+    return () => {
+      ttfbCleanupCallback();
+      fpFcpCleanupCallback();
+      lcpCleanupCallback?.();
+      clsCleanupCallback?.();
+    };
+  }
+  return () => void 0;
+}
+function startTrackingLongTasks() {
+  instrument.addPerformanceInstrumentationHandler("longtask", ({ entries }) => {
+    const parent = core.getActiveSpan();
+    if (!parent) {
+      return;
+    }
+    const { op: parentOp, start_timestamp: parentStartTimestamp } = core.spanToJSON(parent);
+    for (const entry of entries) {
+      const startTime = utils.msToSec(core.browserPerformanceTimeOrigin() + entry.startTime);
+      const duration = utils.msToSec(entry.duration);
+      if (parentOp === "navigation" && parentStartTimestamp && startTime < parentStartTimestamp) {
+        continue;
+      }
+      utils.startAndEndSpan(parent, startTime, startTime + duration, {
+        name: "Main UI thread blocked",
+        op: "ui.long-task",
+        attributes: {
+          [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.ui.browser.metrics"
+        }
+      });
+    }
+  });
+}
+function startTrackingLongAnimationFrames() {
+  const observer = new PerformanceObserver((list) => {
+    const parent = core.getActiveSpan();
+    if (!parent) {
+      return;
+    }
+    for (const entry of list.getEntries()) {
+      if (!entry.scripts[0]) {
+        continue;
+      }
+      const startTime = utils.msToSec(core.browserPerformanceTimeOrigin() + entry.startTime);
+      const { start_timestamp: parentStartTimestamp, op: parentOp } = core.spanToJSON(parent);
+      if (parentOp === "navigation" && parentStartTimestamp && startTime < parentStartTimestamp) {
+        continue;
+      }
+      const duration = utils.msToSec(entry.duration);
+      const attributes = {
+        [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.ui.browser.metrics"
+      };
+      const initialScript = entry.scripts[0];
+      const { invoker, invokerType, sourceURL, sourceFunctionName, sourceCharPosition } = initialScript;
+      attributes["browser.script.invoker"] = invoker;
+      attributes["browser.script.invoker_type"] = invokerType;
+      if (sourceURL) {
+        attributes["code.filepath"] = sourceURL;
+      }
+      if (sourceFunctionName) {
+        attributes["code.function"] = sourceFunctionName;
+      }
+      if (sourceCharPosition !== -1) {
+        attributes["browser.script.source_char_position"] = sourceCharPosition;
+      }
+      utils.startAndEndSpan(parent, startTime, startTime + duration, {
+        name: "Main UI thread blocked",
+        op: "ui.long-animation-frame",
+        attributes
+      });
+    }
+  });
+  observer.observe({ type: "long-animation-frame", buffered: true });
+}
+function startTrackingInteractions() {
+  instrument.addPerformanceInstrumentationHandler("event", ({ entries }) => {
+    const parent = core.getActiveSpan();
+    if (!parent) {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name === "click") {
+        const startTime = utils.msToSec(core.browserPerformanceTimeOrigin() + entry.startTime);
+        const duration = utils.msToSec(entry.duration);
+        const spanOptions = {
+          name: htmlTreeAsString.htmlTreeAsString(entry.target),
+          op: `ui.interaction.${entry.name}`,
+          startTime,
+          attributes: {
+            [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.ui.browser.metrics"
+          }
+        };
+        const componentName = core.getComponentName(entry.target);
+        if (componentName) {
+          spanOptions.attributes["ui.component_name"] = componentName;
+        }
+        utils.startAndEndSpan(parent, startTime, startTime + duration, spanOptions);
+      }
+    }
+  });
+}
+function _trackCLS() {
+  return instrument.addClsInstrumentationHandler(({ metric }) => {
+    const entry = metric.entries[metric.entries.length - 1];
+    if (!entry) {
+      return;
+    }
+    _measurements["cls"] = { value: metric.value, unit: "" };
+    _clsEntry = entry;
+  }, true);
+}
+function _trackLCP() {
+  return instrument.addLcpInstrumentationHandler(({ metric }) => {
+    const entry = metric.entries[metric.entries.length - 1];
+    if (!entry || !lcp.isValidLcpMetric(metric.value)) {
+      return;
+    }
+    _measurements["lcp"] = { value: metric.value, unit: "millisecond" };
+    _lcpEntry = entry;
+  }, true);
+}
+function _trackTtfb() {
+  return instrument.addTtfbInstrumentationHandler(({ metric }) => {
+    const entry = metric.entries[metric.entries.length - 1];
+    if (!entry) {
+      return;
+    }
+    _measurements["ttfb"] = { value: metric.value, unit: "millisecond" };
+  });
+}
+function _trackFpFcp() {
+  return instrument.addPerformanceInstrumentationHandler("paint", ({ entries }) => {
+    const firstHidden = getVisibilityWatcher.getVisibilityWatcher();
+    for (const entry of entries) {
+      const shouldRecord = entry.startTime < firstHidden.firstHiddenTime;
+      if (entry.name === "first-paint" && shouldRecord) {
+        _measurements["fp"] = { value: entry.startTime, unit: "millisecond" };
+      }
+      if (entry.name === "first-contentful-paint" && shouldRecord) {
+        _measurements["fcp"] = { value: entry.startTime, unit: "millisecond" };
+      }
+    }
+  });
+}
+function addPerformanceEntries(span, options) {
+  const performance = utils.getBrowserPerformanceAPI();
+  const origin = core.browserPerformanceTimeOrigin();
+  if (!performance?.getEntries || !origin) {
+    return;
+  }
+  const { spanStreamingEnabled, ignorePerformanceApiSpans, ignoreResourceSpans } = options;
+  const timeOrigin = utils.msToSec(origin);
+  const performanceEntries = performance.getEntries();
+  const { op, start_timestamp: transactionStartTime } = core.spanToJSON(span);
+  performanceEntries.slice(_performanceCursor).forEach((entry) => {
+    const startTime = utils.msToSec(entry.startTime);
+    const duration = utils.msToSec(
+      // Inexplicably, Chrome sometimes emits a negative duration. We need to work around this.
+      // There is a SO post attempting to explain this, but it leaves one with open questions: https://stackoverflow.com/questions/23191918/peformance-getentries-and-negative-duration-display
+      // The way we clamp the value is probably not accurate, since we have observed this happen for things that may take a while to load, like for example the replay worker.
+      // TODO: Investigate why this happens and how to properly mitigate. For now, this is a workaround to prevent transactions being dropped due to negative duration spans.
+      Math.max(0, entry.duration)
+    );
+    if (op === "navigation" && transactionStartTime && timeOrigin + startTime < transactionStartTime) {
+      return;
+    }
+    switch (entry.entryType) {
+      case "navigation": {
+        _addNavigationSpans(span, entry, timeOrigin);
+        break;
+      }
+      case "mark":
+      case "paint":
+      case "measure": {
+        _addMeasureSpans(span, entry, startTime, duration, timeOrigin, ignorePerformanceApiSpans);
+        break;
+      }
+      case "resource": {
+        _addResourceSpans(
+          span,
+          entry,
+          entry.name,
+          startTime,
+          duration,
+          timeOrigin,
+          ignoreResourceSpans
+        );
+        break;
+      }
+    }
+  });
+  _performanceCursor = Math.max(performanceEntries.length - 1, 0);
+  _trackNavigator(span, spanStreamingEnabled);
+}
+function addWebVitalsToSpan(span, options) {
+  const origin = core.browserPerformanceTimeOrigin();
+  if (!utils.getBrowserPerformanceAPI()?.getEntries || !origin) {
+    resetWebVitalState();
+    return;
+  }
+  const { spanStreamingEnabled, recordClsOnPageloadSpan, recordLcpOnPageloadSpan } = options;
+  const timeOrigin = utils.msToSec(origin);
+  if (core.spanToJSON(span).op === "pageload") {
+    _addTtfbRequestTimeToMeasurements(_measurements);
+    if (spanStreamingEnabled) {
+      const setAttr = (shortWebVitalName, value, customAttrName) => {
+        const attrKey = customAttrName ?? `browser.web_vital.${shortWebVitalName}.value`;
+        span.setAttribute(attrKey, value);
+        debugBuild.DEBUG_BUILD && core.debug.log("Setting web vital attribute", { [attrKey]: value }, "on pageload span");
+      };
+      ["ttfb", "fp", "fcp"].forEach((measurementName) => {
+        if (_measurements[measurementName]) {
+          setAttr(measurementName, _measurements[measurementName].value);
+        }
+      });
+      if (_measurements["ttfb.requestTime"]) {
+        setAttr("ttfb.requestTime", _measurements["ttfb.requestTime"].value, "browser.web_vital.ttfb.request_time");
+      }
+    } else {
+      if (!recordClsOnPageloadSpan) {
+        delete _measurements.cls;
+      }
+      if (!recordLcpOnPageloadSpan) {
+        delete _measurements.lcp;
+      }
+      Object.entries(_measurements).forEach(([measurementName, measurement]) => {
+        core.setMeasurement(measurementName, measurement.value, measurement.unit, span);
+      });
+      _setWebVitalAttributes(span, options);
+    }
+    span.setAttribute(spanStreamingEnabled ? "browser.performance.time_origin" : "performance.timeOrigin", timeOrigin);
+    span.setAttribute(
+      spanStreamingEnabled ? "browser.performance.navigation.activation_start" : "performance.activationStart",
+      getActivationStart.getActivationStart()
+    );
+  }
+  resetWebVitalState();
+}
+function resetWebVitalState() {
+  _lcpEntry = void 0;
+  _clsEntry = void 0;
+  _measurements = {};
+}
+function isReact19MeasureEntry(entry) {
+  if (entry?.entryType !== "measure") {
+    return;
+  }
+  try {
+    return entry.detail.devtools.track === "Components \u269B";
+  } catch {
+    return;
+  }
+}
+function _addMeasureSpans(span, entry, startTime, duration, timeOrigin, ignorePerformanceApiSpans) {
+  if (isReact19MeasureEntry(entry)) {
+    return;
+  }
+  if (["mark", "measure"].includes(entry.entryType) && core.stringMatchesSomePattern(entry.name, ignorePerformanceApiSpans)) {
+    return;
+  }
+  const navEntry = getNavigationEntry.getNavigationEntry(false);
+  const requestTime = utils.msToSec(navEntry ? navEntry.requestStart : 0);
+  const measureStartTimestamp = timeOrigin + Math.max(startTime, requestTime);
+  const startTimeStamp = timeOrigin + startTime;
+  const measureEndTimestamp = startTimeStamp + duration;
+  const attributes = {
+    [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.resource.browser.metrics"
+  };
+  if (measureStartTimestamp !== startTimeStamp) {
+    attributes["sentry.browser.measure_happened_before_request"] = true;
+    attributes["sentry.browser.measure_start_time"] = measureStartTimestamp;
+  }
+  _addDetailToSpanAttributes(attributes, entry);
+  if (measureStartTimestamp <= measureEndTimestamp) {
+    utils.startAndEndSpan(span, measureStartTimestamp, measureEndTimestamp, {
+      name: entry.name,
+      op: entry.entryType,
+      attributes
+    });
+  }
+}
+function _addDetailToSpanAttributes(attributes, performanceMeasure) {
+  try {
+    const detail = performanceMeasure.detail;
+    if (!detail) {
+      return;
+    }
+    if (typeof detail === "object") {
+      for (const [key, value] of Object.entries(detail)) {
+        if (value && core.isPrimitive(value)) {
+          attributes[`sentry.browser.measure.detail.${key}`] = value;
+        } else if (value !== void 0) {
+          try {
+            attributes[`sentry.browser.measure.detail.${key}`] = JSON.stringify(value);
+          } catch {
+          }
+        }
+      }
+      return;
+    }
+    if (core.isPrimitive(detail)) {
+      attributes["sentry.browser.measure.detail"] = detail;
+      return;
+    }
+    try {
+      attributes["sentry.browser.measure.detail"] = JSON.stringify(detail);
+    } catch {
+    }
+  } catch {
+  }
+}
+function _addNavigationSpans(span, entry, timeOrigin) {
+  ["unloadEvent", "redirect", "domContentLoadedEvent", "loadEvent", "connect"].forEach((event) => {
+    _addPerformanceNavigationTiming(span, entry, event, timeOrigin);
+  });
+  _addPerformanceNavigationTiming(span, entry, "secureConnection", timeOrigin, "TLS/SSL");
+  _addPerformanceNavigationTiming(span, entry, "fetch", timeOrigin, "cache");
+  _addPerformanceNavigationTiming(span, entry, "domainLookup", timeOrigin, "DNS");
+  _addRequest(span, entry, timeOrigin);
+}
+function _addPerformanceNavigationTiming(span, entry, event, timeOrigin, name = event) {
+  const eventEnd = _getEndPropertyNameForNavigationTiming(event);
+  const end = entry[eventEnd];
+  const start = entry[`${event}Start`];
+  if (!start || !end) {
+    return;
+  }
+  utils.startAndEndSpan(span, timeOrigin + utils.msToSec(start), timeOrigin + utils.msToSec(end), {
+    op: `browser.${name}`,
+    name: entry.name,
+    attributes: {
+      [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.ui.browser.metrics",
+      ...event === "redirect" && entry.redirectCount != null ? { "http.redirect_count": entry.redirectCount } : {}
+    }
+  });
+}
+function _getEndPropertyNameForNavigationTiming(event) {
+  if (event === "secureConnection") {
+    return "connectEnd";
+  }
+  if (event === "fetch") {
+    return "domainLookupStart";
+  }
+  return `${event}End`;
+}
+function _addRequest(span, entry, timeOrigin) {
+  const requestStartTimestamp = timeOrigin + utils.msToSec(entry.requestStart);
+  const responseEndTimestamp = timeOrigin + utils.msToSec(entry.responseEnd);
+  const responseStartTimestamp = timeOrigin + utils.msToSec(entry.responseStart);
+  if (entry.responseEnd) {
+    utils.startAndEndSpan(span, requestStartTimestamp, responseEndTimestamp, {
+      op: "browser.request",
+      name: entry.name,
+      attributes: {
+        [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.ui.browser.metrics"
+      }
+    });
+    utils.startAndEndSpan(span, responseStartTimestamp, responseEndTimestamp, {
+      op: "browser.response",
+      name: entry.name,
+      attributes: {
+        [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.ui.browser.metrics"
+      }
+    });
+  }
+}
+function _addResourceSpans(span, entry, resourceUrl, startTime, duration, timeOrigin, ignoredResourceSpanOps) {
+  if (entry.initiatorType === "xmlhttprequest" || entry.initiatorType === "fetch") {
+    return;
+  }
+  const op = entry.initiatorType ? `resource.${entry.initiatorType}` : "resource.other";
+  if (ignoredResourceSpanOps?.includes(op)) {
+    return;
+  }
+  const attributes = {
+    [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.resource.browser.metrics"
+  };
+  const parsedUrl = core.parseUrl(resourceUrl);
+  if (parsedUrl.protocol) {
+    attributes["url.scheme"] = parsedUrl.protocol.split(":").pop();
+  }
+  if (parsedUrl.host) {
+    attributes["server.address"] = parsedUrl.host;
+  }
+  attributes["url.same_origin"] = resourceUrl.includes(types.WINDOW.location.origin);
+  _setResourceRequestAttributes(entry, attributes, [
+    // https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming/responseStatus
+    ["responseStatus", "http.response.status_code"],
+    ["transferSize", "http.response_transfer_size"],
+    ["encodedBodySize", "http.response_content_length"],
+    ["decodedBodySize", "http.decoded_response_content_length"],
+    // https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming/renderBlockingStatus
+    ["renderBlockingStatus", "resource.render_blocking_status"],
+    // https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming/deliveryType
+    ["deliveryType", "http.response_delivery_type"]
+  ]);
+  const attributesWithResourceTiming = { ...attributes, ...resourceTiming.resourceTimingToSpanAttributes(entry) };
+  const startTimestamp = timeOrigin + startTime;
+  const endTimestamp = startTimestamp + duration;
+  utils.startAndEndSpan(span, startTimestamp, endTimestamp, {
+    name: resourceUrl.replace(types.WINDOW.location.origin, ""),
+    op,
+    attributes: attributesWithResourceTiming
+  });
+}
+function _trackNavigator(span, spanStreamingEnabled) {
+  const navigator = types.WINDOW.navigator;
+  if (!navigator) {
+    return;
+  }
+  const connection = navigator.connection;
+  if (connection) {
+    if (connection.effectiveType) {
+      span.setAttribute(
+        spanStreamingEnabled ? "network.connection.effective_type" : "effectiveConnectionType",
+        connection.effectiveType
+      );
+    }
+    if (connection.type) {
+      span.setAttribute(spanStreamingEnabled ? "network.connection.type" : "connectionType", connection.type);
+    }
+    if (utils.isMeasurementValue(connection.rtt)) {
+      if (spanStreamingEnabled) {
+        span.setAttribute("network.connection.rtt", connection.rtt);
+      } else if (core.spanToJSON(span).op === "pageload") {
+        core.setMeasurement("connection.rtt", connection.rtt, "millisecond");
+      }
+    }
+  }
+  if (utils.isMeasurementValue(navigator.deviceMemory)) {
+    if (spanStreamingEnabled) {
+      span.setAttribute("device.memory.estimated_capacity", navigator.deviceMemory);
+    } else {
+      span.setAttribute("deviceMemory", `${navigator.deviceMemory} GB`);
+    }
+  }
+  if (utils.isMeasurementValue(navigator.hardwareConcurrency)) {
+    if (spanStreamingEnabled) {
+      span.setAttribute("device.processor_count", navigator.hardwareConcurrency);
+    } else {
+      span.setAttribute("hardwareConcurrency", String(navigator.hardwareConcurrency));
+    }
+  }
+}
+function _setWebVitalAttributes(span, options) {
+  if (_lcpEntry && options.recordLcpOnPageloadSpan) {
+    if (_lcpEntry.element) {
+      span.setAttribute("lcp.element", htmlTreeAsString.htmlTreeAsString(_lcpEntry.element));
+    }
+    if (_lcpEntry.id) {
+      span.setAttribute("lcp.id", _lcpEntry.id);
+    }
+    if (_lcpEntry.url) {
+      span.setAttribute("lcp.url", _lcpEntry.url.trim().slice(0, 200));
+    }
+    if (_lcpEntry.loadTime != null) {
+      span.setAttribute("lcp.loadTime", _lcpEntry.loadTime);
+    }
+    if (_lcpEntry.renderTime != null) {
+      span.setAttribute("lcp.renderTime", _lcpEntry.renderTime);
+    }
+    span.setAttribute("lcp.size", _lcpEntry.size);
+  }
+  if (_clsEntry?.sources && options.recordClsOnPageloadSpan) {
+    _clsEntry.sources.forEach(
+      (source, index) => span.setAttribute(`cls.source.${index + 1}`, htmlTreeAsString.htmlTreeAsString(source.node))
+    );
+  }
+}
+function _setResourceRequestAttributes(entry, attributes, properties) {
+  properties.forEach(([entryKey, attributeKey]) => {
+    const entryVal = entry[entryKey];
+    if (entryVal != null && (typeof entryVal === "number" && entryVal < MAX_INT_AS_BYTES || typeof entryVal === "string")) {
+      attributes[attributeKey] = entryVal;
+    }
+  });
+}
+function _addTtfbRequestTimeToMeasurements(_measurements2) {
+  const navEntry = getNavigationEntry.getNavigationEntry(false);
+  if (!navEntry) {
+    return;
+  }
+  const { responseStart, requestStart } = navEntry;
+  if (requestStart <= responseStart) {
+    _measurements2["ttfb.requestTime"] = {
+      value: responseStart - requestStart,
+      unit: "millisecond"
+    };
+  }
+}
+
+exports._addMeasureSpans = _addMeasureSpans;
+exports._addNavigationSpans = _addNavigationSpans;
+exports._addResourceSpans = _addResourceSpans;
+exports._setResourceRequestAttributes = _setResourceRequestAttributes;
+exports.addPerformanceEntries = addPerformanceEntries;
+exports.addWebVitalsToSpan = addWebVitalsToSpan;
+exports.startTrackingInteractions = startTrackingInteractions;
+exports.startTrackingLongAnimationFrames = startTrackingLongAnimationFrames;
+exports.startTrackingLongTasks = startTrackingLongTasks;
+exports.startTrackingWebVitals = startTrackingWebVitals;
+//# sourceMappingURL=browserMetrics.js.map