{"version":3,"file":"browserTracingIntegration.js","sources":["../../../../../src/tracing/browserTracingIntegration.ts"],"sourcesContent":["/* eslint-disable max-lines */\nimport type {\n  Client,\n  IntegrationFn,\n  RequestHookInfo,\n  ResponseHookInfo,\n  Span,\n  StartSpanOptions,\n  TransactionSource,\n} from '@sentry/core/browser';\nimport {\n  addNonEnumerableProperty,\n  browserPerformanceTimeOrigin,\n  consoleSandbox,\n  dateTimestampInSeconds,\n  debug,\n  generateSpanId,\n  generateTraceId,\n  getClient,\n  getCurrentScope,\n  getDynamicSamplingContextFromSpan,\n  getIsolationScope,\n  getLocationHref,\n  GLOBAL_OBJ,\n  hasSpansEnabled,\n  hasSpanStreamingEnabled,\n  parseStringToURLObject,\n  propagationContextFromHeaders,\n  registerSpanErrorInstrumentation,\n  SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,\n  spanIsSampled,\n  spanToJSON,\n  startIdleSpan,\n  startInactiveSpan,\n  timestampInSeconds,\n  TRACING_DEFAULTS,\n} from '@sentry/core/browser';\nimport {\n  addHistoryInstrumentationHandler,\n  addPerformanceEntries,\n  registerInpInteractionListener,\n  startTrackingINP,\n  startTrackingInteractions,\n  startTrackingLongAnimationFrames,\n  startTrackingLongTasks,\n  startTrackingWebVitals,\n  trackClsAsSpan,\n  trackInpAsSpan,\n  trackLcpAsSpan,\n} from '@sentry-internal/browser-utils';\nimport { DEBUG_BUILD } from '../debug-build';\nimport { getHttpRequestData, WINDOW } from '../helpers';\nimport { fetchStreamPerformanceIntegration } from '../integrations/fetchStreamPerformance';\nimport { registerBackgroundTabDetection } from './backgroundtab';\nimport { linkTraces } from './linkedTraces';\nimport { defaultRequestInstrumentationOptions, instrumentOutgoingRequests } from './request';\n\nexport const BROWSER_TRACING_INTEGRATION_ID = 'BrowserTracing';\n\n/**\n * We don't want to start a bunch of idle timers and PerformanceObservers\n * for web crawlers, as they may prevent the page from being seen as \"idle\"\n * by the crawler's rendering engine (e.g. Googlebot's headless Chromium).\n */\nconst BOT_USER_AGENT_RE =\n  /Googlebot|Google-InspectionTool|Storebot-Google|Bingbot|Slurp|DuckDuckBot|Baiduspider|YandexBot|Facebot|facebookexternalhit|LinkedInBot|Twitterbot|Applebot/i;\n\nexport function isBotUserAgent(): boolean {\n  const nav = WINDOW.navigator as Navigator | undefined;\n  if (!nav?.userAgent) {\n    return false;\n  }\n  return BOT_USER_AGENT_RE.test(nav.userAgent);\n}\n\ninterface RouteInfo {\n  name: string | undefined;\n  source: TransactionSource | undefined;\n}\n\n/** Options for Browser Tracing integration */\nexport interface BrowserTracingOptions {\n  /**\n   * The time that has to pass without any span being created.\n   * If this time is exceeded, the idle span will finish.\n   *\n   * Default: 1000 (ms)\n   */\n  idleTimeout: number;\n\n  /**\n   * The max. time an idle span may run.\n   * If this time is exceeded, the idle span will finish no matter what.\n   *\n   * Default: 30000 (ms)\n   */\n  finalTimeout: number;\n\n  /**\n   The max. time an idle span may run.\n   * If this time is exceeded, the idle span will finish no matter what.\n   *\n   * Default: 15000 (ms)\n   */\n  childSpanTimeout: number;\n\n  /**\n   * If a span should be created on page load.\n   * If this is set to `false`, this integration will not start the default page load span.\n   * Default: true\n   */\n  instrumentPageLoad: boolean;\n\n  /**\n   * If a span should be created on navigation (history change).\n   * If this is set to `false`, this integration will not start the default navigation spans.\n   * Default: true\n   */\n  instrumentNavigation: boolean;\n\n  /**\n   * Flag spans where tabs moved to background with \"cancelled\". Browser background tab timing is\n   * not suited towards doing precise measurements of operations. By default, we recommend that this option\n   * be enabled as background transactions can mess up your statistics in nondeterministic ways.\n   *\n   * Default: true\n   */\n  markBackgroundSpan: boolean;\n\n  /**\n   * If true, Sentry will capture long tasks and add them to the corresponding transaction.\n   *\n   * Default: true\n   */\n  enableLongTask: boolean;\n\n  /**\n   * If true, Sentry will capture long animation frames and add them to the corresponding transaction.\n   *\n   * Default: false\n   */\n  enableLongAnimationFrame: boolean;\n\n  /**\n   * If true, Sentry will capture first input delay and add it to the corresponding transaction.\n   *\n   * Default: true\n   */\n  enableInp: boolean;\n\n  /**\n   * @deprecated This option is no longer used. Element timing is now tracked via the standalone\n   * `elementTimingIntegration`. Add it to your `integrations` array to collect element timing metrics.\n   */\n  enableElementTiming?: boolean;\n\n  /**\n   * Flag to disable patching all together for fetch requests.\n   *\n   * Default: true\n   */\n  traceFetch: boolean;\n\n  /**\n   * Flag to disable patching all together for xhr requests.\n   *\n   * Default: true\n   */\n  traceXHR: boolean;\n\n  /**\n   * Flag to disable tracking of long-lived streams, like server-sent events (SSE) via fetch.\n   * Do not enable this in case you have live streams or very long running streams.\n   *\n   * Default: false\n   *\n   * @deprecated Use `fetchStreamPerformanceIntegration()` instead. Add it to your `integrations` array\n   * to track the duration of streamed fetch response bodies.\n   */\n  trackFetchStreamPerformance: boolean;\n\n  /**\n   * If true, Sentry will capture http timings and add them to the corresponding http spans.\n   *\n   * Default: true\n   */\n  enableHTTPTimings: boolean;\n\n  /**\n   * Resource spans with `op`s matching strings in the array will not be emitted.\n   *\n   * Default: []\n   */\n  ignoreResourceSpans: Array<'resouce.script' | 'resource.css' | 'resource.img' | 'resource.other' | string>;\n\n  /**\n   * Spans created from the following browser Performance APIs,\n   *\n   * - [`performance.mark(...)`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/mark)\n   * - [`performance.measure(...)`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/measure)\n   *\n   * will not be emitted if their names match strings in this array.\n   *\n   * This is useful, if you come across `mark` or `measure` spans in your Sentry traces\n   * that you want to ignore. For example, sometimes, browser extensions or libraries\n   * emit these entries on their own, which might not be relevant to your application.\n   *\n   * * @example\n   * ```ts\n   * Sentry.init({\n   *   integrations: [\n   *     Sentry.browserTracingIntegration({\n   *      ignorePerformanceApiSpans: ['myMeasurement', /myMark/],\n   *     }),\n   *   ],\n   * });\n   *\n   * // no spans will be created for these:\n   * performance.mark('myMark');\n   * performance.measure('myMeasurement');\n   *\n   * // spans will be created for these:\n   * performance.mark('authenticated');\n   * performance.measure('input-duration', ...);\n   * ```\n   *\n   * Default: [] - By default, all `mark` and `measure` entries are sent as spans.\n   */\n  ignorePerformanceApiSpans: Array<string | RegExp>;\n\n  /**\n   * By default, the SDK will try to detect redirects and avoid creating separate spans for them.\n   * If you want to opt-out of this behavior, you can set this option to `false`.\n   *\n   * Default: true\n   */\n  detectRedirects: boolean;\n\n  /**\n   * Link the currently started trace to a previous trace (e.g. a prior pageload, navigation or\n   * manually started span). When enabled, this option will allow you to navigate between traces\n   * in the Sentry UI.\n   *\n   * You can set this option to the following values:\n   *\n   * - `'in-memory'`: The previous trace data will be stored in memory.\n   *   This is useful for single-page applications and enabled by default.\n   *\n   * - `'session-storage'`: The previous trace data will be stored in the `sessionStorage`.\n   *   This is useful for multi-page applications or static sites but it means that the\n   *   Sentry SDK writes to the browser's `sessionStorage`.\n   *\n   * - `'off'`: The previous trace data will not be stored or linked.\n   *\n   * You can also use {@link BrowserTracingOptions.consistentTraceSampling} to get\n   * consistent trace sampling of subsequent traces. Otherwise, by default, your\n   * `tracesSampleRate` or `tracesSampler` config significantly influences how often\n   * traces will be linked.\n   *\n   * @default 'in-memory' - see explanation above\n   */\n  linkPreviousTrace: 'in-memory' | 'session-storage' | 'off';\n\n  /**\n   * If true, Sentry will consistently sample subsequent traces based on the\n   * sampling decision of the initial trace. For example, if the initial page\n   * load trace was sampled positively, all subsequent traces (e.g. navigations)\n   * are also sampled positively. In case the initial trace was sampled negatively,\n   * all subsequent traces are also sampled negatively.\n   *\n   * This option allows you to get consistent, linked traces within a user journey\n   * while maintaining an overall quota based on your trace sampling settings.\n   *\n   * This option is only effective if {@link BrowserTracingOptions.linkPreviousTrace}\n   * is enabled (i.e. not set to `'off'`).\n   *\n   * @default `false` - this is an opt-in feature.\n   */\n  consistentTraceSampling: boolean;\n\n  /**\n   * If set to `true`, the pageload span will not end itself automatically, unless it\n   * runs until the {@link BrowserTracingOptions.finalTimeout} (30 seconds by default) is reached.\n   *\n   * Set this option to `true`, if you want full control over the pageload span duration.\n   * You can use `Sentry.reportPageLoaded()` to manually end the pageload span whenever convenient.\n   * Be aware that you have to ensure that this is always called, regardless of the chosen route\n   * or path in the application.\n   *\n   * @default `false`. By default, the pageload span will end itself automatically, based on\n   * the {@link BrowserTracingOptions.finalTimeout}, {@link BrowserTracingOptions.idleTimeout}\n   * and {@link BrowserTracingOptions.childSpanTimeout}. This is more convenient to use but means\n   * that the pageload duration can be arbitrary and might not be fully representative of a perceived\n   * page load time.\n   */\n  enableReportPageLoaded: boolean;\n\n  /**\n   * _experiments allows the user to send options to define how this integration works.\n   *\n   * Default: undefined\n   */\n  _experiments: Partial<{\n    enableInteractions: boolean;\n    enableStandaloneClsSpans: boolean;\n    enableStandaloneLcpSpans: boolean;\n  }>;\n\n  /**\n   * A callback which is called before a span for a pageload or navigation is started.\n   * It receives the options passed to `startSpan`, and expects to return an updated options object.\n   */\n  beforeStartSpan?: (options: StartSpanOptions) => StartSpanOptions;\n\n  /**\n   * This function will be called before creating a span for a request with the given url.\n   * Return false if you don't want a span for the given url.\n   *\n   * Default: (url: string) => true\n   */\n  shouldCreateSpanForRequest?(this: void, url: string): boolean;\n\n  /**\n   * This callback is invoked directly after a span is started for an outgoing fetch or XHR request.\n   * You can use it to annotate the span with additional data or attributes, for example by setting\n   * attributes based on the passed request headers.\n   */\n  onRequestSpanStart?(span: Span, requestInformation: RequestHookInfo): void;\n\n  /**\n   * Is called when spans end for outgoing requests, providing access to response headers.\n   */\n  onRequestSpanEnd?(span: Span, responseInformation: ResponseHookInfo): void;\n}\n\nconst DEFAULT_BROWSER_TRACING_OPTIONS: BrowserTracingOptions = {\n  ...TRACING_DEFAULTS,\n  instrumentNavigation: true,\n  instrumentPageLoad: true,\n  markBackgroundSpan: true,\n  enableLongTask: true,\n  enableLongAnimationFrame: true,\n  enableInp: true,\n  ignoreResourceSpans: [],\n  ignorePerformanceApiSpans: [],\n  detectRedirects: true,\n  linkPreviousTrace: 'in-memory',\n  consistentTraceSampling: false,\n  enableReportPageLoaded: false,\n  _experiments: {},\n  ...defaultRequestInstrumentationOptions,\n};\n\n/**\n * The Browser Tracing integration automatically instruments browser pageload/navigation\n * actions as transactions, and captures requests, metrics and errors as spans.\n *\n * The integration can be configured with a variety of options, and can be extended to use\n * any routing library.\n *\n * We explicitly export the proper type here, as this has to be extended in some cases.\n */\nexport const browserTracingIntegration = ((options: Partial<BrowserTracingOptions> = {}) => {\n  if ('enableElementTiming' in options) {\n    consoleSandbox(() => {\n      // oxlint-disable-next-line no-console\n      console.warn(\n        '[Sentry] `enableElementTiming` is deprecated and no longer has any effect. Use the standalone `elementTimingIntegration` instead.',\n      );\n    });\n  }\n\n  const latestRoute: RouteInfo = {\n    name: undefined,\n    source: undefined,\n  };\n\n  /**\n   * This is just a small wrapper that makes `document` optional.\n   * We want to be extra-safe and always check that this exists, to ensure weird environments do not blow up.\n   */\n  const optionalWindowDocument = WINDOW.document as (typeof WINDOW)['document'] | undefined;\n\n  const {\n    enableInp,\n    enableLongTask,\n    enableLongAnimationFrame,\n    _experiments: { enableInteractions, enableStandaloneClsSpans, enableStandaloneLcpSpans },\n    beforeStartSpan,\n    idleTimeout,\n    finalTimeout,\n    childSpanTimeout,\n    markBackgroundSpan,\n    traceFetch,\n    traceXHR,\n    trackFetchStreamPerformance,\n    shouldCreateSpanForRequest,\n    enableHTTPTimings,\n    ignoreResourceSpans,\n    ignorePerformanceApiSpans,\n    instrumentPageLoad,\n    instrumentNavigation,\n    detectRedirects,\n    linkPreviousTrace,\n    consistentTraceSampling,\n    enableReportPageLoaded,\n    onRequestSpanStart,\n    onRequestSpanEnd,\n  } = {\n    ...DEFAULT_BROWSER_TRACING_OPTIONS,\n    ...options,\n  };\n\n  const _isBot = isBotUserAgent();\n\n  let _collectWebVitals: undefined | (() => void);\n  let lastInteractionTimestamp: number | undefined;\n\n  let _pageloadSpan: Span | undefined;\n\n  /** Create routing idle transaction. */\n  function _createRouteSpan(client: Client, startSpanOptions: StartSpanOptions, makeActive = true): void {\n    const isPageloadSpan = startSpanOptions.op === 'pageload';\n\n    const initialSpanName = startSpanOptions.name;\n    const finalStartSpanOptions: StartSpanOptions = beforeStartSpan\n      ? beforeStartSpan(startSpanOptions)\n      : startSpanOptions;\n\n    const attributes = finalStartSpanOptions.attributes || {};\n\n    // If `finalStartSpanOptions.name` is different than `startSpanOptions.name`\n    // it is because `beforeStartSpan` set a custom name. Therefore we set the source to 'custom'.\n    if (initialSpanName !== finalStartSpanOptions.name) {\n      attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE] = 'custom';\n      finalStartSpanOptions.attributes = attributes;\n    }\n\n    if (!makeActive) {\n      // We want to ensure this has 0s duration\n      const now = dateTimestampInSeconds();\n      startInactiveSpan({\n        ...finalStartSpanOptions,\n        startTime: now,\n      }).end(now);\n      return;\n    }\n\n    latestRoute.name = finalStartSpanOptions.name;\n    latestRoute.source = attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];\n\n    const idleSpan = startIdleSpan(finalStartSpanOptions, {\n      idleTimeout,\n      finalTimeout,\n      childSpanTimeout,\n      // should wait for finish signal if it's a pageload transaction\n      disableAutoFinish: isPageloadSpan,\n      beforeSpanEnd: span => {\n        // This will generally always be defined here, because it is set in `setup()` of the integration\n        // but technically, it is optional, so we guard here to be extra safe\n        _collectWebVitals?.();\n        const spanStreamingEnabled = hasSpanStreamingEnabled(client);\n        addPerformanceEntries(span, {\n          recordClsOnPageloadSpan: !spanStreamingEnabled && !enableStandaloneClsSpans,\n          recordLcpOnPageloadSpan: !spanStreamingEnabled && !enableStandaloneLcpSpans,\n          ignoreResourceSpans,\n          ignorePerformanceApiSpans,\n          spanStreamingEnabled,\n        });\n        setActiveIdleSpan(client, undefined);\n\n        // A trace should stay consistent over the entire timespan of one route - even after the pageload/navigation ended.\n        // Only when another navigation happens, we want to create a new trace.\n        // This way, e.g. errors that occur after the pageload span ended are still associated to the pageload trace.\n        const scope = getCurrentScope();\n        const oldPropagationContext = scope.getPropagationContext();\n\n        scope.setPropagationContext({\n          ...oldPropagationContext,\n          traceId: idleSpan.spanContext().traceId,\n          sampled: spanIsSampled(idleSpan),\n          dsc: getDynamicSamplingContextFromSpan(span),\n        });\n\n        if (isPageloadSpan) {\n          // clean up the stored pageload span on the intergration.\n          _pageloadSpan = undefined;\n        }\n      },\n      trimIdleSpanEndTimestamp: !enableReportPageLoaded,\n    });\n\n    if (isPageloadSpan && enableReportPageLoaded) {\n      _pageloadSpan = idleSpan;\n    }\n\n    setActiveIdleSpan(client, idleSpan);\n\n    function emitFinish(): void {\n      if (optionalWindowDocument && ['interactive', 'complete'].includes(optionalWindowDocument.readyState)) {\n        client.emit('idleSpanEnableAutoFinish', idleSpan);\n      }\n    }\n\n    // Enable auto finish of the pageload span if users are not explicitly ending it\n    if (isPageloadSpan && !enableReportPageLoaded && optionalWindowDocument) {\n      optionalWindowDocument.addEventListener('readystatechange', () => {\n        emitFinish();\n      });\n\n      emitFinish();\n    }\n  }\n\n  return {\n    name: BROWSER_TRACING_INTEGRATION_ID,\n    setup(client) {\n      if (_isBot) {\n        DEBUG_BUILD && debug.log('[Tracing] Skipping browserTracingIntegration setup for bot user agent.');\n        return;\n      }\n\n      registerSpanErrorInstrumentation();\n\n      const spanStreamingEnabled = hasSpanStreamingEnabled(client);\n\n      _collectWebVitals = startTrackingWebVitals({\n        recordClsStandaloneSpans: spanStreamingEnabled ? undefined : enableStandaloneClsSpans || false,\n        recordLcpStandaloneSpans: spanStreamingEnabled ? undefined : enableStandaloneLcpSpans || false,\n        client,\n      });\n\n      if (spanStreamingEnabled) {\n        trackLcpAsSpan(client);\n        trackClsAsSpan(client);\n        if (enableInp) {\n          trackInpAsSpan();\n        }\n      } else if (enableInp) {\n        startTrackingINP();\n      }\n\n      if (\n        enableLongAnimationFrame &&\n        GLOBAL_OBJ.PerformanceObserver &&\n        PerformanceObserver.supportedEntryTypes?.includes('long-animation-frame')\n      ) {\n        startTrackingLongAnimationFrames();\n      } else if (enableLongTask) {\n        startTrackingLongTasks();\n      }\n\n      if (enableInteractions) {\n        startTrackingInteractions();\n      }\n\n      if (detectRedirects && optionalWindowDocument) {\n        const interactionHandler = (): void => {\n          lastInteractionTimestamp = timestampInSeconds();\n        };\n        addEventListener('click', interactionHandler, { capture: true });\n        addEventListener('keydown', interactionHandler, { capture: true, passive: true });\n      }\n\n      function maybeEndActiveSpan(): void {\n        const activeSpan = getActiveIdleSpan(client);\n\n        if (activeSpan && !spanToJSON(activeSpan).timestamp) {\n          DEBUG_BUILD && debug.log(`[Tracing] Finishing current active span with op: ${spanToJSON(activeSpan).op}`);\n          // If there's an open active span, we need to finish it before creating an new one.\n          activeSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON, 'cancelled');\n          activeSpan.end();\n        }\n      }\n\n      client.on('startNavigationSpan', (startSpanOptions, navigationOptions) => {\n        if (getClient() !== client) {\n          return;\n        }\n\n        if (navigationOptions?.isRedirect) {\n          DEBUG_BUILD &&\n            debug.warn('[Tracing] Detected redirect, navigation span will not be the root span, but a child span.');\n          _createRouteSpan(\n            client,\n            {\n              op: 'navigation.redirect',\n              ...startSpanOptions,\n            },\n            false,\n          );\n          return;\n        }\n\n        // Reset the last interaction timestamp since we now start a new navigation.\n        // Any subsequent navigation span starts could again be a redirect, so we\n        // should reset our heuristic detectors.\n        lastInteractionTimestamp = undefined;\n\n        maybeEndActiveSpan();\n\n        getIsolationScope().setPropagationContext({\n          traceId: generateTraceId(),\n          sampleRand: Math.random(),\n          propagationSpanId: hasSpansEnabled() ? undefined : generateSpanId(),\n        });\n\n        const scope = getCurrentScope();\n        scope.setPropagationContext({\n          traceId: generateTraceId(),\n          sampleRand: Math.random(),\n          propagationSpanId: hasSpansEnabled() ? undefined : generateSpanId(),\n        });\n\n        // We reset this to ensure we do not have lingering incorrect data here\n        // places that call this hook may set this where appropriate - else, the URL at span sending time is used\n        scope.setSDKProcessingMetadata({\n          normalizedRequest: undefined,\n        });\n\n        _createRouteSpan(client, {\n          op: 'navigation',\n          ...startSpanOptions,\n          // Navigation starts a new trace and is NOT parented under any active interaction (e.g. ui.action.click)\n          parentSpan: null,\n          forceTransaction: true,\n        });\n      });\n\n      client.on('startPageLoadSpan', (startSpanOptions, traceOptions = {}) => {\n        if (getClient() !== client) {\n          return;\n        }\n        maybeEndActiveSpan();\n\n        const sentryTrace =\n          traceOptions.sentryTrace || getMetaContent('sentry-trace') || getServerTiming('sentry-trace');\n        const baggage = traceOptions.baggage || getMetaContent('baggage') || getServerTiming('baggage');\n\n        const propagationContext = propagationContextFromHeaders(sentryTrace, baggage);\n\n        const scope = getCurrentScope();\n        scope.setPropagationContext(propagationContext);\n        if (!hasSpansEnabled()) {\n          // for browser, we wanna keep the spanIds consistent during the entire lifetime of the trace\n          // this works by setting the propagationSpanId to a random spanId so that we have a consistent\n          // span id to propagate in TwP mode (!hasSpansEnabled())\n          scope.getPropagationContext().propagationSpanId = generateSpanId();\n        }\n\n        // We store the normalized request data on the scope, so we get the request data at time of span creation\n        // otherwise, the URL etc. may already be of the following navigation, and we'd report the wrong URL\n        scope.setSDKProcessingMetadata({\n          normalizedRequest: getHttpRequestData(),\n        });\n\n        _createRouteSpan(client, {\n          op: 'pageload',\n          ...startSpanOptions,\n        });\n      });\n\n      client.on('endPageloadSpan', () => {\n        if (enableReportPageLoaded && _pageloadSpan) {\n          _pageloadSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON, 'reportPageLoaded');\n          _pageloadSpan.end();\n        }\n      });\n    },\n\n    afterAllSetup(client) {\n      if (_isBot) {\n        return;\n      }\n\n      let startingUrl: string | undefined = getLocationHref();\n\n      if (linkPreviousTrace !== 'off') {\n        linkTraces(client, { linkPreviousTrace, consistentTraceSampling });\n      }\n\n      if (WINDOW.location) {\n        if (instrumentPageLoad) {\n          const origin = browserPerformanceTimeOrigin();\n          startBrowserTracingPageLoadSpan(client, {\n            name: WINDOW.location.pathname,\n            // pageload should always start at timeOrigin (and needs to be in s, not ms)\n            startTime: origin ? origin / 1000 : undefined,\n            attributes: {\n              [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'url',\n              [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.pageload.browser',\n            },\n          });\n        }\n\n        if (instrumentNavigation) {\n          addHistoryInstrumentationHandler(({ to, from }) => {\n            /**\n             * This early return is there to account for some cases where a navigation transaction starts right after\n             * long-running pageload. We make sure that if `from` is undefined and a valid `startingURL` exists, we don't\n             * create an uneccessary navigation transaction.\n             *\n             * This was hard to duplicate, but this behavior stopped as soon as this fix was applied. This issue might also\n             * only be caused in certain development environments where the usage of a hot module reloader is causing\n             * errors.\n             */\n            if (from === undefined && startingUrl?.indexOf(to) !== -1) {\n              startingUrl = undefined;\n              return;\n            }\n\n            startingUrl = undefined;\n            const parsed = parseStringToURLObject(to);\n            const activeSpan = getActiveIdleSpan(client);\n            const navigationIsRedirect =\n              activeSpan && detectRedirects && isRedirect(activeSpan, lastInteractionTimestamp);\n\n            startBrowserTracingNavigationSpan(\n              client,\n              {\n                name: parsed?.pathname || WINDOW.location.pathname,\n                attributes: {\n                  [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'url',\n                  [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.navigation.browser',\n                },\n              },\n              { url: to, isRedirect: navigationIsRedirect },\n            );\n          });\n        }\n      }\n\n      if (markBackgroundSpan) {\n        registerBackgroundTabDetection();\n      }\n\n      if (enableInteractions) {\n        registerInteractionListener(client, idleTimeout, finalTimeout, childSpanTimeout, latestRoute);\n      }\n\n      if (enableInp) {\n        registerInpInteractionListener();\n      }\n\n      instrumentOutgoingRequests(client, {\n        traceFetch,\n        traceXHR,\n        tracePropagationTargets: client.getOptions().tracePropagationTargets,\n        shouldCreateSpanForRequest,\n        enableHTTPTimings,\n        onRequestSpanStart,\n        onRequestSpanEnd,\n      });\n\n      if (trackFetchStreamPerformance) {\n        client.addIntegration(fetchStreamPerformanceIntegration());\n      }\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Manually start a page load span.\n * This will only do something if a browser tracing integration integration has been setup.\n *\n * If you provide a custom `traceOptions` object, it will be used to continue the trace\n * instead of the default behavior, which is to look it up on the <meta> tags.\n */\nexport function startBrowserTracingPageLoadSpan(\n  client: Client,\n  spanOptions: StartSpanOptions,\n  traceOptions?: { sentryTrace?: string | undefined; baggage?: string | undefined },\n): Span | undefined {\n  client.emit('startPageLoadSpan', spanOptions, traceOptions);\n  getCurrentScope().setTransactionName(spanOptions.name);\n\n  const pageloadSpan = getActiveIdleSpan(client);\n\n  if (pageloadSpan) {\n    client.emit('afterStartPageLoadSpan', pageloadSpan);\n  }\n\n  return pageloadSpan;\n}\n\n/**\n * Manually start a navigation span.\n * This will only do something if a browser tracing integration has been setup.\n */\nexport function startBrowserTracingNavigationSpan(\n  client: Client,\n  spanOptions: StartSpanOptions,\n  options?: { url?: string; isRedirect?: boolean },\n): Span | undefined {\n  const { url, isRedirect } = options || {};\n  client.emit('beforeStartNavigationSpan', spanOptions, { isRedirect });\n  client.emit('startNavigationSpan', spanOptions, { isRedirect });\n\n  const scope = getCurrentScope();\n  scope.setTransactionName(spanOptions.name);\n\n  // We store the normalized request data on the scope, so we get the request data at time of span creation\n  // otherwise, the URL etc. may already be of the following navigation, and we'd report the wrong URL\n  if (url && !isRedirect) {\n    scope.setSDKProcessingMetadata({\n      normalizedRequest: {\n        ...getHttpRequestData(),\n        url,\n      },\n    });\n  }\n\n  return getActiveIdleSpan(client);\n}\n\n/** Returns the value of a meta tag */\nexport function getMetaContent(metaName: string): string | undefined {\n  /**\n   * This is just a small wrapper that makes `document` optional.\n   * We want to be extra-safe and always check that this exists, to ensure weird environments do not blow up.\n   */\n  const optionalWindowDocument = WINDOW.document as (typeof WINDOW)['document'] | undefined;\n\n  const metaTag = optionalWindowDocument?.querySelector(`meta[name=${metaName}]`);\n  return metaTag?.getAttribute('content') || undefined;\n}\n\n/** Returns the description of a server timing entry */\nexport function getServerTiming(name: string): string | undefined {\n  const navigation = WINDOW.performance?.getEntriesByType?.('navigation')[0] as PerformanceNavigationTiming | undefined;\n  const entry = navigation?.serverTiming?.find(entry => entry.name === name);\n  return entry?.description;\n}\n\n/** Start listener for interaction transactions */\nfunction registerInteractionListener(\n  client: Client,\n  idleTimeout: BrowserTracingOptions['idleTimeout'],\n  finalTimeout: BrowserTracingOptions['finalTimeout'],\n  childSpanTimeout: BrowserTracingOptions['childSpanTimeout'],\n  latestRoute: RouteInfo,\n): void {\n  /**\n   * This is just a small wrapper that makes `document` optional.\n   * We want to be extra-safe and always check that this exists, to ensure weird environments do not blow up.\n   */\n  const optionalWindowDocument = WINDOW.document as (typeof WINDOW)['document'] | undefined;\n\n  let inflightInteractionSpan: Span | undefined;\n  const registerInteractionTransaction = (): void => {\n    const op = 'ui.action.click';\n\n    const activeIdleSpan = getActiveIdleSpan(client);\n    if (activeIdleSpan) {\n      const currentRootSpanOp = spanToJSON(activeIdleSpan).op;\n      if (['navigation', 'pageload'].includes(currentRootSpanOp as string)) {\n        DEBUG_BUILD &&\n          debug.warn(`[Tracing] Did not create ${op} span because a pageload or navigation span is in progress.`);\n        return undefined;\n      }\n    }\n\n    if (inflightInteractionSpan) {\n      inflightInteractionSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON, 'interactionInterrupted');\n      inflightInteractionSpan.end();\n      inflightInteractionSpan = undefined;\n    }\n\n    if (!latestRoute.name) {\n      DEBUG_BUILD && debug.warn(`[Tracing] Did not create ${op} transaction because _latestRouteName is missing.`);\n      return undefined;\n    }\n\n    inflightInteractionSpan = startIdleSpan(\n      {\n        name: latestRoute.name,\n        op,\n        attributes: {\n          [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: latestRoute.source || 'url',\n        },\n      },\n      {\n        idleTimeout,\n        finalTimeout,\n        childSpanTimeout,\n      },\n    );\n  };\n\n  if (optionalWindowDocument) {\n    addEventListener('click', registerInteractionTransaction, { capture: true });\n  }\n}\n\n// We store the active idle span on the client object, so we can access it from exported functions\nconst ACTIVE_IDLE_SPAN_PROPERTY = '_sentry_idleSpan';\nfunction getActiveIdleSpan(client: Client): Span | undefined {\n  return (client as { [ACTIVE_IDLE_SPAN_PROPERTY]?: Span })[ACTIVE_IDLE_SPAN_PROPERTY];\n}\n\nfunction setActiveIdleSpan(client: Client, span: Span | undefined): void {\n  addNonEnumerableProperty(client, ACTIVE_IDLE_SPAN_PROPERTY, span);\n}\n\n// The max. time in seconds between two pageload/navigation spans that makes us consider the second one a redirect\nconst REDIRECT_THRESHOLD = 1.5;\n\nfunction isRedirect(activeSpan: Span, lastInteractionTimestamp: number | undefined): boolean {\n  const spanData = spanToJSON(activeSpan);\n\n  const now = dateTimestampInSeconds();\n\n  // More than REDIRECT_THRESHOLD seconds since last navigation/pageload span?\n  // --> never consider this a redirect\n  const startTimestamp = spanData.start_timestamp;\n  if (now - startTimestamp > REDIRECT_THRESHOLD) {\n    return false;\n  }\n\n  // A click happened in the last REDIRECT_THRESHOLD seconds?\n  // --> never consider this a redirect\n  if (lastInteractionTimestamp && now - lastInteractionTimestamp <= REDIRECT_THRESHOLD) {\n    return false;\n  }\n\n  return true;\n}\n"],"names":["WINDOW","TRACING_DEFAULTS","defaultRequestInstrumentationOptions","consoleSandbox","SEMANTIC_ATTRIBUTE_SENTRY_SOURCE","dateTimestampInSeconds","startInactiveSpan","startIdleSpan","hasSpanStreamingEnabled","addPerformanceEntries","getCurrentScope","spanIsSampled","getDynamicSamplingContextFromSpan","DEBUG_BUILD","debug","registerSpanErrorInstrumentation","startTrackingWebVitals","trackLcpAsSpan","trackClsAsSpan","trackInpAsSpan","startTrackingINP","GLOBAL_OBJ","startTrackingLongAnimationFrames","startTrackingLongTasks","startTrackingInteractions","timestampInSeconds","spanToJSON","SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON","getClient","getIsolationScope","generateTraceId","hasSpansEnabled","generateSpanId","propagationContextFromHeaders","getHttpRequestData","getLocationHref","linkTraces","browserPerformanceTimeOrigin","SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN","addHistoryInstrumentationHandler","parseStringToURLObject","registerBackgroundTabDetection","registerInpInteractionListener","instrumentOutgoingRequests","fetchStreamPerformanceIntegration","isRedirect","entry","addNonEnumerableProperty"],"mappings":"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"}