{"version":3,"file":"static/js/vendors-node_modules_sentry_tracing_esm_index_js.718a6502.chunk.js","mappings":"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","sources":["../node_modules/src/constants.ts","../node_modules/src/flags.ts","../node_modules/src/errors.ts","../node_modules/src/hubextensions.ts","../node_modules/src/idletransaction.ts","../node_modules/src/integrations/node/express.ts","../node_modules/src/integrations/node/postgres.ts","../node_modules/src/integrations/node/mysql.ts","../node_modules/src/integrations/node/mongo.ts","../node_modules/@sentry/src/tracing.ts","../node_modules/src/browser/backgroundtab.ts","../node_modules/src/browser/web-vitals/lib/bindReporter.ts","../node_modules/src/browser/web-vitals/lib/initMetric.ts","../node_modules/src/browser/web-vitals/lib/generateUniqueID.ts","../node_modules/src/browser/web-vitals/lib/observe.ts","../node_modules/src/browser/web-vitals/lib/onHidden.ts","../node_modules/src/browser/web-vitals/lib/getVisibilityWatcher.ts","../node_modules/src/browser/web-vitals/getLCP.ts","../node_modules/src/browser/metrics.ts","../node_modules/src/browser/web-vitals/getCLS.ts","../node_modules/src/browser/web-vitals/getFID.ts","../node_modules/src/browser/request.ts","../node_modules/src/browser/router.ts","../node_modules/src/browser/browsertracing.ts","../node_modules/src/spanstatus.ts","../node_modules/src/index.ts","../node_modules/src/span.ts","../node_modules/src/transaction.ts","../node_modules/src/utils.ts","../node_modules/@sentry/tracing/node_modules/tslib/tslib.es6.js"],"sourcesContent":["// Store finish reasons in tuple to save on bundle size\n// Readonly type should enforce that this is not mutated.\nexport const FINISH_REASON_TAG = 'finishReason';\n\nexport const IDLE_TRANSACTION_FINISH_REASONS = ['heartbeatFailed', 'idleTimeout', 'documentHidden'] as const;\n","/*\n * This file defines flags and constants that can be modified during compile time in order to facilitate tree shaking\n * for users.\n *\n * Debug flags need to be declared in each package individually and must not be imported across package boundaries,\n * because some build tools have trouble tree-shaking imported guards.\n *\n * As a convention, we define debug flags in a `flags.ts` file in the root of a package's `src` folder.\n *\n * Debug flag files will contain \"magic strings\" like `__SENTRY_DEBUG__` that may get replaced with actual values during\n * our, or the user's build process. Take care when introducing new flags - they must not throw if they are not\n * replaced.\n */\n\ndeclare const __SENTRY_DEBUG__: boolean;\n\n/** Flag that is true for debug builds, false otherwise. */\nexport const IS_DEBUG_BUILD = typeof __SENTRY_DEBUG__ === 'undefined' ? true : __SENTRY_DEBUG__;\n","import { addInstrumentationHandler, logger } from '@sentry/utils';\n\nimport { IS_DEBUG_BUILD } from './flags';\nimport { SpanStatusType } from './span';\nimport { getActiveTransaction } from './utils';\n\n/**\n * Configures global error listeners\n */\nexport function registerErrorInstrumentation(): void {\n  addInstrumentationHandler('error', errorCallback);\n  addInstrumentationHandler('unhandledrejection', errorCallback);\n}\n\n/**\n * If an error or unhandled promise occurs, we mark the active transaction as failed\n */\nfunction errorCallback(): void {\n  const activeTransaction = getActiveTransaction();\n  if (activeTransaction) {\n    const status: SpanStatusType = 'internal_error';\n    IS_DEBUG_BUILD && logger.log(`[Tracing] Transaction: ${status} -> Global error occured`);\n    activeTransaction.setStatus(status);\n  }\n}\n","import { getMainCarrier, Hub } from '@sentry/hub';\nimport {\n  CustomSamplingContext,\n  Integration,\n  IntegrationClass,\n  Options,\n  SamplingContext,\n  TransactionContext,\n} from '@sentry/types';\nimport { dynamicRequire, isNaN, isNodeEnv, loadModule, logger } from '@sentry/utils';\n\nimport { registerErrorInstrumentation } from './errors';\nimport { IS_DEBUG_BUILD } from './flags';\nimport { IdleTransaction } from './idletransaction';\nimport { Transaction } from './transaction';\nimport { hasTracingEnabled } from './utils';\n\n/** Returns all trace headers that are currently on the top scope. */\nfunction traceHeaders(this: Hub): { [key: string]: string } {\n  const scope = this.getScope();\n  if (scope) {\n    const span = scope.getSpan();\n    if (span) {\n      return {\n        'sentry-trace': span.toTraceparent(),\n      };\n    }\n  }\n  return {};\n}\n\n/**\n * Makes a sampling decision for the given transaction and stores it on the transaction.\n *\n * Called every time a transaction is created. Only transactions which emerge with a `sampled` value of `true` will be\n * sent to Sentry.\n *\n * @param transaction: The transaction needing a sampling decision\n * @param options: The current client's options, so we can access `tracesSampleRate` and/or `tracesSampler`\n * @param samplingContext: Default and user-provided data which may be used to help make the decision\n *\n * @returns The given transaction with its `sampled` value set\n */\nfunction sample<T extends Transaction>(transaction: T, options: Options, samplingContext: SamplingContext): T {\n  // nothing to do if tracing is not enabled\n  if (!hasTracingEnabled(options)) {\n    transaction.sampled = false;\n    return transaction;\n  }\n\n  // if the user has forced a sampling decision by passing a `sampled` value in their transaction context, go with that\n  if (transaction.sampled !== undefined) {\n    transaction.setMetadata({\n      transactionSampling: { method: 'explicitly_set' },\n    });\n    return transaction;\n  }\n\n  // we would have bailed already if neither `tracesSampler` nor `tracesSampleRate` were defined, so one of these should\n  // work; prefer the hook if so\n  let sampleRate;\n  if (typeof options.tracesSampler === 'function') {\n    sampleRate = options.tracesSampler(samplingContext);\n    transaction.setMetadata({\n      transactionSampling: {\n        method: 'client_sampler',\n        // cast to number in case it's a boolean\n        rate: Number(sampleRate),\n      },\n    });\n  } else if (samplingContext.parentSampled !== undefined) {\n    sampleRate = samplingContext.parentSampled;\n    transaction.setMetadata({\n      transactionSampling: { method: 'inheritance' },\n    });\n  } else {\n    sampleRate = options.tracesSampleRate;\n    transaction.setMetadata({\n      transactionSampling: {\n        method: 'client_rate',\n        // cast to number in case it's a boolean\n        rate: Number(sampleRate),\n      },\n    });\n  }\n\n  // Since this is coming from the user (or from a function provided by the user), who knows what we might get. (The\n  // only valid values are booleans or numbers between 0 and 1.)\n  if (!isValidSampleRate(sampleRate)) {\n    IS_DEBUG_BUILD && logger.warn('[Tracing] Discarding transaction because of invalid sample rate.');\n    transaction.sampled = false;\n    return transaction;\n  }\n\n  // if the function returned 0 (or false), or if `tracesSampleRate` is 0, it's a sign the transaction should be dropped\n  if (!sampleRate) {\n    IS_DEBUG_BUILD &&\n      logger.log(\n        `[Tracing] Discarding transaction because ${\n          typeof options.tracesSampler === 'function'\n            ? 'tracesSampler returned 0 or false'\n            : 'a negative sampling decision was inherited or tracesSampleRate is set to 0'\n        }`,\n      );\n    transaction.sampled = false;\n    return transaction;\n  }\n\n  // Now we roll the dice. Math.random is inclusive of 0, but not of 1, so strict < is safe here. In case sampleRate is\n  // a boolean, the < comparison will cause it to be automatically cast to 1 if it's true and 0 if it's false.\n  transaction.sampled = Math.random() < (sampleRate as number | boolean);\n\n  // if we're not going to keep it, we're done\n  if (!transaction.sampled) {\n    IS_DEBUG_BUILD &&\n      logger.log(\n        `[Tracing] Discarding transaction because it's not included in the random sample (sampling rate = ${Number(\n          sampleRate,\n        )})`,\n      );\n    return transaction;\n  }\n\n  IS_DEBUG_BUILD && logger.log(`[Tracing] starting ${transaction.op} transaction - ${transaction.name}`);\n  return transaction;\n}\n\n/**\n * Checks the given sample rate to make sure it is valid type and value (a boolean, or a number between 0 and 1).\n */\nfunction isValidSampleRate(rate: unknown): boolean {\n  // we need to check NaN explicitly because it's of type 'number' and therefore wouldn't get caught by this typecheck\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  if (isNaN(rate) || !(typeof rate === 'number' || typeof rate === 'boolean')) {\n    IS_DEBUG_BUILD &&\n      logger.warn(\n        `[Tracing] Given sample rate is invalid. Sample rate must be a boolean or a number between 0 and 1. Got ${JSON.stringify(\n          rate,\n        )} of type ${JSON.stringify(typeof rate)}.`,\n      );\n    return false;\n  }\n\n  // in case sampleRate is a boolean, it will get automatically cast to 1 if it's true and 0 if it's false\n  if (rate < 0 || rate > 1) {\n    IS_DEBUG_BUILD &&\n      logger.warn(`[Tracing] Given sample rate is invalid. Sample rate must be between 0 and 1. Got ${rate}.`);\n    return false;\n  }\n  return true;\n}\n\n/**\n * Creates a new transaction and adds a sampling decision if it doesn't yet have one.\n *\n * The Hub.startTransaction method delegates to this method to do its work, passing the Hub instance in as `this`, as if\n * it had been called on the hub directly. Exists as a separate function so that it can be injected into the class as an\n * \"extension method.\"\n *\n * @param this: The Hub starting the transaction\n * @param transactionContext: Data used to configure the transaction\n * @param CustomSamplingContext: Optional data to be provided to the `tracesSampler` function (if any)\n *\n * @returns The new transaction\n *\n * @see {@link Hub.startTransaction}\n */\nfunction _startTransaction(\n  this: Hub,\n  transactionContext: TransactionContext,\n  customSamplingContext?: CustomSamplingContext,\n): Transaction {\n  const client = this.getClient();\n  const options = (client && client.getOptions()) || {};\n\n  let transaction = new Transaction(transactionContext, this);\n  transaction = sample(transaction, options, {\n    parentSampled: transactionContext.parentSampled,\n    transactionContext,\n    ...customSamplingContext,\n  });\n  if (transaction.sampled) {\n    transaction.initSpanRecorder(options._experiments && (options._experiments.maxSpans as number));\n  }\n  return transaction;\n}\n\n/**\n * Create new idle transaction.\n */\nexport function startIdleTransaction(\n  hub: Hub,\n  transactionContext: TransactionContext,\n  idleTimeout?: number,\n  onScope?: boolean,\n  customSamplingContext?: CustomSamplingContext,\n): IdleTransaction {\n  const client = hub.getClient();\n  const options = (client && client.getOptions()) || {};\n\n  let transaction = new IdleTransaction(transactionContext, hub, idleTimeout, onScope);\n  transaction = sample(transaction, options, {\n    parentSampled: transactionContext.parentSampled,\n    transactionContext,\n    ...customSamplingContext,\n  });\n  if (transaction.sampled) {\n    transaction.initSpanRecorder(options._experiments && (options._experiments.maxSpans as number));\n  }\n  return transaction;\n}\n\n/**\n * @private\n */\nexport function _addTracingExtensions(): void {\n  const carrier = getMainCarrier();\n  if (!carrier.__SENTRY__) {\n    return;\n  }\n  carrier.__SENTRY__.extensions = carrier.__SENTRY__.extensions || {};\n  if (!carrier.__SENTRY__.extensions.startTransaction) {\n    carrier.__SENTRY__.extensions.startTransaction = _startTransaction;\n  }\n  if (!carrier.__SENTRY__.extensions.traceHeaders) {\n    carrier.__SENTRY__.extensions.traceHeaders = traceHeaders;\n  }\n}\n\n/**\n * @private\n */\nfunction _autoloadDatabaseIntegrations(): void {\n  const carrier = getMainCarrier();\n  if (!carrier.__SENTRY__) {\n    return;\n  }\n\n  const packageToIntegrationMapping: Record<string, () => Integration> = {\n    mongodb() {\n      const integration = dynamicRequire(module, './integrations/node/mongo') as {\n        Mongo: IntegrationClass<Integration>;\n      };\n      return new integration.Mongo();\n    },\n    mongoose() {\n      const integration = dynamicRequire(module, './integrations/node/mongo') as {\n        Mongo: IntegrationClass<Integration>;\n      };\n      return new integration.Mongo({ mongoose: true });\n    },\n    mysql() {\n      const integration = dynamicRequire(module, './integrations/node/mysql') as {\n        Mysql: IntegrationClass<Integration>;\n      };\n      return new integration.Mysql();\n    },\n    pg() {\n      const integration = dynamicRequire(module, './integrations/node/postgres') as {\n        Postgres: IntegrationClass<Integration>;\n      };\n      return new integration.Postgres();\n    },\n  };\n\n  const mappedPackages = Object.keys(packageToIntegrationMapping)\n    .filter(moduleName => !!loadModule(moduleName))\n    .map(pkg => {\n      try {\n        return packageToIntegrationMapping[pkg]();\n      } catch (e) {\n        return undefined;\n      }\n    })\n    .filter(p => p) as Integration[];\n\n  if (mappedPackages.length > 0) {\n    carrier.__SENTRY__.integrations = [...(carrier.__SENTRY__.integrations || []), ...mappedPackages];\n  }\n}\n\n/**\n * This patches the global object and injects the Tracing extensions methods\n */\nexport function addExtensionMethods(): void {\n  _addTracingExtensions();\n\n  // Detect and automatically load specified integrations.\n  if (isNodeEnv()) {\n    _autoloadDatabaseIntegrations();\n  }\n\n  // If an error happens globally, we should make sure transaction status is set to error.\n  registerErrorInstrumentation();\n}\n","import { Hub } from '@sentry/hub';\nimport { TransactionContext } from '@sentry/types';\nimport { logger, timestampWithMs } from '@sentry/utils';\n\nimport { FINISH_REASON_TAG, IDLE_TRANSACTION_FINISH_REASONS } from './constants';\nimport { IS_DEBUG_BUILD } from './flags';\nimport { Span, SpanRecorder } from './span';\nimport { Transaction } from './transaction';\n\nexport const DEFAULT_IDLE_TIMEOUT = 1000;\nexport const HEARTBEAT_INTERVAL = 5000;\n\n/**\n * @inheritDoc\n */\nexport class IdleTransactionSpanRecorder extends SpanRecorder {\n  public constructor(\n    private readonly _pushActivity: (id: string) => void,\n    private readonly _popActivity: (id: string) => void,\n    public transactionSpanId: string = '',\n    maxlen?: number,\n  ) {\n    super(maxlen);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public add(span: Span): void {\n    // We should make sure we do not push and pop activities for\n    // the transaction that this span recorder belongs to.\n    if (span.spanId !== this.transactionSpanId) {\n      // We patch span.finish() to pop an activity after setting an endTimestamp.\n      span.finish = (endTimestamp?: number) => {\n        span.endTimestamp = typeof endTimestamp === 'number' ? endTimestamp : timestampWithMs();\n        this._popActivity(span.spanId);\n      };\n\n      // We should only push new activities if the span does not have an end timestamp.\n      if (span.endTimestamp === undefined) {\n        this._pushActivity(span.spanId);\n      }\n    }\n\n    super.add(span);\n  }\n}\n\nexport type BeforeFinishCallback = (transactionSpan: IdleTransaction, endTimestamp: number) => void;\n\n/**\n * An IdleTransaction is a transaction that automatically finishes. It does this by tracking child spans as activities.\n * You can have multiple IdleTransactions active, but if the `onScope` option is specified, the idle transaction will\n * put itself on the scope on creation.\n */\nexport class IdleTransaction extends Transaction {\n  // Activities store a list of active spans\n  public activities: Record<string, boolean> = {};\n\n  // Track state of activities in previous heartbeat\n  private _prevHeartbeatString: string | undefined;\n\n  // Amount of times heartbeat has counted. Will cause transaction to finish after 3 beats.\n  private _heartbeatCounter: number = 0;\n\n  // We should not use heartbeat if we finished a transaction\n  private _finished: boolean = false;\n\n  private readonly _beforeFinishCallbacks: BeforeFinishCallback[] = [];\n\n  /**\n   * If a transaction is created and no activities are added, we want to make sure that\n   * it times out properly. This is cleared and not used when activities are added.\n   */\n  private _initTimeout: ReturnType<typeof setTimeout> | undefined;\n\n  public constructor(\n    transactionContext: TransactionContext,\n    private readonly _idleHub?: Hub,\n    /**\n     * The time to wait in ms until the idle transaction will be finished.\n     * @default 1000\n     */\n    private readonly _idleTimeout: number = DEFAULT_IDLE_TIMEOUT,\n    // Whether or not the transaction should put itself on the scope when it starts and pop itself off when it ends\n    private readonly _onScope: boolean = false,\n  ) {\n    super(transactionContext, _idleHub);\n\n    if (_idleHub && _onScope) {\n      // There should only be one active transaction on the scope\n      clearActiveTransaction(_idleHub);\n\n      // We set the transaction here on the scope so error events pick up the trace\n      // context and attach it to the error.\n      IS_DEBUG_BUILD && logger.log(`Setting idle transaction on scope. Span ID: ${this.spanId}`);\n      _idleHub.configureScope(scope => scope.setSpan(this));\n    }\n\n    this._initTimeout = setTimeout(() => {\n      if (!this._finished) {\n        this.finish();\n      }\n    }, this._idleTimeout);\n  }\n\n  /** {@inheritDoc} */\n  public finish(endTimestamp: number = timestampWithMs()): string | undefined {\n    this._finished = true;\n    this.activities = {};\n\n    if (this.spanRecorder) {\n      IS_DEBUG_BUILD &&\n        logger.log('[Tracing] finishing IdleTransaction', new Date(endTimestamp * 1000).toISOString(), this.op);\n\n      for (const callback of this._beforeFinishCallbacks) {\n        callback(this, endTimestamp);\n      }\n\n      this.spanRecorder.spans = this.spanRecorder.spans.filter((span: Span) => {\n        // If we are dealing with the transaction itself, we just return it\n        if (span.spanId === this.spanId) {\n          return true;\n        }\n\n        // We cancel all pending spans with status \"cancelled\" to indicate the idle transaction was finished early\n        if (!span.endTimestamp) {\n          span.endTimestamp = endTimestamp;\n          span.setStatus('cancelled');\n          IS_DEBUG_BUILD &&\n            logger.log('[Tracing] cancelling span since transaction ended early', JSON.stringify(span, undefined, 2));\n        }\n\n        const keepSpan = span.startTimestamp < endTimestamp;\n        if (!keepSpan) {\n          IS_DEBUG_BUILD &&\n            logger.log(\n              '[Tracing] discarding Span since it happened after Transaction was finished',\n              JSON.stringify(span, undefined, 2),\n            );\n        }\n        return keepSpan;\n      });\n\n      IS_DEBUG_BUILD && logger.log('[Tracing] flushing IdleTransaction');\n    } else {\n      IS_DEBUG_BUILD && logger.log('[Tracing] No active IdleTransaction');\n    }\n\n    // if `this._onScope` is `true`, the transaction put itself on the scope when it started\n    if (this._onScope) {\n      clearActiveTransaction(this._idleHub);\n    }\n\n    return super.finish(endTimestamp);\n  }\n\n  /**\n   * Register a callback function that gets excecuted before the transaction finishes.\n   * Useful for cleanup or if you want to add any additional spans based on current context.\n   *\n   * This is exposed because users have no other way of running something before an idle transaction\n   * finishes.\n   */\n  public registerBeforeFinishCallback(callback: BeforeFinishCallback): void {\n    this._beforeFinishCallbacks.push(callback);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public initSpanRecorder(maxlen?: number): void {\n    if (!this.spanRecorder) {\n      const pushActivity = (id: string): void => {\n        if (this._finished) {\n          return;\n        }\n        this._pushActivity(id);\n      };\n      const popActivity = (id: string): void => {\n        if (this._finished) {\n          return;\n        }\n        this._popActivity(id);\n      };\n\n      this.spanRecorder = new IdleTransactionSpanRecorder(pushActivity, popActivity, this.spanId, maxlen);\n\n      // Start heartbeat so that transactions do not run forever.\n      IS_DEBUG_BUILD && logger.log('Starting heartbeat');\n      this._pingHeartbeat();\n    }\n    this.spanRecorder.add(this);\n  }\n\n  /**\n   * Start tracking a specific activity.\n   * @param spanId The span id that represents the activity\n   */\n  private _pushActivity(spanId: string): void {\n    if (this._initTimeout) {\n      clearTimeout(this._initTimeout);\n      this._initTimeout = undefined;\n    }\n    IS_DEBUG_BUILD && logger.log(`[Tracing] pushActivity: ${spanId}`);\n    this.activities[spanId] = true;\n    IS_DEBUG_BUILD && logger.log('[Tracing] new activities count', Object.keys(this.activities).length);\n  }\n\n  /**\n   * Remove an activity from usage\n   * @param spanId The span id that represents the activity\n   */\n  private _popActivity(spanId: string): void {\n    if (this.activities[spanId]) {\n      IS_DEBUG_BUILD && logger.log(`[Tracing] popActivity ${spanId}`);\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete this.activities[spanId];\n      IS_DEBUG_BUILD && logger.log('[Tracing] new activities count', Object.keys(this.activities).length);\n    }\n\n    if (Object.keys(this.activities).length === 0) {\n      const timeout = this._idleTimeout;\n      // We need to add the timeout here to have the real endtimestamp of the transaction\n      // Remember timestampWithMs is in seconds, timeout is in ms\n      const end = timestampWithMs() + timeout / 1000;\n\n      setTimeout(() => {\n        if (!this._finished) {\n          this.setTag(FINISH_REASON_TAG, IDLE_TRANSACTION_FINISH_REASONS[1]);\n          this.finish(end);\n        }\n      }, timeout);\n    }\n  }\n\n  /**\n   * Checks when entries of this.activities are not changing for 3 beats.\n   * If this occurs we finish the transaction.\n   */\n  private _beat(): void {\n    // We should not be running heartbeat if the idle transaction is finished.\n    if (this._finished) {\n      return;\n    }\n\n    const heartbeatString = Object.keys(this.activities).join('');\n\n    if (heartbeatString === this._prevHeartbeatString) {\n      this._heartbeatCounter += 1;\n    } else {\n      this._heartbeatCounter = 1;\n    }\n\n    this._prevHeartbeatString = heartbeatString;\n\n    if (this._heartbeatCounter >= 3) {\n      IS_DEBUG_BUILD && logger.log('[Tracing] Transaction finished because of no change for 3 heart beats');\n      this.setStatus('deadline_exceeded');\n      this.setTag(FINISH_REASON_TAG, IDLE_TRANSACTION_FINISH_REASONS[0]);\n      this.finish();\n    } else {\n      this._pingHeartbeat();\n    }\n  }\n\n  /**\n   * Pings the heartbeat\n   */\n  private _pingHeartbeat(): void {\n    IS_DEBUG_BUILD && logger.log(`pinging Heartbeat -> current counter: ${this._heartbeatCounter}`);\n    setTimeout(() => {\n      this._beat();\n    }, HEARTBEAT_INTERVAL);\n  }\n}\n\n/**\n * Reset transaction on scope to `undefined`\n */\nfunction clearActiveTransaction(hub?: Hub): void {\n  if (hub) {\n    const scope = hub.getScope();\n    if (scope) {\n      const transaction = scope.getTransaction();\n      if (transaction) {\n        scope.setSpan(undefined);\n      }\n    }\n  }\n}\n","import { Integration, Transaction } from '@sentry/types';\nimport { logger } from '@sentry/utils';\n\nimport { IS_DEBUG_BUILD } from '../../flags';\n\ntype Method =\n  | 'all'\n  | 'get'\n  | 'post'\n  | 'put'\n  | 'delete'\n  | 'patch'\n  | 'options'\n  | 'head'\n  | 'checkout'\n  | 'copy'\n  | 'lock'\n  | 'merge'\n  | 'mkactivity'\n  | 'mkcol'\n  | 'move'\n  | 'm-search'\n  | 'notify'\n  | 'purge'\n  | 'report'\n  | 'search'\n  | 'subscribe'\n  | 'trace'\n  | 'unlock'\n  | 'unsubscribe'\n  | 'use';\n\ntype Router = {\n  [method in Method]: (...args: any) => any; // eslint-disable-line @typescript-eslint/no-explicit-any\n};\n\ninterface ExpressResponse {\n  once(name: string, callback: () => void): void;\n}\n\n/**\n * Internal helper for `__sentry_transaction`\n * @hidden\n */\ninterface SentryTracingResponse {\n  __sentry_transaction?: Transaction;\n}\n\n/**\n * Express integration\n *\n * Provides an request and error handler for Express framework as well as tracing capabilities\n */\nexport class Express implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'Express';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = Express.id;\n\n  /**\n   * Express App instance\n   */\n  private readonly _router?: Router;\n  private readonly _methods?: Method[];\n\n  /**\n   * @inheritDoc\n   */\n  public constructor(options: { app?: Router; router?: Router; methods?: Method[] } = {}) {\n    this._router = options.router || options.app;\n    this._methods = (Array.isArray(options.methods) ? options.methods : []).concat('use');\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(): void {\n    if (!this._router) {\n      IS_DEBUG_BUILD && logger.error('ExpressIntegration is missing an Express instance');\n      return;\n    }\n    instrumentMiddlewares(this._router, this._methods);\n  }\n}\n\n/**\n * Wraps original middleware function in a tracing call, which stores the info about the call as a span,\n * and finishes it once the middleware is done invoking.\n *\n * Express middlewares have 3 various forms, thus we have to take care of all of them:\n * // sync\n * app.use(function (req, res) { ... })\n * // async\n * app.use(function (req, res, next) { ... })\n * // error handler\n * app.use(function (err, req, res, next) { ... })\n *\n * They all internally delegate to the `router[method]` of the given application instance.\n */\n// eslint-disable-next-line @typescript-eslint/ban-types, @typescript-eslint/no-explicit-any\nfunction wrap(fn: Function, method: Method): (...args: any[]) => void {\n  const arity = fn.length;\n\n  switch (arity) {\n    case 2: {\n      return function (this: NodeJS.Global, req: unknown, res: ExpressResponse & SentryTracingResponse): void {\n        const transaction = res.__sentry_transaction;\n        if (transaction) {\n          const span = transaction.startChild({\n            description: fn.name,\n            op: `express.middleware.${method}`,\n          });\n          res.once('finish', () => {\n            span.finish();\n          });\n        }\n        return fn.call(this, req, res);\n      };\n    }\n    case 3: {\n      return function (\n        this: NodeJS.Global,\n        req: unknown,\n        res: ExpressResponse & SentryTracingResponse,\n        next: () => void,\n      ): void {\n        const transaction = res.__sentry_transaction;\n        const span = transaction?.startChild({\n          description: fn.name,\n          op: `express.middleware.${method}`,\n        });\n        fn.call(this, req, res, function (this: NodeJS.Global, ...args: unknown[]): void {\n          span?.finish();\n          next.call(this, ...args);\n        });\n      };\n    }\n    case 4: {\n      return function (\n        this: NodeJS.Global,\n        err: Error,\n        req: Request,\n        res: Response & SentryTracingResponse,\n        next: () => void,\n      ): void {\n        const transaction = res.__sentry_transaction;\n        const span = transaction?.startChild({\n          description: fn.name,\n          op: `express.middleware.${method}`,\n        });\n        fn.call(this, err, req, res, function (this: NodeJS.Global, ...args: unknown[]): void {\n          span?.finish();\n          next.call(this, ...args);\n        });\n      };\n    }\n    default: {\n      throw new Error(`Express middleware takes 2-4 arguments. Got: ${arity}`);\n    }\n  }\n}\n\n/**\n * Takes all the function arguments passed to the original `app` or `router` method, eg. `app.use` or `router.use`\n * and wraps every function, as well as array of functions with a call to our `wrap` method.\n * We have to take care of the arrays as well as iterate over all of the arguments,\n * as `app.use` can accept middlewares in few various forms.\n *\n * app.use([<path>], <fn>)\n * app.use([<path>], <fn>, ...<fn>)\n * app.use([<path>], ...<fn>[])\n */\nfunction wrapMiddlewareArgs(args: unknown[], method: Method): unknown[] {\n  return args.map((arg: unknown) => {\n    if (typeof arg === 'function') {\n      return wrap(arg, method);\n    }\n\n    if (Array.isArray(arg)) {\n      return arg.map((a: unknown) => {\n        if (typeof a === 'function') {\n          return wrap(a, method);\n        }\n        return a;\n      });\n    }\n\n    return arg;\n  });\n}\n\n/**\n * Patches original router to utilize our tracing functionality\n */\nfunction patchMiddleware(router: Router, method: Method): Router {\n  const originalCallback = router[method];\n\n  router[method] = function (...args: unknown[]): void {\n    return originalCallback.call(this, ...wrapMiddlewareArgs(args, method));\n  };\n\n  return router;\n}\n\n/**\n * Patches original router methods\n */\nfunction instrumentMiddlewares(router: Router, methods: Method[] = []): void {\n  methods.forEach((method: Method) => patchMiddleware(router, method));\n}\n","import { Hub } from '@sentry/hub';\nimport { EventProcessor, Integration } from '@sentry/types';\nimport { fill, isThenable, loadModule, logger } from '@sentry/utils';\n\nimport { IS_DEBUG_BUILD } from '../../flags';\n\ninterface PgClient {\n  prototype: {\n    query: () => void | Promise<unknown>;\n  };\n}\n\ninterface PgOptions {\n  usePgNative?: boolean;\n}\n\n/** Tracing integration for node-postgres package */\nexport class Postgres implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'Postgres';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = Postgres.id;\n\n  private _usePgNative: boolean;\n\n  public constructor(options: PgOptions = {}) {\n    this._usePgNative = !!options.usePgNative;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(_: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {\n    const pkg = loadModule<{ Client: PgClient; native: { Client: PgClient } }>('pg');\n\n    if (!pkg) {\n      IS_DEBUG_BUILD && logger.error('Postgres Integration was unable to require `pg` package.');\n      return;\n    }\n\n    if (this._usePgNative && !pkg.native?.Client) {\n      IS_DEBUG_BUILD && logger.error(\"Postgres Integration was unable to access 'pg-native' bindings.\");\n      return;\n    }\n\n    const { Client } = this._usePgNative ? pkg.native : pkg;\n\n    /**\n     * function (query, callback) => void\n     * function (query, params, callback) => void\n     * function (query) => Promise\n     * function (query, params) => Promise\n     * function (pg.Cursor) => pg.Cursor\n     */\n    fill(Client.prototype, 'query', function (orig: () => void | Promise<unknown>) {\n      return function (this: unknown, config: unknown, values: unknown, callback: unknown) {\n        const scope = getCurrentHub().getScope();\n        const parentSpan = scope?.getSpan();\n        const span = parentSpan?.startChild({\n          description: typeof config === 'string' ? config : (config as { text: string }).text,\n          op: 'db',\n        });\n\n        if (typeof callback === 'function') {\n          return orig.call(this, config, values, function (err: Error, result: unknown) {\n            span?.finish();\n            callback(err, result);\n          });\n        }\n\n        if (typeof values === 'function') {\n          return orig.call(this, config, function (err: Error, result: unknown) {\n            span?.finish();\n            values(err, result);\n          });\n        }\n\n        const rv = typeof values !== 'undefined' ? orig.call(this, config, values) : orig.call(this, config);\n\n        if (isThenable(rv)) {\n          return rv.then((res: unknown) => {\n            span?.finish();\n            return res;\n          });\n        }\n\n        span?.finish();\n        return rv;\n      };\n    });\n  }\n}\n","import { Hub } from '@sentry/hub';\nimport { EventProcessor, Integration } from '@sentry/types';\nimport { fill, loadModule, logger } from '@sentry/utils';\n\nimport { IS_DEBUG_BUILD } from '../../flags';\n\ninterface MysqlConnection {\n  createQuery: () => void;\n}\n\n/** Tracing integration for node-mysql package */\nexport class Mysql implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'Mysql';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = Mysql.id;\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(_: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {\n    const pkg = loadModule<MysqlConnection>('mysql/lib/Connection.js');\n\n    if (!pkg) {\n      IS_DEBUG_BUILD && logger.error('Mysql Integration was unable to require `mysql` package.');\n      return;\n    }\n\n    // The original function will have one of these signatures:\n    //    function (callback) => void\n    //    function (options, callback) => void\n    //    function (options, values, callback) => void\n    fill(pkg, 'createQuery', function (orig: () => void) {\n      return function (this: unknown, options: unknown, values: unknown, callback: unknown) {\n        const scope = getCurrentHub().getScope();\n        const parentSpan = scope?.getSpan();\n        const span = parentSpan?.startChild({\n          description: typeof options === 'string' ? options : (options as { sql: string }).sql,\n          op: 'db',\n        });\n\n        if (typeof callback === 'function') {\n          return orig.call(this, options, values, function (err: Error, result: unknown, fields: unknown) {\n            span?.finish();\n            callback(err, result, fields);\n          });\n        }\n\n        if (typeof values === 'function') {\n          return orig.call(this, options, function (err: Error, result: unknown, fields: unknown) {\n            span?.finish();\n            values(err, result, fields);\n          });\n        }\n\n        return orig.call(this, options, values, callback);\n      };\n    });\n  }\n}\n","import { Hub } from '@sentry/hub';\nimport { EventProcessor, Integration, SpanContext } from '@sentry/types';\nimport { fill, isThenable, loadModule, logger } from '@sentry/utils';\n\nimport { IS_DEBUG_BUILD } from '../../flags';\n\n// This allows us to use the same array for both defaults options and the type itself.\n// (note `as const` at the end to make it a union of string literal types (i.e. \"a\" | \"b\" | ... )\n// and not just a string[])\ntype Operation = typeof OPERATIONS[number];\nconst OPERATIONS = [\n  'aggregate', // aggregate(pipeline, options, callback)\n  'bulkWrite', // bulkWrite(operations, options, callback)\n  'countDocuments', // countDocuments(query, options, callback)\n  'createIndex', // createIndex(fieldOrSpec, options, callback)\n  'createIndexes', // createIndexes(indexSpecs, options, callback)\n  'deleteMany', // deleteMany(filter, options, callback)\n  'deleteOne', // deleteOne(filter, options, callback)\n  'distinct', // distinct(key, query, options, callback)\n  'drop', // drop(options, callback)\n  'dropIndex', // dropIndex(indexName, options, callback)\n  'dropIndexes', // dropIndexes(options, callback)\n  'estimatedDocumentCount', // estimatedDocumentCount(options, callback)\n  'find', // find(query, options, callback)\n  'findOne', // findOne(query, options, callback)\n  'findOneAndDelete', // findOneAndDelete(filter, options, callback)\n  'findOneAndReplace', // findOneAndReplace(filter, replacement, options, callback)\n  'findOneAndUpdate', // findOneAndUpdate(filter, update, options, callback)\n  'indexes', // indexes(options, callback)\n  'indexExists', // indexExists(indexes, options, callback)\n  'indexInformation', // indexInformation(options, callback)\n  'initializeOrderedBulkOp', // initializeOrderedBulkOp(options, callback)\n  'insertMany', // insertMany(docs, options, callback)\n  'insertOne', // insertOne(doc, options, callback)\n  'isCapped', // isCapped(options, callback)\n  'mapReduce', // mapReduce(map, reduce, options, callback)\n  'options', // options(options, callback)\n  'parallelCollectionScan', // parallelCollectionScan(options, callback)\n  'rename', // rename(newName, options, callback)\n  'replaceOne', // replaceOne(filter, doc, options, callback)\n  'stats', // stats(options, callback)\n  'updateMany', // updateMany(filter, update, options, callback)\n  'updateOne', // updateOne(filter, update, options, callback)\n] as const;\n\n// All of the operations above take `options` and `callback` as their final parameters, but some of them\n// take additional parameters as well. For those operations, this is a map of\n// { <operation name>:  [<names of additional parameters>] }, as a way to know what to call the operation's\n// positional arguments when we add them to the span's `data` object later\nconst OPERATION_SIGNATURES: {\n  [op in Operation]?: string[];\n} = {\n  // aggregate intentionally not included because `pipeline` arguments are too complex to serialize well\n  // see https://github.com/getsentry/sentry-javascript/pull/3102\n  bulkWrite: ['operations'],\n  countDocuments: ['query'],\n  createIndex: ['fieldOrSpec'],\n  createIndexes: ['indexSpecs'],\n  deleteMany: ['filter'],\n  deleteOne: ['filter'],\n  distinct: ['key', 'query'],\n  dropIndex: ['indexName'],\n  find: ['query'],\n  findOne: ['query'],\n  findOneAndDelete: ['filter'],\n  findOneAndReplace: ['filter', 'replacement'],\n  findOneAndUpdate: ['filter', 'update'],\n  indexExists: ['indexes'],\n  insertMany: ['docs'],\n  insertOne: ['doc'],\n  mapReduce: ['map', 'reduce'],\n  rename: ['newName'],\n  replaceOne: ['filter', 'doc'],\n  updateMany: ['filter', 'update'],\n  updateOne: ['filter', 'update'],\n};\n\ninterface MongoCollection {\n  collectionName: string;\n  dbName: string;\n  namespace: string;\n  prototype: {\n    [operation in Operation]: (...args: unknown[]) => unknown;\n  };\n}\n\ninterface MongoOptions {\n  operations?: Operation[];\n  describeOperations?: boolean | Operation[];\n  useMongoose?: boolean;\n}\n\n/** Tracing integration for mongo package */\nexport class Mongo implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'Mongo';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = Mongo.id;\n\n  private _operations: Operation[];\n  private _describeOperations?: boolean | Operation[];\n  private _useMongoose: boolean;\n\n  /**\n   * @inheritDoc\n   */\n  public constructor(options: MongoOptions = {}) {\n    this._operations = Array.isArray(options.operations) ? options.operations : (OPERATIONS as unknown as Operation[]);\n    this._describeOperations = 'describeOperations' in options ? options.describeOperations : true;\n    this._useMongoose = !!options.useMongoose;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(_: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {\n    const moduleName = this._useMongoose ? 'mongoose' : 'mongodb';\n    const pkg = loadModule<{ Collection: MongoCollection }>(moduleName);\n\n    if (!pkg) {\n      IS_DEBUG_BUILD && logger.error(`Mongo Integration was unable to require \\`${moduleName}\\` package.`);\n      return;\n    }\n\n    this._instrumentOperations(pkg.Collection, this._operations, getCurrentHub);\n  }\n\n  /**\n   * Patches original collection methods\n   */\n  private _instrumentOperations(collection: MongoCollection, operations: Operation[], getCurrentHub: () => Hub): void {\n    operations.forEach((operation: Operation) => this._patchOperation(collection, operation, getCurrentHub));\n  }\n\n  /**\n   * Patches original collection to utilize our tracing functionality\n   */\n  private _patchOperation(collection: MongoCollection, operation: Operation, getCurrentHub: () => Hub): void {\n    if (!(operation in collection.prototype)) return;\n\n    const getSpanContext = this._getSpanContextFromOperationArguments.bind(this);\n\n    fill(collection.prototype, operation, function (orig: () => void | Promise<unknown>) {\n      return function (this: unknown, ...args: unknown[]) {\n        const lastArg = args[args.length - 1];\n        const scope = getCurrentHub().getScope();\n        const parentSpan = scope?.getSpan();\n\n        // Check if the operation was passed a callback. (mapReduce requires a different check, as\n        // its (non-callback) arguments can also be functions.)\n        if (typeof lastArg !== 'function' || (operation === 'mapReduce' && args.length === 2)) {\n          const span = parentSpan?.startChild(getSpanContext(this, operation, args));\n          const maybePromise = orig.call(this, ...args) as Promise<unknown>;\n\n          if (isThenable(maybePromise)) {\n            return maybePromise.then((res: unknown) => {\n              span?.finish();\n              return res;\n            });\n          } else {\n            span?.finish();\n            return maybePromise;\n          }\n        }\n\n        const span = parentSpan?.startChild(getSpanContext(this, operation, args.slice(0, -1)));\n        return orig.call(this, ...args.slice(0, -1), function (err: Error, result: unknown) {\n          span?.finish();\n          lastArg(err, result);\n        });\n      };\n    });\n  }\n\n  /**\n   * Form a SpanContext based on the user input to a given operation.\n   */\n  private _getSpanContextFromOperationArguments(\n    collection: MongoCollection,\n    operation: Operation,\n    args: unknown[],\n  ): SpanContext {\n    const data: { [key: string]: string } = {\n      collectionName: collection.collectionName,\n      dbName: collection.dbName,\n      namespace: collection.namespace,\n    };\n    const spanContext: SpanContext = {\n      op: 'db',\n      description: operation,\n      data,\n    };\n\n    // If the operation takes no arguments besides `options` and `callback`, or if argument\n    // collection is disabled for this operation, just return early.\n    const signature = OPERATION_SIGNATURES[operation];\n    const shouldDescribe = Array.isArray(this._describeOperations)\n      ? this._describeOperations.includes(operation)\n      : this._describeOperations;\n\n    if (!signature || !shouldDescribe) {\n      return spanContext;\n    }\n\n    try {\n      // Special case for `mapReduce`, as the only one accepting functions as arguments.\n      if (operation === 'mapReduce') {\n        const [map, reduce] = args as { name?: string }[];\n        data[signature[0]] = typeof map === 'string' ? map : map.name || '<anonymous>';\n        data[signature[1]] = typeof reduce === 'string' ? reduce : reduce.name || '<anonymous>';\n      } else {\n        for (let i = 0; i < signature.length; i++) {\n          data[signature[i]] = JSON.stringify(args[i]);\n        }\n      }\n    } catch (_oO) {\n      // no-empty\n    }\n\n    return spanContext;\n  }\n}\n","import { TraceparentData } from '@sentry/types';\n\nexport const TRACEPARENT_REGEXP = new RegExp(\n  '^[ \\\\t]*' + // whitespace\n    '([0-9a-f]{32})?' + // trace_id\n    '-?([0-9a-f]{16})?' + // span_id\n    '-?([01])?' + // sampled\n    '[ \\\\t]*$', // whitespace\n);\n\n/**\n * Extract transaction context data from a `sentry-trace` header.\n *\n * @param traceparent Traceparent string\n *\n * @returns Object containing data from the header, or undefined if traceparent string is malformed\n */\nexport function extractTraceparentData(traceparent: string): TraceparentData | undefined {\n  const matches = traceparent.match(TRACEPARENT_REGEXP);\n  if (matches) {\n    let parentSampled: boolean | undefined;\n    if (matches[3] === '1') {\n      parentSampled = true;\n    } else if (matches[3] === '0') {\n      parentSampled = false;\n    }\n    return {\n      traceId: matches[1],\n      parentSampled,\n      parentSpanId: matches[2],\n    };\n  }\n  return undefined;\n}\n","import { getGlobalObject, logger } from '@sentry/utils';\n\nimport { FINISH_REASON_TAG, IDLE_TRANSACTION_FINISH_REASONS } from '../constants';\nimport { IS_DEBUG_BUILD } from '../flags';\nimport { IdleTransaction } from '../idletransaction';\nimport { SpanStatusType } from '../span';\nimport { getActiveTransaction } from '../utils';\n\nconst global = getGlobalObject<Window>();\n\n/**\n * Add a listener that cancels and finishes a transaction when the global\n * document is hidden.\n */\nexport function registerBackgroundTabDetection(): void {\n  if (global && global.document) {\n    global.document.addEventListener('visibilitychange', () => {\n      const activeTransaction = getActiveTransaction() as IdleTransaction;\n      if (global.document.hidden && activeTransaction) {\n        const statusType: SpanStatusType = 'cancelled';\n\n        IS_DEBUG_BUILD &&\n          logger.log(\n            `[Tracing] Transaction: ${statusType} -> since tab moved to the background, op: ${activeTransaction.op}`,\n          );\n        // We should not set status if it is already set, this prevent important statuses like\n        // error or data loss from being overwritten on transaction.\n        if (!activeTransaction.status) {\n          activeTransaction.setStatus(statusType);\n        }\n        activeTransaction.setTag('visibilitychange', 'document.hidden');\n        activeTransaction.setTag(FINISH_REASON_TAG, IDLE_TRANSACTION_FINISH_REASONS[2]);\n        activeTransaction.finish();\n      }\n    });\n  } else {\n    IS_DEBUG_BUILD && logger.warn('[Tracing] Could not set up background tab detection due to lack of global document');\n  }\n}\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Metric, ReportHandler } from '../types';\n\nexport const bindReporter = (\n  callback: ReportHandler,\n  metric: Metric,\n  reportAllChanges?: boolean,\n): ((forceReport?: boolean) => void) => {\n  let prevValue: number;\n  return (forceReport?: boolean) => {\n    if (metric.value >= 0) {\n      if (forceReport || reportAllChanges) {\n        metric.delta = metric.value - (prevValue || 0);\n\n        // Report the metric if there's a non-zero delta or if no previous\n        // value exists (which can happen in the case of the document becoming\n        // hidden when the metric value is 0).\n        // See: https://github.com/GoogleChrome/web-vitals/issues/14\n        if (metric.delta || prevValue === undefined) {\n          prevValue = metric.value;\n          callback(metric);\n        }\n      }\n    }\n  };\n};\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Metric } from '../types';\nimport { generateUniqueID } from './generateUniqueID';\n\nexport const initMetric = (name: Metric['name'], value?: number): Metric => {\n  return {\n    name,\n    value: value ?? -1,\n    delta: 0,\n    entries: [],\n    id: generateUniqueID(),\n  };\n};\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Performantly generate a unique, 30-char string by combining a version\n * number, the current timestamp with a 13-digit number integer.\n * @return {string}\n */\nexport const generateUniqueID = (): string => {\n  return `v2-${Date.now()}-${Math.floor(Math.random() * (9e12 - 1)) + 1e12}`;\n};\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport interface PerformanceEntryHandler {\n  (entry: PerformanceEntry): void;\n}\n\n/**\n * Takes a performance entry type and a callback function, and creates a\n * `PerformanceObserver` instance that will observe the specified entry type\n * with buffering enabled and call the callback _for each entry_.\n *\n * This function also feature-detects entry support and wraps the logic in a\n * try/catch to avoid errors in unsupporting browsers.\n */\nexport const observe = (type: string, callback: PerformanceEntryHandler): PerformanceObserver | undefined => {\n  try {\n    if (PerformanceObserver.supportedEntryTypes.includes(type)) {\n      // More extensive feature detect needed for Firefox due to:\n      // https://github.com/GoogleChrome/web-vitals/issues/142\n      if (type === 'first-input' && !('PerformanceEventTiming' in self)) {\n        return;\n      }\n\n      const po: PerformanceObserver = new PerformanceObserver(l => l.getEntries().map(callback));\n\n      po.observe({ type, buffered: true });\n      return po;\n    }\n  } catch (e) {\n    // Do nothing.\n  }\n  return;\n};\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { getGlobalObject } from '@sentry/utils';\n\nexport interface OnHiddenCallback {\n  (event: Event): void;\n}\n\nexport const onHidden = (cb: OnHiddenCallback, once?: boolean): void => {\n  const onHiddenOrPageHide = (event: Event): void => {\n    if (event.type === 'pagehide' || getGlobalObject<Window>().document.visibilityState === 'hidden') {\n      cb(event);\n      if (once) {\n        removeEventListener('visibilitychange', onHiddenOrPageHide, true);\n        removeEventListener('pagehide', onHiddenOrPageHide, true);\n      }\n    }\n  };\n  addEventListener('visibilitychange', onHiddenOrPageHide, true);\n  // Some browsers have buggy implementations of visibilitychange,\n  // so we use pagehide in addition, just to be safe.\n  addEventListener('pagehide', onHiddenOrPageHide, true);\n};\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { getGlobalObject } from '@sentry/utils';\n\nimport { onHidden } from './onHidden';\n\nlet firstHiddenTime = -1;\n\nconst initHiddenTime = (): number => {\n  return getGlobalObject<Window>().document.visibilityState === 'hidden' ? 0 : Infinity;\n};\n\nconst trackChanges = (): void => {\n  // Update the time if/when the document becomes hidden.\n  onHidden(({ timeStamp }) => {\n    firstHiddenTime = timeStamp;\n  }, true);\n};\n\nexport const getVisibilityWatcher = (): {\n  readonly firstHiddenTime: number;\n} => {\n  if (firstHiddenTime < 0) {\n    // If the document is hidden when this code runs, assume it was hidden\n    // since navigation start. This isn't a perfect heuristic, but it's the\n    // best we can do until an API is available to support querying past\n    // visibilityState.\n    firstHiddenTime = initHiddenTime();\n    trackChanges();\n  }\n  return {\n    get firstHiddenTime() {\n      return firstHiddenTime;\n    },\n  };\n};\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { bindReporter } from './lib/bindReporter';\nimport { getVisibilityWatcher } from './lib/getVisibilityWatcher';\nimport { initMetric } from './lib/initMetric';\nimport { observe, PerformanceEntryHandler } from './lib/observe';\nimport { onHidden } from './lib/onHidden';\nimport { ReportHandler } from './types';\n\n// https://wicg.github.io/largest-contentful-paint/#sec-largest-contentful-paint-interface\nexport interface LargestContentfulPaint extends PerformanceEntry {\n  renderTime: DOMHighResTimeStamp;\n  loadTime: DOMHighResTimeStamp;\n  size: number;\n  id: string;\n  url: string;\n  element?: Element;\n  toJSON(): Record<string, string>;\n}\n\nconst reportedMetricIDs: Record<string, boolean> = {};\n\nexport const getLCP = (onReport: ReportHandler, reportAllChanges?: boolean): void => {\n  const visibilityWatcher = getVisibilityWatcher();\n  const metric = initMetric('LCP');\n  let report: ReturnType<typeof bindReporter>;\n\n  const entryHandler = (entry: PerformanceEntry): void => {\n    // The startTime attribute returns the value of the renderTime if it is not 0,\n    // and the value of the loadTime otherwise.\n    const value = entry.startTime;\n\n    // If the page was hidden prior to paint time of the entry,\n    // ignore it and mark the metric as final, otherwise add the entry.\n    if (value < visibilityWatcher.firstHiddenTime) {\n      metric.value = value;\n      metric.entries.push(entry);\n    }\n\n    if (report) {\n      report();\n    }\n  };\n\n  const po = observe('largest-contentful-paint', entryHandler);\n\n  if (po) {\n    report = bindReporter(onReport, metric, reportAllChanges);\n\n    const stopListening = (): void => {\n      if (!reportedMetricIDs[metric.id]) {\n        po.takeRecords().map(entryHandler as PerformanceEntryHandler);\n        po.disconnect();\n        reportedMetricIDs[metric.id] = true;\n        report(true);\n      }\n    };\n\n    // Stop listening after input. Note: while scrolling is an input that\n    // stop LCP observation, it's unreliable since it can be programmatically\n    // generated. See: https://github.com/GoogleChrome/web-vitals/issues/75\n    ['keydown', 'click'].forEach(type => {\n      addEventListener(type, stopListening, { once: true, capture: true });\n    });\n\n    onHidden(stopListening, true);\n  }\n};\n","/* eslint-disable max-lines */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Measurements, SpanContext } from '@sentry/types';\nimport { browserPerformanceTimeOrigin, getGlobalObject, htmlTreeAsString, isNodeEnv, logger } from '@sentry/utils';\n\nimport { IS_DEBUG_BUILD } from '../flags';\nimport { Span } from '../span';\nimport { Transaction } from '../transaction';\nimport { msToSec } from '../utils';\nimport { getCLS, LayoutShift } from './web-vitals/getCLS';\nimport { getFID } from './web-vitals/getFID';\nimport { getLCP, LargestContentfulPaint } from './web-vitals/getLCP';\nimport { getVisibilityWatcher } from './web-vitals/lib/getVisibilityWatcher';\nimport { NavigatorDeviceMemory, NavigatorNetworkInformation } from './web-vitals/types';\n\nconst global = getGlobalObject<Window>();\n\n/** Class tracking metrics  */\nexport class MetricsInstrumentation {\n  private _measurements: Measurements = {};\n\n  private _performanceCursor: number = 0;\n  private _lcpEntry: LargestContentfulPaint | undefined;\n  private _clsEntry: LayoutShift | undefined;\n\n  public constructor(private _reportAllChanges: boolean = false) {\n    if (!isNodeEnv() && global && global.performance && global.document) {\n      if (global.performance.mark) {\n        global.performance.mark('sentry-tracing-init');\n      }\n\n      this._trackCLS();\n      this._trackLCP();\n      this._trackFID();\n    }\n  }\n\n  /** Add performance related spans to a transaction */\n  public addPerformanceEntries(transaction: Transaction): void {\n    if (!global || !global.performance || !global.performance.getEntries || !browserPerformanceTimeOrigin) {\n      // Gatekeeper if performance API not available\n      return;\n    }\n\n    IS_DEBUG_BUILD && logger.log('[Tracing] Adding & adjusting spans using Performance API');\n\n    const timeOrigin = msToSec(browserPerformanceTimeOrigin);\n\n    let responseStartTimestamp: number | undefined;\n    let requestStartTimestamp: number | undefined;\n\n    global.performance\n      .getEntries()\n      .slice(this._performanceCursor)\n      .forEach((entry: Record<string, any>) => {\n        const startTime = msToSec(entry.startTime as number);\n        const duration = msToSec(entry.duration as number);\n\n        if (transaction.op === 'navigation' && timeOrigin + startTime < transaction.startTimestamp) {\n          return;\n        }\n\n        switch (entry.entryType) {\n          case 'navigation': {\n            addNavigationSpans(transaction, entry, timeOrigin);\n            responseStartTimestamp = timeOrigin + msToSec(entry.responseStart as number);\n            requestStartTimestamp = timeOrigin + msToSec(entry.requestStart as number);\n            break;\n          }\n          case 'mark':\n          case 'paint':\n          case 'measure': {\n            const startTimestamp = addMeasureSpans(transaction, entry, startTime, duration, timeOrigin);\n            // capture web vitals\n\n            const firstHidden = getVisibilityWatcher();\n            // Only report if the page wasn't hidden prior to the web vital.\n            const shouldRecord = entry.startTime < firstHidden.firstHiddenTime;\n\n            if (entry.name === 'first-paint' && shouldRecord) {\n              IS_DEBUG_BUILD && logger.log('[Measurements] Adding FP');\n              this._measurements['fp'] = { value: entry.startTime };\n              this._measurements['mark.fp'] = { value: startTimestamp };\n            }\n\n            if (entry.name === 'first-contentful-paint' && shouldRecord) {\n              IS_DEBUG_BUILD && logger.log('[Measurements] Adding FCP');\n              this._measurements['fcp'] = { value: entry.startTime };\n              this._measurements['mark.fcp'] = { value: startTimestamp };\n            }\n\n            break;\n          }\n          case 'resource': {\n            const resourceName = (entry.name as string).replace(global.location.origin, '');\n            addResourceSpans(transaction, entry, resourceName, startTime, duration, timeOrigin);\n            break;\n          }\n          default:\n          // Ignore other entry types.\n        }\n      });\n\n    this._performanceCursor = Math.max(performance.getEntries().length - 1, 0);\n\n    this._trackNavigator(transaction);\n\n    // Measurements are only available for pageload transactions\n    if (transaction.op === 'pageload') {\n      // normalize applicable web vital values to be relative to transaction.startTimestamp\n\n      const timeOrigin = msToSec(browserPerformanceTimeOrigin);\n\n      // Generate TTFB (Time to First Byte), which measured as the time between the beginning of the transaction and the\n      // start of the response in milliseconds\n      if (typeof responseStartTimestamp === 'number') {\n        IS_DEBUG_BUILD && logger.log('[Measurements] Adding TTFB');\n        this._measurements['ttfb'] = { value: (responseStartTimestamp - transaction.startTimestamp) * 1000 };\n\n        if (typeof requestStartTimestamp === 'number' && requestStartTimestamp <= responseStartTimestamp) {\n          // Capture the time spent making the request and receiving the first byte of the response.\n          // This is the time between the start of the request and the start of the response in milliseconds.\n          this._measurements['ttfb.requestTime'] = { value: (responseStartTimestamp - requestStartTimestamp) * 1000 };\n        }\n      }\n\n      ['fcp', 'fp', 'lcp'].forEach(name => {\n        if (!this._measurements[name] || timeOrigin >= transaction.startTimestamp) {\n          return;\n        }\n\n        // The web vitals, fcp, fp, lcp, and ttfb, all measure relative to timeOrigin.\n        // Unfortunately, timeOrigin is not captured within the transaction span data, so these web vitals will need\n        // to be adjusted to be relative to transaction.startTimestamp.\n\n        const oldValue = this._measurements[name].value;\n        const measurementTimestamp = timeOrigin + msToSec(oldValue);\n        // normalizedValue should be in milliseconds\n        const normalizedValue = Math.abs((measurementTimestamp - transaction.startTimestamp) * 1000);\n\n        const delta = normalizedValue - oldValue;\n        IS_DEBUG_BUILD &&\n          logger.log(`[Measurements] Normalized ${name} from ${oldValue} to ${normalizedValue} (${delta})`);\n\n        this._measurements[name].value = normalizedValue;\n      });\n\n      if (this._measurements['mark.fid'] && this._measurements['fid']) {\n        // create span for FID\n\n        _startChild(transaction, {\n          description: 'first input delay',\n          endTimestamp: this._measurements['mark.fid'].value + msToSec(this._measurements['fid'].value),\n          op: 'web.vitals',\n          startTimestamp: this._measurements['mark.fid'].value,\n        });\n      }\n\n      // If FCP is not recorded we should not record the cls value\n      // according to the new definition of CLS.\n      if (!('fcp' in this._measurements)) {\n        delete this._measurements.cls;\n      }\n\n      transaction.setMeasurements(this._measurements);\n      tagMetricInfo(transaction, this._lcpEntry, this._clsEntry);\n      transaction.setTag('sentry_reportAllChanges', this._reportAllChanges);\n    }\n  }\n\n  /**\n   * Capture the information of the user agent.\n   */\n  private _trackNavigator(transaction: Transaction): void {\n    const navigator = global.navigator as null | (Navigator & NavigatorNetworkInformation & NavigatorDeviceMemory);\n    if (!navigator) {\n      return;\n    }\n\n    // track network connectivity\n    const connection = navigator.connection;\n    if (connection) {\n      if (connection.effectiveType) {\n        transaction.setTag('effectiveConnectionType', connection.effectiveType);\n      }\n\n      if (connection.type) {\n        transaction.setTag('connectionType', connection.type);\n      }\n\n      if (isMeasurementValue(connection.rtt)) {\n        this._measurements['connection.rtt'] = { value: connection.rtt as number };\n      }\n\n      if (isMeasurementValue(connection.downlink)) {\n        this._measurements['connection.downlink'] = { value: connection.downlink as number };\n      }\n    }\n\n    if (isMeasurementValue(navigator.deviceMemory)) {\n      transaction.setTag('deviceMemory', String(navigator.deviceMemory));\n    }\n\n    if (isMeasurementValue(navigator.hardwareConcurrency)) {\n      transaction.setTag('hardwareConcurrency', String(navigator.hardwareConcurrency));\n    }\n  }\n\n  /** Starts tracking the Cumulative Layout Shift on the current page. */\n  private _trackCLS(): void {\n    // See:\n    // https://web.dev/evolving-cls/\n    // https://web.dev/cls-web-tooling/\n    getCLS(metric => {\n      const entry = metric.entries.pop();\n      if (!entry) {\n        return;\n      }\n\n      IS_DEBUG_BUILD && logger.log('[Measurements] Adding CLS');\n      this._measurements['cls'] = { value: metric.value };\n      this._clsEntry = entry as LayoutShift;\n    });\n  }\n\n  /** Starts tracking the Largest Contentful Paint on the current page. */\n  private _trackLCP(): void {\n    getLCP(metric => {\n      const entry = metric.entries.pop();\n      if (!entry) {\n        return;\n      }\n\n      const timeOrigin = msToSec(browserPerformanceTimeOrigin as number);\n      const startTime = msToSec(entry.startTime);\n      IS_DEBUG_BUILD && logger.log('[Measurements] Adding LCP');\n      this._measurements['lcp'] = { value: metric.value };\n      this._measurements['mark.lcp'] = { value: timeOrigin + startTime };\n      this._lcpEntry = entry as LargestContentfulPaint;\n    }, this._reportAllChanges);\n  }\n\n  /** Starts tracking the First Input Delay on the current page. */\n  private _trackFID(): void {\n    getFID(metric => {\n      const entry = metric.entries.pop();\n      if (!entry) {\n        return;\n      }\n\n      const timeOrigin = msToSec(browserPerformanceTimeOrigin as number);\n      const startTime = msToSec(entry.startTime);\n      IS_DEBUG_BUILD && logger.log('[Measurements] Adding FID');\n      this._measurements['fid'] = { value: metric.value };\n      this._measurements['mark.fid'] = { value: timeOrigin + startTime };\n    });\n  }\n}\n\n/** Instrument navigation entries */\nfunction addNavigationSpans(transaction: Transaction, entry: Record<string, any>, timeOrigin: number): void {\n  ['unloadEvent', 'redirect', 'domContentLoadedEvent', 'loadEvent', 'connect'].forEach(event => {\n    addPerformanceNavigationTiming(transaction, entry, event, timeOrigin);\n  });\n  addPerformanceNavigationTiming(transaction, entry, 'secureConnection', timeOrigin, 'TLS/SSL', 'connectEnd');\n  addPerformanceNavigationTiming(transaction, entry, 'fetch', timeOrigin, 'cache', 'domainLookupStart');\n  addPerformanceNavigationTiming(transaction, entry, 'domainLookup', timeOrigin, 'DNS');\n  addRequest(transaction, entry, timeOrigin);\n}\n\n/** Create measure related spans */\nfunction addMeasureSpans(\n  transaction: Transaction,\n  entry: Record<string, any>,\n  startTime: number,\n  duration: number,\n  timeOrigin: number,\n): number {\n  const measureStartTimestamp = timeOrigin + startTime;\n  const measureEndTimestamp = measureStartTimestamp + duration;\n\n  _startChild(transaction, {\n    description: entry.name as string,\n    endTimestamp: measureEndTimestamp,\n    op: entry.entryType as string,\n    startTimestamp: measureStartTimestamp,\n  });\n\n  return measureStartTimestamp;\n}\n\nexport interface ResourceEntry extends Record<string, unknown> {\n  initiatorType?: string;\n  transferSize?: number;\n  encodedBodySize?: number;\n  decodedBodySize?: number;\n}\n\n/** Create resource-related spans */\nexport function addResourceSpans(\n  transaction: Transaction,\n  entry: ResourceEntry,\n  resourceName: string,\n  startTime: number,\n  duration: number,\n  timeOrigin: number,\n): void {\n  // we already instrument based on fetch and xhr, so we don't need to\n  // duplicate spans here.\n  if (entry.initiatorType === 'xmlhttprequest' || entry.initiatorType === 'fetch') {\n    return;\n  }\n\n  const data: Record<string, any> = {};\n  if ('transferSize' in entry) {\n    data['Transfer Size'] = entry.transferSize;\n  }\n  if ('encodedBodySize' in entry) {\n    data['Encoded Body Size'] = entry.encodedBodySize;\n  }\n  if ('decodedBodySize' in entry) {\n    data['Decoded Body Size'] = entry.decodedBodySize;\n  }\n\n  const startTimestamp = timeOrigin + startTime;\n  const endTimestamp = startTimestamp + duration;\n\n  _startChild(transaction, {\n    description: resourceName,\n    endTimestamp,\n    op: entry.initiatorType ? `resource.${entry.initiatorType}` : 'resource',\n    startTimestamp,\n    data,\n  });\n}\n\n/** Create performance navigation related spans */\nfunction addPerformanceNavigationTiming(\n  transaction: Transaction,\n  entry: Record<string, any>,\n  event: string,\n  timeOrigin: number,\n  description?: string,\n  eventEnd?: string,\n): void {\n  const end = eventEnd ? (entry[eventEnd] as number | undefined) : (entry[`${event}End`] as number | undefined);\n  const start = entry[`${event}Start`] as number | undefined;\n  if (!start || !end) {\n    return;\n  }\n  _startChild(transaction, {\n    op: 'browser',\n    description: description ?? event,\n    startTimestamp: timeOrigin + msToSec(start),\n    endTimestamp: timeOrigin + msToSec(end),\n  });\n}\n\n/** Create request and response related spans */\nfunction addRequest(transaction: Transaction, entry: Record<string, any>, timeOrigin: number): void {\n  _startChild(transaction, {\n    op: 'browser',\n    description: 'request',\n    startTimestamp: timeOrigin + msToSec(entry.requestStart as number),\n    endTimestamp: timeOrigin + msToSec(entry.responseEnd as number),\n  });\n\n  _startChild(transaction, {\n    op: 'browser',\n    description: 'response',\n    startTimestamp: timeOrigin + msToSec(entry.responseStart as number),\n    endTimestamp: timeOrigin + msToSec(entry.responseEnd as number),\n  });\n}\n\n/**\n * Helper function to start child on transactions. This function will make sure that the transaction will\n * use the start timestamp of the created child span if it is earlier than the transactions actual\n * start timestamp.\n */\nexport function _startChild(transaction: Transaction, { startTimestamp, ...ctx }: SpanContext): Span {\n  if (startTimestamp && transaction.startTimestamp > startTimestamp) {\n    transaction.startTimestamp = startTimestamp;\n  }\n\n  return transaction.startChild({\n    startTimestamp,\n    ...ctx,\n  });\n}\n\n/**\n * Checks if a given value is a valid measurement value.\n */\nfunction isMeasurementValue(value: any): boolean {\n  return typeof value === 'number' && isFinite(value);\n}\n\n/** Add LCP / CLS data to transaction to allow debugging */\nfunction tagMetricInfo(\n  transaction: Transaction,\n  lcpEntry: MetricsInstrumentation['_lcpEntry'],\n  clsEntry: MetricsInstrumentation['_clsEntry'],\n): void {\n  if (lcpEntry) {\n    IS_DEBUG_BUILD && logger.log('[Measurements] Adding LCP Data');\n\n    // Capture Properties of the LCP element that contributes to the LCP.\n\n    if (lcpEntry.element) {\n      transaction.setTag('lcp.element', htmlTreeAsString(lcpEntry.element));\n    }\n\n    if (lcpEntry.id) {\n      transaction.setTag('lcp.id', lcpEntry.id);\n    }\n\n    if (lcpEntry.url) {\n      // Trim URL to the first 200 characters.\n      transaction.setTag('lcp.url', lcpEntry.url.trim().slice(0, 200));\n    }\n\n    transaction.setTag('lcp.size', lcpEntry.size);\n  }\n\n  // See: https://developer.mozilla.org/en-US/docs/Web/API/LayoutShift\n  if (clsEntry && clsEntry.sources) {\n    IS_DEBUG_BUILD && logger.log('[Measurements] Adding CLS Data');\n    clsEntry.sources.forEach((source, index) =>\n      transaction.setTag(`cls.source.${index + 1}`, htmlTreeAsString(source.node)),\n    );\n  }\n}\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { bindReporter } from './lib/bindReporter';\nimport { initMetric } from './lib/initMetric';\nimport { observe, PerformanceEntryHandler } from './lib/observe';\nimport { onHidden } from './lib/onHidden';\nimport { ReportHandler } from './types';\n\n// https://wicg.github.io/layout-instability/#sec-layout-shift\nexport interface LayoutShift extends PerformanceEntry {\n  value: number;\n  hadRecentInput: boolean;\n  sources: Array<LayoutShiftAttribution>;\n  toJSON(): Record<string, unknown>;\n}\n\nexport interface LayoutShiftAttribution {\n  node?: Node;\n  previousRect: DOMRectReadOnly;\n  currentRect: DOMRectReadOnly;\n}\n\nexport const getCLS = (onReport: ReportHandler, reportAllChanges?: boolean): void => {\n  const metric = initMetric('CLS', 0);\n  let report: ReturnType<typeof bindReporter>;\n\n  let sessionValue = 0;\n  let sessionEntries: PerformanceEntry[] = [];\n\n  const entryHandler = (entry: LayoutShift): void => {\n    // Only count layout shifts without recent user input.\n    // TODO: Figure out why entry can be undefined\n    if (entry && !entry.hadRecentInput) {\n      const firstSessionEntry = sessionEntries[0];\n      const lastSessionEntry = sessionEntries[sessionEntries.length - 1];\n\n      // If the entry occurred less than 1 second after the previous entry and\n      // less than 5 seconds after the first entry in the session, include the\n      // entry in the current session. Otherwise, start a new session.\n      if (\n        sessionValue &&\n        sessionEntries.length !== 0 &&\n        entry.startTime - lastSessionEntry.startTime < 1000 &&\n        entry.startTime - firstSessionEntry.startTime < 5000\n      ) {\n        sessionValue += entry.value;\n        sessionEntries.push(entry);\n      } else {\n        sessionValue = entry.value;\n        sessionEntries = [entry];\n      }\n\n      // If the current session value is larger than the current CLS value,\n      // update CLS and the entries contributing to it.\n      if (sessionValue > metric.value) {\n        metric.value = sessionValue;\n        metric.entries = sessionEntries;\n        if (report) {\n          report();\n        }\n      }\n    }\n  };\n\n  const po = observe('layout-shift', entryHandler as PerformanceEntryHandler);\n  if (po) {\n    report = bindReporter(onReport, metric, reportAllChanges);\n\n    onHidden(() => {\n      po.takeRecords().map(entryHandler as PerformanceEntryHandler);\n      report(true);\n    });\n  }\n};\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { bindReporter } from './lib/bindReporter';\nimport { getVisibilityWatcher } from './lib/getVisibilityWatcher';\nimport { initMetric } from './lib/initMetric';\nimport { observe, PerformanceEntryHandler } from './lib/observe';\nimport { onHidden } from './lib/onHidden';\nimport { PerformanceEventTiming, ReportHandler } from './types';\n\nexport const getFID = (onReport: ReportHandler, reportAllChanges?: boolean): void => {\n  const visibilityWatcher = getVisibilityWatcher();\n  const metric = initMetric('FID');\n  let report: ReturnType<typeof bindReporter>;\n\n  const entryHandler = (entry: PerformanceEventTiming): void => {\n    // Only report if the page wasn't hidden prior to the first input.\n    if (report && entry.startTime < visibilityWatcher.firstHiddenTime) {\n      metric.value = entry.processingStart - entry.startTime;\n      metric.entries.push(entry);\n      report(true);\n    }\n  };\n\n  const po = observe('first-input', entryHandler as PerformanceEntryHandler);\n  if (po) {\n    report = bindReporter(onReport, metric, reportAllChanges);\n    onHidden(() => {\n      po.takeRecords().map(entryHandler as PerformanceEntryHandler);\n      po.disconnect();\n    }, true);\n  }\n};\n","import { addInstrumentationHandler, isInstanceOf, isMatchingPattern } from '@sentry/utils';\n\nimport { Span } from '../span';\nimport { getActiveTransaction, hasTracingEnabled } from '../utils';\n\nexport const DEFAULT_TRACING_ORIGINS = ['localhost', /^\\//];\n\n/** Options for Request Instrumentation */\nexport interface RequestInstrumentationOptions {\n  /**\n   * List of strings / regex where the integration should create Spans out of. Additionally this will be used\n   * to define which outgoing requests the `sentry-trace` header will be attached to.\n   *\n   * Default: ['localhost', /^\\//] {@see DEFAULT_TRACING_ORIGINS}\n   */\n  tracingOrigins: Array<string | RegExp>;\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   * 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   * By default it uses the `tracingOrigins` options as a url match.\n   */\n  shouldCreateSpanForRequest?(url: string): boolean;\n}\n\n/** Data returned from fetch callback */\nexport interface FetchData {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  args: any[]; // the arguments passed to the fetch call itself\n  fetchData?: {\n    method: string;\n    url: string;\n    // span_id\n    __span?: string;\n  };\n\n  // TODO Should this be unknown instead? If we vendor types, make it a Response\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  response?: any;\n  error?: unknown;\n\n  startTimestamp: number;\n  endTimestamp?: number;\n}\n\n/** Data returned from XHR request */\nexport interface XHRData {\n  xhr?: {\n    __sentry_xhr__?: {\n      method: string;\n      url: string;\n      status_code: number;\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      data: Record<string, any>;\n    };\n    __sentry_xhr_span_id__?: string;\n    setRequestHeader?: (key: string, val: string) => void;\n    __sentry_own_request__?: boolean;\n  };\n  startTimestamp: number;\n  endTimestamp?: number;\n}\n\nexport const defaultRequestInstrumentationOptions: RequestInstrumentationOptions = {\n  traceFetch: true,\n  traceXHR: true,\n  tracingOrigins: DEFAULT_TRACING_ORIGINS,\n};\n\n/** Registers span creators for xhr and fetch requests  */\nexport function instrumentOutgoingRequests(_options?: Partial<RequestInstrumentationOptions>): void {\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  const { traceFetch, traceXHR, tracingOrigins, shouldCreateSpanForRequest } = {\n    ...defaultRequestInstrumentationOptions,\n    ..._options,\n  };\n\n  // We should cache url -> decision so that we don't have to compute\n  // regexp everytime we create a request.\n  const urlMap: Record<string, boolean> = {};\n\n  const defaultShouldCreateSpan = (url: string): boolean => {\n    if (urlMap[url]) {\n      return urlMap[url];\n    }\n    const origins = tracingOrigins;\n    urlMap[url] =\n      origins.some((origin: string | RegExp) => isMatchingPattern(url, origin)) &&\n      !isMatchingPattern(url, 'sentry_key');\n    return urlMap[url];\n  };\n\n  // We want that our users don't have to re-implement shouldCreateSpanForRequest themselves\n  // That's why we filter out already unwanted Spans from tracingOrigins\n  let shouldCreateSpan = defaultShouldCreateSpan;\n  if (typeof shouldCreateSpanForRequest === 'function') {\n    shouldCreateSpan = (url: string) => {\n      return defaultShouldCreateSpan(url) && shouldCreateSpanForRequest(url);\n    };\n  }\n\n  const spans: Record<string, Span> = {};\n\n  if (traceFetch) {\n    addInstrumentationHandler('fetch', (handlerData: FetchData) => {\n      fetchCallback(handlerData, shouldCreateSpan, spans);\n    });\n  }\n\n  if (traceXHR) {\n    addInstrumentationHandler('xhr', (handlerData: XHRData) => {\n      xhrCallback(handlerData, shouldCreateSpan, spans);\n    });\n  }\n}\n\n/**\n * Create and track fetch request spans\n */\nexport function fetchCallback(\n  handlerData: FetchData,\n  shouldCreateSpan: (url: string) => boolean,\n  spans: Record<string, Span>,\n): void {\n  if (!hasTracingEnabled() || !(handlerData.fetchData && shouldCreateSpan(handlerData.fetchData.url))) {\n    return;\n  }\n\n  if (handlerData.endTimestamp) {\n    const spanId = handlerData.fetchData.__span;\n    if (!spanId) return;\n\n    const span = spans[spanId];\n    if (span) {\n      if (handlerData.response) {\n        // TODO (kmclb) remove this once types PR goes through\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        span.setHttpStatus(handlerData.response.status);\n      } else if (handlerData.error) {\n        span.setStatus('internal_error');\n      }\n      span.finish();\n\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete spans[spanId];\n    }\n    return;\n  }\n\n  const activeTransaction = getActiveTransaction();\n  if (activeTransaction) {\n    const span = activeTransaction.startChild({\n      data: {\n        ...handlerData.fetchData,\n        type: 'fetch',\n      },\n      description: `${handlerData.fetchData.method} ${handlerData.fetchData.url}`,\n      op: 'http.client',\n    });\n\n    handlerData.fetchData.__span = span.spanId;\n    spans[span.spanId] = span;\n\n    const request = (handlerData.args[0] = handlerData.args[0] as string | Request);\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const options = (handlerData.args[1] = (handlerData.args[1] as { [key: string]: any }) || {});\n    let headers = options.headers;\n    if (isInstanceOf(request, Request)) {\n      headers = (request as Request).headers;\n    }\n    if (headers) {\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      if (typeof headers.append === 'function') {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        headers.append('sentry-trace', span.toTraceparent());\n      } else if (Array.isArray(headers)) {\n        headers = [...headers, ['sentry-trace', span.toTraceparent()]];\n      } else {\n        headers = { ...headers, 'sentry-trace': span.toTraceparent() };\n      }\n    } else {\n      headers = { 'sentry-trace': span.toTraceparent() };\n    }\n    options.headers = headers;\n  }\n}\n\n/**\n * Create and track xhr request spans\n */\nexport function xhrCallback(\n  handlerData: XHRData,\n  shouldCreateSpan: (url: string) => boolean,\n  spans: Record<string, Span>,\n): void {\n  if (\n    !hasTracingEnabled() ||\n    (handlerData.xhr && handlerData.xhr.__sentry_own_request__) ||\n    !(handlerData.xhr && handlerData.xhr.__sentry_xhr__ && shouldCreateSpan(handlerData.xhr.__sentry_xhr__.url))\n  ) {\n    return;\n  }\n\n  const xhr = handlerData.xhr.__sentry_xhr__;\n\n  // check first if the request has finished and is tracked by an existing span which should now end\n  if (handlerData.endTimestamp) {\n    const spanId = handlerData.xhr.__sentry_xhr_span_id__;\n    if (!spanId) return;\n\n    const span = spans[spanId];\n    if (span) {\n      span.setHttpStatus(xhr.status_code);\n      span.finish();\n\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete spans[spanId];\n    }\n    return;\n  }\n\n  // if not, create a new span to track it\n  const activeTransaction = getActiveTransaction();\n  if (activeTransaction) {\n    const span = activeTransaction.startChild({\n      data: {\n        ...xhr.data,\n        type: 'xhr',\n        method: xhr.method,\n        url: xhr.url,\n      },\n      description: `${xhr.method} ${xhr.url}`,\n      op: 'http.client',\n    });\n\n    handlerData.xhr.__sentry_xhr_span_id__ = span.spanId;\n    spans[handlerData.xhr.__sentry_xhr_span_id__] = span;\n\n    if (handlerData.xhr.setRequestHeader) {\n      try {\n        handlerData.xhr.setRequestHeader('sentry-trace', span.toTraceparent());\n      } catch (_) {\n        // Error: InvalidStateError: Failed to execute 'setRequestHeader' on 'XMLHttpRequest': The object's state must be OPENED.\n      }\n    }\n  }\n}\n","import { Transaction, TransactionContext } from '@sentry/types';\nimport { addInstrumentationHandler, getGlobalObject, logger } from '@sentry/utils';\n\nimport { IS_DEBUG_BUILD } from '../flags';\n\nconst global = getGlobalObject<Window>();\n\n/**\n * Default function implementing pageload and navigation transactions\n */\nexport function instrumentRoutingWithDefaults<T extends Transaction>(\n  customStartTransaction: (context: TransactionContext) => T | undefined,\n  startTransactionOnPageLoad: boolean = true,\n  startTransactionOnLocationChange: boolean = true,\n): void {\n  if (!global || !global.location) {\n    IS_DEBUG_BUILD && logger.warn('Could not initialize routing instrumentation due to invalid location');\n    return;\n  }\n\n  let startingUrl: string | undefined = global.location.href;\n\n  let activeTransaction: T | undefined;\n  if (startTransactionOnPageLoad) {\n    activeTransaction = customStartTransaction({ name: global.location.pathname, op: 'pageload' });\n  }\n\n  if (startTransactionOnLocationChange) {\n    addInstrumentationHandler('history', ({ to, from }: { to: string; from?: string }) => {\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 && startingUrl.indexOf(to) !== -1) {\n        startingUrl = undefined;\n        return;\n      }\n\n      if (from !== to) {\n        startingUrl = undefined;\n        if (activeTransaction) {\n          IS_DEBUG_BUILD && logger.log(`[Tracing] Finishing current transaction with op: ${activeTransaction.op}`);\n          // If there's an open transaction on the scope, we need to finish it before creating an new one.\n          activeTransaction.finish();\n        }\n        activeTransaction = customStartTransaction({ name: global.location.pathname, op: 'navigation' });\n      }\n    });\n  }\n}\n","import { Hub } from '@sentry/hub';\nimport { EventProcessor, Integration, Transaction, TransactionContext } from '@sentry/types';\nimport { getGlobalObject, logger } from '@sentry/utils';\n\nimport { IS_DEBUG_BUILD } from '../flags';\nimport { startIdleTransaction } from '../hubextensions';\nimport { DEFAULT_IDLE_TIMEOUT, IdleTransaction } from '../idletransaction';\nimport { extractTraceparentData, secToMs } from '../utils';\nimport { registerBackgroundTabDetection } from './backgroundtab';\nimport { MetricsInstrumentation } from './metrics';\nimport {\n  defaultRequestInstrumentationOptions,\n  instrumentOutgoingRequests,\n  RequestInstrumentationOptions,\n} from './request';\nimport { instrumentRoutingWithDefaults } from './router';\n\nexport const DEFAULT_MAX_TRANSACTION_DURATION_SECONDS = 600;\n\n/** Options for Browser Tracing integration */\nexport interface BrowserTracingOptions extends RequestInstrumentationOptions {\n  /**\n   * The time to wait in ms until the transaction will be finished. The transaction will use the end timestamp of\n   * the last finished span as the endtime for the transaction.\n   * Time is in ms.\n   *\n   * Default: 1000\n   */\n  idleTimeout: number;\n\n  /**\n   * Flag to enable/disable creation of `navigation` transaction on history changes.\n   *\n   * Default: true\n   */\n  startTransactionOnLocationChange: boolean;\n\n  /**\n   * Flag to enable/disable creation of `pageload` transaction on first pageload.\n   *\n   * Default: true\n   */\n  startTransactionOnPageLoad: boolean;\n\n  /**\n   * The maximum duration of a transaction before it will be marked as \"deadline_exceeded\".\n   * If you never want to mark a transaction set it to 0.\n   * Time is in seconds.\n   *\n   * Default: 600\n   */\n  maxTransactionDuration: number;\n\n  /**\n   * Flag Transactions 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  markBackgroundTransactions: boolean;\n\n  /**\n   * _metricOptions allows the user to send options to change how metrics are collected.\n   *\n   * _metricOptions is currently experimental.\n   *\n   * Default: undefined\n   */\n  _metricOptions?: Partial<{ _reportAllChanges: boolean }>;\n\n  /**\n   * beforeNavigate is called before a pageload/navigation transaction is created and allows users to modify transaction\n   * context data, or drop the transaction entirely (by setting `sampled = false` in the context).\n   *\n   * Note: For legacy reasons, transactions can also be dropped by returning `undefined`.\n   *\n   * @param context: The context data which will be passed to `startTransaction` by default\n   *\n   * @returns A (potentially) modified context object, with `sampled = false` if the transaction should be dropped.\n   */\n  beforeNavigate?(context: TransactionContext): TransactionContext | undefined;\n\n  /**\n   * Instrumentation that creates routing change transactions. By default creates\n   * pageload and navigation transactions.\n   */\n  routingInstrumentation<T extends Transaction>(\n    customStartTransaction: (context: TransactionContext) => T | undefined,\n    startTransactionOnPageLoad?: boolean,\n    startTransactionOnLocationChange?: boolean,\n  ): void;\n}\n\nconst DEFAULT_BROWSER_TRACING_OPTIONS = {\n  idleTimeout: DEFAULT_IDLE_TIMEOUT,\n  markBackgroundTransactions: true,\n  maxTransactionDuration: DEFAULT_MAX_TRANSACTION_DURATION_SECONDS,\n  routingInstrumentation: instrumentRoutingWithDefaults,\n  startTransactionOnLocationChange: true,\n  startTransactionOnPageLoad: true,\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. This integration uses {@see IdleTransaction} to create transactions.\n */\nexport class BrowserTracing implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'BrowserTracing';\n\n  /** Browser Tracing integration options */\n  public options: BrowserTracingOptions;\n\n  /**\n   * @inheritDoc\n   */\n  public name: string = BrowserTracing.id;\n\n  private _getCurrentHub?: () => Hub;\n\n  private readonly _metrics: MetricsInstrumentation;\n\n  private readonly _emitOptionsWarning?: boolean;\n\n  /** Store configured idle timeout so that it can be added as a tag to transactions */\n  private _configuredIdleTimeout: BrowserTracingOptions['idleTimeout'] | undefined = undefined;\n\n  public constructor(_options?: Partial<BrowserTracingOptions>) {\n    let tracingOrigins = defaultRequestInstrumentationOptions.tracingOrigins;\n    // NOTE: Logger doesn't work in constructors, as it's initialized after integrations instances\n    if (_options) {\n      this._configuredIdleTimeout = _options.idleTimeout;\n      if (_options.tracingOrigins && Array.isArray(_options.tracingOrigins) && _options.tracingOrigins.length !== 0) {\n        tracingOrigins = _options.tracingOrigins;\n      } else {\n        IS_DEBUG_BUILD && (this._emitOptionsWarning = true);\n      }\n    }\n\n    this.options = {\n      ...DEFAULT_BROWSER_TRACING_OPTIONS,\n      ..._options,\n      tracingOrigins,\n    };\n\n    const { _metricOptions } = this.options;\n    this._metrics = new MetricsInstrumentation(_metricOptions && _metricOptions._reportAllChanges);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(_: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {\n    this._getCurrentHub = getCurrentHub;\n\n    if (this._emitOptionsWarning) {\n      IS_DEBUG_BUILD &&\n        logger.warn(\n          '[Tracing] You need to define `tracingOrigins` in the options. Set an array of urls or patterns to trace.',\n        );\n      IS_DEBUG_BUILD &&\n        logger.warn(\n          `[Tracing] We added a reasonable default for you: ${defaultRequestInstrumentationOptions.tracingOrigins}`,\n        );\n    }\n\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    const {\n      routingInstrumentation: instrumentRouting,\n      startTransactionOnLocationChange,\n      startTransactionOnPageLoad,\n      markBackgroundTransactions,\n      traceFetch,\n      traceXHR,\n      tracingOrigins,\n      shouldCreateSpanForRequest,\n    } = this.options;\n\n    instrumentRouting(\n      (context: TransactionContext) => this._createRouteTransaction(context),\n      startTransactionOnPageLoad,\n      startTransactionOnLocationChange,\n    );\n\n    if (markBackgroundTransactions) {\n      registerBackgroundTabDetection();\n    }\n\n    instrumentOutgoingRequests({ traceFetch, traceXHR, tracingOrigins, shouldCreateSpanForRequest });\n  }\n\n  /** Create routing idle transaction. */\n  private _createRouteTransaction(context: TransactionContext): Transaction | undefined {\n    if (!this._getCurrentHub) {\n      IS_DEBUG_BUILD &&\n        logger.warn(`[Tracing] Did not create ${context.op} transaction because _getCurrentHub is invalid.`);\n      return undefined;\n    }\n\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    const { beforeNavigate, idleTimeout, maxTransactionDuration } = this.options;\n\n    const parentContextFromHeader = context.op === 'pageload' ? getHeaderContext() : undefined;\n\n    const expandedContext = {\n      ...context,\n      ...parentContextFromHeader,\n      trimEnd: true,\n    };\n    const modifiedContext = typeof beforeNavigate === 'function' ? beforeNavigate(expandedContext) : expandedContext;\n\n    // For backwards compatibility reasons, beforeNavigate can return undefined to \"drop\" the transaction (prevent it\n    // from being sent to Sentry).\n    const finalContext = modifiedContext === undefined ? { ...expandedContext, sampled: false } : modifiedContext;\n\n    if (finalContext.sampled === false) {\n      IS_DEBUG_BUILD && logger.log(`[Tracing] Will not send ${finalContext.op} transaction because of beforeNavigate.`);\n    }\n\n    IS_DEBUG_BUILD && logger.log(`[Tracing] Starting ${finalContext.op} transaction on scope`);\n\n    const hub = this._getCurrentHub();\n    const { location } = getGlobalObject() as WindowOrWorkerGlobalScope & { location: Location };\n\n    const idleTransaction = startIdleTransaction(\n      hub,\n      finalContext,\n      idleTimeout,\n      true,\n      { location }, // for use in the tracesSampler\n    );\n    idleTransaction.registerBeforeFinishCallback((transaction, endTimestamp) => {\n      this._metrics.addPerformanceEntries(transaction);\n      adjustTransactionDuration(secToMs(maxTransactionDuration), transaction, endTimestamp);\n    });\n\n    idleTransaction.setTag('idleTimeout', this._configuredIdleTimeout);\n\n    return idleTransaction as Transaction;\n  }\n}\n\n/**\n * Gets transaction context from a sentry-trace meta.\n *\n * @returns Transaction context data from the header or undefined if there's no header or the header is malformed\n */\nexport function getHeaderContext(): Partial<TransactionContext> | undefined {\n  const header = getMetaContent('sentry-trace');\n  if (header) {\n    return extractTraceparentData(header);\n  }\n\n  return undefined;\n}\n\n/** Returns the value of a meta tag */\nexport function getMetaContent(metaName: string): string | null {\n  const el = getGlobalObject<Window>().document.querySelector(`meta[name=${metaName}]`);\n  return el ? el.getAttribute('content') : null;\n}\n\n/** Adjusts transaction value based on max transaction duration */\nfunction adjustTransactionDuration(maxDuration: number, transaction: IdleTransaction, endTimestamp: number): void {\n  const diff = endTimestamp - transaction.startTimestamp;\n  const isOutdatedTransaction = endTimestamp && (diff > maxDuration || diff < 0);\n  if (isOutdatedTransaction) {\n    transaction.setStatus('deadline_exceeded');\n    transaction.setTag('maxTransactionDurationExceeded', 'true');\n  }\n}\n","/** The status of an Span.\n *\n * @deprecated Use string literals - if you require type casting, cast to SpanStatusType type\n */\n// eslint-disable-next-line import/export\nexport enum SpanStatus {\n  /** The operation completed successfully. */\n  Ok = 'ok',\n  /** Deadline expired before operation could complete. */\n  DeadlineExceeded = 'deadline_exceeded',\n  /** 401 Unauthorized (actually does mean unauthenticated according to RFC 7235) */\n  Unauthenticated = 'unauthenticated',\n  /** 403 Forbidden */\n  PermissionDenied = 'permission_denied',\n  /** 404 Not Found. Some requested entity (file or directory) was not found. */\n  NotFound = 'not_found',\n  /** 429 Too Many Requests */\n  ResourceExhausted = 'resource_exhausted',\n  /** Client specified an invalid argument. 4xx. */\n  InvalidArgument = 'invalid_argument',\n  /** 501 Not Implemented */\n  Unimplemented = 'unimplemented',\n  /** 503 Service Unavailable */\n  Unavailable = 'unavailable',\n  /** Other/generic 5xx. */\n  InternalError = 'internal_error',\n  /** Unknown. Any non-standard HTTP status code. */\n  UnknownError = 'unknown_error',\n  /** The operation was cancelled (typically by the user). */\n  Cancelled = 'cancelled',\n  /** Already exists (409) */\n  AlreadyExists = 'already_exists',\n  /** Operation was rejected because the system is not in a state required for the operation's */\n  FailedPrecondition = 'failed_precondition',\n  /** The operation was aborted, typically due to a concurrency issue. */\n  Aborted = 'aborted',\n  /** Operation was attempted past the valid range. */\n  OutOfRange = 'out_of_range',\n  /** Unrecoverable data loss or corruption */\n  DataLoss = 'data_loss',\n}\n","import { addExtensionMethods } from './hubextensions';\nimport * as Integrations from './integrations';\n\nexport { Integrations };\n\n// This is already exported as part of `Integrations` above (and for the moment will remain so for\n// backwards compatibility), but that interferes with treeshaking, so we also export it separately\n// here.\n//\n// Previously we expected users to import tracing integrations like\n//\n// import { Integrations } from '@sentry/tracing';\n// const instance = new Integrations.BrowserTracing();\n//\n// This makes the integrations unable to be treeshaken though. To address this, we now have\n// this individual export. We now expect users to consume BrowserTracing like so:\n//\n// import { BrowserTracing } from '@sentry/tracing';\n// const instance = new BrowserTracing();\n//\n// For an example of of the new usage of BrowserTracing, see @sentry/nextjs index.client.ts\nexport { BrowserTracing } from './browser';\n\nexport { Span, SpanStatusType, spanStatusfromHttpCode } from './span';\n// eslint-disable-next-line deprecation/deprecation\nexport { SpanStatus } from './spanstatus';\nexport { Transaction } from './transaction';\nexport {\n  // TODO deprecate old name in v7\n  instrumentOutgoingRequests as registerRequestInstrumentation,\n  RequestInstrumentationOptions,\n  defaultRequestInstrumentationOptions,\n} from './browser';\nexport { IdleTransaction } from './idletransaction';\nexport { startIdleTransaction } from './hubextensions';\n\n// We are patching the global object with our hub extension methods\naddExtensionMethods();\n\nexport { addExtensionMethods };\n\nexport {\n  extractTraceparentData,\n  getActiveTransaction,\n  hasTracingEnabled,\n  stripUrlQueryAndFragment,\n  TRACEPARENT_REGEXP,\n} from './utils';\n","/* eslint-disable max-lines */\nimport { Primitive, Span as SpanInterface, SpanContext, Transaction } from '@sentry/types';\nimport { dropUndefinedKeys, timestampWithMs, uuid4 } from '@sentry/utils';\n\n/**\n * Keeps track of finished spans for a given transaction\n * @internal\n * @hideconstructor\n * @hidden\n */\nexport class SpanRecorder {\n  public spans: Span[] = [];\n\n  private readonly _maxlen: number;\n\n  public constructor(maxlen: number = 1000) {\n    this._maxlen = maxlen;\n  }\n\n  /**\n   * This is just so that we don't run out of memory while recording a lot\n   * of spans. At some point we just stop and flush out the start of the\n   * trace tree (i.e.the first n spans with the smallest\n   * start_timestamp).\n   */\n  public add(span: Span): void {\n    if (this.spans.length > this._maxlen) {\n      span.spanRecorder = undefined;\n    } else {\n      this.spans.push(span);\n    }\n  }\n}\n\n/**\n * Span contains all data about a span\n */\nexport class Span implements SpanInterface {\n  /**\n   * @inheritDoc\n   */\n  public traceId: string = uuid4();\n\n  /**\n   * @inheritDoc\n   */\n  public spanId: string = uuid4().substring(16);\n\n  /**\n   * @inheritDoc\n   */\n  public parentSpanId?: string;\n\n  /**\n   * Internal keeper of the status\n   */\n  public status?: SpanStatusType | string;\n\n  /**\n   * @inheritDoc\n   */\n  public sampled?: boolean;\n\n  /**\n   * Timestamp in seconds when the span was created.\n   */\n  public startTimestamp: number = timestampWithMs();\n\n  /**\n   * Timestamp in seconds when the span ended.\n   */\n  public endTimestamp?: number;\n\n  /**\n   * @inheritDoc\n   */\n  public op?: string;\n\n  /**\n   * @inheritDoc\n   */\n  public description?: string;\n\n  /**\n   * @inheritDoc\n   */\n  public tags: { [key: string]: Primitive } = {};\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  public data: { [key: string]: any } = {};\n\n  /**\n   * List of spans that were finalized\n   */\n  public spanRecorder?: SpanRecorder;\n\n  /**\n   * @inheritDoc\n   */\n  public transaction?: Transaction;\n\n  /**\n   * You should never call the constructor manually, always use `Sentry.startTransaction()`\n   * or call `startChild()` on an existing span.\n   * @internal\n   * @hideconstructor\n   * @hidden\n   */\n  public constructor(spanContext?: SpanContext) {\n    if (!spanContext) {\n      return this;\n    }\n    if (spanContext.traceId) {\n      this.traceId = spanContext.traceId;\n    }\n    if (spanContext.spanId) {\n      this.spanId = spanContext.spanId;\n    }\n    if (spanContext.parentSpanId) {\n      this.parentSpanId = spanContext.parentSpanId;\n    }\n    // We want to include booleans as well here\n    if ('sampled' in spanContext) {\n      this.sampled = spanContext.sampled;\n    }\n    if (spanContext.op) {\n      this.op = spanContext.op;\n    }\n    if (spanContext.description) {\n      this.description = spanContext.description;\n    }\n    if (spanContext.data) {\n      this.data = spanContext.data;\n    }\n    if (spanContext.tags) {\n      this.tags = spanContext.tags;\n    }\n    if (spanContext.status) {\n      this.status = spanContext.status;\n    }\n    if (spanContext.startTimestamp) {\n      this.startTimestamp = spanContext.startTimestamp;\n    }\n    if (spanContext.endTimestamp) {\n      this.endTimestamp = spanContext.endTimestamp;\n    }\n  }\n\n  /**\n   * @inheritDoc\n   * @deprecated\n   */\n  public child(\n    spanContext?: Pick<SpanContext, Exclude<keyof SpanContext, 'spanId' | 'sampled' | 'traceId' | 'parentSpanId'>>,\n  ): Span {\n    return this.startChild(spanContext);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public startChild(\n    spanContext?: Pick<SpanContext, Exclude<keyof SpanContext, 'spanId' | 'sampled' | 'traceId' | 'parentSpanId'>>,\n  ): Span {\n    const childSpan = new Span({\n      ...spanContext,\n      parentSpanId: this.spanId,\n      sampled: this.sampled,\n      traceId: this.traceId,\n    });\n\n    childSpan.spanRecorder = this.spanRecorder;\n    if (childSpan.spanRecorder) {\n      childSpan.spanRecorder.add(childSpan);\n    }\n\n    childSpan.transaction = this.transaction;\n\n    return childSpan;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setTag(key: string, value: Primitive): this {\n    this.tags = { ...this.tags, [key]: value };\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n  public setData(key: string, value: any): this {\n    this.data = { ...this.data, [key]: value };\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setStatus(value: SpanStatusType): this {\n    this.status = value;\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setHttpStatus(httpStatus: number): this {\n    this.setTag('http.status_code', String(httpStatus));\n    const spanStatus = spanStatusfromHttpCode(httpStatus);\n    if (spanStatus !== 'unknown_error') {\n      this.setStatus(spanStatus);\n    }\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public isSuccess(): boolean {\n    return this.status === 'ok';\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public finish(endTimestamp?: number): void {\n    this.endTimestamp = typeof endTimestamp === 'number' ? endTimestamp : timestampWithMs();\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public toTraceparent(): string {\n    let sampledString = '';\n    if (this.sampled !== undefined) {\n      sampledString = this.sampled ? '-1' : '-0';\n    }\n    return `${this.traceId}-${this.spanId}${sampledString}`;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public toContext(): SpanContext {\n    return dropUndefinedKeys({\n      data: this.data,\n      description: this.description,\n      endTimestamp: this.endTimestamp,\n      op: this.op,\n      parentSpanId: this.parentSpanId,\n      sampled: this.sampled,\n      spanId: this.spanId,\n      startTimestamp: this.startTimestamp,\n      status: this.status,\n      tags: this.tags,\n      traceId: this.traceId,\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public updateWithContext(spanContext: SpanContext): this {\n    this.data = spanContext.data ?? {};\n    this.description = spanContext.description;\n    this.endTimestamp = spanContext.endTimestamp;\n    this.op = spanContext.op;\n    this.parentSpanId = spanContext.parentSpanId;\n    this.sampled = spanContext.sampled;\n    this.spanId = spanContext.spanId ?? this.spanId;\n    this.startTimestamp = spanContext.startTimestamp ?? this.startTimestamp;\n    this.status = spanContext.status;\n    this.tags = spanContext.tags ?? {};\n    this.traceId = spanContext.traceId ?? this.traceId;\n\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getTraceContext(): {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    data?: { [key: string]: any };\n    description?: string;\n    op?: string;\n    parent_span_id?: string;\n    span_id: string;\n    status?: string;\n    tags?: { [key: string]: Primitive };\n    trace_id: string;\n  } {\n    return dropUndefinedKeys({\n      data: Object.keys(this.data).length > 0 ? this.data : undefined,\n      description: this.description,\n      op: this.op,\n      parent_span_id: this.parentSpanId,\n      span_id: this.spanId,\n      status: this.status,\n      tags: Object.keys(this.tags).length > 0 ? this.tags : undefined,\n      trace_id: this.traceId,\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public toJSON(): {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    data?: { [key: string]: any };\n    description?: string;\n    op?: string;\n    parent_span_id?: string;\n    span_id: string;\n    start_timestamp: number;\n    status?: string;\n    tags?: { [key: string]: Primitive };\n    timestamp?: number;\n    trace_id: string;\n  } {\n    return dropUndefinedKeys({\n      data: Object.keys(this.data).length > 0 ? this.data : undefined,\n      description: this.description,\n      op: this.op,\n      parent_span_id: this.parentSpanId,\n      span_id: this.spanId,\n      start_timestamp: this.startTimestamp,\n      status: this.status,\n      tags: Object.keys(this.tags).length > 0 ? this.tags : undefined,\n      timestamp: this.endTimestamp,\n      trace_id: this.traceId,\n    });\n  }\n}\n\nexport type SpanStatusType =\n  /** The operation completed successfully. */\n  | 'ok'\n  /** Deadline expired before operation could complete. */\n  | 'deadline_exceeded'\n  /** 401 Unauthorized (actually does mean unauthenticated according to RFC 7235) */\n  | 'unauthenticated'\n  /** 403 Forbidden */\n  | 'permission_denied'\n  /** 404 Not Found. Some requested entity (file or directory) was not found. */\n  | 'not_found'\n  /** 429 Too Many Requests */\n  | 'resource_exhausted'\n  /** Client specified an invalid argument. 4xx. */\n  | 'invalid_argument'\n  /** 501 Not Implemented */\n  | 'unimplemented'\n  /** 503 Service Unavailable */\n  | 'unavailable'\n  /** Other/generic 5xx. */\n  | 'internal_error'\n  /** Unknown. Any non-standard HTTP status code. */\n  | 'unknown_error'\n  /** The operation was cancelled (typically by the user). */\n  | 'cancelled'\n  /** Already exists (409) */\n  | 'already_exists'\n  /** Operation was rejected because the system is not in a state required for the operation's */\n  | 'failed_precondition'\n  /** The operation was aborted, typically due to a concurrency issue. */\n  | 'aborted'\n  /** Operation was attempted past the valid range. */\n  | 'out_of_range'\n  /** Unrecoverable data loss or corruption */\n  | 'data_loss';\n\n/**\n * Converts a HTTP status code into a {@link SpanStatusType}.\n *\n * @param httpStatus The HTTP response status code.\n * @returns The span status or unknown_error.\n */\nexport function spanStatusfromHttpCode(httpStatus: number): SpanStatusType {\n  if (httpStatus < 400 && httpStatus >= 100) {\n    return 'ok';\n  }\n\n  if (httpStatus >= 400 && httpStatus < 500) {\n    switch (httpStatus) {\n      case 401:\n        return 'unauthenticated';\n      case 403:\n        return 'permission_denied';\n      case 404:\n        return 'not_found';\n      case 409:\n        return 'already_exists';\n      case 413:\n        return 'failed_precondition';\n      case 429:\n        return 'resource_exhausted';\n      default:\n        return 'invalid_argument';\n    }\n  }\n\n  if (httpStatus >= 500 && httpStatus < 600) {\n    switch (httpStatus) {\n      case 501:\n        return 'unimplemented';\n      case 503:\n        return 'unavailable';\n      case 504:\n        return 'deadline_exceeded';\n      default:\n        return 'internal_error';\n    }\n  }\n\n  return 'unknown_error';\n}\n","import { getCurrentHub, Hub } from '@sentry/hub';\nimport {\n  Event,\n  Measurements,\n  Transaction as TransactionInterface,\n  TransactionContext,\n  TransactionMetadata,\n} from '@sentry/types';\nimport { dropUndefinedKeys, isInstanceOf, logger } from '@sentry/utils';\n\nimport { IS_DEBUG_BUILD } from './flags';\nimport { Span as SpanClass, SpanRecorder } from './span';\n\n/** JSDoc */\nexport class Transaction extends SpanClass implements TransactionInterface {\n  public name: string;\n\n  public metadata: TransactionMetadata;\n\n  private _measurements: Measurements = {};\n\n  /**\n   * The reference to the current hub.\n   */\n  private readonly _hub: Hub = getCurrentHub() as unknown as Hub;\n\n  private _trimEnd?: boolean;\n\n  /**\n   * This constructor should never be called manually. Those instrumenting tracing should use\n   * `Sentry.startTransaction()`, and internal methods should use `hub.startTransaction()`.\n   * @internal\n   * @hideconstructor\n   * @hidden\n   */\n  public constructor(transactionContext: TransactionContext, hub?: Hub) {\n    super(transactionContext);\n\n    if (isInstanceOf(hub, Hub)) {\n      this._hub = hub as Hub;\n    }\n\n    this.name = transactionContext.name || '';\n\n    this.metadata = transactionContext.metadata || {};\n    this._trimEnd = transactionContext.trimEnd;\n\n    // this is because transactions are also spans, and spans have a transaction pointer\n    this.transaction = this;\n  }\n\n  /**\n   * JSDoc\n   */\n  public setName(name: string): void {\n    this.name = name;\n  }\n\n  /**\n   * Attaches SpanRecorder to the span itself\n   * @param maxlen maximum number of spans that can be recorded\n   */\n  public initSpanRecorder(maxlen: number = 1000): void {\n    if (!this.spanRecorder) {\n      this.spanRecorder = new SpanRecorder(maxlen);\n    }\n    this.spanRecorder.add(this);\n  }\n\n  /**\n   * Set observed measurements for this transaction.\n   * @hidden\n   */\n  public setMeasurements(measurements: Measurements): void {\n    this._measurements = { ...measurements };\n  }\n\n  /**\n   * Set metadata for this transaction.\n   * @hidden\n   */\n  public setMetadata(newMetadata: TransactionMetadata): void {\n    this.metadata = { ...this.metadata, ...newMetadata };\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public finish(endTimestamp?: number): string | undefined {\n    // This transaction is already finished, so we should not flush it again.\n    if (this.endTimestamp !== undefined) {\n      return undefined;\n    }\n\n    if (!this.name) {\n      IS_DEBUG_BUILD && logger.warn('Transaction has no name, falling back to `<unlabeled transaction>`.');\n      this.name = '<unlabeled transaction>';\n    }\n\n    // just sets the end timestamp\n    super.finish(endTimestamp);\n\n    if (this.sampled !== true) {\n      // At this point if `sampled !== true` we want to discard the transaction.\n      IS_DEBUG_BUILD && logger.log('[Tracing] Discarding transaction because its trace was not chosen to be sampled.');\n\n      const client = this._hub.getClient();\n      const transport = client && client.getTransport && client.getTransport();\n      if (transport && transport.recordLostEvent) {\n        transport.recordLostEvent('sample_rate', 'transaction');\n      }\n      return undefined;\n    }\n\n    const finishedSpans = this.spanRecorder ? this.spanRecorder.spans.filter(s => s !== this && s.endTimestamp) : [];\n\n    if (this._trimEnd && finishedSpans.length > 0) {\n      this.endTimestamp = finishedSpans.reduce((prev: SpanClass, current: SpanClass) => {\n        if (prev.endTimestamp && current.endTimestamp) {\n          return prev.endTimestamp > current.endTimestamp ? prev : current;\n        }\n        return prev;\n      }).endTimestamp;\n    }\n\n    const transaction: Event = {\n      contexts: {\n        trace: this.getTraceContext(),\n      },\n      spans: finishedSpans,\n      start_timestamp: this.startTimestamp,\n      tags: this.tags,\n      timestamp: this.endTimestamp,\n      transaction: this.name,\n      type: 'transaction',\n      sdkProcessingMetadata: this.metadata,\n    };\n\n    const hasMeasurements = Object.keys(this._measurements).length > 0;\n\n    if (hasMeasurements) {\n      IS_DEBUG_BUILD &&\n        logger.log(\n          '[Measurements] Adding measurements to transaction',\n          JSON.stringify(this._measurements, undefined, 2),\n        );\n      transaction.measurements = this._measurements;\n    }\n\n    IS_DEBUG_BUILD && logger.log(`[Tracing] Finishing ${this.op} transaction: ${this.name}.`);\n\n    return this._hub.captureEvent(transaction);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public toContext(): TransactionContext {\n    const spanContext = super.toContext();\n\n    return dropUndefinedKeys({\n      ...spanContext,\n      name: this.name,\n      trimEnd: this._trimEnd,\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public updateWithContext(transactionContext: TransactionContext): this {\n    super.updateWithContext(transactionContext);\n\n    this.name = transactionContext.name ?? '';\n\n    this._trimEnd = transactionContext.trimEnd;\n\n    return this;\n  }\n}\n","import { getCurrentHub, Hub } from '@sentry/hub';\nimport { Options, Transaction } from '@sentry/types';\n\n/**\n * The `extractTraceparentData` function and `TRACEPARENT_REGEXP` constant used\n * to be declared in this file. It was later moved into `@sentry/utils` as part of a\n * move to remove `@sentry/tracing` dependencies from `@sentry/node` (`extractTraceparentData`\n * is the only tracing function used by `@sentry/node`).\n *\n * These exports are kept here for backwards compatability's sake.\n *\n * TODO(v7): Reorganize these exports\n *\n * See https://github.com/getsentry/sentry-javascript/issues/4642 for more details.\n */\nexport { TRACEPARENT_REGEXP, extractTraceparentData } from '@sentry/utils';\n\n/**\n * Determines if tracing is currently enabled.\n *\n * Tracing is enabled when at least one of `tracesSampleRate` and `tracesSampler` is defined in the SDK config.\n */\nexport function hasTracingEnabled(maybeOptions?: Options | undefined): boolean {\n  const client = getCurrentHub().getClient();\n  const options = maybeOptions || (client && client.getOptions());\n  return !!options && ('tracesSampleRate' in options || 'tracesSampler' in options);\n}\n\n/** Grabs active transaction off scope, if any */\nexport function getActiveTransaction<T extends Transaction>(maybeHub?: Hub): T | undefined {\n  const hub = maybeHub || getCurrentHub();\n  const scope = hub.getScope();\n  return scope && (scope.getTransaction() as T | undefined);\n}\n\n/**\n * Converts from milliseconds to seconds\n * @param time time in ms\n */\nexport function msToSec(time: number): number {\n  return time / 1000;\n}\n\n/**\n * Converts from seconds to milliseconds\n * @param time time in seconds\n */\nexport function secToMs(time: number): number {\n  return time * 1000;\n}\n\n// so it can be used in manual instrumentation without necessitating a hard dependency on @sentry/utils\nexport { stripUrlQueryAndFragment } from '@sentry/utils';\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n"],"names":["FINISH_REASON_TAG","IDLE_TRANSACTION_FINISH_REASONS","IS_DEBUG_BUILD","__SENTRY_DEBUG__","errorCallback","activeTransaction","getActiveTransaction","status_1","logger","setStatus","traceHeaders","scope","this","getScope","span","getSpan","toTraceparent","sample","transaction","options","samplingContext","hasTracingEnabled","undefined","sampled","setMetadata","transactionSampling","method","tracesSampler","sampleRate","rate","Number","parentSampled","tracesSampleRate","isNaN","JSON","stringify","isValidSampleRate","Math","random","op","name","_startTransaction","transactionContext","customSamplingContext","client","getClient","getOptions","Transaction","initSpanRecorder","_experiments","maxSpans","startIdleTransaction","hub","idleTimeout","onScope","IdleTransaction","addExtensionMethods","carrier","getMainCarrier","__SENTRY__","extensions","startTransaction","_addTracingExtensions","isNodeEnv","packageToIntegrationMapping","mongodb","dynamicRequire","module","Mongo","mongoose","mysql","Mysql","pg","Postgres","mappedPackages","Object","keys","filter","moduleName","loadModule","map","pkg","e","p","length","integrations","_autoloadDatabaseIntegrations","addInstrumentationHandler","DEFAULT_IDLE_TIMEOUT","_pushActivity","_popActivity","transactionSpanId","maxlen","_super","_this","__extends","IdleTransactionSpanRecorder","spanId","finish","endTimestamp","timestampWithMs","add","SpanRecorder","_idleHub","_idleTimeout","_onScope","clearActiveTransaction","configureScope","setSpan","_initTimeout","setTimeout","_finished","activities","spanRecorder","Date","toISOString","_beforeFinishCallbacks","callback","spans","keepSpan","startTimestamp","push","id","_pingHeartbeat","clearTimeout","timeout","end_1","setTag","heartbeatString","join","_prevHeartbeatString","_heartbeatCounter","_beat","getTransaction","Express","_router","router","app","_methods","Array","isArray","methods","concat","forEach","originalCallback","_i","args","call","wrapMiddlewareArgs","patchMiddleware","instrumentMiddlewares","wrap","fn","arity","req","res","__sentry_transaction","span_1","startChild","description","once","next","err","Error","arg","a","_usePgNative","usePgNative","_","getCurrentHub","native","Client","fill","prototype","orig","config","values","text","result","rv","isThenable","then","sql","fields","OPERATIONS","OPERATION_SIGNATURES","bulkWrite","countDocuments","createIndex","createIndexes","deleteMany","deleteOne","distinct","dropIndex","find","findOne","findOneAndDelete","findOneAndReplace","findOneAndUpdate","indexExists","insertMany","insertOne","mapReduce","rename","replaceOne","updateMany","updateOne","_operations","operations","_describeOperations","describeOperations","_useMongoose","useMongoose","_instrumentOperations","Collection","collection","operation","_patchOperation","getSpanContext","_getSpanContextFromOperationArguments","bind","lastArg","parentSpan","maybePromise","slice","data","collectionName","dbName","namespace","spanContext","signature","shouldDescribe","includes","reduce","i","_oO","TRACEPARENT_REGEXP","RegExp","extractTraceparentData","traceparent","matches","match","traceId","parentSpanId","global","getGlobalObject","bindReporter","metric","reportAllChanges","prevValue","forceReport","value","delta","initMetric","entries","now","floor","observe","type","PerformanceObserver","supportedEntryTypes","self","po","l","getEntries","buffered","onHidden","cb","onHiddenOrPageHide","event","document","visibilityState","removeEventListener","addEventListener","firstHiddenTime","getVisibilityWatcher","Infinity","_a","timeStamp","reportedMetricIDs","_reportAllChanges","_measurements","_performanceCursor","performance","mark","_trackCLS","_trackLCP","_trackFID","MetricsInstrumentation","browserPerformanceTimeOrigin","responseStartTimestamp","requestStartTimestamp","timeOrigin","msToSec","entry","startTime","duration","entryType","addPerformanceNavigationTiming","_startChild","requestStart","responseEnd","responseStart","addRequest","addNavigationSpans","measureStartTimestamp","measureEndTimestamp","addMeasureSpans","firstHidden","shouldRecord","resourceName","replace","location","origin","initiatorType","transferSize","encodedBodySize","decodedBodySize","addResourceSpans","max","_trackNavigator","timeOrigin_1","oldValue","measurementTimestamp","normalizedValue","abs","cls","setMeasurements","lcpEntry","clsEntry","element","htmlTreeAsString","url","trim","size","sources","source","index","node","tagMetricInfo","_lcpEntry","_clsEntry","navigator","connection","effectiveType","isMeasurementValue","rtt","downlink","deviceMemory","String","hardwareConcurrency","onReport","report","sessionValue","sessionEntries","entryHandler","hadRecentInput","firstSessionEntry","lastSessionEntry","takeRecords","getCLS","pop","visibilityWatcher","stopListening_1","disconnect","capture","getLCP","processingStart","getFID","eventEnd","end","start","ctx","isFinite","defaultRequestInstrumentationOptions","traceFetch","traceXHR","tracingOrigins","instrumentOutgoingRequests","_options","shouldCreateSpanForRequest","urlMap","defaultShouldCreateSpan","origins","some","isMatchingPattern","shouldCreateSpan","handlerData","fetchData","__span","response","setHttpStatus","status","error","request","headers","isInstanceOf","Request","append","fetchCallback","xhr","__sentry_own_request__","__sentry_xhr__","__sentry_xhr_span_id__","status_code","setRequestHeader","xhrCallback","DEFAULT_BROWSER_TRACING_OPTIONS","markBackgroundTransactions","maxTransactionDuration","routingInstrumentation","customStartTransaction","startTransactionOnPageLoad","startTransactionOnLocationChange","startingUrl","href","pathname","to","from","indexOf","BrowserTracing","_configuredIdleTimeout","_emitOptionsWarning","_metricOptions","_metrics","_getCurrentHub","instrumentRouting","context","_createRouteTransaction","hidden","statusType","beforeNavigate","parentContextFromHeader","header","metaName","el","querySelector","getAttribute","getMetaContent","getHeaderContext","expandedContext","trimEnd","modifiedContext","finalContext","__assign","idleTransaction","registerBeforeFinishCallback","addPerformanceEntries","maxDuration","diff","adjustTransactionDuration","secToMs","SpanStatus","_maxlen","uuid4","substring","tags","Span","childSpan","key","httpStatus","spanStatus","spanStatusfromHttpCode","sampledString","dropUndefinedKeys","parent_span_id","span_id","trace_id","start_timestamp","timestamp","Hub","_hub","metadata","_trimEnd","measurements","newMetadata","finishedSpans","s","prev","current","contexts","trace","getTraceContext","sdkProcessingMetadata","captureEvent","transport","getTransport","recordLostEvent","toContext","updateWithContext","SpanClass","maybeOptions","maybeHub","time","extendStatics","d","b","setPrototypeOf","__proto__","hasOwnProperty","__","constructor","create","assign","t","n","arguments","apply","__rest","getOwnPropertySymbols","propertyIsEnumerable","__values","o","Symbol","iterator","m","done","TypeError","__read","r","ar","__spread"],"sourceRoot":""}