{"version":3,"file":"js/chunk-vendors-f4d1ac8d-legacy.66be4f0f.js","mappings":"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CA,C,uRCpjBA,M,aA2DA,6BACA,4BACA,wBACA,yBACA,qBACA,qBACA,cACA,cACA,eACA,kBACA,8BACA,C,+CA8BA,YACA,4BACA,G,+BAKA,YAEA,OADA,8BACA,IACA,G,qBAKA,YAMA,OALA,iBACA,gBACA1G,EAAAA,EAAAA,IAAAA,KAAAA,SAAAA,CAAAoB,KAAAA,IAEA,6BACA,IACA,G,qBAKA,WACA,iBACA,G,+BAKA,WACA,2BACA,G,+BAKA,YAEA,OADA,uBACA,IACA,G,qBAKA,YAMA,OALA,8BACA,YACAuF,GAEA,6BACA,IACA,G,oBAKA,cAGA,OAFA,8DACA,6BACA,IACA,G,uBAKA,YAMA,OALA,+BACA,aACAC,GAEA,6BACA,IACA,G,sBAKA,cAGA,OAFA,gEACA,6BACA,IACA,G,4BAKA,YAGA,OAFA,oBACA,6BACA,IACA,G,sBAKA,SACAhH,GAKA,OAFA,cACA,6BACA,IACA,G,gCAKA,YAGA,OAFA,wBACA,6BACA,IACA,G,wBAKA,cASA,OARA,gBACA,kBAGA,sEAGA,6BACA,IACA,G,qBAKA,YAGA,OAFA,aACA,6BACA,IACA,G,qBAKA,WACA,iBACA,G,4BAKA,WAGA,qBACA,uBACA,G,wBAKA,YAOA,OANA,EAGA,uBAFA,cAIA,6BACA,IACA,G,wBAKA,WACA,oBACA,G,oBAKA,YACA,MACA,YAGA,0BACA,cACA,4BACA,CAsCA,OApCA,gBACA,mDACA,sDACA,+DACA,uCACA,oBAEA,WACA,sBAEA,iBACA,kCAEA,oBACA,0CAEA,aAGA,kDACA,qDACA,8DACA,SACA,mBAEA,UACA,qBAEA,gBACA,iCAEA,mBACA,wCAIA,IACA,G,mBAKA,WAcA,OAbA,qBACA,cACA,eACA,cACA,kBACA,mBACA,6BACA,yBACA,4BACA,kBACA,qBACA,6BACA,qBACA,IACA,G,2BAKA,cACA,0CAGA,QACA,YAGA,eACAkB,WAAAA,EAAAA,EAAAA,OACA+F,GAKA,OAHA,sEACA,6BAEA,IACA,G,8BAKA,WAGA,OAFA,qBACA,6BACA,IACA,G,2BAKA,YAEA,OADA,0BACA,IACA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","sources":["webpack://procon-web/../api.ts","webpack://procon-web/../envelope.ts","webpack://procon-web/../baseclient.ts","webpack://procon-web/../integration.ts","webpack://procon-web/../../../src/integrations/functiontostring.ts","webpack://procon-web/../../../src/integrations/inboundfilters.ts","webpack://procon-web/../sdk.ts","webpack://procon-web/../../../src/transports/base.ts","webpack://procon-web/../exports.ts","webpack://procon-web/../hub.ts","webpack://procon-web/../scope.ts","webpack://procon-web/../session.ts"],"sourcesContent":["import { ClientOptions, DsnComponents, DsnLike, SdkInfo } from '@sentry/types';\nimport { dsnToString, makeDsn, urlEncode } from '@sentry/utils';\n\nconst SENTRY_API_VERSION = '7';\n\n/** Returns the prefix to construct Sentry ingestion API endpoints. */\nfunction getBaseApiEndpoint(dsn: DsnComponents): string {\n const protocol = dsn.protocol ? `${dsn.protocol}:` : '';\n const port = dsn.port ? `:${dsn.port}` : '';\n return `${protocol}//${dsn.host}${port}${dsn.path ? `/${dsn.path}` : ''}/api/`;\n}\n\n/** Returns the ingest API endpoint for target. */\nfunction _getIngestEndpoint(dsn: DsnComponents): string {\n return `${getBaseApiEndpoint(dsn)}${dsn.projectId}/envelope/`;\n}\n\n/** Returns a URL-encoded string with auth config suitable for a query string. */\nfunction _encodedAuth(dsn: DsnComponents, sdkInfo: SdkInfo | undefined): string {\n return urlEncode({\n // We send only the minimum set of required information. See\n // https://github.com/getsentry/sentry-javascript/issues/2572.\n sentry_key: dsn.publicKey,\n sentry_version: SENTRY_API_VERSION,\n ...(sdkInfo && { sentry_client: `${sdkInfo.name}/${sdkInfo.version}` }),\n });\n}\n\n/**\n * Returns the envelope endpoint URL with auth in the query string.\n *\n * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.\n */\nexport function getEnvelopeEndpointWithUrlEncodedAuth(\n dsn: DsnComponents,\n // TODO (v8): Remove `tunnelOrOptions` in favor of `options`, and use the substitute code below\n // options: ClientOptions = {} as ClientOptions,\n tunnelOrOptions: string | ClientOptions = {} as ClientOptions,\n): string {\n // TODO (v8): Use this code instead\n // const { tunnel, _metadata = {} } = options;\n // return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn, _metadata.sdk)}`;\n\n const tunnel = typeof tunnelOrOptions === 'string' ? tunnelOrOptions : tunnelOrOptions.tunnel;\n const sdkInfo =\n typeof tunnelOrOptions === 'string' || !tunnelOrOptions._metadata ? undefined : tunnelOrOptions._metadata.sdk;\n\n return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn, sdkInfo)}`;\n}\n\n/** Returns the url to the report dialog endpoint. */\nexport function getReportDialogEndpoint(\n dsnLike: DsnLike,\n dialogOptions: {\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n [key: string]: any;\n user?: { name?: string; email?: string };\n },\n): string {\n const dsn = makeDsn(dsnLike);\n const endpoint = `${getBaseApiEndpoint(dsn)}embed/error-page/`;\n\n let encodedOptions = `dsn=${dsnToString(dsn)}`;\n for (const key in dialogOptions) {\n if (key === 'dsn') {\n continue;\n }\n\n if (key === 'user') {\n const user = dialogOptions.user;\n if (!user) {\n continue;\n }\n if (user.name) {\n encodedOptions += `&name=${encodeURIComponent(user.name)}`;\n }\n if (user.email) {\n encodedOptions += `&email=${encodeURIComponent(user.email)}`;\n }\n } else {\n encodedOptions += `&${encodeURIComponent(key)}=${encodeURIComponent(dialogOptions[key] as string)}`;\n }\n }\n\n return `${endpoint}?${encodedOptions}`;\n}\n","import {\n DsnComponents,\n Event,\n EventEnvelope,\n EventEnvelopeHeaders,\n EventItem,\n SdkInfo,\n SdkMetadata,\n Session,\n SessionAggregates,\n SessionEnvelope,\n SessionItem,\n} from '@sentry/types';\nimport { createEnvelope, dropUndefinedKeys, dsnToString } from '@sentry/utils';\n\n/** Extract sdk info from from the API metadata */\nfunction getSdkMetadataForEnvelopeHeader(metadata?: SdkMetadata): SdkInfo | undefined {\n if (!metadata || !metadata.sdk) {\n return;\n }\n const { name, version } = metadata.sdk;\n return { name, version };\n}\n\n/**\n * Apply SdkInfo (name, version, packages, integrations) to the corresponding event key.\n * Merge with existing data if any.\n **/\nfunction enhanceEventWithSdkInfo(event: Event, sdkInfo?: SdkInfo): Event {\n if (!sdkInfo) {\n return event;\n }\n event.sdk = event.sdk || {};\n event.sdk.name = event.sdk.name || sdkInfo.name;\n event.sdk.version = event.sdk.version || sdkInfo.version;\n event.sdk.integrations = [...(event.sdk.integrations || []), ...(sdkInfo.integrations || [])];\n event.sdk.packages = [...(event.sdk.packages || []), ...(sdkInfo.packages || [])];\n return event;\n}\n\n/** Creates an envelope from a Session */\nexport function createSessionEnvelope(\n session: Session | SessionAggregates,\n dsn: DsnComponents,\n metadata?: SdkMetadata,\n tunnel?: string,\n): SessionEnvelope {\n const sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);\n const envelopeHeaders = {\n sent_at: new Date().toISOString(),\n ...(sdkInfo && { sdk: sdkInfo }),\n ...(!!tunnel && { dsn: dsnToString(dsn) }),\n };\n\n const envelopeItem: SessionItem =\n 'aggregates' in session ? [{ type: 'sessions' }, session] : [{ type: 'session' }, session];\n\n return createEnvelope<SessionEnvelope>(envelopeHeaders, [envelopeItem]);\n}\n\n/**\n * Create an Envelope from an event.\n */\nexport function createEventEnvelope(\n event: Event,\n dsn: DsnComponents,\n metadata?: SdkMetadata,\n tunnel?: string,\n): EventEnvelope {\n const sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);\n const eventType = event.type || 'event';\n\n const { transactionSampling } = event.sdkProcessingMetadata || {};\n const { method: samplingMethod, rate: sampleRate } = transactionSampling || {};\n\n enhanceEventWithSdkInfo(event, metadata && metadata.sdk);\n\n const envelopeHeaders = createEventEnvelopeHeaders(event, sdkInfo, tunnel, dsn);\n\n // Prevent this data (which, if it exists, was used in earlier steps in the processing pipeline) from being sent to\n // sentry. (Note: Our use of this property comes and goes with whatever we might be debugging, whatever hacks we may\n // have temporarily added, etc. Even if we don't happen to be using it at some point in the future, let's not get rid\n // of this `delete`, lest we miss putting it back in the next time the property is in use.)\n delete event.sdkProcessingMetadata;\n\n const eventItem: EventItem = [\n {\n type: eventType,\n sample_rates: [{ id: samplingMethod, rate: sampleRate }],\n },\n event,\n ];\n return createEnvelope<EventEnvelope>(envelopeHeaders, [eventItem]);\n}\n\nfunction createEventEnvelopeHeaders(\n event: Event,\n sdkInfo: SdkInfo | undefined,\n tunnel: string | undefined,\n dsn: DsnComponents,\n): EventEnvelopeHeaders {\n const dynamicSamplingContext = event.sdkProcessingMetadata && event.sdkProcessingMetadata.dynamicSamplingContext;\n\n return {\n event_id: event.event_id as string,\n sent_at: new Date().toISOString(),\n ...(sdkInfo && { sdk: sdkInfo }),\n ...(!!tunnel && { dsn: dsnToString(dsn) }),\n ...(event.type === 'transaction' &&\n dynamicSamplingContext && {\n trace: dropUndefinedKeys({ ...dynamicSamplingContext }),\n }),\n };\n}\n","/* eslint-disable max-lines */\nimport { Scope, updateSession } from '@sentry/hub';\nimport {\n Client,\n ClientOptions,\n DataCategory,\n DsnComponents,\n Envelope,\n Event,\n EventDropReason,\n EventHint,\n Integration,\n IntegrationClass,\n Outcome,\n Session,\n SessionAggregates,\n Severity,\n SeverityLevel,\n Transport,\n} from '@sentry/types';\nimport {\n addItemToEnvelope,\n checkOrSetAlreadyCaught,\n createAttachmentEnvelopeItem,\n dateTimestampInSeconds,\n isPlainObject,\n isPrimitive,\n isThenable,\n logger,\n makeDsn,\n normalize,\n rejectedSyncPromise,\n resolvedSyncPromise,\n SentryError,\n SyncPromise,\n truncate,\n uuid4,\n} from '@sentry/utils';\n\nimport { getEnvelopeEndpointWithUrlEncodedAuth } from './api';\nimport { createEventEnvelope, createSessionEnvelope } from './envelope';\nimport { IntegrationIndex, setupIntegrations } from './integration';\n\nconst ALREADY_SEEN_ERROR = \"Not capturing exception because it's already been captured.\";\n\n/**\n * Base implementation for all JavaScript SDK clients.\n *\n * Call the constructor with the corresponding options\n * specific to the client subclass. To access these options later, use\n * {@link Client.getOptions}.\n *\n * If a Dsn is specified in the options, it will be parsed and stored. Use\n * {@link Client.getDsn} to retrieve the Dsn at any moment. In case the Dsn is\n * invalid, the constructor will throw a {@link SentryException}. Note that\n * without a valid Dsn, the SDK will not send any events to Sentry.\n *\n * Before sending an event, it is passed through\n * {@link BaseClient._prepareEvent} to add SDK information and scope data\n * (breadcrumbs and context). To add more custom information, override this\n * method and extend the resulting prepared event.\n *\n * To issue automatically created events (e.g. via instrumentation), use\n * {@link Client.captureEvent}. It will prepare the event and pass it through\n * the callback lifecycle. To issue auto-breadcrumbs, use\n * {@link Client.addBreadcrumb}.\n *\n * @example\n * class NodeClient extends BaseClient<NodeOptions> {\n * public constructor(options: NodeOptions) {\n * super(options);\n * }\n *\n * // ...\n * }\n */\nexport abstract class BaseClient<O extends ClientOptions> implements Client<O> {\n /** Options passed to the SDK. */\n protected readonly _options: O;\n\n /** The client Dsn, if specified in options. Without this Dsn, the SDK will be disabled. */\n protected readonly _dsn?: DsnComponents;\n\n protected readonly _transport?: Transport;\n\n /** Array of set up integrations. */\n protected _integrations: IntegrationIndex = {};\n\n /** Indicates whether this client's integrations have been set up. */\n protected _integrationsInitialized: boolean = false;\n\n /** Number of calls being processed */\n protected _numProcessing: number = 0;\n\n /** Holds flushable */\n private _outcomes: { [key: string]: number } = {};\n\n /**\n * Initializes this client instance.\n *\n * @param options Options for the client.\n */\n protected constructor(options: O) {\n this._options = options;\n if (options.dsn) {\n this._dsn = makeDsn(options.dsn);\n const url = getEnvelopeEndpointWithUrlEncodedAuth(this._dsn, options);\n this._transport = options.transport({\n recordDroppedEvent: this.recordDroppedEvent.bind(this),\n ...options.transportOptions,\n url,\n });\n } else {\n __DEBUG_BUILD__ && logger.warn('No DSN provided, client will not do anything.');\n }\n }\n\n /**\n * @inheritDoc\n */\n // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n public captureException(exception: any, hint?: EventHint, scope?: Scope): string | undefined {\n // ensure we haven't captured this very object before\n if (checkOrSetAlreadyCaught(exception)) {\n __DEBUG_BUILD__ && logger.log(ALREADY_SEEN_ERROR);\n return;\n }\n\n let eventId: string | undefined = hint && hint.event_id;\n\n this._process(\n this.eventFromException(exception, hint)\n .then(event => this._captureEvent(event, hint, scope))\n .then(result => {\n eventId = result;\n }),\n );\n\n return eventId;\n }\n\n /**\n * @inheritDoc\n */\n public captureMessage(\n message: string,\n // eslint-disable-next-line deprecation/deprecation\n level?: Severity | SeverityLevel,\n hint?: EventHint,\n scope?: Scope,\n ): string | undefined {\n let eventId: string | undefined = hint && hint.event_id;\n\n const promisedEvent = isPrimitive(message)\n ? this.eventFromMessage(String(message), level, hint)\n : this.eventFromException(message, hint);\n\n this._process(\n promisedEvent\n .then(event => this._captureEvent(event, hint, scope))\n .then(result => {\n eventId = result;\n }),\n );\n\n return eventId;\n }\n\n /**\n * @inheritDoc\n */\n public captureEvent(event: Event, hint?: EventHint, scope?: Scope): string | undefined {\n // ensure we haven't captured this very object before\n if (hint && hint.originalException && checkOrSetAlreadyCaught(hint.originalException)) {\n __DEBUG_BUILD__ && logger.log(ALREADY_SEEN_ERROR);\n return;\n }\n\n let eventId: string | undefined = hint && hint.event_id;\n\n this._process(\n this._captureEvent(event, hint, scope).then(result => {\n eventId = result;\n }),\n );\n\n return eventId;\n }\n\n /**\n * @inheritDoc\n */\n public captureSession(session: Session): void {\n if (!this._isEnabled()) {\n __DEBUG_BUILD__ && logger.warn('SDK not enabled, will not capture session.');\n return;\n }\n\n if (!(typeof session.release === 'string')) {\n __DEBUG_BUILD__ && logger.warn('Discarded session because of missing or non-string release');\n } else {\n this.sendSession(session);\n // After sending, we set init false to indicate it's not the first occurrence\n updateSession(session, { init: false });\n }\n }\n\n /**\n * @inheritDoc\n */\n public getDsn(): DsnComponents | undefined {\n return this._dsn;\n }\n\n /**\n * @inheritDoc\n */\n public getOptions(): O {\n return this._options;\n }\n\n /**\n * @inheritDoc\n */\n public getTransport(): Transport | undefined {\n return this._transport;\n }\n\n /**\n * @inheritDoc\n */\n public flush(timeout?: number): PromiseLike<boolean> {\n const transport = this._transport;\n if (transport) {\n return this._isClientDoneProcessing(timeout).then(clientFinished => {\n return transport.flush(timeout).then(transportFlushed => clientFinished && transportFlushed);\n });\n } else {\n return resolvedSyncPromise(true);\n }\n }\n\n /**\n * @inheritDoc\n */\n public close(timeout?: number): PromiseLike<boolean> {\n return this.flush(timeout).then(result => {\n this.getOptions().enabled = false;\n return result;\n });\n }\n\n /**\n * Sets up the integrations\n */\n public setupIntegrations(): void {\n if (this._isEnabled() && !this._integrationsInitialized) {\n this._integrations = setupIntegrations(this._options.integrations);\n this._integrationsInitialized = true;\n }\n }\n\n /**\n * Gets an installed integration by its `id`.\n *\n * @returns The installed integration or `undefined` if no integration with that `id` was installed.\n */\n public getIntegrationById(integrationId: string): Integration | undefined {\n return this._integrations[integrationId];\n }\n\n /**\n * @inheritDoc\n */\n public getIntegration<T extends Integration>(integration: IntegrationClass<T>): T | null {\n try {\n return (this._integrations[integration.id] as T) || null;\n } catch (_oO) {\n __DEBUG_BUILD__ && logger.warn(`Cannot retrieve integration ${integration.id} from the current Client`);\n return null;\n }\n }\n\n /**\n * @inheritDoc\n */\n public sendEvent(event: Event, hint: EventHint = {}): void {\n if (this._dsn) {\n let env = createEventEnvelope(event, this._dsn, this._options._metadata, this._options.tunnel);\n\n for (const attachment of hint.attachments || []) {\n env = addItemToEnvelope(\n env,\n createAttachmentEnvelopeItem(\n attachment,\n this._options.transportOptions && this._options.transportOptions.textEncoder,\n ),\n );\n }\n\n this._sendEnvelope(env);\n }\n }\n\n /**\n * @inheritDoc\n */\n public sendSession(session: Session | SessionAggregates): void {\n if (this._dsn) {\n const env = createSessionEnvelope(session, this._dsn, this._options._metadata, this._options.tunnel);\n this._sendEnvelope(env);\n }\n }\n\n /**\n * @inheritDoc\n */\n public recordDroppedEvent(reason: EventDropReason, category: DataCategory): void {\n if (this._options.sendClientReports) {\n // We want to track each category (error, transaction, session) separately\n // but still keep the distinction between different type of outcomes.\n // We could use nested maps, but it's much easier to read and type this way.\n // A correct type for map-based implementation if we want to go that route\n // would be `Partial<Record<SentryRequestType, Partial<Record<Outcome, number>>>>`\n // With typescript 4.1 we could even use template literal types\n const key = `${reason}:${category}`;\n __DEBUG_BUILD__ && logger.log(`Adding outcome: \"${key}\"`);\n\n // The following works because undefined + 1 === NaN and NaN is falsy\n this._outcomes[key] = this._outcomes[key] + 1 || 1;\n }\n }\n\n /** Updates existing session based on the provided event */\n protected _updateSessionFromEvent(session: Session, event: Event): void {\n let crashed = false;\n let errored = false;\n const exceptions = event.exception && event.exception.values;\n\n if (exceptions) {\n errored = true;\n\n for (const ex of exceptions) {\n const mechanism = ex.mechanism;\n if (mechanism && mechanism.handled === false) {\n crashed = true;\n break;\n }\n }\n }\n\n // A session is updated and that session update is sent in only one of the two following scenarios:\n // 1. Session with non terminal status and 0 errors + an error occurred -> Will set error count to 1 and send update\n // 2. Session with non terminal status and 1 error + a crash occurred -> Will set status crashed and send update\n const sessionNonTerminal = session.status === 'ok';\n const shouldUpdateAndSend = (sessionNonTerminal && session.errors === 0) || (sessionNonTerminal && crashed);\n\n if (shouldUpdateAndSend) {\n updateSession(session, {\n ...(crashed && { status: 'crashed' }),\n errors: session.errors || Number(errored || crashed),\n });\n this.captureSession(session);\n }\n }\n\n /**\n * Determine if the client is finished processing. Returns a promise because it will wait `timeout` ms before saying\n * \"no\" (resolving to `false`) in order to give the client a chance to potentially finish first.\n *\n * @param timeout The time, in ms, after which to resolve to `false` if the client is still busy. Passing `0` (or not\n * passing anything) will make the promise wait as long as it takes for processing to finish before resolving to\n * `true`.\n * @returns A promise which will resolve to `true` if processing is already done or finishes before the timeout, and\n * `false` otherwise\n */\n protected _isClientDoneProcessing(timeout?: number): PromiseLike<boolean> {\n return new SyncPromise(resolve => {\n let ticked: number = 0;\n const tick: number = 1;\n\n const interval = setInterval(() => {\n if (this._numProcessing == 0) {\n clearInterval(interval);\n resolve(true);\n } else {\n ticked += tick;\n if (timeout && ticked >= timeout) {\n clearInterval(interval);\n resolve(false);\n }\n }\n }, tick);\n });\n }\n\n /** Determines whether this SDK is enabled and a valid Dsn is present. */\n protected _isEnabled(): boolean {\n return this.getOptions().enabled !== false && this._dsn !== undefined;\n }\n\n /**\n * Adds common information to events.\n *\n * The information includes release and environment from `options`,\n * breadcrumbs and context (extra, tags and user) from the scope.\n *\n * Information that is already present in the event is never overwritten. For\n * nested objects, such as the context, keys are merged.\n *\n * @param event The original event.\n * @param hint May contain additional information about the original exception.\n * @param scope A scope containing event metadata.\n * @returns A new event with more information.\n */\n protected _prepareEvent(event: Event, hint: EventHint, scope?: Scope): PromiseLike<Event | null> {\n const { normalizeDepth = 3, normalizeMaxBreadth = 1_000 } = this.getOptions();\n const prepared: Event = {\n ...event,\n event_id: event.event_id || hint.event_id || uuid4(),\n timestamp: event.timestamp || dateTimestampInSeconds(),\n };\n\n this._applyClientOptions(prepared);\n this._applyIntegrationsMetadata(prepared);\n\n // If we have scope given to us, use it as the base for further modifications.\n // This allows us to prevent unnecessary copying of data if `captureContext` is not provided.\n let finalScope = scope;\n if (hint.captureContext) {\n finalScope = Scope.clone(finalScope).update(hint.captureContext);\n }\n\n // We prepare the result here with a resolved Event.\n let result = resolvedSyncPromise<Event | null>(prepared);\n\n // This should be the last thing called, since we want that\n // {@link Hub.addEventProcessor} gets the finished prepared event.\n if (finalScope) {\n // Collect attachments from the hint and scope\n const attachments = [...(hint.attachments || []), ...finalScope.getAttachments()];\n\n if (attachments.length) {\n hint.attachments = attachments;\n }\n\n // In case we have a hub we reassign it.\n result = finalScope.applyToEvent(prepared, hint);\n }\n\n return result.then(evt => {\n if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {\n return this._normalizeEvent(evt, normalizeDepth, normalizeMaxBreadth);\n }\n return evt;\n });\n }\n\n /**\n * Applies `normalize` function on necessary `Event` attributes to make them safe for serialization.\n * Normalized keys:\n * - `breadcrumbs.data`\n * - `user`\n * - `contexts`\n * - `extra`\n * @param event Event\n * @returns Normalized event\n */\n protected _normalizeEvent(event: Event | null, depth: number, maxBreadth: number): Event | null {\n if (!event) {\n return null;\n }\n\n const normalized: Event = {\n ...event,\n ...(event.breadcrumbs && {\n breadcrumbs: event.breadcrumbs.map(b => ({\n ...b,\n ...(b.data && {\n data: normalize(b.data, depth, maxBreadth),\n }),\n })),\n }),\n ...(event.user && {\n user: normalize(event.user, depth, maxBreadth),\n }),\n ...(event.contexts && {\n contexts: normalize(event.contexts, depth, maxBreadth),\n }),\n ...(event.extra && {\n extra: normalize(event.extra, depth, maxBreadth),\n }),\n };\n\n // event.contexts.trace stores information about a Transaction. Similarly,\n // event.spans[] stores information about child Spans. Given that a\n // Transaction is conceptually a Span, normalization should apply to both\n // Transactions and Spans consistently.\n // For now the decision is to skip normalization of Transactions and Spans,\n // so this block overwrites the normalized event to add back the original\n // Transaction information prior to normalization.\n if (event.contexts && event.contexts.trace && normalized.contexts) {\n normalized.contexts.trace = event.contexts.trace;\n\n // event.contexts.trace.data may contain circular/dangerous data so we need to normalize it\n if (event.contexts.trace.data) {\n normalized.contexts.trace.data = normalize(event.contexts.trace.data, depth, maxBreadth);\n }\n }\n\n // event.spans[].data may contain circular/dangerous data so we need to normalize it\n if (event.spans) {\n normalized.spans = event.spans.map(span => {\n // We cannot use the spread operator here because `toJSON` on `span` is non-enumerable\n if (span.data) {\n span.data = normalize(span.data, depth, maxBreadth);\n }\n return span;\n });\n }\n\n return normalized;\n }\n\n /**\n * Enhances event using the client configuration.\n * It takes care of all \"static\" values like environment, release and `dist`,\n * as well as truncating overly long values.\n * @param event event instance to be enhanced\n */\n protected _applyClientOptions(event: Event): void {\n const options = this.getOptions();\n const { environment, release, dist, maxValueLength = 250 } = options;\n\n if (!('environment' in event)) {\n event.environment = 'environment' in options ? environment : 'production';\n }\n\n if (event.release === undefined && release !== undefined) {\n event.release = release;\n }\n\n if (event.dist === undefined && dist !== undefined) {\n event.dist = dist;\n }\n\n if (event.message) {\n event.message = truncate(event.message, maxValueLength);\n }\n\n const exception = event.exception && event.exception.values && event.exception.values[0];\n if (exception && exception.value) {\n exception.value = truncate(exception.value, maxValueLength);\n }\n\n const request = event.request;\n if (request && request.url) {\n request.url = truncate(request.url, maxValueLength);\n }\n }\n\n /**\n * This function adds all used integrations to the SDK info in the event.\n * @param event The event that will be filled with all integrations.\n */\n protected _applyIntegrationsMetadata(event: Event): void {\n const integrationsArray = Object.keys(this._integrations);\n if (integrationsArray.length > 0) {\n event.sdk = event.sdk || {};\n event.sdk.integrations = [...(event.sdk.integrations || []), ...integrationsArray];\n }\n }\n\n /**\n * Processes the event and logs an error in case of rejection\n * @param event\n * @param hint\n * @param scope\n */\n protected _captureEvent(event: Event, hint: EventHint = {}, scope?: Scope): PromiseLike<string | undefined> {\n return this._processEvent(event, hint, scope).then(\n finalEvent => {\n return finalEvent.event_id;\n },\n reason => {\n if (__DEBUG_BUILD__) {\n // If something's gone wrong, log the error as a warning. If it's just us having used a `SentryError` for\n // control flow, log just the message (no stack) as a log-level log.\n const sentryError = reason as SentryError;\n if (sentryError.logLevel === 'log') {\n logger.log(sentryError.message);\n } else {\n logger.warn(sentryError);\n }\n }\n return undefined;\n },\n );\n }\n\n /**\n * Processes an event (either error or message) and sends it to Sentry.\n *\n * This also adds breadcrumbs and context information to the event. However,\n * platform specific meta data (such as the User's IP address) must be added\n * by the SDK implementor.\n *\n *\n * @param event The event to send to Sentry.\n * @param hint May contain additional information about the original exception.\n * @param scope A scope containing event metadata.\n * @returns A SyncPromise that resolves with the event or rejects in case event was/will not be send.\n */\n protected _processEvent(event: Event, hint: EventHint, scope?: Scope): PromiseLike<Event> {\n const { beforeSend, sampleRate } = this.getOptions();\n\n if (!this._isEnabled()) {\n return rejectedSyncPromise(new SentryError('SDK not enabled, will not capture event.', 'log'));\n }\n\n const isTransaction = event.type === 'transaction';\n // 1.0 === 100% events are sent\n // 0.0 === 0% events are sent\n // Sampling for transaction happens somewhere else\n if (!isTransaction && typeof sampleRate === 'number' && Math.random() > sampleRate) {\n this.recordDroppedEvent('sample_rate', 'error');\n return rejectedSyncPromise(\n new SentryError(\n `Discarding event because it's not included in the random sample (sampling rate = ${sampleRate})`,\n 'log',\n ),\n );\n }\n\n return this._prepareEvent(event, hint, scope)\n .then(prepared => {\n if (prepared === null) {\n this.recordDroppedEvent('event_processor', event.type || 'error');\n throw new SentryError('An event processor returned null, will not send event.', 'log');\n }\n\n const isInternalException = hint.data && (hint.data as { __sentry__: boolean }).__sentry__ === true;\n if (isInternalException || isTransaction || !beforeSend) {\n return prepared;\n }\n\n const beforeSendResult = beforeSend(prepared, hint);\n return _ensureBeforeSendRv(beforeSendResult);\n })\n .then(processedEvent => {\n if (processedEvent === null) {\n this.recordDroppedEvent('before_send', event.type || 'error');\n throw new SentryError('`beforeSend` returned `null`, will not send event.', 'log');\n }\n\n const session = scope && scope.getSession();\n if (!isTransaction && session) {\n this._updateSessionFromEvent(session, processedEvent);\n }\n\n // None of the Sentry built event processor will update transaction name,\n // so if the transaction name has been changed by an event processor, we know\n // it has to come from custom event processor added by a user\n const transactionInfo = processedEvent.transaction_info;\n if (isTransaction && transactionInfo && processedEvent.transaction !== event.transaction) {\n const source = 'custom';\n processedEvent.transaction_info = {\n ...transactionInfo,\n source,\n changes: [\n ...transactionInfo.changes,\n {\n source,\n // use the same timestamp as the processed event.\n timestamp: processedEvent.timestamp as number,\n propagations: transactionInfo.propagations,\n },\n ],\n };\n }\n\n this.sendEvent(processedEvent, hint);\n return processedEvent;\n })\n .then(null, reason => {\n if (reason instanceof SentryError) {\n throw reason;\n }\n\n this.captureException(reason, {\n data: {\n __sentry__: true,\n },\n originalException: reason as Error,\n });\n throw new SentryError(\n `Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.\\nReason: ${reason}`,\n );\n });\n }\n\n /**\n * Occupies the client with processing and event\n */\n protected _process<T>(promise: PromiseLike<T>): void {\n this._numProcessing += 1;\n void promise.then(\n value => {\n this._numProcessing -= 1;\n return value;\n },\n reason => {\n this._numProcessing -= 1;\n return reason;\n },\n );\n }\n\n /**\n * @inheritdoc\n */\n protected _sendEnvelope(envelope: Envelope): void {\n if (this._transport && this._dsn) {\n this._transport.send(envelope).then(null, reason => {\n __DEBUG_BUILD__ && logger.error('Error while sending event:', reason);\n });\n } else {\n __DEBUG_BUILD__ && logger.error('Transport disabled');\n }\n }\n\n /**\n * Clears outcomes on this client and returns them.\n */\n protected _clearOutcomes(): Outcome[] {\n const outcomes = this._outcomes;\n this._outcomes = {};\n return Object.keys(outcomes).map(key => {\n const [reason, category] = key.split(':') as [EventDropReason, DataCategory];\n return {\n reason,\n category,\n quantity: outcomes[key],\n };\n });\n }\n\n /**\n * @inheritDoc\n */\n // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n public abstract eventFromException(_exception: any, _hint?: EventHint): PromiseLike<Event>;\n\n /**\n * @inheritDoc\n */\n public abstract eventFromMessage(\n _message: string,\n // eslint-disable-next-line deprecation/deprecation\n _level?: Severity | SeverityLevel,\n _hint?: EventHint,\n ): PromiseLike<Event>;\n}\n\n/**\n * Verifies that return value of configured `beforeSend` is of expected type.\n */\nfunction _ensureBeforeSendRv(rv: PromiseLike<Event | null> | Event | null): PromiseLike<Event | null> | Event | null {\n const nullErr = '`beforeSend` method has to return `null` or a valid event.';\n if (isThenable(rv)) {\n return rv.then(\n event => {\n if (!(isPlainObject(event) || event === null)) {\n throw new SentryError(nullErr);\n }\n return event;\n },\n e => {\n throw new SentryError(`beforeSend rejected with ${e}`);\n },\n );\n } else if (!(isPlainObject(rv) || rv === null)) {\n throw new SentryError(nullErr);\n }\n return rv;\n}\n","import { addGlobalEventProcessor, getCurrentHub } from '@sentry/hub';\nimport { Integration, Options } from '@sentry/types';\nimport { arrayify, logger } from '@sentry/utils';\n\ndeclare module '@sentry/types' {\n interface Integration {\n isDefaultInstance?: boolean;\n }\n}\n\nexport const installedIntegrations: string[] = [];\n\n/** Map of integrations assigned to a client */\nexport type IntegrationIndex = {\n [key: string]: Integration;\n};\n\n/**\n * Remove duplicates from the given array, preferring the last instance of any duplicate. Not guaranteed to\n * preseve the order of integrations in the array.\n *\n * @private\n */\nfunction filterDuplicates(integrations: Integration[]): Integration[] {\n const integrationsByName: { [key: string]: Integration } = {};\n\n integrations.forEach(currentInstance => {\n const { name } = currentInstance;\n\n const existingInstance = integrationsByName[name];\n\n // We want integrations later in the array to overwrite earlier ones of the same type, except that we never want a\n // default instance to overwrite an existing user instance\n if (existingInstance && !existingInstance.isDefaultInstance && currentInstance.isDefaultInstance) {\n return;\n }\n\n integrationsByName[name] = currentInstance;\n });\n\n return Object.values(integrationsByName);\n}\n\n/** Gets integrations to install */\nexport function getIntegrationsToSetup(options: Options): Integration[] {\n const defaultIntegrations = options.defaultIntegrations || [];\n const userIntegrations = options.integrations;\n\n // We flag default instances, so that later we can tell them apart from any user-created instances of the same class\n defaultIntegrations.forEach(integration => {\n integration.isDefaultInstance = true;\n });\n\n let integrations: Integration[];\n\n if (Array.isArray(userIntegrations)) {\n integrations = [...defaultIntegrations, ...userIntegrations];\n } else if (typeof userIntegrations === 'function') {\n integrations = arrayify(userIntegrations(defaultIntegrations));\n } else {\n integrations = defaultIntegrations;\n }\n\n const finalIntegrations = filterDuplicates(integrations);\n\n // The `Debug` integration prints copies of the `event` and `hint` which will be passed to `beforeSend`. It therefore\n // has to run after all other integrations, so that the changes of all event processors will be reflected in the\n // printed values. For lack of a more elegant way to guarantee that, we therefore locate it and, assuming it exists,\n // pop it out of its current spot and shove it onto the end of the array.\n const debugIndex = finalIntegrations.findIndex(integration => integration.name === 'Debug');\n if (debugIndex !== -1) {\n const [debugInstance] = finalIntegrations.splice(debugIndex, 1);\n finalIntegrations.push(debugInstance);\n }\n\n return finalIntegrations;\n}\n\n/**\n * Given a list of integration instances this installs them all. When `withDefaults` is set to `true` then all default\n * integrations are added unless they were already provided before.\n * @param integrations array of integration instances\n * @param withDefault should enable default integrations\n */\nexport function setupIntegrations(integrations: Integration[]): IntegrationIndex {\n const integrationIndex: IntegrationIndex = {};\n\n integrations.forEach(integration => {\n integrationIndex[integration.name] = integration;\n\n if (installedIntegrations.indexOf(integration.name) === -1) {\n integration.setupOnce(addGlobalEventProcessor, getCurrentHub);\n installedIntegrations.push(integration.name);\n __DEBUG_BUILD__ && logger.log(`Integration installed: ${integration.name}`);\n }\n });\n\n return integrationIndex;\n}\n","import { Integration, WrappedFunction } from '@sentry/types';\nimport { getOriginalFunction } from '@sentry/utils';\n\nlet originalFunctionToString: () => void;\n\n/** Patch toString calls to return proper name for wrapped functions */\nexport class FunctionToString implements Integration {\n /**\n * @inheritDoc\n */\n public static id: string = 'FunctionToString';\n\n /**\n * @inheritDoc\n */\n public name: string = FunctionToString.id;\n\n /**\n * @inheritDoc\n */\n public setupOnce(): void {\n // eslint-disable-next-line @typescript-eslint/unbound-method\n originalFunctionToString = Function.prototype.toString;\n\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n Function.prototype.toString = function (this: WrappedFunction, ...args: any[]): string {\n const context = getOriginalFunction(this) || this;\n return originalFunctionToString.apply(context, args);\n };\n }\n}\n","import { Event, EventProcessor, Hub, Integration, StackFrame } from '@sentry/types';\nimport { getEventDescription, isMatchingPattern, logger } from '@sentry/utils';\n\n// \"Script error.\" is hard coded into browsers for errors that it can't read.\n// this is the result of a script being pulled in from an external domain and CORS.\nconst DEFAULT_IGNORE_ERRORS = [/^Script error\\.?$/, /^Javascript error: Script error\\.? on line 0$/];\n\n/** Options for the InboundFilters integration */\nexport interface InboundFiltersOptions {\n allowUrls: Array<string | RegExp>;\n denyUrls: Array<string | RegExp>;\n ignoreErrors: Array<string | RegExp>;\n ignoreInternal: boolean;\n}\n\n/** Inbound filters configurable by the user */\nexport class InboundFilters implements Integration {\n /**\n * @inheritDoc\n */\n public static id: string = 'InboundFilters';\n\n /**\n * @inheritDoc\n */\n public name: string = InboundFilters.id;\n\n public constructor(private readonly _options: Partial<InboundFiltersOptions> = {}) {}\n\n /**\n * @inheritDoc\n */\n public setupOnce(addGlobalEventProcessor: (processor: EventProcessor) => void, getCurrentHub: () => Hub): void {\n const eventProcess: EventProcessor = (event: Event) => {\n const hub = getCurrentHub();\n if (hub) {\n const self = hub.getIntegration(InboundFilters);\n if (self) {\n const client = hub.getClient();\n const clientOptions = client ? client.getOptions() : {};\n const options = _mergeOptions(self._options, clientOptions);\n return _shouldDropEvent(event, options) ? null : event;\n }\n }\n return event;\n };\n\n eventProcess.id = this.name;\n addGlobalEventProcessor(eventProcess);\n }\n}\n\n/** JSDoc */\nexport function _mergeOptions(\n internalOptions: Partial<InboundFiltersOptions> = {},\n clientOptions: Partial<InboundFiltersOptions> = {},\n): Partial<InboundFiltersOptions> {\n return {\n allowUrls: [...(internalOptions.allowUrls || []), ...(clientOptions.allowUrls || [])],\n denyUrls: [...(internalOptions.denyUrls || []), ...(clientOptions.denyUrls || [])],\n ignoreErrors: [\n ...(internalOptions.ignoreErrors || []),\n ...(clientOptions.ignoreErrors || []),\n ...DEFAULT_IGNORE_ERRORS,\n ],\n ignoreInternal: internalOptions.ignoreInternal !== undefined ? internalOptions.ignoreInternal : true,\n };\n}\n\n/** JSDoc */\nexport function _shouldDropEvent(event: Event, options: Partial<InboundFiltersOptions>): boolean {\n if (options.ignoreInternal && _isSentryError(event)) {\n __DEBUG_BUILD__ &&\n logger.warn(`Event dropped due to being internal Sentry Error.\\nEvent: ${getEventDescription(event)}`);\n return true;\n }\n if (_isIgnoredError(event, options.ignoreErrors)) {\n __DEBUG_BUILD__ &&\n logger.warn(\n `Event dropped due to being matched by \\`ignoreErrors\\` option.\\nEvent: ${getEventDescription(event)}`,\n );\n return true;\n }\n if (_isDeniedUrl(event, options.denyUrls)) {\n __DEBUG_BUILD__ &&\n logger.warn(\n `Event dropped due to being matched by \\`denyUrls\\` option.\\nEvent: ${getEventDescription(\n event,\n )}.\\nUrl: ${_getEventFilterUrl(event)}`,\n );\n return true;\n }\n if (!_isAllowedUrl(event, options.allowUrls)) {\n __DEBUG_BUILD__ &&\n logger.warn(\n `Event dropped due to not being matched by \\`allowUrls\\` option.\\nEvent: ${getEventDescription(\n event,\n )}.\\nUrl: ${_getEventFilterUrl(event)}`,\n );\n return true;\n }\n return false;\n}\n\nfunction _isIgnoredError(event: Event, ignoreErrors?: Array<string | RegExp>): boolean {\n if (!ignoreErrors || !ignoreErrors.length) {\n return false;\n }\n\n return _getPossibleEventMessages(event).some(message =>\n ignoreErrors.some(pattern => isMatchingPattern(message, pattern)),\n );\n}\n\nfunction _isDeniedUrl(event: Event, denyUrls?: Array<string | RegExp>): boolean {\n // TODO: Use Glob instead?\n if (!denyUrls || !denyUrls.length) {\n return false;\n }\n const url = _getEventFilterUrl(event);\n return !url ? false : denyUrls.some(pattern => isMatchingPattern(url, pattern));\n}\n\nfunction _isAllowedUrl(event: Event, allowUrls?: Array<string | RegExp>): boolean {\n // TODO: Use Glob instead?\n if (!allowUrls || !allowUrls.length) {\n return true;\n }\n const url = _getEventFilterUrl(event);\n return !url ? true : allowUrls.some(pattern => isMatchingPattern(url, pattern));\n}\n\nfunction _getPossibleEventMessages(event: Event): string[] {\n if (event.message) {\n return [event.message];\n }\n if (event.exception) {\n try {\n const { type = '', value = '' } = (event.exception.values && event.exception.values[0]) || {};\n return [`${value}`, `${type}: ${value}`];\n } catch (oO) {\n __DEBUG_BUILD__ && logger.error(`Cannot extract message for event ${getEventDescription(event)}`);\n return [];\n }\n }\n return [];\n}\n\nfunction _isSentryError(event: Event): boolean {\n try {\n // @ts-ignore can't be a sentry error if undefined\n // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n return event.exception.values[0].type === 'SentryError';\n } catch (e) {\n // ignore\n }\n return false;\n}\n\nfunction _getLastValidUrl(frames: StackFrame[] = []): string | null {\n for (let i = frames.length - 1; i >= 0; i--) {\n const frame = frames[i];\n\n if (frame && frame.filename !== '<anonymous>' && frame.filename !== '[native code]') {\n return frame.filename || null;\n }\n }\n\n return null;\n}\n\nfunction _getEventFilterUrl(event: Event): string | null {\n try {\n let frames;\n try {\n // @ts-ignore we only care about frames if the whole thing here is defined\n frames = event.exception.values[0].stacktrace.frames;\n } catch (e) {\n // ignore\n }\n return frames ? _getLastValidUrl(frames) : null;\n } catch (oO) {\n __DEBUG_BUILD__ && logger.error(`Cannot extract url for event ${getEventDescription(event)}`);\n return null;\n }\n}\n","import { getCurrentHub } from '@sentry/hub';\nimport { Client, ClientOptions } from '@sentry/types';\nimport { logger } from '@sentry/utils';\n\n/** A class object that can instantiate Client objects. */\nexport type ClientClass<F extends Client, O extends ClientOptions> = new (options: O) => F;\n\n/**\n * Internal function to create a new SDK client instance. The client is\n * installed and then bound to the current scope.\n *\n * @param clientClass The client class to instantiate.\n * @param options Options to pass to the client.\n */\nexport function initAndBind<F extends Client, O extends ClientOptions>(\n clientClass: ClientClass<F, O>,\n options: O,\n): void {\n if (options.debug === true) {\n if (__DEBUG_BUILD__) {\n logger.enable();\n } else {\n // use `console.warn` rather than `logger.warn` since by non-debug bundles have all `logger.x` statements stripped\n // eslint-disable-next-line no-console\n console.warn('[Sentry] Cannot initialize SDK with `debug` option using a non-debug bundle.');\n }\n }\n const hub = getCurrentHub();\n const scope = hub.getScope();\n if (scope) {\n scope.update(options.initialScope);\n }\n\n const client = new clientClass(options);\n hub.bindClient(client);\n}\n","import {\n Envelope,\n EnvelopeItem,\n EventDropReason,\n InternalBaseTransportOptions,\n Transport,\n TransportRequestExecutor,\n} from '@sentry/types';\nimport {\n createEnvelope,\n envelopeItemTypeToDataCategory,\n forEachEnvelopeItem,\n isRateLimited,\n logger,\n makePromiseBuffer,\n PromiseBuffer,\n RateLimits,\n resolvedSyncPromise,\n SentryError,\n serializeEnvelope,\n updateRateLimits,\n} from '@sentry/utils';\n\nexport const DEFAULT_TRANSPORT_BUFFER_SIZE = 30;\n\n/**\n * Creates an instance of a Sentry `Transport`\n *\n * @param options\n * @param makeRequest\n */\nexport function createTransport(\n options: InternalBaseTransportOptions,\n makeRequest: TransportRequestExecutor,\n buffer: PromiseBuffer<void> = makePromiseBuffer(options.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE),\n): Transport {\n let rateLimits: RateLimits = {};\n\n const flush = (timeout?: number): PromiseLike<boolean> => buffer.drain(timeout);\n\n function send(envelope: Envelope): PromiseLike<void> {\n const filteredEnvelopeItems: EnvelopeItem[] = [];\n\n // Drop rate limited items from envelope\n forEachEnvelopeItem(envelope, (item, type) => {\n const envelopeItemDataCategory = envelopeItemTypeToDataCategory(type);\n if (isRateLimited(rateLimits, envelopeItemDataCategory)) {\n options.recordDroppedEvent('ratelimit_backoff', envelopeItemDataCategory);\n } else {\n filteredEnvelopeItems.push(item);\n }\n });\n\n // Skip sending if envelope is empty after filtering out rate limited events\n if (filteredEnvelopeItems.length === 0) {\n return resolvedSyncPromise();\n }\n\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n const filteredEnvelope: Envelope = createEnvelope(envelope[0], filteredEnvelopeItems as any);\n\n // Creates client report for each item in an envelope\n const recordEnvelopeLoss = (reason: EventDropReason): void => {\n forEachEnvelopeItem(filteredEnvelope, (_, type) => {\n options.recordDroppedEvent(reason, envelopeItemTypeToDataCategory(type));\n });\n };\n\n const requestTask = (): PromiseLike<void> =>\n makeRequest({ body: serializeEnvelope(filteredEnvelope, options.textEncoder) }).then(\n response => {\n // We don't want to throw on NOK responses, but we want to at least log them\n if (response.statusCode !== undefined && (response.statusCode < 200 || response.statusCode >= 300)) {\n __DEBUG_BUILD__ && logger.warn(`Sentry responded with status code ${response.statusCode} to sent event.`);\n }\n\n rateLimits = updateRateLimits(rateLimits, response);\n },\n error => {\n __DEBUG_BUILD__ && logger.error('Failed while sending event:', error);\n recordEnvelopeLoss('network_error');\n },\n );\n\n return buffer.add(requestTask).then(\n result => result,\n error => {\n if (error instanceof SentryError) {\n __DEBUG_BUILD__ && logger.error('Skipped sending event because buffer is full.');\n recordEnvelopeLoss('queue_overflow');\n return resolvedSyncPromise();\n } else {\n throw error;\n }\n },\n );\n }\n\n return {\n send,\n flush,\n };\n}\n","import {\n Breadcrumb,\n CaptureContext,\n CustomSamplingContext,\n Event,\n EventHint,\n Extra,\n Extras,\n Primitive,\n Severity,\n SeverityLevel,\n TransactionContext,\n User,\n} from '@sentry/types';\n\nimport { getCurrentHub, Hub } from './hub';\nimport { Scope } from './scope';\n\n// Note: All functions in this file are typed with a return value of `ReturnType<Hub[HUB_FUNCTION]>`,\n// where HUB_FUNCTION is some method on the Hub class.\n//\n// This is done to make sure the top level SDK methods stay in sync with the hub methods.\n// Although every method here has an explicit return type, some of them (that map to void returns) do not\n// contain `return` keywords. This is done to save on bundle size, as `return` is not minifiable.\n\n/**\n * Captures an exception event and sends it to Sentry.\n *\n * @param exception An exception-like object.\n * @param captureContext Additional scope data to apply to exception event.\n * @returns The generated eventId.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\nexport function captureException(exception: any, captureContext?: CaptureContext): ReturnType<Hub['captureException']> {\n return getCurrentHub().captureException(exception, { captureContext });\n}\n\n/**\n * Captures a message event and sends it to Sentry.\n *\n * @param message The message to send to Sentry.\n * @param Severity Define the level of the message.\n * @returns The generated eventId.\n */\nexport function captureMessage(\n message: string,\n // eslint-disable-next-line deprecation/deprecation\n captureContext?: CaptureContext | Severity | SeverityLevel,\n): ReturnType<Hub['captureMessage']> {\n // This is necessary to provide explicit scopes upgrade, without changing the original\n // arity of the `captureMessage(message, level)` method.\n const level = typeof captureContext === 'string' ? captureContext : undefined;\n const context = typeof captureContext !== 'string' ? { captureContext } : undefined;\n return getCurrentHub().captureMessage(message, level, context);\n}\n\n/**\n * Captures a manually created event and sends it to Sentry.\n *\n * @param event The event to send to Sentry.\n * @returns The generated eventId.\n */\nexport function captureEvent(event: Event, hint?: EventHint): ReturnType<Hub['captureEvent']> {\n return getCurrentHub().captureEvent(event, hint);\n}\n\n/**\n * Callback to set context information onto the scope.\n * @param callback Callback function that receives Scope.\n */\nexport function configureScope(callback: (scope: Scope) => void): ReturnType<Hub['configureScope']> {\n getCurrentHub().configureScope(callback);\n}\n\n/**\n * Records a new breadcrumb which will be attached to future events.\n *\n * Breadcrumbs will be added to subsequent events to provide more context on\n * user's actions prior to an error or crash.\n *\n * @param breadcrumb The breadcrumb to record.\n */\nexport function addBreadcrumb(breadcrumb: Breadcrumb): ReturnType<Hub['addBreadcrumb']> {\n getCurrentHub().addBreadcrumb(breadcrumb);\n}\n\n/**\n * Sets context data with the given name.\n * @param name of the context\n * @param context Any kind of data. This data will be normalized.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function setContext(name: string, context: { [key: string]: any } | null): ReturnType<Hub['setContext']> {\n getCurrentHub().setContext(name, context);\n}\n\n/**\n * Set an object that will be merged sent as extra data with the event.\n * @param extras Extras object to merge into current context.\n */\nexport function setExtras(extras: Extras): ReturnType<Hub['setExtras']> {\n getCurrentHub().setExtras(extras);\n}\n\n/**\n * Set key:value that will be sent as extra data with the event.\n * @param key String of extra\n * @param extra Any kind of data. This data will be normalized.\n */\nexport function setExtra(key: string, extra: Extra): ReturnType<Hub['setExtra']> {\n getCurrentHub().setExtra(key, extra);\n}\n\n/**\n * Set an object that will be merged sent as tags data with the event.\n * @param tags Tags context object to merge into current context.\n */\nexport function setTags(tags: { [key: string]: Primitive }): ReturnType<Hub['setTags']> {\n getCurrentHub().setTags(tags);\n}\n\n/**\n * Set key:value that will be sent as tags data with the event.\n *\n * Can also be used to unset a tag, by passing `undefined`.\n *\n * @param key String key of tag\n * @param value Value of tag\n */\nexport function setTag(key: string, value: Primitive): ReturnType<Hub['setTag']> {\n getCurrentHub().setTag(key, value);\n}\n\n/**\n * Updates user context information for future events.\n *\n * @param user User context object to be set in the current context. Pass `null` to unset the user.\n */\nexport function setUser(user: User | null): ReturnType<Hub['setUser']> {\n getCurrentHub().setUser(user);\n}\n\n/**\n * Creates a new scope with and executes the given operation within.\n * The scope is automatically removed once the operation\n * finishes or throws.\n *\n * This is essentially a convenience function for:\n *\n * pushScope();\n * callback();\n * popScope();\n *\n * @param callback that will be enclosed into push/popScope.\n */\nexport function withScope(callback: (scope: Scope) => void): ReturnType<Hub['withScope']> {\n getCurrentHub().withScope(callback);\n}\n\n/**\n * Starts a new `Transaction` and returns it. This is the entry point to manual tracing instrumentation.\n *\n * A tree structure can be built by adding child spans to the transaction, and child spans to other spans. To start a\n * new child span within the transaction or any span, call the respective `.startChild()` method.\n *\n * Every child span must be finished before the transaction is finished, otherwise the unfinished spans are discarded.\n *\n * The transaction must be finished with a call to its `.finish()` method, at which point the transaction with all its\n * finished child spans will be sent to Sentry.\n *\n * NOTE: This function should only be used for *manual* instrumentation. Auto-instrumentation should call\n * `startTransaction` directly on the hub.\n *\n * @param context Properties of the new `Transaction`.\n * @param customSamplingContext Information given to the transaction sampling function (along with context-dependent\n * default values). See {@link Options.tracesSampler}.\n *\n * @returns The transaction which was just started\n */\nexport function startTransaction(\n context: TransactionContext,\n customSamplingContext?: CustomSamplingContext,\n): ReturnType<Hub['startTransaction']> {\n return getCurrentHub().startTransaction({ ...context }, customSamplingContext);\n}\n","/* eslint-disable max-lines */\nimport {\n Breadcrumb,\n BreadcrumbHint,\n Client,\n CustomSamplingContext,\n Event,\n EventHint,\n Extra,\n Extras,\n Hub as HubInterface,\n Integration,\n IntegrationClass,\n Primitive,\n Session,\n SessionContext,\n Severity,\n SeverityLevel,\n Transaction,\n TransactionContext,\n User,\n} from '@sentry/types';\nimport {\n consoleSandbox,\n dateTimestampInSeconds,\n getGlobalObject,\n getGlobalSingleton,\n isNodeEnv,\n logger,\n uuid4,\n} from '@sentry/utils';\n\nimport { Scope } from './scope';\nimport { closeSession, makeSession, updateSession } from './session';\n\n/**\n * API compatibility version of this hub.\n *\n * WARNING: This number should only be increased when the global interface\n * changes and new methods are introduced.\n *\n * @hidden\n */\nexport const API_VERSION = 4;\n\n/**\n * Default maximum number of breadcrumbs added to an event. Can be overwritten\n * with {@link Options.maxBreadcrumbs}.\n */\nconst DEFAULT_BREADCRUMBS = 100;\n\n/**\n * A layer in the process stack.\n * @hidden\n */\nexport interface Layer {\n client?: Client;\n scope?: Scope;\n}\n\n/**\n * An object that contains a hub and maintains a scope stack.\n * @hidden\n */\nexport interface Carrier {\n __SENTRY__?: {\n hub?: Hub;\n /**\n * Extra Hub properties injected by various SDKs\n */\n integrations?: Integration[];\n extensions?: {\n /** Hack to prevent bundlers from breaking our usage of the domain package in the cross-platform Hub package */\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n domain?: { [key: string]: any };\n } & {\n /** Extension methods for the hub, which are bound to the current Hub instance */\n // eslint-disable-next-line @typescript-eslint/ban-types\n [key: string]: Function;\n };\n };\n}\n\n/**\n * @inheritDoc\n */\nexport class Hub implements HubInterface {\n /** Is a {@link Layer}[] containing the client and scope */\n private readonly _stack: Layer[] = [{}];\n\n /** Contains the last event id of a captured event. */\n private _lastEventId?: string;\n\n /**\n * Creates a new instance of the hub, will push one {@link Layer} into the\n * internal stack on creation.\n *\n * @param client bound to the hub.\n * @param scope bound to the hub.\n * @param version number, higher number means higher priority.\n */\n public constructor(client?: Client, scope: Scope = new Scope(), private readonly _version: number = API_VERSION) {\n this.getStackTop().scope = scope;\n if (client) {\n this.bindClient(client);\n }\n }\n\n /**\n * @inheritDoc\n */\n public isOlderThan(version: number): boolean {\n return this._version < version;\n }\n\n /**\n * @inheritDoc\n */\n public bindClient(client?: Client): void {\n const top = this.getStackTop();\n top.client = client;\n if (client && client.setupIntegrations) {\n client.setupIntegrations();\n }\n }\n\n /**\n * @inheritDoc\n */\n public pushScope(): Scope {\n // We want to clone the content of prev scope\n const scope = Scope.clone(this.getScope());\n this.getStack().push({\n client: this.getClient(),\n scope,\n });\n return scope;\n }\n\n /**\n * @inheritDoc\n */\n public popScope(): boolean {\n if (this.getStack().length <= 1) return false;\n return !!this.getStack().pop();\n }\n\n /**\n * @inheritDoc\n */\n public withScope(callback: (scope: Scope) => void): void {\n const scope = this.pushScope();\n try {\n callback(scope);\n } finally {\n this.popScope();\n }\n }\n\n /**\n * @inheritDoc\n */\n public getClient<C extends Client>(): C | undefined {\n return this.getStackTop().client as C;\n }\n\n /** Returns the scope of the top stack. */\n public getScope(): Scope | undefined {\n return this.getStackTop().scope;\n }\n\n /** Returns the scope stack for domains or the process. */\n public getStack(): Layer[] {\n return this._stack;\n }\n\n /** Returns the topmost scope layer in the order domain > local > process. */\n public getStackTop(): Layer {\n return this._stack[this._stack.length - 1];\n }\n\n /**\n * @inheritDoc\n */\n // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n public captureException(exception: any, hint?: EventHint): string {\n const eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());\n const syntheticException = new Error('Sentry syntheticException');\n this._withClient((client, scope) => {\n client.captureException(\n exception,\n {\n originalException: exception,\n syntheticException,\n ...hint,\n event_id: eventId,\n },\n scope,\n );\n });\n return eventId;\n }\n\n /**\n * @inheritDoc\n */\n public captureMessage(\n message: string,\n // eslint-disable-next-line deprecation/deprecation\n level?: Severity | SeverityLevel,\n hint?: EventHint,\n ): string {\n const eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());\n const syntheticException = new Error(message);\n this._withClient((client, scope) => {\n client.captureMessage(\n message,\n level,\n {\n originalException: message,\n syntheticException,\n ...hint,\n event_id: eventId,\n },\n scope,\n );\n });\n return eventId;\n }\n\n /**\n * @inheritDoc\n */\n public captureEvent(event: Event, hint?: EventHint): string {\n const eventId = hint && hint.event_id ? hint.event_id : uuid4();\n if (event.type !== 'transaction') {\n this._lastEventId = eventId;\n }\n\n this._withClient((client, scope) => {\n client.captureEvent(event, { ...hint, event_id: eventId }, scope);\n });\n return eventId;\n }\n\n /**\n * @inheritDoc\n */\n public lastEventId(): string | undefined {\n return this._lastEventId;\n }\n\n /**\n * @inheritDoc\n */\n public addBreadcrumb(breadcrumb: Breadcrumb, hint?: BreadcrumbHint): void {\n const { scope, client } = this.getStackTop();\n\n if (!scope || !client) return;\n\n // eslint-disable-next-line @typescript-eslint/unbound-method\n const { beforeBreadcrumb = null, maxBreadcrumbs = DEFAULT_BREADCRUMBS } =\n (client.getOptions && client.getOptions()) || {};\n\n if (maxBreadcrumbs <= 0) return;\n\n const timestamp = dateTimestampInSeconds();\n const mergedBreadcrumb = { timestamp, ...breadcrumb };\n const finalBreadcrumb = beforeBreadcrumb\n ? (consoleSandbox(() => beforeBreadcrumb(mergedBreadcrumb, hint)) as Breadcrumb | null)\n : mergedBreadcrumb;\n\n if (finalBreadcrumb === null) return;\n\n scope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);\n }\n\n /**\n * @inheritDoc\n */\n public setUser(user: User | null): void {\n const scope = this.getScope();\n if (scope) scope.setUser(user);\n }\n\n /**\n * @inheritDoc\n */\n public setTags(tags: { [key: string]: Primitive }): void {\n const scope = this.getScope();\n if (scope) scope.setTags(tags);\n }\n\n /**\n * @inheritDoc\n */\n public setExtras(extras: Extras): void {\n const scope = this.getScope();\n if (scope) scope.setExtras(extras);\n }\n\n /**\n * @inheritDoc\n */\n public setTag(key: string, value: Primitive): void {\n const scope = this.getScope();\n if (scope) scope.setTag(key, value);\n }\n\n /**\n * @inheritDoc\n */\n public setExtra(key: string, extra: Extra): void {\n const scope = this.getScope();\n if (scope) scope.setExtra(key, extra);\n }\n\n /**\n * @inheritDoc\n */\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n public setContext(name: string, context: { [key: string]: any } | null): void {\n const scope = this.getScope();\n if (scope) scope.setContext(name, context);\n }\n\n /**\n * @inheritDoc\n */\n public configureScope(callback: (scope: Scope) => void): void {\n const { scope, client } = this.getStackTop();\n if (scope && client) {\n callback(scope);\n }\n }\n\n /**\n * @inheritDoc\n */\n public run(callback: (hub: Hub) => void): void {\n const oldHub = makeMain(this);\n try {\n callback(this);\n } finally {\n makeMain(oldHub);\n }\n }\n\n /**\n * @inheritDoc\n */\n public getIntegration<T extends Integration>(integration: IntegrationClass<T>): T | null {\n const client = this.getClient();\n if (!client) return null;\n try {\n return client.getIntegration(integration);\n } catch (_oO) {\n __DEBUG_BUILD__ && logger.warn(`Cannot retrieve integration ${integration.id} from the current Hub`);\n return null;\n }\n }\n\n /**\n * @inheritDoc\n */\n public startTransaction(context: TransactionContext, customSamplingContext?: CustomSamplingContext): Transaction {\n return this._callExtensionMethod('startTransaction', context, customSamplingContext);\n }\n\n /**\n * @inheritDoc\n */\n public traceHeaders(): { [key: string]: string } {\n return this._callExtensionMethod<{ [key: string]: string }>('traceHeaders');\n }\n\n /**\n * @inheritDoc\n */\n public captureSession(endSession: boolean = false): void {\n // both send the update and pull the session from the scope\n if (endSession) {\n return this.endSession();\n }\n\n // only send the update\n this._sendSessionUpdate();\n }\n\n /**\n * @inheritDoc\n */\n public endSession(): void {\n const layer = this.getStackTop();\n const scope = layer && layer.scope;\n const session = scope && scope.getSession();\n if (session) {\n closeSession(session);\n }\n this._sendSessionUpdate();\n\n // the session is over; take it off of the scope\n if (scope) {\n scope.setSession();\n }\n }\n\n /**\n * @inheritDoc\n */\n public startSession(context?: SessionContext): Session {\n const { scope, client } = this.getStackTop();\n const { release, environment } = (client && client.getOptions()) || {};\n\n // Will fetch userAgent if called from browser sdk\n const global = getGlobalObject<{ navigator?: { userAgent?: string } }>();\n const { userAgent } = global.navigator || {};\n\n const session = makeSession({\n release,\n environment,\n ...(scope && { user: scope.getUser() }),\n ...(userAgent && { userAgent }),\n ...context,\n });\n\n if (scope) {\n // End existing session if there's one\n const currentSession = scope.getSession && scope.getSession();\n if (currentSession && currentSession.status === 'ok') {\n updateSession(currentSession, { status: 'exited' });\n }\n this.endSession();\n\n // Afterwards we set the new session on the scope\n scope.setSession(session);\n }\n\n return session;\n }\n\n /**\n * Returns if default PII should be sent to Sentry and propagated in ourgoing requests\n * when Tracing is used.\n */\n public shouldSendDefaultPii(): boolean {\n const client = this.getClient();\n const options = client && client.getOptions();\n return Boolean(options && options.sendDefaultPii);\n }\n\n /**\n * Sends the current Session on the scope\n */\n private _sendSessionUpdate(): void {\n const { scope, client } = this.getStackTop();\n if (!scope) return;\n\n const session = scope.getSession();\n if (session) {\n if (client && client.captureSession) {\n client.captureSession(session);\n }\n }\n }\n\n /**\n * Internal helper function to call a method on the top client if it exists.\n *\n * @param method The method to call on the client.\n * @param args Arguments to pass to the client function.\n */\n private _withClient(callback: (client: Client, scope: Scope | undefined) => void): void {\n const { scope, client } = this.getStackTop();\n if (client) {\n callback(client, scope);\n }\n }\n\n /**\n * Calls global extension method and binding current instance to the function call\n */\n // @ts-ignore Function lacks ending return statement and return type does not include 'undefined'. ts(2366)\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n private _callExtensionMethod<T>(method: string, ...args: any[]): T {\n const carrier = getMainCarrier();\n const sentry = carrier.__SENTRY__;\n if (sentry && sentry.extensions && typeof sentry.extensions[method] === 'function') {\n return sentry.extensions[method].apply(this, args);\n }\n __DEBUG_BUILD__ && logger.warn(`Extension method ${method} couldn't be found, doing nothing.`);\n }\n}\n\n/**\n * Returns the global shim registry.\n *\n * FIXME: This function is problematic, because despite always returning a valid Carrier,\n * it has an optional `__SENTRY__` property, which then in turn requires us to always perform an unnecessary check\n * at the call-site. We always access the carrier through this function, so we can guarantee that `__SENTRY__` is there.\n **/\nexport function getMainCarrier(): Carrier {\n const carrier = getGlobalObject();\n carrier.__SENTRY__ = carrier.__SENTRY__ || {\n extensions: {},\n hub: undefined,\n };\n return carrier;\n}\n\n/**\n * Replaces the current main hub with the passed one on the global object\n *\n * @returns The old replaced hub\n */\nexport function makeMain(hub: Hub): Hub {\n const registry = getMainCarrier();\n const oldHub = getHubFromCarrier(registry);\n setHubOnCarrier(registry, hub);\n return oldHub;\n}\n\n/**\n * Returns the default hub instance.\n *\n * If a hub is already registered in the global carrier but this module\n * contains a more recent version, it replaces the registered version.\n * Otherwise, the currently registered hub will be returned.\n */\nexport function getCurrentHub(): Hub {\n // Get main carrier (global for every environment)\n const registry = getMainCarrier();\n\n // If there's no hub, or its an old API, assign a new one\n if (!hasHubOnCarrier(registry) || getHubFromCarrier(registry).isOlderThan(API_VERSION)) {\n setHubOnCarrier(registry, new Hub());\n }\n\n // Prefer domains over global if they are there (applicable only to Node environment)\n if (isNodeEnv()) {\n return getHubFromActiveDomain(registry);\n }\n // Return hub that lives on a global object\n return getHubFromCarrier(registry);\n}\n\n/**\n * Try to read the hub from an active domain, and fallback to the registry if one doesn't exist\n * @returns discovered hub\n */\nfunction getHubFromActiveDomain(registry: Carrier): Hub {\n try {\n const sentry = getMainCarrier().__SENTRY__;\n const activeDomain = sentry && sentry.extensions && sentry.extensions.domain && sentry.extensions.domain.active;\n\n // If there's no active domain, just return global hub\n if (!activeDomain) {\n return getHubFromCarrier(registry);\n }\n\n // If there's no hub on current domain, or it's an old API, assign a new one\n if (!hasHubOnCarrier(activeDomain) || getHubFromCarrier(activeDomain).isOlderThan(API_VERSION)) {\n const registryHubTopStack = getHubFromCarrier(registry).getStackTop();\n setHubOnCarrier(activeDomain, new Hub(registryHubTopStack.client, Scope.clone(registryHubTopStack.scope)));\n }\n\n // Return hub that lives on a domain\n return getHubFromCarrier(activeDomain);\n } catch (_Oo) {\n // Return hub that lives on a global object\n return getHubFromCarrier(registry);\n }\n}\n\n/**\n * This will tell whether a carrier has a hub on it or not\n * @param carrier object\n */\nfunction hasHubOnCarrier(carrier: Carrier): boolean {\n return !!(carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub);\n}\n\n/**\n * This will create a new {@link Hub} and add to the passed object on\n * __SENTRY__.hub.\n * @param carrier object\n * @hidden\n */\nexport function getHubFromCarrier(carrier: Carrier): Hub {\n return getGlobalSingleton<Hub>('hub', () => new Hub(), carrier);\n}\n\n/**\n * This will set passed {@link Hub} on the passed object's __SENTRY__.hub attribute\n * @param carrier object\n * @param hub Hub\n * @returns A boolean indicating success or failure\n */\nexport function setHubOnCarrier(carrier: Carrier, hub: Hub): boolean {\n if (!carrier) return false;\n const __SENTRY__ = (carrier.__SENTRY__ = carrier.__SENTRY__ || {});\n __SENTRY__.hub = hub;\n return true;\n}\n","/* eslint-disable max-lines */\nimport {\n Attachment,\n Breadcrumb,\n CaptureContext,\n Context,\n Contexts,\n Event,\n EventHint,\n EventProcessor,\n Extra,\n Extras,\n Primitive,\n RequestSession,\n Scope as ScopeInterface,\n ScopeContext,\n Session,\n Severity,\n SeverityLevel,\n Span,\n Transaction,\n User,\n} from '@sentry/types';\nimport {\n arrayify,\n dateTimestampInSeconds,\n getGlobalSingleton,\n isPlainObject,\n isThenable,\n logger,\n SyncPromise,\n} from '@sentry/utils';\n\nimport { updateSession } from './session';\n\n/**\n * Absolute maximum number of breadcrumbs added to an event.\n * The `maxBreadcrumbs` option cannot be higher than this value.\n */\nconst MAX_BREADCRUMBS = 100;\n\n/**\n * Holds additional event information. {@link Scope.applyToEvent} will be\n * called by the client before an event will be sent.\n */\nexport class Scope implements ScopeInterface {\n /** Flag if notifying is happening. */\n protected _notifyingListeners: boolean;\n\n /** Callback for client to receive scope changes. */\n protected _scopeListeners: Array<(scope: Scope) => void>;\n\n /** Callback list that will be called after {@link applyToEvent}. */\n protected _eventProcessors: EventProcessor[];\n\n /** Array of breadcrumbs. */\n protected _breadcrumbs: Breadcrumb[];\n\n /** User */\n protected _user: User;\n\n /** Tags */\n protected _tags: { [key: string]: Primitive };\n\n /** Extra */\n protected _extra: Extras;\n\n /** Contexts */\n protected _contexts: Contexts;\n\n /** Attachments */\n protected _attachments: Attachment[];\n\n /**\n * A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get\n * sent to Sentry\n */\n protected _sdkProcessingMetadata: { [key: string]: unknown };\n\n /** Fingerprint */\n protected _fingerprint?: string[];\n\n /** Severity */\n // eslint-disable-next-line deprecation/deprecation\n protected _level?: Severity | SeverityLevel;\n\n /** Transaction Name */\n protected _transactionName?: string;\n\n /** Span */\n protected _span?: Span;\n\n /** Session */\n protected _session?: Session;\n\n /** Request Mode Session Status */\n protected _requestSession?: RequestSession;\n\n public constructor() {\n this._notifyingListeners = false;\n this._scopeListeners = [];\n this._eventProcessors = [];\n this._breadcrumbs = [];\n this._attachments = [];\n this._user = {};\n this._tags = {};\n this._extra = {};\n this._contexts = {};\n this._sdkProcessingMetadata = {};\n }\n\n /**\n * Inherit values from the parent scope.\n * @param scope to clone.\n */\n public static clone(scope?: Scope): Scope {\n const newScope = new Scope();\n if (scope) {\n newScope._breadcrumbs = [...scope._breadcrumbs];\n newScope._tags = { ...scope._tags };\n newScope._extra = { ...scope._extra };\n newScope._contexts = { ...scope._contexts };\n newScope._user = scope._user;\n newScope._level = scope._level;\n newScope._span = scope._span;\n newScope._session = scope._session;\n newScope._transactionName = scope._transactionName;\n newScope._fingerprint = scope._fingerprint;\n newScope._eventProcessors = [...scope._eventProcessors];\n newScope._requestSession = scope._requestSession;\n newScope._attachments = [...scope._attachments];\n }\n return newScope;\n }\n\n /**\n * Add internal on change listener. Used for sub SDKs that need to store the scope.\n * @hidden\n */\n public addScopeListener(callback: (scope: Scope) => void): void {\n this._scopeListeners.push(callback);\n }\n\n /**\n * @inheritDoc\n */\n public addEventProcessor(callback: EventProcessor): this {\n this._eventProcessors.push(callback);\n return this;\n }\n\n /**\n * @inheritDoc\n */\n public setUser(user: User | null): this {\n this._user = user || {};\n if (this._session) {\n updateSession(this._session, { user });\n }\n this._notifyScopeListeners();\n return this;\n }\n\n /**\n * @inheritDoc\n */\n public getUser(): User | undefined {\n return this._user;\n }\n\n /**\n * @inheritDoc\n */\n public getRequestSession(): RequestSession | undefined {\n return this._requestSession;\n }\n\n /**\n * @inheritDoc\n */\n public setRequestSession(requestSession?: RequestSession): this {\n this._requestSession = requestSession;\n return this;\n }\n\n /**\n * @inheritDoc\n */\n public setTags(tags: { [key: string]: Primitive }): this {\n this._tags = {\n ...this._tags,\n ...tags,\n };\n this._notifyScopeListeners();\n return this;\n }\n\n /**\n * @inheritDoc\n */\n public setTag(key: string, value: Primitive): this {\n this._tags = { ...this._tags, [key]: value };\n this._notifyScopeListeners();\n return this;\n }\n\n /**\n * @inheritDoc\n */\n public setExtras(extras: Extras): this {\n this._extra = {\n ...this._extra,\n ...extras,\n };\n this._notifyScopeListeners();\n return this;\n }\n\n /**\n * @inheritDoc\n */\n public setExtra(key: string, extra: Extra): this {\n this._extra = { ...this._extra, [key]: extra };\n this._notifyScopeListeners();\n return this;\n }\n\n /**\n * @inheritDoc\n */\n public setFingerprint(fingerprint: string[]): this {\n this._fingerprint = fingerprint;\n this._notifyScopeListeners();\n return this;\n }\n\n /**\n * @inheritDoc\n */\n public setLevel(\n // eslint-disable-next-line deprecation/deprecation\n level: Severity | SeverityLevel,\n ): this {\n this._level = level;\n this._notifyScopeListeners();\n return this;\n }\n\n /**\n * @inheritDoc\n */\n public setTransactionName(name?: string): this {\n this._transactionName = name;\n this._notifyScopeListeners();\n return this;\n }\n\n /**\n * @inheritDoc\n */\n public setContext(key: string, context: Context | null): this {\n if (context === null) {\n // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n delete this._contexts[key];\n } else {\n this._contexts = { ...this._contexts, [key]: context };\n }\n\n this._notifyScopeListeners();\n return this;\n }\n\n /**\n * @inheritDoc\n */\n public setSpan(span?: Span): this {\n this._span = span;\n this._notifyScopeListeners();\n return this;\n }\n\n /**\n * @inheritDoc\n */\n public getSpan(): Span | undefined {\n return this._span;\n }\n\n /**\n * @inheritDoc\n */\n public getTransaction(): Transaction | undefined {\n // Often, this span (if it exists at all) will be a transaction, but it's not guaranteed to be. Regardless, it will\n // have a pointer to the currently-active transaction.\n const span = this.getSpan();\n return span && span.transaction;\n }\n\n /**\n * @inheritDoc\n */\n public setSession(session?: Session): this {\n if (!session) {\n delete this._session;\n } else {\n this._session = session;\n }\n this._notifyScopeListeners();\n return this;\n }\n\n /**\n * @inheritDoc\n */\n public getSession(): Session | undefined {\n return this._session;\n }\n\n /**\n * @inheritDoc\n */\n public update(captureContext?: CaptureContext): this {\n if (!captureContext) {\n return this;\n }\n\n if (typeof captureContext === 'function') {\n const updatedScope = (captureContext as <T>(scope: T) => T)(this);\n return updatedScope instanceof Scope ? updatedScope : this;\n }\n\n if (captureContext instanceof Scope) {\n this._tags = { ...this._tags, ...captureContext._tags };\n this._extra = { ...this._extra, ...captureContext._extra };\n this._contexts = { ...this._contexts, ...captureContext._contexts };\n if (captureContext._user && Object.keys(captureContext._user).length) {\n this._user = captureContext._user;\n }\n if (captureContext._level) {\n this._level = captureContext._level;\n }\n if (captureContext._fingerprint) {\n this._fingerprint = captureContext._fingerprint;\n }\n if (captureContext._requestSession) {\n this._requestSession = captureContext._requestSession;\n }\n } else if (isPlainObject(captureContext)) {\n // eslint-disable-next-line no-param-reassign\n captureContext = captureContext as ScopeContext;\n this._tags = { ...this._tags, ...captureContext.tags };\n this._extra = { ...this._extra, ...captureContext.extra };\n this._contexts = { ...this._contexts, ...captureContext.contexts };\n if (captureContext.user) {\n this._user = captureContext.user;\n }\n if (captureContext.level) {\n this._level = captureContext.level;\n }\n if (captureContext.fingerprint) {\n this._fingerprint = captureContext.fingerprint;\n }\n if (captureContext.requestSession) {\n this._requestSession = captureContext.requestSession;\n }\n }\n\n return this;\n }\n\n /**\n * @inheritDoc\n */\n public clear(): this {\n this._breadcrumbs = [];\n this._tags = {};\n this._extra = {};\n this._user = {};\n this._contexts = {};\n this._level = undefined;\n this._transactionName = undefined;\n this._fingerprint = undefined;\n this._requestSession = undefined;\n this._span = undefined;\n this._session = undefined;\n this._notifyScopeListeners();\n this._attachments = [];\n return this;\n }\n\n /**\n * @inheritDoc\n */\n public addBreadcrumb(breadcrumb: Breadcrumb, maxBreadcrumbs?: number): this {\n const maxCrumbs = typeof maxBreadcrumbs === 'number' ? Math.min(maxBreadcrumbs, MAX_BREADCRUMBS) : MAX_BREADCRUMBS;\n\n // No data has been changed, so don't notify scope listeners\n if (maxCrumbs <= 0) {\n return this;\n }\n\n const mergedBreadcrumb = {\n timestamp: dateTimestampInSeconds(),\n ...breadcrumb,\n };\n this._breadcrumbs = [...this._breadcrumbs, mergedBreadcrumb].slice(-maxCrumbs);\n this._notifyScopeListeners();\n\n return this;\n }\n\n /**\n * @inheritDoc\n */\n public clearBreadcrumbs(): this {\n this._breadcrumbs = [];\n this._notifyScopeListeners();\n return this;\n }\n\n /**\n * @inheritDoc\n */\n public addAttachment(attachment: Attachment): this {\n this._attachments.push(attachment);\n return this;\n }\n\n /**\n * @inheritDoc\n */\n public getAttachments(): Attachment[] {\n return this._attachments;\n }\n\n /**\n * @inheritDoc\n */\n public clearAttachments(): this {\n this._attachments = [];\n return this;\n }\n\n /**\n * Applies data from the scope to the event and runs all event processors on it.\n *\n * @param event Event\n * @param hint Object containing additional information about the original exception, for use by the event processors.\n * @hidden\n */\n public applyToEvent(event: Event, hint: EventHint = {}): PromiseLike<Event | null> {\n if (this._extra && Object.keys(this._extra).length) {\n event.extra = { ...this._extra, ...event.extra };\n }\n if (this._tags && Object.keys(this._tags).length) {\n event.tags = { ...this._tags, ...event.tags };\n }\n if (this._user && Object.keys(this._user).length) {\n event.user = { ...this._user, ...event.user };\n }\n if (this._contexts && Object.keys(this._contexts).length) {\n event.contexts = { ...this._contexts, ...event.contexts };\n }\n if (this._level) {\n event.level = this._level;\n }\n if (this._transactionName) {\n event.transaction = this._transactionName;\n }\n\n // We want to set the trace context for normal events only if there isn't already\n // a trace context on the event. There is a product feature in place where we link\n // errors with transaction and it relies on that.\n if (this._span) {\n event.contexts = { trace: this._span.getTraceContext(), ...event.contexts };\n const transactionName = this._span.transaction && this._span.transaction.name;\n if (transactionName) {\n event.tags = { transaction: transactionName, ...event.tags };\n }\n }\n\n this._applyFingerprint(event);\n\n event.breadcrumbs = [...(event.breadcrumbs || []), ...this._breadcrumbs];\n event.breadcrumbs = event.breadcrumbs.length > 0 ? event.breadcrumbs : undefined;\n\n event.sdkProcessingMetadata = { ...event.sdkProcessingMetadata, ...this._sdkProcessingMetadata };\n\n return this._notifyEventProcessors([...getGlobalEventProcessors(), ...this._eventProcessors], event, hint);\n }\n\n /**\n * Add data which will be accessible during event processing but won't get sent to Sentry\n */\n public setSDKProcessingMetadata(newData: { [key: string]: unknown }): this {\n this._sdkProcessingMetadata = { ...this._sdkProcessingMetadata, ...newData };\n\n return this;\n }\n\n /**\n * This will be called after {@link applyToEvent} is finished.\n */\n protected _notifyEventProcessors(\n processors: EventProcessor[],\n event: Event | null,\n hint: EventHint,\n index: number = 0,\n ): PromiseLike<Event | null> {\n return new SyncPromise<Event | null>((resolve, reject) => {\n const processor = processors[index];\n if (event === null || typeof processor !== 'function') {\n resolve(event);\n } else {\n const result = processor({ ...event }, hint) as Event | null;\n\n __DEBUG_BUILD__ &&\n processor.id &&\n result === null &&\n logger.log(`Event processor \"${processor.id}\" dropped event`);\n\n if (isThenable(result)) {\n void result\n .then(final => this._notifyEventProcessors(processors, final, hint, index + 1).then(resolve))\n .then(null, reject);\n } else {\n void this._notifyEventProcessors(processors, result, hint, index + 1)\n .then(resolve)\n .then(null, reject);\n }\n }\n });\n }\n\n /**\n * This will be called on every set call.\n */\n protected _notifyScopeListeners(): void {\n // We need this check for this._notifyingListeners to be able to work on scope during updates\n // If this check is not here we'll produce endless recursion when something is done with the scope\n // during the callback.\n if (!this._notifyingListeners) {\n this._notifyingListeners = true;\n this._scopeListeners.forEach(callback => {\n callback(this);\n });\n this._notifyingListeners = false;\n }\n }\n\n /**\n * Applies fingerprint from the scope to the event if there's one,\n * uses message if there's one instead or get rid of empty fingerprint\n */\n private _applyFingerprint(event: Event): void {\n // Make sure it's an array first and we actually have something in place\n event.fingerprint = event.fingerprint ? arrayify(event.fingerprint) : [];\n\n // If we have something on the scope, then merge it with event\n if (this._fingerprint) {\n event.fingerprint = event.fingerprint.concat(this._fingerprint);\n }\n\n // If we have no data at all, remove empty array default\n if (event.fingerprint && !event.fingerprint.length) {\n delete event.fingerprint;\n }\n }\n}\n\n/**\n * Returns the global event processors.\n */\nfunction getGlobalEventProcessors(): EventProcessor[] {\n return getGlobalSingleton<EventProcessor[]>('globalEventProcessors', () => []);\n}\n\n/**\n * Add a EventProcessor to be kept globally.\n * @param callback EventProcessor to add\n */\nexport function addGlobalEventProcessor(callback: EventProcessor): void {\n getGlobalEventProcessors().push(callback);\n}\n","import { SerializedSession, Session, SessionContext, SessionStatus } from '@sentry/types';\nimport { dropUndefinedKeys, timestampInSeconds, uuid4 } from '@sentry/utils';\n\n/**\n * Creates a new `Session` object by setting certain default parameters. If optional @param context\n * is passed, the passed properties are applied to the session object.\n *\n * @param context (optional) additional properties to be applied to the returned session object\n *\n * @returns a new `Session` object\n */\nexport function makeSession(context?: Omit<SessionContext, 'started' | 'status'>): Session {\n // Both timestamp and started are in seconds since the UNIX epoch.\n const startingTime = timestampInSeconds();\n\n const session: Session = {\n sid: uuid4(),\n init: true,\n timestamp: startingTime,\n started: startingTime,\n duration: 0,\n status: 'ok',\n errors: 0,\n ignoreDuration: false,\n toJSON: () => sessionToJSON(session),\n };\n\n if (context) {\n updateSession(session, context);\n }\n\n return session;\n}\n\n/**\n * Updates a session object with the properties passed in the context.\n *\n * Note that this function mutates the passed object and returns void.\n * (Had to do this instead of returning a new and updated session because closing and sending a session\n * makes an update to the session after it was passed to the sending logic.\n * @see BaseClient.captureSession )\n *\n * @param session the `Session` to update\n * @param context the `SessionContext` holding the properties that should be updated in @param session\n */\n// eslint-disable-next-line complexity\nexport function updateSession(session: Session, context: SessionContext = {}): void {\n if (context.user) {\n if (!session.ipAddress && context.user.ip_address) {\n session.ipAddress = context.user.ip_address;\n }\n\n if (!session.did && !context.did) {\n session.did = context.user.id || context.user.email || context.user.username;\n }\n }\n\n session.timestamp = context.timestamp || timestampInSeconds();\n\n if (context.ignoreDuration) {\n session.ignoreDuration = context.ignoreDuration;\n }\n if (context.sid) {\n // Good enough uuid validation. — Kamil\n session.sid = context.sid.length === 32 ? context.sid : uuid4();\n }\n if (context.init !== undefined) {\n session.init = context.init;\n }\n if (!session.did && context.did) {\n session.did = `${context.did}`;\n }\n if (typeof context.started === 'number') {\n session.started = context.started;\n }\n if (session.ignoreDuration) {\n session.duration = undefined;\n } else if (typeof context.duration === 'number') {\n session.duration = context.duration;\n } else {\n const duration = session.timestamp - session.started;\n session.duration = duration >= 0 ? duration : 0;\n }\n if (context.release) {\n session.release = context.release;\n }\n if (context.environment) {\n session.environment = context.environment;\n }\n if (!session.ipAddress && context.ipAddress) {\n session.ipAddress = context.ipAddress;\n }\n if (!session.userAgent && context.userAgent) {\n session.userAgent = context.userAgent;\n }\n if (typeof context.errors === 'number') {\n session.errors = context.errors;\n }\n if (context.status) {\n session.status = context.status;\n }\n}\n\n/**\n * Closes a session by setting its status and updating the session object with it.\n * Internally calls `updateSession` to update the passed session object.\n *\n * Note that this function mutates the passed session (@see updateSession for explanation).\n *\n * @param session the `Session` object to be closed\n * @param status the `SessionStatus` with which the session was closed. If you don't pass a status,\n * this function will keep the previously set status, unless it was `'ok'` in which case\n * it is changed to `'exited'`.\n */\nexport function closeSession(session: Session, status?: Exclude<SessionStatus, 'ok'>): void {\n let context = {};\n if (status) {\n context = { status };\n } else if (session.status === 'ok') {\n context = { status: 'exited' };\n }\n\n updateSession(session, context);\n}\n\n/**\n * Serializes a passed session object to a JSON object with a slightly different structure.\n * This is necessary because the Sentry backend requires a slightly different schema of a session\n * than the one the JS SDKs use internally.\n *\n * @param session the session to be converted\n *\n * @returns a JSON object of the passed session\n */\nfunction sessionToJSON(session: Session): SerializedSession {\n return dropUndefinedKeys({\n sid: `${session.sid}`,\n init: session.init,\n // Make sure that sec is converted to ms for date constructor\n started: new Date(session.started * 1000).toISOString(),\n timestamp: new Date(session.timestamp * 1000).toISOString(),\n status: session.status,\n errors: session.errors,\n did: typeof session.did === 'number' || typeof session.did === 'string' ? `${session.did}` : undefined,\n duration: session.duration,\n attrs: {\n release: session.release,\n environment: session.environment,\n ip_address: session.ipAddress,\n user_agent: session.userAgent,\n },\n });\n}\n"],"names":["getBaseApiEndpoint","dsn","_getIngestEndpoint","_encodedAuth","sentry_key","sentry_version","sdkInfo","sentry_client","tunnelOrOptions","getSdkMetadataForEnvelopeHeader","metadata","name","version","enhanceEventWithSdkInfo","event","session","tunnel","sent_at","sdk","type","sample_rates","id","rate","createEventEnvelopeHeaders","event_id","dynamicSamplingContext","trace","BaseClient","recordDroppedEvent","options","url","then","eventId","message","level","hint","scope","promisedEvent","updateSession","init","env","createAttachmentEnvelopeItem","attachment","errored","exceptions","crashed","status","errors","clearInterval","resolve","ticked","tick","timestamp","finalScope","result","breadcrumbs","b","data","user","contexts","extra","normalized","span","exception","request","logger","sampleRate","processedEvent","transactionInfo","source","changes","propagations","__sentry__","originalException","reason","category","quantity","_ensureBeforeSendRv","rv","filterDuplicates","integrations","integrationsByName","defaultIntegrations","integration","finalIntegrations","integrationIndex","installedIntegrations","originalFunctionToString","Function","args","FunctionToString","InboundFilters","eventProcess","addGlobalEventProcessor","internalOptions","clientOptions","allowUrls","denyUrls","ignoreErrors","DEFAULT_IGNORE_ERRORS","ignoreInternal","getEventDescription","_getEventFilterUrl","_isIgnoredError","_isDeniedUrl","_isAllowedUrl","_getPossibleEventMessages","_isSentryError","_getLastValidUrl","frames","clientClass","console","hub","makeRequest","buffer","makePromiseBuffer","forEachEnvelopeItem","filteredEnvelopeItems","body","rateLimits","recordEnvelopeLoss","send","flush","captureContext","getCurrentHub","Hub","top","client","callback","syntheticException","consoleSandbox","mergedBreadcrumb","makeMain","closeSession","release","environment","userAgent","context","carrier","extensions","setHubOnCarrier","getHubFromActiveDomain","registry","hasHubOnCarrier","__SENTRY__","tags","extras","breadcrumb","transaction","processors","index","processor","reject","newScope","getGlobalEventProcessors","sid","started","duration","ignoreDuration","toJSON","sessionToJSON","did","attrs","ip_address","user_agent"],"sourceRoot":""}