{"version":3,"sources":["webpack:///../../../src/utils/version.ts","webpack:///../../../src/utils/should-ignore-span.ts","webpack:///../../../src/utils/request.ts","webpack:///../../../../src/utils/vercel-ai/utils.ts","webpack:///../../../src/utils/spanOnScope.ts","webpack:///../../../src/utils/transactionEvent.ts","webpack:///../../../../src/utils/vercel-ai/index.ts","webpack:///../../../src/utils/tracing.ts","webpack:///../../../src/vendor/escapeStringForRegex.ts","webpack:///../../../src/utils/propagationContext.ts","webpack:///../../../src/utils/sdkMetadata.ts","webpack:///../../../src/utils/traceData.ts","webpack:///../../../src/utils/stacktrace.ts","webpack:///../../../src/utils/prepareEvent.ts","webpack:///../../../src/utils/string.ts","webpack:///../../../src/vendor/getIpAddress.ts","webpack:///../../../../src/utils/vercel-ai/vercel-ai-attributes.ts","webpack:///../../../src/utils/worldwide.ts","webpack:///../../../src/utils/promisebuffer.ts","webpack:///../../../src/utils/time.ts","webpack:///../../../src/utils/url.ts","webpack:///../../../src/utils/severity.ts","webpack:///../../../../src/utils/vercel-ai/constants.ts","webpack:///../../../src/utils/syncpromise.ts","webpack:///../../../src/utils/vercelWaitUntil.ts","webpack:///../../../src/utils/supports.ts","webpack:///../../../src/utils/ratelimit.ts","webpack:///../../../src/utils/spanUtils.ts"],"names":["SDK_VERSION","logIgnoredSpan","droppedSpan","debug","log","concat","op","description","shouldIgnoreSpan","span","ignoreSpans","length","pattern","isStringOrRegExp","isMatchingPattern","DEBUG_BUILD","name","nameMatches","opMatches","reparentChildSpans","spans","dropSpan","droppedSpanParentId","parent_span_id","droppedSpanId","span_id","value","RegExp","winterCGHeadersToDict","winterCGHeaders","headers","forEach","key","_unused","headersToDict","reqHeaders","Object","create","entries","_ref","_unused2","winterCGRequestToRequestData","req","method","url","query_string","extractQueryParamsFromUrl","httpRequestToRequestData","request","_request$socket","forwardedHost","undefined","host","forwardedProto","protocol","socket","encrypted","absoluteUrl","getAbsoluteUrl","data","body","cookies","_ref2","startsWith","SENSITIVE_HEADER_SNIPPETS","httpHeadersToSpanAttributes","sendDefaultPii","arguments","spanAttributes","_ref3","lowerCasedKey","toLowerCase","some","snippet","includes","normalizedKey","replace","Array","isArray","map","v","String","join","_unused3","queryParams","URL","search","slice","_unused4","accumulateTokensForParent","tokenAccumulator","parentSpanId","inputTokens","GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE","outputTokens","GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE","existing","get","set","applyAccumulatedTokens","spanOrTrace","accumulated","_INTERNAL_getSpanForToolCallId","toolCallId","toolCallSpanMap","_INTERNAL_cleanupToolCallSpan","delete","SCOPE_SPAN_FIELD","_setSpanForScope","scope","addNonEnumerableProperty","_getSpanForScope","convertTransactionEventToSpanJson","event","_event$contexts$trace","_event$contexts","_event$start_timestam","trace_id","status","origin","contexts","trace","transaction","start_timestamp","timestamp","profile_id","SEMANTIC_ATTRIBUTE_PROFILE_ID","exclusive_time","SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME","measurements","is_segment","convertSpanJsonToTransactionEvent","type","_objectSpread","addOriginToSpan","setAttribute","SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN","onVercelAiSpanStart","attributes","spanToJSON","AI_TOOL_CALL_NAME_ATTRIBUTE","AI_TOOL_CALL_ID_ATTRIBUTE","processToolCallSpan","aiModelId","AI_MODEL_ID_ATTRIBUTE","aiModelProvider","AI_MODEL_PROVIDER_ATTRIBUTE","processGenerateSpan","vercelAiEventProcessor","Map","processEndedVercelAiSpan","renameAttributeKey","AI_USAGE_COMPLETION_TOKENS_ATTRIBUTE","AI_USAGE_PROMPT_TOKENS_ATTRIBUTE","AI_PROMPT_MESSAGES_ATTRIBUTE","AI_RESPONSE_TEXT_ATTRIBUTE","AI_RESPONSE_TOOL_CALLS_ATTRIBUTE","AI_RESPONSE_OBJECT_ATTRIBUTE","AI_PROMPT_TOOLS_ATTRIBUTE","AI_TOOL_CALL_ARGS_ATTRIBUTE","AI_TOOL_CALL_RESULT_ATTRIBUTE","AI_SCHEMA_ATTRIBUTE","addProviderMetadataToAttributes","keys","oldKey","newKey","SEMANTIC_ATTRIBUTE_SENTRY_OP","toolName","updateName","nameWthoutAi","functionId","AI_TELEMETRY_FUNCTION_ID_ATTRIBUTE","AI_PROMPT_ATTRIBUTE","GEN_AI_RESPONSE_MODEL_ATTRIBUTE","addVercelAiProcessors","client","on","addEventProcessor","assign","id","providerMetadata","AI_RESPONSE_PROVIDER_METADATA_ATTRIBUTE","_providerMetadataObje","providerMetadataObject","JSON","parse","openai","setAttributeIfDefined","cachedPromptTokens","reasoningTokens","acceptedPredictionTokens","rejectedPredictionTokens","responseId","anthropic","cacheReadInputTokens","cacheCreationInputTokens","bedrock","usage","cacheWriteInputTokens","deepseek","promptCacheHitTokens","promptCacheMissTokens","TRACEPARENT_REGEXP","extractTraceparentData","traceparent","matches","match","parentSampled","traceId","propagationContextFromHeaders","sentryTrace","baggage","traceparentData","dynamicSamplingContext","baggageHeaderToDynamicSamplingContext","generateTraceId","sampleRand","Math","random","getSampleRandFromTraceparentAndDsc","sample_rand","toString","sampled","dsc","generateSentryTraceHeader","spanId","generateSpanId","sampledString","generateTraceparentHeader","parsedSampleRand","parseSampleRate","parsedSampleRate","sample_rate","shouldContinueTrace","baggageOrgId","clientOrgId","extractOrgIdFromClient","strictTraceContinuation","getOptions","escapeStringForRegex","regexString","uuid4","substring","applySdkMetadata","options","names","source","metadata","_metadata","sdk","packages","version","getTraceData","getClient","isEnabled","carrier","getMainCarrier","acs","getAsyncContextStrategy","getCurrentScope","getActiveSpan","spanToTraceHeader","scopeToTraceHeader","getDynamicSamplingContextFromSpan","getDynamicSamplingContextFromScope","dynamicSamplingContextToSentryBaggageHeader","isValidSentryTraceHeader","test","warn","traceData","propagateTraceparent","spanToTraceparentHeader","scopeToTraceparentHeader","propagationSpanId","getPropagationContext","STACKTRACE_FRAME_LIMIT","UNKNOWN_FUNCTION","WEBPACK_ERROR_REGEXP","STRIP_FRAME_REGEXP","createStackParser","_len","parsers","_key","sortedParsers","sort","a","b","p","stack","skipFirstLines","framesToPop","frames","lines","split","i","line","cleanedLine","parser","frame","push","stripSentryFramesAndReverse","stackParserFromStackParserOptions","stackParser","localStack","from","getLastStackFrame","function","pop","reverse","filename","arr","defaultFunctionName","getFunctionName","fn","getFramesFromEvent","exception","values","stacktrace","prepareEvent","hint","isolationScope","normalizeDepth","normalizeMaxBreadth","prepared","event_id","dateTimestampInSeconds","integrations","applyClientOptions","applyIntegrationsMetadata","emit","applyDebugIds","finalScope","getFinalScope","captureContext","mechanism","addExceptionMechanism","clientEventProcessors","getEventProcessors","getGlobalScope","getScopeData","isolationData","mergeScopeData","finalScopeData","attachments","applyScopeDataToEvent","eventProcessors","result","notifyEventProcessors","then","evt","applyDebugMeta","normalizeEvent","environment","release","dist","maxValueLength","DEFAULT_ENVIRONMENT","truncate","_event$exception","filenameDebugIdMap","getFilenameToDebugIdMap","_exception$stacktrace","debug_id","_event$exception2","_exception$stacktrace2","abs_path","debug_meta","images","code_file","integrationNames","depth","maxBreadth","_event$contexts2","normalized","breadcrumbs","normalize","user","extra","flags","clone","Scope","update","parseEventHintOrCaptureContext","hintIsScopeOrFunction","hintIsScopeContext","captureContextKeys","str","max","snipLine","colno","newLine","lineLength","start","end","min","safeJoin","input","delimiter","output","isVueViewModel","requireExactStringMatch","isString","isRegExp","stringMatchesSomePattern","testString","patterns","ipHeaderNames","getClientIPAddress","headerValues","headerName","rawValue","parseForwardedHeader","trim","flattenedHeaderValues","reduce","acc","val","ipAddress","find","ip","isIP","part","regex","GLOBAL_OBJ","globalThis","SENTRY_BUFFER_FULL_ERROR","Symbol","for","makePromiseBuffer","limit","buffer","Set","isReady","size","remove","task","add","taskProducer","rejectedSyncPromise","drain","timeout","resolvedSyncPromise","drainPromise","Promise","allSettled","promises","resolve","setTimeout","race","$","ONE_SECOND_IN_MS","Date","now","createUnixTimestampInSecondsFunc","performance","timeOrigin","_cachedTimestampInSeconds","timestampInSeconds","func","cachedTimeOrigin","getBrowserTimeOrigin","_performance$timing","threshold","performanceNow","dateNow","timeOriginDelta","abs","timeOriginIsReliable","navigationStart","timing","hasNavigationStart","navigationStartDelta","navigationStartIsReliable","browserPerformanceTimeOrigin","DEFAULT_BASE_URL","isURLObjectRelative","parseStringToURLObject","urlBase","isRelative","indexOf","base","canParse","fullUrlObject","pathname","hash","getSanitizedUrlStringFromUrlObject","newUrl","port","password","username","getHttpSpanNameFromUrlObject","urlObject","kind","routeName","_request$method$toUpp","_request$method","toUpperCase","route","getHttpSpanDetailsFromUrlObject","spanOrigin","SEMANTIC_ATTRIBUTE_SENTRY_SOURCE","SEMANTIC_ATTRIBUTE_HTTP_REQUEST_METHOD","SEMANTIC_ATTRIBUTE_URL_FULL","href","hostname","parseUrl","query","fragment","path","relative","stripUrlQueryAndFragment","urlPath","getSanitizedUrlString","filteredHost","severityLevelFromString","level","STATE_PENDING","STATE_RESOLVED","STATE_REJECTED","SyncPromise","reason","_","reject","constructor","executor","_state","_handlers","_runExecutor","onfulfilled","onrejected","e","_executeHandlers","catch","finally","onfinally","isRejected","cachedHandlers","handler","_value","setResult","state","isThenable","vercelWaitUntil","_vercelRequestContext","vercelRequestContextGlobal","ctx","call","waitUntil","WINDOW","supportsErrorEvent","ErrorEvent","supportsDOMError","DOMError","supportsDOMException","DOMException","supportsHistory","history","supportsFetch","_isFetchSupported","Headers","Request","Response","isNativeFunction","supportsNativeFetch","EdgeRuntime","fetch","doc","document","createElement","_sandbox$contentWindo","sandbox","hidden","head","appendChild","contentWindow","removeChild","err","supportsReportingObserver","supportsReferrerPolicy","referrerPolicy","_unused5","DEFAULT_RETRY_AFTER","parseRetryAfterHeader","header","headerDelay","parseInt","isNaN","headerDate","disabledUntil","limits","dataCategory","all","isRateLimited","updateRateLimits","statusCode","updatedRateLimits","rateLimitHeader","retryAfterHeader","retryAfter","categories","namespaces","delay","category","TRACE_FLAG_NONE","TRACE_FLAG_SAMPLED","hasShownSpanDropWarning","spanToTransactionTraceContext","spanContext","links","spanToTraceContext","isRemote","getCapturedScopesOnSpan","spanIsSampled","convertSpanLinksForEnvelope","context","traceFlags","restContext","_objectWithoutProperties","_excluded","spanTimeInputToSeconds","ensureTimestampInSeconds","getTime","isMs","spanIsSentrySpan","getSpanJSON","spanIsOpenTelemetrySdkTraceBaseSpan","_span$parentSpanConte","startTime","endTime","parentSpanContext","getStatusMessage","castSpan","code","SPAN_STATUS_UNSET","SPAN_STATUS_OK","message","CHILD_SPANS_FIELD","ROOT_SPAN_FIELD","addChildSpanToSpan","childSpan","rootSpan","removeChildSpanFromSpan","getSpanDescendants","resultSet","addSpanChildren","has","childSpans","getRootSpan","showSpanDropWarning","consoleSandbox","console","updateSpanName","setAttributes","SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME"],"mappings":"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C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMX,mBAAA,GAAsB;;AAsBnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMJ,4BAAA,GAA+B;;AA0C5C;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMF,0BAAA,GAA6B;;AAE1C;AACA;AACA;AACA;AACA;AACA;AACO,MAAMC,gCAAA,GAAmC;;AA0BhD;AACA;AACA;AACA;AACA;AACA;AACO,MAAMF,4BAAA,GAA+B;;AAE5C;AACA;AACA;AACA;AACA;AACA;AACO,MAAMI,yBAAA,GAA4B;;AAuEzC;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMd,qBAAA,GAAwB;;AAErC;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAME,2BAAA,GAA8B;;AAW3C;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMmC,uCAAA,GAA0C;;AAWvD;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMV,kCAAA,GAAqC;;AAWlD;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMnB,oCAAA,GAAuC;;AAEpD;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMC,gCAAA,GAAmC;;AA+HhD;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMoB,+BAAA,GAAkC;;AAW/C;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMhF,mCAAA,GAAsC;;AAEnD;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAME,oCAAA,GAAuC;;AAepD;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAM6C,2BAAA,GAA8B;;AAE3C;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMC,yBAAA,GAA4B;;AAEzC;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMkB,2BAAA,GAA8B;;AAE3C;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMC,6BAAA,GAAgC;;AA2Q7C;AACA;AACA;;AAEA;AACA;AAC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","file":"vendors~964240b4.71ff2c0ad52d6c797d15.chunk.js","sourcesContent":["// This is a magic string replaced by rollup\ndeclare const __SENTRY_SDK_VERSION__: string;\n\nexport const SDK_VERSION = typeof __SENTRY_SDK_VERSION__ === 'string' ? __SENTRY_SDK_VERSION__ : '0.0.0-unknown.0';\n","import { DEBUG_BUILD } from '../debug-build';\nimport type { ClientOptions } from '../types-hoist/options';\nimport type { SpanJSON } from '../types-hoist/span';\nimport { debug } from './debug-logger';\nimport { isMatchingPattern } from './string';\n\nfunction logIgnoredSpan(droppedSpan: Pick): void {\n debug.log(`Ignoring span ${droppedSpan.op} - ${droppedSpan.description} because it matches \\`ignoreSpans\\`.`);\n}\n\n/**\n * Check if a span should be ignored based on the ignoreSpans configuration.\n */\nexport function shouldIgnoreSpan(\n span: Pick,\n ignoreSpans: Required['ignoreSpans'],\n): boolean {\n if (!ignoreSpans?.length || !span.description) {\n return false;\n }\n\n for (const pattern of ignoreSpans) {\n if (isStringOrRegExp(pattern)) {\n if (isMatchingPattern(span.description, pattern)) {\n DEBUG_BUILD && logIgnoredSpan(span);\n return true;\n }\n continue;\n }\n\n if (!pattern.name && !pattern.op) {\n continue;\n }\n\n const nameMatches = pattern.name ? isMatchingPattern(span.description, pattern.name) : true;\n const opMatches = pattern.op ? span.op && isMatchingPattern(span.op, pattern.op) : true;\n\n // This check here is only correct because we can guarantee that we ran `isMatchingPattern`\n // for at least one of `nameMatches` and `opMatches`. So in contrary to how this looks,\n // not both op and name actually have to match. This is the most efficient way to check\n // for all combinations of name and op patterns.\n if (nameMatches && opMatches) {\n DEBUG_BUILD && logIgnoredSpan(span);\n return true;\n }\n }\n\n return false;\n}\n\n/**\n * Takes a list of spans, and a span that was dropped, and re-parents the child spans of the dropped span to the parent of the dropped span, if possible.\n * This mutates the spans array in place!\n */\nexport function reparentChildSpans(spans: SpanJSON[], dropSpan: SpanJSON): void {\n const droppedSpanParentId = dropSpan.parent_span_id;\n const droppedSpanId = dropSpan.span_id;\n\n // This should generally not happen, as we do not apply this on root spans\n // but to be safe, we just bail in this case\n if (!droppedSpanParentId) {\n return;\n }\n\n for (const span of spans) {\n if (span.parent_span_id === droppedSpanId) {\n span.parent_span_id = droppedSpanParentId;\n }\n }\n}\n\nfunction isStringOrRegExp(value: unknown): value is string | RegExp {\n return typeof value === 'string' || value instanceof RegExp;\n}\n","import type { PolymorphicRequest } from '../types-hoist/polymorphics';\nimport type { RequestEventData } from '../types-hoist/request';\nimport type { WebFetchHeaders, WebFetchRequest } from '../types-hoist/webfetchapi';\n\n/**\n * Transforms a `Headers` object that implements the `Web Fetch API` (https://developer.mozilla.org/en-US/docs/Web/API/Headers) into a simple key-value dict.\n * The header keys will be lower case: e.g. A \"Content-Type\" header will be stored as \"content-type\".\n */\nexport function winterCGHeadersToDict(winterCGHeaders: WebFetchHeaders): Record {\n const headers: Record = {};\n try {\n winterCGHeaders.forEach((value, key) => {\n if (typeof value === 'string') {\n // We check that value is a string even though it might be redundant to make sure prototype pollution is not possible.\n headers[key] = value;\n }\n });\n } catch {\n // just return the empty headers\n }\n\n return headers;\n}\n\n/**\n * Convert common request headers to a simple dictionary.\n */\nexport function headersToDict(reqHeaders: Record): Record {\n const headers: Record = Object.create(null);\n\n try {\n Object.entries(reqHeaders).forEach(([key, value]) => {\n if (typeof value === 'string') {\n headers[key] = value;\n }\n });\n } catch {\n // just return the empty headers\n }\n\n return headers;\n}\n\n/**\n * Converts a `Request` object that implements the `Web Fetch API` (https://developer.mozilla.org/en-US/docs/Web/API/Headers) into the format that the `RequestData` integration understands.\n */\nexport function winterCGRequestToRequestData(req: WebFetchRequest): RequestEventData {\n const headers = winterCGHeadersToDict(req.headers);\n\n return {\n method: req.method,\n url: req.url,\n query_string: extractQueryParamsFromUrl(req.url),\n headers,\n // TODO: Can we extract body data from the request?\n };\n}\n\n/**\n * Convert a HTTP request object to RequestEventData to be passed as normalizedRequest.\n * Instead of allowing `PolymorphicRequest` to be passed,\n * we want to be more specific and generally require a http.IncomingMessage-like object.\n */\nexport function httpRequestToRequestData(request: {\n method?: string;\n url?: string;\n headers?: {\n [key: string]: string | string[] | undefined;\n };\n protocol?: string;\n socket?: {\n encrypted?: boolean;\n remoteAddress?: string;\n };\n}): RequestEventData {\n const headers = request.headers || {};\n\n // Check for x-forwarded-host first, then fall back to host header\n const forwardedHost = typeof headers['x-forwarded-host'] === 'string' ? headers['x-forwarded-host'] : undefined;\n const host = forwardedHost || (typeof headers.host === 'string' ? headers.host : undefined);\n\n // Check for x-forwarded-proto first, then fall back to existing protocol detection\n const forwardedProto = typeof headers['x-forwarded-proto'] === 'string' ? headers['x-forwarded-proto'] : undefined;\n const protocol = forwardedProto || request.protocol || (request.socket?.encrypted ? 'https' : 'http');\n\n const url = request.url || '';\n\n const absoluteUrl = getAbsoluteUrl({\n url,\n host,\n protocol,\n });\n\n // This is non-standard, but may be sometimes set\n // It may be overwritten later by our own body handling\n const data = (request as PolymorphicRequest).body || undefined;\n\n // This is non-standard, but may be set on e.g. Next.js or Express requests\n const cookies = (request as PolymorphicRequest).cookies;\n\n return {\n url: absoluteUrl,\n method: request.method,\n query_string: extractQueryParamsFromUrl(url),\n headers: headersToDict(headers),\n cookies,\n data,\n };\n}\n\nfunction getAbsoluteUrl({\n url,\n protocol,\n host,\n}: {\n url?: string;\n protocol: string;\n host?: string;\n}): string | undefined {\n if (url?.startsWith('http')) {\n return url;\n }\n\n if (url && host) {\n return `${protocol}://${host}${url}`;\n }\n\n return undefined;\n}\n\n// \"-user\" because otherwise it would match \"user-agent\"\nconst SENSITIVE_HEADER_SNIPPETS = ['auth', 'token', 'secret', 'cookie', '-user', 'password', 'key'];\n\n/**\n * Converts incoming HTTP request headers to OpenTelemetry span attributes following semantic conventions.\n * Header names are converted to the format: http.request.header.\n * where is the header name in lowercase with dashes converted to underscores.\n *\n * @see https://opentelemetry.io/docs/specs/semconv/registry/attributes/http/#http-request-header\n */\nexport function httpHeadersToSpanAttributes(\n headers: Record,\n sendDefaultPii: boolean = false,\n): Record {\n const spanAttributes: Record = {};\n\n try {\n Object.entries(headers).forEach(([key, value]) => {\n if (value !== undefined) {\n const lowerCasedKey = key.toLowerCase();\n\n if (!sendDefaultPii && SENSITIVE_HEADER_SNIPPETS.some(snippet => lowerCasedKey.includes(snippet))) {\n return;\n }\n\n const normalizedKey = `http.request.header.${lowerCasedKey.replace(/-/g, '_')}`;\n\n if (Array.isArray(value)) {\n spanAttributes[normalizedKey] = value.map(v => (v !== null && v !== undefined ? String(v) : v)).join(';');\n } else if (typeof value === 'string') {\n spanAttributes[normalizedKey] = value;\n }\n }\n });\n } catch {\n // Return empty object if there's an error\n }\n\n return spanAttributes;\n}\n\n/** Extract the query params from an URL. */\nexport function extractQueryParamsFromUrl(url: string): string | undefined {\n // url is path and query string\n if (!url) {\n return;\n }\n\n try {\n // The `URL` constructor can't handle internal URLs of the form `/some/path/here`, so stick a dummy protocol and\n // hostname as the base. Since the point here is just to grab the query string, it doesn't matter what we use.\n const queryParams = new URL(url, 'http://s.io').search.slice(1);\n return queryParams.length ? queryParams : undefined;\n } catch {\n return undefined;\n }\n}\n","import type { TraceContext } from '../../types-hoist/context';\nimport type { Span, SpanJSON } from '../../types-hoist/span';\nimport { GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE, GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE } from '../ai/gen-ai-attributes';\nimport { toolCallSpanMap } from './constants';\nimport type { TokenSummary } from './types';\n\n/**\n * Accumulates token data from a span to its parent in the token accumulator map.\n * This function extracts token usage from the current span and adds it to the\n * accumulated totals for its parent span.\n */\nexport function accumulateTokensForParent(span: SpanJSON, tokenAccumulator: Map): void {\n const parentSpanId = span.parent_span_id;\n if (!parentSpanId) {\n return;\n }\n\n const inputTokens = span.data[GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE];\n const outputTokens = span.data[GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE];\n\n if (typeof inputTokens === 'number' || typeof outputTokens === 'number') {\n const existing = tokenAccumulator.get(parentSpanId) || { inputTokens: 0, outputTokens: 0 };\n\n if (typeof inputTokens === 'number') {\n existing.inputTokens += inputTokens;\n }\n if (typeof outputTokens === 'number') {\n existing.outputTokens += outputTokens;\n }\n\n tokenAccumulator.set(parentSpanId, existing);\n }\n}\n\n/**\n * Applies accumulated token data to the `gen_ai.invoke_agent` span.\n * Only immediate children of the `gen_ai.invoke_agent` span are considered,\n * since aggregation will automatically occur for each parent span.\n */\nexport function applyAccumulatedTokens(\n spanOrTrace: SpanJSON | TraceContext,\n tokenAccumulator: Map,\n): void {\n const accumulated = tokenAccumulator.get(spanOrTrace.span_id);\n if (!accumulated || !spanOrTrace.data) {\n return;\n }\n\n if (accumulated.inputTokens > 0) {\n spanOrTrace.data[GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE] = accumulated.inputTokens;\n }\n if (accumulated.outputTokens > 0) {\n spanOrTrace.data[GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE] = accumulated.outputTokens;\n }\n if (accumulated.inputTokens > 0 || accumulated.outputTokens > 0) {\n spanOrTrace.data['gen_ai.usage.total_tokens'] = accumulated.inputTokens + accumulated.outputTokens;\n }\n}\n\n/**\n * Get the span associated with a tool call ID\n */\nexport function _INTERNAL_getSpanForToolCallId(toolCallId: string): Span | undefined {\n return toolCallSpanMap.get(toolCallId);\n}\n\n/**\n * Clean up the span mapping for a tool call ID\n */\nexport function _INTERNAL_cleanupToolCallSpan(toolCallId: string): void {\n toolCallSpanMap.delete(toolCallId);\n}\n","import type { Scope } from '../scope';\nimport type { Span } from '../types-hoist/span';\nimport { addNonEnumerableProperty } from '../utils/object';\n\nconst SCOPE_SPAN_FIELD = '_sentrySpan';\n\ntype ScopeWithMaybeSpan = Scope & {\n [SCOPE_SPAN_FIELD]?: Span;\n};\n\n/**\n * Set the active span for a given scope.\n * NOTE: This should NOT be used directly, but is only used internally by the trace methods.\n */\nexport function _setSpanForScope(scope: Scope, span: Span | undefined): void {\n if (span) {\n addNonEnumerableProperty(scope as ScopeWithMaybeSpan, SCOPE_SPAN_FIELD, span);\n } else {\n // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n delete (scope as ScopeWithMaybeSpan)[SCOPE_SPAN_FIELD];\n }\n}\n\n/**\n * Get the active span for a given scope.\n * NOTE: This should NOT be used directly, but is only used internally by the trace methods.\n */\nexport function _getSpanForScope(scope: ScopeWithMaybeSpan): Span | undefined {\n return scope[SCOPE_SPAN_FIELD];\n}\n","import { SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME, SEMANTIC_ATTRIBUTE_PROFILE_ID } from '../semanticAttributes';\nimport type { TransactionEvent } from '../types-hoist/event';\nimport type { SpanJSON } from '../types-hoist/span';\n\n/**\n * Converts a transaction event to a span JSON object.\n */\nexport function convertTransactionEventToSpanJson(event: TransactionEvent): SpanJSON {\n const { trace_id, parent_span_id, span_id, status, origin, data, op } = event.contexts?.trace ?? {};\n\n return {\n data: data ?? {},\n description: event.transaction,\n op,\n parent_span_id,\n span_id: span_id ?? '',\n start_timestamp: event.start_timestamp ?? 0,\n status,\n timestamp: event.timestamp,\n trace_id: trace_id ?? '',\n origin,\n profile_id: data?.[SEMANTIC_ATTRIBUTE_PROFILE_ID] as string | undefined,\n exclusive_time: data?.[SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME] as number | undefined,\n measurements: event.measurements,\n is_segment: true,\n };\n}\n\n/**\n * Converts a span JSON object to a transaction event.\n */\nexport function convertSpanJsonToTransactionEvent(span: SpanJSON): TransactionEvent {\n return {\n type: 'transaction',\n timestamp: span.timestamp,\n start_timestamp: span.start_timestamp,\n transaction: span.description,\n contexts: {\n trace: {\n trace_id: span.trace_id,\n span_id: span.span_id,\n parent_span_id: span.parent_span_id,\n op: span.op,\n status: span.status,\n origin: span.origin,\n data: {\n ...span.data,\n ...(span.profile_id && { [SEMANTIC_ATTRIBUTE_PROFILE_ID]: span.profile_id }),\n ...(span.exclusive_time && { [SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME]: span.exclusive_time }),\n },\n },\n },\n measurements: span.measurements,\n };\n}\n","import type { Client } from '../../client';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '../../semanticAttributes';\nimport type { Event } from '../../types-hoist/event';\nimport type { Span, SpanAttributes, SpanAttributeValue, SpanJSON, SpanOrigin } from '../../types-hoist/span';\nimport { spanToJSON } from '../spanUtils';\nimport { toolCallSpanMap } from './constants';\nimport type { TokenSummary } from './types';\nimport { accumulateTokensForParent, applyAccumulatedTokens } from './utils';\nimport type { ProviderMetadata } from './vercel-ai-attributes';\nimport {\n AI_MODEL_ID_ATTRIBUTE,\n AI_MODEL_PROVIDER_ATTRIBUTE,\n AI_PROMPT_ATTRIBUTE,\n AI_PROMPT_MESSAGES_ATTRIBUTE,\n AI_PROMPT_TOOLS_ATTRIBUTE,\n AI_RESPONSE_OBJECT_ATTRIBUTE,\n AI_RESPONSE_PROVIDER_METADATA_ATTRIBUTE,\n AI_RESPONSE_TEXT_ATTRIBUTE,\n AI_RESPONSE_TOOL_CALLS_ATTRIBUTE,\n AI_SCHEMA_ATTRIBUTE,\n AI_TELEMETRY_FUNCTION_ID_ATTRIBUTE,\n AI_TOOL_CALL_ARGS_ATTRIBUTE,\n AI_TOOL_CALL_ID_ATTRIBUTE,\n AI_TOOL_CALL_NAME_ATTRIBUTE,\n AI_TOOL_CALL_RESULT_ATTRIBUTE,\n AI_USAGE_COMPLETION_TOKENS_ATTRIBUTE,\n AI_USAGE_PROMPT_TOKENS_ATTRIBUTE,\n GEN_AI_RESPONSE_MODEL_ATTRIBUTE,\n GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE,\n GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE,\n} from './vercel-ai-attributes';\n\nfunction addOriginToSpan(span: Span, origin: SpanOrigin): void {\n span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, origin);\n}\n\n/**\n * Post-process spans emitted by the Vercel AI SDK.\n * This is supposed to be used in `client.on('spanStart', ...)\n */\nfunction onVercelAiSpanStart(span: Span): void {\n const { data: attributes, description: name } = spanToJSON(span);\n\n if (!name) {\n return;\n }\n\n // Tool call spans\n // https://ai-sdk.dev/docs/ai-sdk-core/telemetry#tool-call-spans\n if (attributes[AI_TOOL_CALL_NAME_ATTRIBUTE] && attributes[AI_TOOL_CALL_ID_ATTRIBUTE] && name === 'ai.toolCall') {\n processToolCallSpan(span, attributes);\n return;\n }\n\n // The AI and Provider must be defined for generate, stream, and embed spans.\n // The id of the model\n const aiModelId = attributes[AI_MODEL_ID_ATTRIBUTE];\n // the provider of the model\n const aiModelProvider = attributes[AI_MODEL_PROVIDER_ATTRIBUTE];\n if (typeof aiModelId !== 'string' || typeof aiModelProvider !== 'string' || !aiModelId || !aiModelProvider) {\n return;\n }\n\n processGenerateSpan(span, name, attributes);\n}\n\nfunction vercelAiEventProcessor(event: Event): Event {\n if (event.type === 'transaction' && event.spans) {\n // Map to accumulate token data by parent span ID\n const tokenAccumulator: Map = new Map();\n\n // First pass: process all spans and accumulate token data\n for (const span of event.spans) {\n processEndedVercelAiSpan(span);\n\n // Accumulate token data for parent spans\n accumulateTokensForParent(span, tokenAccumulator);\n }\n\n // Second pass: apply accumulated token data to parent spans\n for (const span of event.spans) {\n if (span.op !== 'gen_ai.invoke_agent') {\n continue;\n }\n\n applyAccumulatedTokens(span, tokenAccumulator);\n }\n\n // Also apply to root when it is the invoke_agent pipeline\n const trace = event.contexts?.trace;\n if (trace && trace.op === 'gen_ai.invoke_agent') {\n applyAccumulatedTokens(trace, tokenAccumulator);\n }\n }\n\n return event;\n}\n/**\n * Post-process spans emitted by the Vercel AI SDK.\n */\nfunction processEndedVercelAiSpan(span: SpanJSON): void {\n const { data: attributes, origin } = span;\n\n if (origin !== 'auto.vercelai.otel') {\n return;\n }\n\n renameAttributeKey(attributes, AI_USAGE_COMPLETION_TOKENS_ATTRIBUTE, GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE);\n renameAttributeKey(attributes, AI_USAGE_PROMPT_TOKENS_ATTRIBUTE, GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE);\n\n if (\n typeof attributes[GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE] === 'number' &&\n typeof attributes[GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE] === 'number'\n ) {\n attributes['gen_ai.usage.total_tokens'] =\n attributes[GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE] + attributes[GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE];\n }\n\n // Rename AI SDK attributes to standardized gen_ai attributes\n renameAttributeKey(attributes, AI_PROMPT_MESSAGES_ATTRIBUTE, 'gen_ai.request.messages');\n renameAttributeKey(attributes, AI_RESPONSE_TEXT_ATTRIBUTE, 'gen_ai.response.text');\n renameAttributeKey(attributes, AI_RESPONSE_TOOL_CALLS_ATTRIBUTE, 'gen_ai.response.tool_calls');\n renameAttributeKey(attributes, AI_RESPONSE_OBJECT_ATTRIBUTE, 'gen_ai.response.object');\n renameAttributeKey(attributes, AI_PROMPT_TOOLS_ATTRIBUTE, 'gen_ai.request.available_tools');\n\n renameAttributeKey(attributes, AI_TOOL_CALL_ARGS_ATTRIBUTE, 'gen_ai.tool.input');\n renameAttributeKey(attributes, AI_TOOL_CALL_RESULT_ATTRIBUTE, 'gen_ai.tool.output');\n\n renameAttributeKey(attributes, AI_SCHEMA_ATTRIBUTE, 'gen_ai.request.schema');\n\n addProviderMetadataToAttributes(attributes);\n\n // Change attributes namespaced with `ai.X` to `vercel.ai.X`\n for (const key of Object.keys(attributes)) {\n if (key.startsWith('ai.')) {\n renameAttributeKey(attributes, key, `vercel.${key}`);\n }\n }\n}\n\n/**\n * Renames an attribute key in the provided attributes object if the old key exists.\n * This function safely handles null and undefined values.\n */\nfunction renameAttributeKey(attributes: Record, oldKey: string, newKey: string): void {\n if (attributes[oldKey] != null) {\n attributes[newKey] = attributes[oldKey];\n // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n delete attributes[oldKey];\n }\n}\n\nfunction processToolCallSpan(span: Span, attributes: SpanAttributes): void {\n addOriginToSpan(span, 'auto.vercelai.otel');\n span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, 'gen_ai.execute_tool');\n renameAttributeKey(attributes, AI_TOOL_CALL_NAME_ATTRIBUTE, 'gen_ai.tool.name');\n renameAttributeKey(attributes, AI_TOOL_CALL_ID_ATTRIBUTE, 'gen_ai.tool.call.id');\n\n // Store the span in our global map using the tool call ID\n // This allows us to capture tool errors and link them to the correct span\n const toolCallId = attributes['gen_ai.tool.call.id'];\n\n if (typeof toolCallId === 'string') {\n toolCallSpanMap.set(toolCallId, span);\n }\n\n // https://opentelemetry.io/docs/specs/semconv/registry/attributes/gen-ai/#gen-ai-tool-type\n if (!attributes['gen_ai.tool.type']) {\n span.setAttribute('gen_ai.tool.type', 'function');\n }\n const toolName = attributes['gen_ai.tool.name'];\n if (toolName) {\n span.updateName(`execute_tool ${toolName}`);\n }\n}\n\nfunction processGenerateSpan(span: Span, name: string, attributes: SpanAttributes): void {\n addOriginToSpan(span, 'auto.vercelai.otel');\n\n const nameWthoutAi = name.replace('ai.', '');\n span.setAttribute('ai.pipeline.name', nameWthoutAi);\n span.updateName(nameWthoutAi);\n\n // If a telemetry name is set and the span represents a pipeline, use it as the operation name.\n // This name can be set at the request level by adding `experimental_telemetry.functionId`.\n const functionId = attributes[AI_TELEMETRY_FUNCTION_ID_ATTRIBUTE];\n if (functionId && typeof functionId === 'string') {\n span.updateName(`${nameWthoutAi} ${functionId}`);\n span.setAttribute('gen_ai.function_id', functionId);\n }\n\n if (attributes[AI_PROMPT_ATTRIBUTE]) {\n span.setAttribute('gen_ai.prompt', attributes[AI_PROMPT_ATTRIBUTE]);\n }\n if (attributes[AI_MODEL_ID_ATTRIBUTE] && !attributes[GEN_AI_RESPONSE_MODEL_ATTRIBUTE]) {\n span.setAttribute(GEN_AI_RESPONSE_MODEL_ATTRIBUTE, attributes[AI_MODEL_ID_ATTRIBUTE]);\n }\n span.setAttribute('ai.streaming', name.includes('stream'));\n\n // Generate Spans\n if (name === 'ai.generateText') {\n span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, 'gen_ai.invoke_agent');\n return;\n }\n\n if (name === 'ai.generateText.doGenerate') {\n span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, 'gen_ai.generate_text');\n span.updateName(`generate_text ${attributes[AI_MODEL_ID_ATTRIBUTE]}`);\n return;\n }\n\n if (name === 'ai.streamText') {\n span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, 'gen_ai.invoke_agent');\n return;\n }\n\n if (name === 'ai.streamText.doStream') {\n span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, 'gen_ai.stream_text');\n span.updateName(`stream_text ${attributes[AI_MODEL_ID_ATTRIBUTE]}`);\n return;\n }\n\n if (name === 'ai.generateObject') {\n span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, 'gen_ai.invoke_agent');\n return;\n }\n\n if (name === 'ai.generateObject.doGenerate') {\n span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, 'gen_ai.generate_object');\n span.updateName(`generate_object ${attributes[AI_MODEL_ID_ATTRIBUTE]}`);\n return;\n }\n\n if (name === 'ai.streamObject') {\n span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, 'gen_ai.invoke_agent');\n return;\n }\n\n if (name === 'ai.streamObject.doStream') {\n span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, 'gen_ai.stream_object');\n span.updateName(`stream_object ${attributes[AI_MODEL_ID_ATTRIBUTE]}`);\n return;\n }\n\n if (name === 'ai.embed') {\n span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, 'gen_ai.invoke_agent');\n return;\n }\n\n if (name === 'ai.embed.doEmbed') {\n span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, 'gen_ai.embed');\n span.updateName(`embed ${attributes[AI_MODEL_ID_ATTRIBUTE]}`);\n return;\n }\n\n if (name === 'ai.embedMany') {\n span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, 'gen_ai.invoke_agent');\n return;\n }\n\n if (name === 'ai.embedMany.doEmbed') {\n span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, 'gen_ai.embed_many');\n span.updateName(`embed_many ${attributes[AI_MODEL_ID_ATTRIBUTE]}`);\n return;\n }\n\n if (name.startsWith('ai.stream')) {\n span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, 'ai.run');\n return;\n }\n}\n\n/**\n * Add event processors to the given client to process Vercel AI spans.\n */\nexport function addVercelAiProcessors(client: Client): void {\n client.on('spanStart', onVercelAiSpanStart);\n // Note: We cannot do this on `spanEnd`, because the span cannot be mutated anymore at this point\n client.addEventProcessor(Object.assign(vercelAiEventProcessor, { id: 'VercelAiEventProcessor' }));\n}\n\nfunction addProviderMetadataToAttributes(attributes: SpanAttributes): void {\n const providerMetadata = attributes[AI_RESPONSE_PROVIDER_METADATA_ATTRIBUTE] as string | undefined;\n if (providerMetadata) {\n try {\n const providerMetadataObject = JSON.parse(providerMetadata) as ProviderMetadata;\n if (providerMetadataObject.openai) {\n setAttributeIfDefined(\n attributes,\n 'gen_ai.usage.input_tokens.cached',\n providerMetadataObject.openai.cachedPromptTokens,\n );\n setAttributeIfDefined(\n attributes,\n 'gen_ai.usage.output_tokens.reasoning',\n providerMetadataObject.openai.reasoningTokens,\n );\n setAttributeIfDefined(\n attributes,\n 'gen_ai.usage.output_tokens.prediction_accepted',\n providerMetadataObject.openai.acceptedPredictionTokens,\n );\n setAttributeIfDefined(\n attributes,\n 'gen_ai.usage.output_tokens.prediction_rejected',\n providerMetadataObject.openai.rejectedPredictionTokens,\n );\n setAttributeIfDefined(attributes, 'gen_ai.conversation.id', providerMetadataObject.openai.responseId);\n }\n\n if (providerMetadataObject.anthropic) {\n setAttributeIfDefined(\n attributes,\n 'gen_ai.usage.input_tokens.cached',\n providerMetadataObject.anthropic.cacheReadInputTokens,\n );\n setAttributeIfDefined(\n attributes,\n 'gen_ai.usage.input_tokens.cache_write',\n providerMetadataObject.anthropic.cacheCreationInputTokens,\n );\n }\n\n if (providerMetadataObject.bedrock?.usage) {\n setAttributeIfDefined(\n attributes,\n 'gen_ai.usage.input_tokens.cached',\n providerMetadataObject.bedrock.usage.cacheReadInputTokens,\n );\n setAttributeIfDefined(\n attributes,\n 'gen_ai.usage.input_tokens.cache_write',\n providerMetadataObject.bedrock.usage.cacheWriteInputTokens,\n );\n }\n\n if (providerMetadataObject.deepseek) {\n setAttributeIfDefined(\n attributes,\n 'gen_ai.usage.input_tokens.cached',\n providerMetadataObject.deepseek.promptCacheHitTokens,\n );\n setAttributeIfDefined(\n attributes,\n 'gen_ai.usage.input_tokens.cache_miss',\n providerMetadataObject.deepseek.promptCacheMissTokens,\n );\n }\n } catch {\n // Ignore\n }\n }\n}\n\n/**\n * Sets an attribute only if the value is not null or undefined.\n */\nfunction setAttributeIfDefined(attributes: SpanAttributes, key: string, value: SpanAttributeValue | undefined): void {\n if (value != null) {\n attributes[key] = value;\n }\n}\n","import type { Client } from '../client';\nimport type { DynamicSamplingContext } from '../types-hoist/envelope';\nimport type { PropagationContext } from '../types-hoist/tracing';\nimport type { TraceparentData } from '../types-hoist/transaction';\nimport { debug } from '../utils/debug-logger';\nimport { baggageHeaderToDynamicSamplingContext } from './baggage';\nimport { extractOrgIdFromClient } from './dsn';\nimport { parseSampleRate } from './parseSampleRate';\nimport { generateSpanId, generateTraceId } from './propagationContext';\n\n// eslint-disable-next-line @sentry-internal/sdk/no-regexp-constructor -- RegExp is used for readability here\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 * This is terrible naming but the function has nothing to do with the W3C traceparent header.\n * It can only parse the `sentry-trace` header and extract the \"trace parent\" data.\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 if (!traceparent) {\n return undefined;\n }\n\n const matches = traceparent.match(TRACEPARENT_REGEXP);\n if (!matches) {\n return undefined;\n }\n\n let parentSampled: boolean | undefined;\n if (matches[3] === '1') {\n parentSampled = true;\n } else if (matches[3] === '0') {\n parentSampled = false;\n }\n\n return {\n traceId: matches[1],\n parentSampled,\n parentSpanId: matches[2],\n };\n}\n\n/**\n * Create a propagation context from incoming headers or\n * creates a minimal new one if the headers are undefined.\n */\nexport function propagationContextFromHeaders(\n sentryTrace: string | undefined,\n baggage: string | number | boolean | string[] | null | undefined,\n): PropagationContext {\n const traceparentData = extractTraceparentData(sentryTrace);\n const dynamicSamplingContext = baggageHeaderToDynamicSamplingContext(baggage);\n\n if (!traceparentData?.traceId) {\n return {\n traceId: generateTraceId(),\n sampleRand: Math.random(),\n };\n }\n\n const sampleRand = getSampleRandFromTraceparentAndDsc(traceparentData, dynamicSamplingContext);\n\n // The sample_rand on the DSC needs to be generated based on traceparent + baggage.\n if (dynamicSamplingContext) {\n dynamicSamplingContext.sample_rand = sampleRand.toString();\n }\n\n const { traceId, parentSpanId, parentSampled } = traceparentData;\n\n return {\n traceId,\n parentSpanId,\n sampled: parentSampled,\n dsc: dynamicSamplingContext || {}, // If we have traceparent data but no DSC it means we are not head of trace and we must freeze it\n sampleRand,\n };\n}\n\n/**\n * Create sentry-trace header from span context values.\n */\nexport function generateSentryTraceHeader(\n traceId: string | undefined = generateTraceId(),\n spanId: string | undefined = generateSpanId(),\n sampled?: boolean,\n): string {\n let sampledString = '';\n if (sampled !== undefined) {\n sampledString = sampled ? '-1' : '-0';\n }\n return `${traceId}-${spanId}${sampledString}`;\n}\n\n/**\n * Creates a W3C traceparent header from the given trace and span ids.\n */\nexport function generateTraceparentHeader(\n traceId: string | undefined = generateTraceId(),\n spanId: string | undefined = generateSpanId(),\n sampled?: boolean,\n): string {\n return `00-${traceId}-${spanId}-${sampled ? '01' : '00'}`;\n}\n\n/**\n * Given any combination of an incoming trace, generate a sample rand based on its defined semantics.\n *\n * Read more: https://develop.sentry.dev/sdk/telemetry/traces/#propagated-random-value\n */\nfunction getSampleRandFromTraceparentAndDsc(\n traceparentData: TraceparentData | undefined,\n dsc: Partial | undefined,\n): number {\n // When there is an incoming sample rand use it.\n const parsedSampleRand = parseSampleRate(dsc?.sample_rand);\n if (parsedSampleRand !== undefined) {\n return parsedSampleRand;\n }\n\n // Otherwise, if there is an incoming sampling decision + sample rate, generate a sample rand that would lead to the same sampling decision.\n const parsedSampleRate = parseSampleRate(dsc?.sample_rate);\n if (parsedSampleRate && traceparentData?.parentSampled !== undefined) {\n return traceparentData.parentSampled\n ? // Returns a sample rand with positive sampling decision [0, sampleRate)\n Math.random() * parsedSampleRate\n : // Returns a sample rand with negative sampling decision [sampleRate, 1)\n parsedSampleRate + Math.random() * (1 - parsedSampleRate);\n } else {\n // If nothing applies, return a random sample rand.\n return Math.random();\n }\n}\n\n/**\n * Determines whether a new trace should be continued based on the provided baggage org ID and the client's `strictTraceContinuation` option.\n * If the trace should not be continued, a new trace will be started.\n *\n * The result is dependent on the `strictTraceContinuation` option in the client.\n * See https://develop.sentry.dev/sdk/telemetry/traces/#stricttracecontinuation\n */\nexport function shouldContinueTrace(client: Client, baggageOrgId?: string): boolean {\n const clientOrgId = extractOrgIdFromClient(client);\n\n // Case: baggage orgID and Client orgID don't match - always start new trace\n if (baggageOrgId && clientOrgId && baggageOrgId !== clientOrgId) {\n debug.log(\n `Won't continue trace because org IDs don't match (incoming baggage: ${baggageOrgId}, SDK options: ${clientOrgId})`,\n );\n return false;\n }\n\n const strictTraceContinuation = client.getOptions().strictTraceContinuation || false; // default for `strictTraceContinuation` is `false`\n\n if (strictTraceContinuation) {\n // With strict continuation enabled, don't continue trace if:\n // - Baggage has orgID, but Client doesn't have one\n // - Client has orgID, but baggage doesn't have one\n if ((baggageOrgId && !clientOrgId) || (!baggageOrgId && clientOrgId)) {\n debug.log(\n `Starting a new trace because strict trace continuation is enabled but one org ID is missing (incoming baggage: ${baggageOrgId}, Sentry client: ${clientOrgId})`,\n );\n return false;\n }\n }\n\n return true;\n}\n","// Based on https://github.com/sindresorhus/escape-string-regexp but with modifications to:\n// a) reduce the size by skipping the runtime type - checking\n// b) ensure it gets down - compiled for old versions of Node(the published package only supports Node 14+).\n//\n// MIT License\n//\n// Copyright (c) Sindre Sorhus (https://sindresorhus.com)\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated\n// documentation files(the \"Software\"), to deal in the Software without restriction, including without limitation\n// the rights to use, copy, modify, merge, publish, distribute, sublicense, and / or sell copies of the Software, and\n// to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all copies or substantial portions of\n// the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO\n// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\n// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n// IN THE SOFTWARE.\n\n/**\n * Given a string, escape characters which have meaning in the regex grammar, such that the result is safe to feed to\n * `new RegExp()`.\n *\n * @param regexString The string to escape\n * @returns An version of the string with all special regex characters escaped\n */\nexport function escapeStringForRegex(regexString: string): string {\n // escape the hyphen separately so we can also replace it with a unicode literal hyphen, to avoid the problems\n // discussed in https://github.com/sindresorhus/escape-string-regexp/issues/20.\n return regexString.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&').replace(/-/g, '\\\\x2d');\n}\n","import { uuid4 } from './misc';\n\n/**\n * Generate a random, valid trace ID.\n */\nexport function generateTraceId(): string {\n return uuid4();\n}\n\n/**\n * Generate a random, valid span ID.\n */\nexport function generateSpanId(): string {\n return uuid4().substring(16);\n}\n","import type { CoreOptions } from '../types-hoist/options';\nimport { SDK_VERSION } from '../utils/version';\n\n/**\n * A builder for the SDK metadata in the options for the SDK initialization.\n *\n * Note: This function is identical to `buildMetadata` in Remix and NextJS and SvelteKit.\n * We don't extract it for bundle size reasons.\n * @see https://github.com/getsentry/sentry-javascript/pull/7404\n * @see https://github.com/getsentry/sentry-javascript/pull/4196\n *\n * If you make changes to this function consider updating the others as well.\n *\n * @param options SDK options object that gets mutated\n * @param names list of package names\n */\nexport function applySdkMetadata(options: CoreOptions, name: string, names = [name], source = 'npm'): void {\n const metadata = options._metadata || {};\n\n if (!metadata.sdk) {\n metadata.sdk = {\n name: `sentry.javascript.${name}`,\n packages: names.map(name => ({\n name: `${source}:@sentry/${name}`,\n version: SDK_VERSION,\n })),\n version: SDK_VERSION,\n };\n }\n\n options._metadata = metadata;\n}\n","import { getAsyncContextStrategy } from '../asyncContext';\nimport { getMainCarrier } from '../carrier';\nimport type { Client } from '../client';\nimport { getClient, getCurrentScope } from '../currentScopes';\nimport { isEnabled } from '../exports';\nimport type { Scope } from '../scope';\nimport { getDynamicSamplingContextFromScope, getDynamicSamplingContextFromSpan } from '../tracing';\nimport type { Span } from '../types-hoist/span';\nimport type { SerializedTraceData } from '../types-hoist/tracing';\nimport { dynamicSamplingContextToSentryBaggageHeader } from './baggage';\nimport { debug } from './debug-logger';\nimport { getActiveSpan, spanToTraceHeader, spanToTraceparentHeader } from './spanUtils';\nimport { generateSentryTraceHeader, generateTraceparentHeader, TRACEPARENT_REGEXP } from './tracing';\n\n/**\n * Extracts trace propagation data from the current span or from the client's scope (via transaction or propagation\n * context) and serializes it to `sentry-trace` and `baggage` values. These values can be used to propagate\n * a trace via our tracing Http headers or Html `` tags.\n *\n * This function also applies some validation to the generated sentry-trace and baggage values to ensure that\n * only valid strings are returned.\n *\n * If (@param options.propagateTraceparent) is `true`, the function will also generate a `traceparent` value,\n * following the W3C traceparent header format.\n *\n * @returns an object with the tracing data values. The object keys are the name of the tracing key to be used as header\n * or meta tag name.\n */\nexport function getTraceData(\n options: { span?: Span; scope?: Scope; client?: Client; propagateTraceparent?: boolean } = {},\n): SerializedTraceData {\n const client = options.client || getClient();\n if (!isEnabled() || !client) {\n return {};\n }\n\n const carrier = getMainCarrier();\n const acs = getAsyncContextStrategy(carrier);\n if (acs.getTraceData) {\n return acs.getTraceData(options);\n }\n\n const scope = options.scope || getCurrentScope();\n const span = options.span || getActiveSpan();\n const sentryTrace = span ? spanToTraceHeader(span) : scopeToTraceHeader(scope);\n const dsc = span ? getDynamicSamplingContextFromSpan(span) : getDynamicSamplingContextFromScope(client, scope);\n const baggage = dynamicSamplingContextToSentryBaggageHeader(dsc);\n\n const isValidSentryTraceHeader = TRACEPARENT_REGEXP.test(sentryTrace);\n if (!isValidSentryTraceHeader) {\n debug.warn('Invalid sentry-trace data. Cannot generate trace data');\n return {};\n }\n\n const traceData: SerializedTraceData = {\n 'sentry-trace': sentryTrace,\n baggage,\n };\n\n if (options.propagateTraceparent) {\n const traceparent = span ? spanToTraceparentHeader(span) : scopeToTraceparentHeader(scope);\n if (traceparent) {\n traceData.traceparent = traceparent;\n }\n }\n\n return traceData;\n}\n\n/**\n * Get a sentry-trace header value for the given scope.\n */\nfunction scopeToTraceHeader(scope: Scope): string {\n const { traceId, sampled, propagationSpanId } = scope.getPropagationContext();\n return generateSentryTraceHeader(traceId, propagationSpanId, sampled);\n}\n\nfunction scopeToTraceparentHeader(scope: Scope): string {\n const { traceId, sampled, propagationSpanId } = scope.getPropagationContext();\n return generateTraceparentHeader(traceId, propagationSpanId, sampled);\n}\n","import type { Event } from '../types-hoist/event';\nimport type { StackFrame } from '../types-hoist/stackframe';\nimport type { StackLineParser, StackParser } from '../types-hoist/stacktrace';\n\nconst STACKTRACE_FRAME_LIMIT = 50;\nexport const UNKNOWN_FUNCTION = '?';\n// Used to sanitize webpack (error: *) wrapped stack errors\nconst WEBPACK_ERROR_REGEXP = /\\(error: (.*)\\)/;\nconst STRIP_FRAME_REGEXP = /captureMessage|captureException/;\n\n/**\n * Creates a stack parser with the supplied line parsers\n *\n * StackFrames are returned in the correct order for Sentry Exception\n * frames and with Sentry SDK internal frames removed from the top and bottom\n *\n */\nexport function createStackParser(...parsers: StackLineParser[]): StackParser {\n const sortedParsers = parsers.sort((a, b) => a[0] - b[0]).map(p => p[1]);\n\n return (stack: string, skipFirstLines: number = 0, framesToPop: number = 0): StackFrame[] => {\n const frames: StackFrame[] = [];\n const lines = stack.split('\\n');\n\n for (let i = skipFirstLines; i < lines.length; i++) {\n let line = lines[i] as string;\n // Truncate lines over 1kb because many of the regular expressions use\n // backtracking which results in run time that increases exponentially\n // with input size. Huge strings can result in hangs/Denial of Service:\n // https://github.com/getsentry/sentry-javascript/issues/2286\n if (line.length > 1024) {\n line = line.slice(0, 1024);\n }\n\n // https://github.com/getsentry/sentry-javascript/issues/5459\n // Remove webpack (error: *) wrappers\n const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, '$1') : line;\n\n // https://github.com/getsentry/sentry-javascript/issues/7813\n // Skip Error: lines\n if (cleanedLine.match(/\\S*Error: /)) {\n continue;\n }\n\n for (const parser of sortedParsers) {\n const frame = parser(cleanedLine);\n\n if (frame) {\n frames.push(frame);\n break;\n }\n }\n\n if (frames.length >= STACKTRACE_FRAME_LIMIT + framesToPop) {\n break;\n }\n }\n\n return stripSentryFramesAndReverse(frames.slice(framesToPop));\n };\n}\n\n/**\n * Gets a stack parser implementation from Options.stackParser\n * @see Options\n *\n * If options contains an array of line parsers, it is converted into a parser\n */\nexport function stackParserFromStackParserOptions(stackParser: StackParser | StackLineParser[]): StackParser {\n if (Array.isArray(stackParser)) {\n return createStackParser(...stackParser);\n }\n return stackParser;\n}\n\n/**\n * Removes Sentry frames from the top and bottom of the stack if present and enforces a limit of max number of frames.\n * Assumes stack input is ordered from top to bottom and returns the reverse representation so call site of the\n * function that caused the crash is the last frame in the array.\n * @hidden\n */\nexport function stripSentryFramesAndReverse(stack: ReadonlyArray): StackFrame[] {\n if (!stack.length) {\n return [];\n }\n\n const localStack = Array.from(stack);\n\n // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)\n if (/sentryWrapped/.test(getLastStackFrame(localStack).function || '')) {\n localStack.pop();\n }\n\n // Reversing in the middle of the procedure allows us to just pop the values off the stack\n localStack.reverse();\n\n // If stack ends with one of our internal API calls, remove it (ends, meaning it's the bottom of the stack - aka top-most call)\n if (STRIP_FRAME_REGEXP.test(getLastStackFrame(localStack).function || '')) {\n localStack.pop();\n\n // When using synthetic events, we will have a 2 levels deep stack, as `new Error('Sentry syntheticException')`\n // is produced within the scope itself, making it:\n //\n // Sentry.captureException()\n // scope.captureException()\n //\n // instead of just the top `Sentry` call itself.\n // This forces us to possibly strip an additional frame in the exact same was as above.\n if (STRIP_FRAME_REGEXP.test(getLastStackFrame(localStack).function || '')) {\n localStack.pop();\n }\n }\n\n return localStack.slice(0, STACKTRACE_FRAME_LIMIT).map(frame => ({\n ...frame,\n filename: frame.filename || getLastStackFrame(localStack).filename,\n function: frame.function || UNKNOWN_FUNCTION,\n }));\n}\n\nfunction getLastStackFrame(arr: StackFrame[]): StackFrame {\n return arr[arr.length - 1] || {};\n}\n\nconst defaultFunctionName = '';\n\n/**\n * Safely extract function name from itself\n */\nexport function getFunctionName(fn: unknown): string {\n try {\n if (!fn || typeof fn !== 'function') {\n return defaultFunctionName;\n }\n return fn.name || defaultFunctionName;\n } catch {\n // Just accessing custom props in some Selenium environments\n // can cause a \"Permission denied\" exception (see raven-js#495).\n return defaultFunctionName;\n }\n}\n\n/**\n * Get's stack frames from an event without needing to check for undefined properties.\n */\nexport function getFramesFromEvent(event: Event): StackFrame[] | undefined {\n const exception = event.exception;\n\n if (exception) {\n const frames: StackFrame[] = [];\n try {\n // @ts-expect-error Object could be undefined\n exception.values.forEach(value => {\n // @ts-expect-error Value could be undefined\n if (value.stacktrace.frames) {\n // @ts-expect-error Value could be undefined\n frames.push(...value.stacktrace.frames);\n }\n });\n return frames;\n } catch {\n return undefined;\n }\n }\n return undefined;\n}\n","import type { Client } from '../client';\nimport { DEFAULT_ENVIRONMENT } from '../constants';\nimport { getGlobalScope } from '../currentScopes';\nimport { notifyEventProcessors } from '../eventProcessors';\nimport type { CaptureContext, ScopeContext } from '../scope';\nimport { Scope } from '../scope';\nimport type { Event, EventHint } from '../types-hoist/event';\nimport type { ClientOptions } from '../types-hoist/options';\nimport type { StackParser } from '../types-hoist/stacktrace';\nimport { applyScopeDataToEvent, mergeScopeData } from './applyScopeDataToEvent';\nimport { getFilenameToDebugIdMap } from './debug-ids';\nimport { addExceptionMechanism, uuid4 } from './misc';\nimport { normalize } from './normalize';\nimport { truncate } from './string';\nimport { dateTimestampInSeconds } from './time';\n\n/**\n * This type makes sure that we get either a CaptureContext, OR an EventHint.\n * It does not allow mixing them, which could lead to unexpected outcomes, e.g. this is disallowed:\n * { user: { id: '123' }, mechanism: { handled: false } }\n */\nexport type ExclusiveEventHintOrCaptureContext =\n | (CaptureContext & Partial<{ [key in keyof EventHint]: never }>)\n | (EventHint & Partial<{ [key in keyof ScopeContext]: never }>);\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 * @hidden\n */\nexport function prepareEvent(\n options: ClientOptions,\n event: Event,\n hint: EventHint,\n scope?: Scope,\n client?: Client,\n isolationScope?: Scope,\n): PromiseLike {\n const { normalizeDepth = 3, normalizeMaxBreadth = 1_000 } = options;\n const prepared: Event = {\n ...event,\n event_id: event.event_id || hint.event_id || uuid4(),\n timestamp: event.timestamp || dateTimestampInSeconds(),\n };\n const integrations = hint.integrations || options.integrations.map(i => i.name);\n\n applyClientOptions(prepared, options);\n applyIntegrationsMetadata(prepared, integrations);\n\n if (client) {\n client.emit('applyFrameMetadata', event);\n }\n\n // Only put debug IDs onto frames for error events.\n if (event.type === undefined) {\n applyDebugIds(prepared, options.stackParser);\n }\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 const finalScope = getFinalScope(scope, hint.captureContext);\n\n if (hint.mechanism) {\n addExceptionMechanism(prepared, hint.mechanism);\n }\n\n const clientEventProcessors = client ? client.getEventProcessors() : [];\n\n // This should be the last thing called, since we want that\n // {@link Scope.addEventProcessor} gets the finished prepared event.\n // Merge scope data together\n const data = getGlobalScope().getScopeData();\n\n if (isolationScope) {\n const isolationData = isolationScope.getScopeData();\n mergeScopeData(data, isolationData);\n }\n\n if (finalScope) {\n const finalScopeData = finalScope.getScopeData();\n mergeScopeData(data, finalScopeData);\n }\n\n const attachments = [...(hint.attachments || []), ...data.attachments];\n if (attachments.length) {\n hint.attachments = attachments;\n }\n\n applyScopeDataToEvent(prepared, data);\n\n const eventProcessors = [\n ...clientEventProcessors,\n // Run scope event processors _after_ all other processors\n ...data.eventProcessors,\n ];\n\n const result = notifyEventProcessors(eventProcessors, prepared, hint);\n\n return result.then(evt => {\n if (evt) {\n // We apply the debug_meta field only after all event processors have ran, so that if any event processors modified\n // file names (e.g.the RewriteFrames integration) the filename -> debug ID relationship isn't destroyed.\n // This should not cause any PII issues, since we're only moving data that is already on the event and not adding\n // any new data\n applyDebugMeta(evt);\n }\n\n if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {\n return normalizeEvent(evt, normalizeDepth, normalizeMaxBreadth);\n }\n return evt;\n });\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 *\n * Only exported for tests.\n *\n * @param event event instance to be enhanced\n */\nexport function applyClientOptions(event: Event, options: ClientOptions): void {\n const { environment, release, dist, maxValueLength = 250 } = options;\n\n // empty strings do not make sense for environment, release, and dist\n // so we handle them the same as if they were not provided\n event.environment = event.environment || environment || DEFAULT_ENVIRONMENT;\n\n if (!event.release && release) {\n event.release = release;\n }\n\n if (!event.dist && dist) {\n event.dist = dist;\n }\n\n const request = event.request;\n if (request?.url) {\n request.url = truncate(request.url, maxValueLength);\n }\n}\n\n/**\n * Puts debug IDs into the stack frames of an error event.\n */\nexport function applyDebugIds(event: Event, stackParser: StackParser): void {\n // Build a map of filename -> debug_id\n const filenameDebugIdMap = getFilenameToDebugIdMap(stackParser);\n\n event.exception?.values?.forEach(exception => {\n exception.stacktrace?.frames?.forEach(frame => {\n if (frame.filename) {\n frame.debug_id = filenameDebugIdMap[frame.filename];\n }\n });\n });\n}\n\n/**\n * Moves debug IDs from the stack frames of an error event into the debug_meta field.\n */\nexport function applyDebugMeta(event: Event): void {\n // Extract debug IDs and filenames from the stack frames on the event.\n const filenameDebugIdMap: Record = {};\n event.exception?.values?.forEach(exception => {\n exception.stacktrace?.frames?.forEach(frame => {\n if (frame.debug_id) {\n if (frame.abs_path) {\n filenameDebugIdMap[frame.abs_path] = frame.debug_id;\n } else if (frame.filename) {\n filenameDebugIdMap[frame.filename] = frame.debug_id;\n }\n delete frame.debug_id;\n }\n });\n });\n\n if (Object.keys(filenameDebugIdMap).length === 0) {\n return;\n }\n\n // Fill debug_meta information\n event.debug_meta = event.debug_meta || {};\n event.debug_meta.images = event.debug_meta.images || [];\n const images = event.debug_meta.images;\n Object.entries(filenameDebugIdMap).forEach(([filename, debug_id]) => {\n images.push({\n type: 'sourcemap',\n code_file: filename,\n debug_id,\n });\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 */\nfunction applyIntegrationsMetadata(event: Event, integrationNames: string[]): void {\n if (integrationNames.length > 0) {\n event.sdk = event.sdk || {};\n event.sdk.integrations = [...(event.sdk.integrations || []), ...integrationNames];\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 */\nfunction 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?.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 return {\n ...span,\n ...(span.data && {\n data: normalize(span.data, depth, maxBreadth),\n }),\n };\n });\n }\n\n // event.contexts.flags (FeatureFlagContext) stores context for our feature\n // flag integrations. It has a greater nesting depth than our other typed\n // Contexts, so we re-normalize with a fixed depth of 3 here. We do not want\n // to skip this in case of conflicting, user-provided context.\n if (event.contexts?.flags && normalized.contexts) {\n normalized.contexts.flags = normalize(event.contexts.flags, 3, maxBreadth);\n }\n\n return normalized;\n}\n\nfunction getFinalScope(scope: Scope | undefined, captureContext: CaptureContext | undefined): Scope | undefined {\n if (!captureContext) {\n return scope;\n }\n\n const finalScope = scope ? scope.clone() : new Scope();\n finalScope.update(captureContext);\n return finalScope;\n}\n\n/**\n * Parse either an `EventHint` directly, or convert a `CaptureContext` to an `EventHint`.\n * This is used to allow to update method signatures that used to accept a `CaptureContext` but should now accept an `EventHint`.\n */\nexport function parseEventHintOrCaptureContext(\n hint: ExclusiveEventHintOrCaptureContext | undefined,\n): EventHint | undefined {\n if (!hint) {\n return undefined;\n }\n\n // If you pass a Scope or `() => Scope` as CaptureContext, we just return this as captureContext\n if (hintIsScopeOrFunction(hint)) {\n return { captureContext: hint };\n }\n\n if (hintIsScopeContext(hint)) {\n return {\n captureContext: hint,\n };\n }\n\n return hint;\n}\n\nfunction hintIsScopeOrFunction(hint: CaptureContext | EventHint): hint is Scope | ((scope: Scope) => Scope) {\n return hint instanceof Scope || typeof hint === 'function';\n}\n\ntype ScopeContextProperty = keyof ScopeContext;\nconst captureContextKeys: readonly ScopeContextProperty[] = [\n 'user',\n 'level',\n 'extra',\n 'contexts',\n 'tags',\n 'fingerprint',\n 'propagationContext',\n] as const;\n\nfunction hintIsScopeContext(hint: Partial | EventHint): hint is Partial {\n return Object.keys(hint).some(key => captureContextKeys.includes(key as ScopeContextProperty));\n}\n","import { isRegExp, isString, isVueViewModel } from './is';\n\nexport { escapeStringForRegex } from '../vendor/escapeStringForRegex';\n\n/**\n * Truncates given string to the maximum characters count\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string (0 = unlimited)\n * @returns string Encoded\n */\nexport function truncate(str: string, max: number = 0): string {\n if (typeof str !== 'string' || max === 0) {\n return str;\n }\n return str.length <= max ? str : `${str.slice(0, max)}...`;\n}\n\n/**\n * This is basically just `trim_line` from\n * https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string\n * @returns string Encoded\n */\nexport function snipLine(line: string, colno: number): string {\n let newLine = line;\n const lineLength = newLine.length;\n if (lineLength <= 150) {\n return newLine;\n }\n if (colno > lineLength) {\n // eslint-disable-next-line no-param-reassign\n colno = lineLength;\n }\n\n let start = Math.max(colno - 60, 0);\n if (start < 5) {\n start = 0;\n }\n\n let end = Math.min(start + 140, lineLength);\n if (end > lineLength - 5) {\n end = lineLength;\n }\n if (end === lineLength) {\n start = Math.max(end - 140, 0);\n }\n\n newLine = newLine.slice(start, end);\n if (start > 0) {\n newLine = `'{snip} ${newLine}`;\n }\n if (end < lineLength) {\n newLine += ' {snip}';\n }\n\n return newLine;\n}\n\n/**\n * Join values in array\n * @param input array of values to be joined together\n * @param delimiter string to be placed in-between values\n * @returns Joined values\n */\nexport function safeJoin(input: unknown[], delimiter?: string): string {\n if (!Array.isArray(input)) {\n return '';\n }\n\n const output = [];\n // eslint-disable-next-line @typescript-eslint/prefer-for-of\n for (let i = 0; i < input.length; i++) {\n const value = input[i];\n try {\n // This is a hack to fix a Vue3-specific bug that causes an infinite loop of\n // console warnings. This happens when a Vue template is rendered with\n // an undeclared variable, which we try to stringify, ultimately causing\n // Vue to issue another warning which repeats indefinitely.\n // see: https://github.com/getsentry/sentry-javascript/pull/8981\n if (isVueViewModel(value)) {\n output.push('[VueViewModel]');\n } else {\n output.push(String(value));\n }\n } catch {\n output.push('[value cannot be serialized]');\n }\n }\n\n return output.join(delimiter);\n}\n\n/**\n * Checks if the given value matches a regex or string\n *\n * @param value The string to test\n * @param pattern Either a regex or a string against which `value` will be matched\n * @param requireExactStringMatch If true, `value` must match `pattern` exactly. If false, `value` will match\n * `pattern` if it contains `pattern`. Only applies to string-type patterns.\n */\nexport function isMatchingPattern(\n value: string,\n pattern: RegExp | string,\n requireExactStringMatch: boolean = false,\n): boolean {\n if (!isString(value)) {\n return false;\n }\n\n if (isRegExp(pattern)) {\n return pattern.test(value);\n }\n if (isString(pattern)) {\n return requireExactStringMatch ? value === pattern : value.includes(pattern);\n }\n\n return false;\n}\n\n/**\n * Test the given string against an array of strings and regexes. By default, string matching is done on a\n * substring-inclusion basis rather than a strict equality basis\n *\n * @param testString The string to test\n * @param patterns The patterns against which to test the string\n * @param requireExactStringMatch If true, `testString` must match one of the given string patterns exactly in order to\n * count. If false, `testString` will match a string pattern if it contains that pattern.\n * @returns\n */\nexport function stringMatchesSomePattern(\n testString: string,\n patterns: Array = [],\n requireExactStringMatch: boolean = false,\n): boolean {\n return patterns.some(pattern => isMatchingPattern(testString, pattern, requireExactStringMatch));\n}\n","// Vendored / modified from @sergiodxa/remix-utils\n\n// https://github.com/sergiodxa/remix-utils/blob/02af80e12829a53696bfa8f3c2363975cf59f55e/src/server/get-client-ip-address.ts\n// MIT License\n\n// Copyright (c) 2021 Sergio Xalambrí\n\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n\n// The headers to check, in priority order\nexport const ipHeaderNames = [\n 'X-Client-IP',\n 'X-Forwarded-For',\n 'Fly-Client-IP',\n 'CF-Connecting-IP',\n 'Fastly-Client-Ip',\n 'True-Client-Ip',\n 'X-Real-IP',\n 'X-Cluster-Client-IP',\n 'X-Forwarded',\n 'Forwarded-For',\n 'Forwarded',\n 'X-Vercel-Forwarded-For',\n];\n\n/**\n * Get the IP address of the client sending a request.\n *\n * It receives a Request headers object and use it to get the\n * IP address from one of the following headers in order.\n *\n * If the IP address is valid, it will be returned. Otherwise, null will be\n * returned.\n *\n * If the header values contains more than one IP address, the first valid one\n * will be returned.\n */\nexport function getClientIPAddress(headers: { [key: string]: string | string[] | undefined }): string | null {\n // This will end up being Array because of the various possible values a header\n // can take\n const headerValues = ipHeaderNames.map((headerName: string) => {\n const rawValue = headers[headerName];\n const value = Array.isArray(rawValue) ? rawValue.join(';') : rawValue;\n\n if (headerName === 'Forwarded') {\n return parseForwardedHeader(value);\n }\n\n return value?.split(',').map((v: string) => v.trim());\n });\n\n // Flatten the array and filter out any falsy entries\n const flattenedHeaderValues = headerValues.reduce((acc: string[], val) => {\n if (!val) {\n return acc;\n }\n\n return acc.concat(val);\n }, []);\n\n // Find the first value which is a valid IP address, if any\n const ipAddress = flattenedHeaderValues.find(ip => ip !== null && isIP(ip));\n\n return ipAddress || null;\n}\n\nfunction parseForwardedHeader(value: string | null | undefined): string | null {\n if (!value) {\n return null;\n }\n\n for (const part of value.split(';')) {\n if (part.startsWith('for=')) {\n return part.slice(4);\n }\n }\n\n return null;\n}\n\n//\n/**\n * Custom method instead of importing this from `net` package, as this only exists in node\n * Accepts:\n * 127.0.0.1\n * 192.168.1.1\n * 192.168.1.255\n * 255.255.255.255\n * 10.1.1.1\n * 0.0.0.0\n * 2b01:cb19:8350:ed00:d0dd:fa5b:de31:8be5\n *\n * Rejects:\n * 1.1.1.01\n * 30.168.1.255.1\n * 127.1\n * 192.168.1.256\n * -1.2.3.4\n * 1.1.1.1.\n * 3...3\n * 192.168.1.099\n */\nfunction isIP(str: string): boolean {\n const regex =\n /(?:^(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}$)|(?:^(?:(?:[a-fA-F\\d]{1,4}:){7}(?:[a-fA-F\\d]{1,4}|:)|(?:[a-fA-F\\d]{1,4}:){6}(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}|:[a-fA-F\\d]{1,4}|:)|(?:[a-fA-F\\d]{1,4}:){5}(?::(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}|(?::[a-fA-F\\d]{1,4}){1,2}|:)|(?:[a-fA-F\\d]{1,4}:){4}(?:(?::[a-fA-F\\d]{1,4}){0,1}:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}|(?::[a-fA-F\\d]{1,4}){1,3}|:)|(?:[a-fA-F\\d]{1,4}:){3}(?:(?::[a-fA-F\\d]{1,4}){0,2}:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}|(?::[a-fA-F\\d]{1,4}){1,4}|:)|(?:[a-fA-F\\d]{1,4}:){2}(?:(?::[a-fA-F\\d]{1,4}){0,3}:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}|(?::[a-fA-F\\d]{1,4}){1,5}|:)|(?:[a-fA-F\\d]{1,4}:){1}(?:(?::[a-fA-F\\d]{1,4}){0,4}:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}|(?::[a-fA-F\\d]{1,4}){1,6}|:)|(?::(?:(?::[a-fA-F\\d]{1,4}){0,5}:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}|(?::[a-fA-F\\d]{1,4}){1,7}|:)))(?:%[0-9a-zA-Z]{1,})?$)/;\n return regex.test(str);\n}\n","/* eslint-disable max-lines */\n/**\n * AI SDK Telemetry Attributes\n * Based on https://ai-sdk.dev/docs/ai-sdk-core/telemetry#collected-data\n */\n\n// =============================================================================\n// COMMON ATTRIBUTES\n// =============================================================================\n\n/**\n * Common attribute for operation name across all functions and spans\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#collected-data\n */\nexport const OPERATION_NAME_ATTRIBUTE = 'operation.name';\n\n/**\n * Common attribute for AI operation ID across all functions and spans\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#collected-data\n */\nexport const AI_OPERATION_ID_ATTRIBUTE = 'ai.operationId';\n\n// =============================================================================\n// SHARED ATTRIBUTES\n// =============================================================================\n\n/**\n * `generateText` function - `ai.generateText` span\n * `streamText` function - `ai.streamText` span\n *\n * The prompt that was used when calling the function\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#generatetext-function\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#streamtext-function\n */\nexport const AI_PROMPT_ATTRIBUTE = 'ai.prompt';\n\n/**\n * `generateObject` function - `ai.generateObject` span\n * `streamObject` function - `ai.streamObject` span\n *\n * The JSON schema version of the schema that was passed into the function\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#generateobject-function\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#streamobject-function\n */\nexport const AI_SCHEMA_ATTRIBUTE = 'ai.schema';\n\n/**\n * `generateObject` function - `ai.generateObject` span\n * `streamObject` function - `ai.streamObject` span\n *\n * The name of the schema that was passed into the function\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#generateobject-function\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#streamobject-function\n */\nexport const AI_SCHEMA_NAME_ATTRIBUTE = 'ai.schema.name';\n\n/**\n * `generateObject` function - `ai.generateObject` span\n * `streamObject` function - `ai.streamObject` span\n *\n * The description of the schema that was passed into the function\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#generateobject-function\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#streamobject-function\n */\nexport const AI_SCHEMA_DESCRIPTION_ATTRIBUTE = 'ai.schema.description';\n\n/**\n * `generateObject` function - `ai.generateObject` span\n * `streamObject` function - `ai.streamObject` span\n *\n * The object that was generated (stringified JSON)\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#generateobject-function\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#streamobject-function\n */\nexport const AI_RESPONSE_OBJECT_ATTRIBUTE = 'ai.response.object';\n\n/**\n * `generateObject` function - `ai.generateObject` span\n * `streamObject` function - `ai.streamObject` span\n *\n * The object generation mode, e.g. `json`\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#generateobject-function\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#streamobject-function\n */\nexport const AI_SETTINGS_MODE_ATTRIBUTE = 'ai.settings.mode';\n\n/**\n * `generateObject` function - `ai.generateObject` span\n * `streamObject` function - `ai.streamObject` span\n *\n * The output type that was used, e.g. `object` or `no-schema`\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#generateobject-function\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#streamobject-function\n */\nexport const AI_SETTINGS_OUTPUT_ATTRIBUTE = 'ai.settings.output';\n\n/**\n * `embed` function - `ai.embed.doEmbed` span\n * `embedMany` function - `ai.embedMany` span\n *\n * The values that were passed into the function (array)\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#embed-function\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#embedmany-function\n */\nexport const AI_VALUES_ATTRIBUTE = 'ai.values';\n\n/**\n * `embed` function - `ai.embed.doEmbed` span\n * `embedMany` function - `ai.embedMany` span\n *\n * An array of JSON-stringified embeddings\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#embed-function\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#embedmany-function\n */\nexport const AI_EMBEDDINGS_ATTRIBUTE = 'ai.embeddings';\n\n// =============================================================================\n// GENERATETEXT FUNCTION - UNIQUE ATTRIBUTES\n// =============================================================================\n\n/**\n * `generateText` function - `ai.generateText` span\n *\n * The text that was generated\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#generatetext-function\n */\nexport const AI_RESPONSE_TEXT_ATTRIBUTE = 'ai.response.text';\n\n/**\n * `generateText` function - `ai.generateText` span\n *\n * The tool calls that were made as part of the generation (stringified JSON)\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#generatetext-function\n */\nexport const AI_RESPONSE_TOOL_CALLS_ATTRIBUTE = 'ai.response.toolCalls';\n\n/**\n * `generateText` function - `ai.generateText` span\n *\n * The reason why the generation finished\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#generatetext-function\n */\nexport const AI_RESPONSE_FINISH_REASON_ATTRIBUTE = 'ai.response.finishReason';\n\n/**\n * `generateText` function - `ai.generateText` span\n *\n * The maximum number of steps that were set\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#generatetext-function\n */\nexport const AI_SETTINGS_MAX_STEPS_ATTRIBUTE = 'ai.settings.maxSteps';\n\n/**\n * `generateText` function - `ai.generateText.doGenerate` span\n *\n * The format of the prompt\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#generatetext-function\n */\nexport const AI_PROMPT_FORMAT_ATTRIBUTE = 'ai.prompt.format';\n\n/**\n * `generateText` function - `ai.generateText.doGenerate` span\n *\n * The messages that were passed into the provider\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#generatetext-function\n */\nexport const AI_PROMPT_MESSAGES_ATTRIBUTE = 'ai.prompt.messages';\n\n/**\n * `generateText` function - `ai.generateText.doGenerate` span\n *\n * Array of stringified tool definitions\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#generatetext-function\n */\nexport const AI_PROMPT_TOOLS_ATTRIBUTE = 'ai.prompt.tools';\n\n/**\n * `generateText` function - `ai.generateText.doGenerate` span\n *\n * The stringified tool choice setting (JSON)\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#generatetext-function\n */\nexport const AI_PROMPT_TOOL_CHOICE_ATTRIBUTE = 'ai.prompt.toolChoice';\n\n// =============================================================================\n// STREAMTEXT FUNCTION - UNIQUE ATTRIBUTES\n// =============================================================================\n\n/**\n * `streamText` function - `ai.streamText.doStream` span\n *\n * The time it took to receive the first chunk in milliseconds\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#streamtext-function\n */\nexport const AI_RESPONSE_MS_TO_FIRST_CHUNK_ATTRIBUTE = 'ai.response.msToFirstChunk';\n\n/**\n * `streamText` function - `ai.streamText.doStream` span\n *\n * The time it took to receive the finish part of the LLM stream in milliseconds\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#streamtext-function\n */\nexport const AI_RESPONSE_MS_TO_FINISH_ATTRIBUTE = 'ai.response.msToFinish';\n\n/**\n * `streamText` function - `ai.streamText.doStream` span\n *\n * The average completion tokens per second\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#streamtext-function\n */\nexport const AI_RESPONSE_AVG_COMPLETION_TOKENS_PER_SECOND_ATTRIBUTE = 'ai.response.avgCompletionTokensPerSecond';\n\n// =============================================================================\n// EMBED FUNCTION - UNIQUE ATTRIBUTES\n// =============================================================================\n\n/**\n * `embed` function - `ai.embed` span\n *\n * The value that was passed into the `embed` function\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#embed-function\n */\nexport const AI_VALUE_ATTRIBUTE = 'ai.value';\n\n/**\n * `embed` function - `ai.embed` span\n *\n * A JSON-stringified embedding\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#embed-function\n */\nexport const AI_EMBEDDING_ATTRIBUTE = 'ai.embedding';\n\n// =============================================================================\n// BASIC LLM SPAN INFORMATION\n// =============================================================================\n\n/**\n * Basic LLM span information\n * Multiple spans\n *\n * The functionId that was set through `telemetry.functionId`\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#basic-llm-span-information\n */\nexport const RESOURCE_NAME_ATTRIBUTE = 'resource.name';\n\n/**\n * Basic LLM span information\n * Multiple spans\n *\n * The id of the model\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#basic-llm-span-information\n */\nexport const AI_MODEL_ID_ATTRIBUTE = 'ai.model.id';\n\n/**\n * Basic LLM span information\n * Multiple spans\n *\n * The provider of the model\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#basic-llm-span-information\n */\nexport const AI_MODEL_PROVIDER_ATTRIBUTE = 'ai.model.provider';\n\n/**\n * Basic LLM span information\n * Multiple spans\n *\n * The request headers that were passed in through `headers`\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#basic-llm-span-information\n */\nexport const AI_REQUEST_HEADERS_ATTRIBUTE = 'ai.request.headers';\n\n/**\n * Basic LLM span information\n * Multiple spans\n *\n * Provider specific metadata returned with the generation response\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#basic-llm-span-information\n */\nexport const AI_RESPONSE_PROVIDER_METADATA_ATTRIBUTE = 'ai.response.providerMetadata';\n\n/**\n * Basic LLM span information\n * Multiple spans\n *\n * The maximum number of retries that were set\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#basic-llm-span-information\n */\nexport const AI_SETTINGS_MAX_RETRIES_ATTRIBUTE = 'ai.settings.maxRetries';\n\n/**\n * Basic LLM span information\n * Multiple spans\n *\n * The functionId that was set through `telemetry.functionId`\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#basic-llm-span-information\n */\nexport const AI_TELEMETRY_FUNCTION_ID_ATTRIBUTE = 'ai.telemetry.functionId';\n\n/**\n * Basic LLM span information\n * Multiple spans\n *\n * The metadata that was passed in through `telemetry.metadata`\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#basic-llm-span-information\n */\nexport const AI_TELEMETRY_METADATA_ATTRIBUTE = 'ai.telemetry.metadata';\n\n/**\n * Basic LLM span information\n * Multiple spans\n *\n * The number of completion tokens that were used\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#basic-llm-span-information\n */\nexport const AI_USAGE_COMPLETION_TOKENS_ATTRIBUTE = 'ai.usage.completionTokens';\n\n/**\n * Basic LLM span information\n * Multiple spans\n *\n * The number of prompt tokens that were used\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#basic-llm-span-information\n */\nexport const AI_USAGE_PROMPT_TOKENS_ATTRIBUTE = 'ai.usage.promptTokens';\n\n// =============================================================================\n// CALL LLM SPAN INFORMATION\n// =============================================================================\n\n/**\n * Call LLM span information\n * Individual LLM call spans\n *\n * The model that was used to generate the response\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#call-llm-span-information\n */\nexport const AI_RESPONSE_MODEL_ATTRIBUTE = 'ai.response.model';\n\n/**\n * Call LLM span information\n * Individual LLM call spans\n *\n * The id of the response\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#call-llm-span-information\n */\nexport const AI_RESPONSE_ID_ATTRIBUTE = 'ai.response.id';\n\n/**\n * Call LLM span information\n * Individual LLM call spans\n *\n * The timestamp of the response\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#call-llm-span-information\n */\nexport const AI_RESPONSE_TIMESTAMP_ATTRIBUTE = 'ai.response.timestamp';\n\n// =============================================================================\n// SEMANTIC CONVENTIONS FOR GENAI OPERATIONS\n// =============================================================================\n\n/**\n * Semantic Conventions for GenAI operations\n * Individual LLM call spans\n *\n * The provider that was used\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#call-llm-span-information\n */\nexport const GEN_AI_SYSTEM_ATTRIBUTE = 'gen_ai.system';\n\n/**\n * Semantic Conventions for GenAI operations\n * Individual LLM call spans\n *\n * The model that was requested\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#call-llm-span-information\n */\nexport const GEN_AI_REQUEST_MODEL_ATTRIBUTE = 'gen_ai.request.model';\n\n/**\n * Semantic Conventions for GenAI operations\n * Individual LLM call spans\n *\n * The temperature that was set\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#call-llm-span-information\n */\nexport const GEN_AI_REQUEST_TEMPERATURE_ATTRIBUTE = 'gen_ai.request.temperature';\n\n/**\n * Semantic Conventions for GenAI operations\n * Individual LLM call spans\n *\n * The maximum number of tokens that were set\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#call-llm-span-information\n */\nexport const GEN_AI_REQUEST_MAX_TOKENS_ATTRIBUTE = 'gen_ai.request.max_tokens';\n\n/**\n * Semantic Conventions for GenAI operations\n * Individual LLM call spans\n *\n * The frequency penalty that was set\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#call-llm-span-information\n */\nexport const GEN_AI_REQUEST_FREQUENCY_PENALTY_ATTRIBUTE = 'gen_ai.request.frequency_penalty';\n\n/**\n * Semantic Conventions for GenAI operations\n * Individual LLM call spans\n *\n * The presence penalty that was set\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#call-llm-span-information\n */\nexport const GEN_AI_REQUEST_PRESENCE_PENALTY_ATTRIBUTE = 'gen_ai.request.presence_penalty';\n\n/**\n * Semantic Conventions for GenAI operations\n * Individual LLM call spans\n *\n * The topK parameter value that was set\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#call-llm-span-information\n */\nexport const GEN_AI_REQUEST_TOP_K_ATTRIBUTE = 'gen_ai.request.top_k';\n\n/**\n * Semantic Conventions for GenAI operations\n * Individual LLM call spans\n *\n * The topP parameter value that was set\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#call-llm-span-information\n */\nexport const GEN_AI_REQUEST_TOP_P_ATTRIBUTE = 'gen_ai.request.top_p';\n\n/**\n * Semantic Conventions for GenAI operations\n * Individual LLM call spans\n *\n * The stop sequences\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#call-llm-span-information\n */\nexport const GEN_AI_REQUEST_STOP_SEQUENCES_ATTRIBUTE = 'gen_ai.request.stop_sequences';\n\n/**\n * Semantic Conventions for GenAI operations\n * Individual LLM call spans\n *\n * The finish reasons that were returned by the provider\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#call-llm-span-information\n */\nexport const GEN_AI_RESPONSE_FINISH_REASONS_ATTRIBUTE = 'gen_ai.response.finish_reasons';\n\n/**\n * Semantic Conventions for GenAI operations\n * Individual LLM call spans\n *\n * The model that was used to generate the response\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#call-llm-span-information\n */\nexport const GEN_AI_RESPONSE_MODEL_ATTRIBUTE = 'gen_ai.response.model';\n\n/**\n * Semantic Conventions for GenAI operations\n * Individual LLM call spans\n *\n * The id of the response\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#call-llm-span-information\n */\nexport const GEN_AI_RESPONSE_ID_ATTRIBUTE = 'gen_ai.response.id';\n\n/**\n * Semantic Conventions for GenAI operations\n * Individual LLM call spans\n *\n * The number of prompt tokens that were used\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#call-llm-span-information\n */\nexport const GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE = 'gen_ai.usage.input_tokens';\n\n/**\n * Semantic Conventions for GenAI operations\n * Individual LLM call spans\n *\n * The number of completion tokens that were used\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#call-llm-span-information\n */\nexport const GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE = 'gen_ai.usage.output_tokens';\n\n// =============================================================================\n// BASIC EMBEDDING SPAN INFORMATION\n// =============================================================================\n\n/**\n * Basic embedding span information\n * Embedding spans\n *\n * The number of tokens that were used\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#basic-embedding-span-information\n */\nexport const AI_USAGE_TOKENS_ATTRIBUTE = 'ai.usage.tokens';\n\n// =============================================================================\n// TOOL CALL SPANS\n// =============================================================================\n\n/**\n * Tool call spans\n * `ai.toolCall` span\n *\n * The name of the tool\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#tool-call-spans\n */\nexport const AI_TOOL_CALL_NAME_ATTRIBUTE = 'ai.toolCall.name';\n\n/**\n * Tool call spans\n * `ai.toolCall` span\n *\n * The id of the tool call\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#tool-call-spans\n */\nexport const AI_TOOL_CALL_ID_ATTRIBUTE = 'ai.toolCall.id';\n\n/**\n * Tool call spans\n * `ai.toolCall` span\n *\n * The parameters of the tool call\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#tool-call-spans\n */\nexport const AI_TOOL_CALL_ARGS_ATTRIBUTE = 'ai.toolCall.args';\n\n/**\n * Tool call spans\n * `ai.toolCall` span\n *\n * The result of the tool call\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#tool-call-spans\n */\nexport const AI_TOOL_CALL_RESULT_ATTRIBUTE = 'ai.toolCall.result';\n\n// =============================================================================\n// SPAN ATTRIBUTE OBJECTS\n// =============================================================================\n\n/**\n * Attributes collected for `ai.generateText` span\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#generatetext-function\n */\nexport const AI_GENERATE_TEXT_SPAN_ATTRIBUTES = {\n OPERATION_NAME: OPERATION_NAME_ATTRIBUTE,\n AI_OPERATION_ID: AI_OPERATION_ID_ATTRIBUTE,\n AI_PROMPT: AI_PROMPT_ATTRIBUTE,\n AI_RESPONSE_TEXT: AI_RESPONSE_TEXT_ATTRIBUTE,\n AI_RESPONSE_TOOL_CALLS: AI_RESPONSE_TOOL_CALLS_ATTRIBUTE,\n AI_RESPONSE_FINISH_REASON: AI_RESPONSE_FINISH_REASON_ATTRIBUTE,\n AI_SETTINGS_MAX_STEPS: AI_SETTINGS_MAX_STEPS_ATTRIBUTE,\n // Basic LLM span information\n RESOURCE_NAME: RESOURCE_NAME_ATTRIBUTE,\n AI_MODEL_ID: AI_MODEL_ID_ATTRIBUTE,\n AI_MODEL_PROVIDER: AI_MODEL_PROVIDER_ATTRIBUTE,\n AI_REQUEST_HEADERS: AI_REQUEST_HEADERS_ATTRIBUTE,\n AI_SETTINGS_MAX_RETRIES: AI_SETTINGS_MAX_RETRIES_ATTRIBUTE,\n AI_TELEMETRY_FUNCTION_ID: AI_TELEMETRY_FUNCTION_ID_ATTRIBUTE,\n AI_TELEMETRY_METADATA: AI_TELEMETRY_METADATA_ATTRIBUTE,\n AI_USAGE_COMPLETION_TOKENS: AI_USAGE_COMPLETION_TOKENS_ATTRIBUTE,\n AI_USAGE_PROMPT_TOKENS: AI_USAGE_PROMPT_TOKENS_ATTRIBUTE,\n} as const;\n\n/**\n * Attributes collected for `ai.generateText.doGenerate` span\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#generatetext-function\n */\nexport const AI_GENERATE_TEXT_DO_GENERATE_SPAN_ATTRIBUTES = {\n OPERATION_NAME: OPERATION_NAME_ATTRIBUTE,\n AI_OPERATION_ID: AI_OPERATION_ID_ATTRIBUTE,\n AI_PROMPT_FORMAT: AI_PROMPT_FORMAT_ATTRIBUTE,\n AI_PROMPT_MESSAGES: AI_PROMPT_MESSAGES_ATTRIBUTE,\n AI_PROMPT_TOOLS: AI_PROMPT_TOOLS_ATTRIBUTE,\n AI_PROMPT_TOOL_CHOICE: AI_PROMPT_TOOL_CHOICE_ATTRIBUTE,\n // Basic LLM span information\n RESOURCE_NAME: RESOURCE_NAME_ATTRIBUTE,\n AI_MODEL_ID: AI_MODEL_ID_ATTRIBUTE,\n AI_MODEL_PROVIDER: AI_MODEL_PROVIDER_ATTRIBUTE,\n AI_REQUEST_HEADERS: AI_REQUEST_HEADERS_ATTRIBUTE,\n AI_SETTINGS_MAX_RETRIES: AI_SETTINGS_MAX_RETRIES_ATTRIBUTE,\n AI_TELEMETRY_FUNCTION_ID: AI_TELEMETRY_FUNCTION_ID_ATTRIBUTE,\n AI_TELEMETRY_METADATA: AI_TELEMETRY_METADATA_ATTRIBUTE,\n AI_USAGE_COMPLETION_TOKENS: AI_USAGE_COMPLETION_TOKENS_ATTRIBUTE,\n AI_USAGE_PROMPT_TOKENS: AI_USAGE_PROMPT_TOKENS_ATTRIBUTE,\n // Call LLM span information\n AI_RESPONSE_MODEL: AI_RESPONSE_MODEL_ATTRIBUTE,\n AI_RESPONSE_ID: AI_RESPONSE_ID_ATTRIBUTE,\n AI_RESPONSE_TIMESTAMP: AI_RESPONSE_TIMESTAMP_ATTRIBUTE,\n // Semantic Conventions for GenAI operations\n GEN_AI_SYSTEM: GEN_AI_SYSTEM_ATTRIBUTE,\n GEN_AI_REQUEST_MODEL: GEN_AI_REQUEST_MODEL_ATTRIBUTE,\n GEN_AI_REQUEST_TEMPERATURE: GEN_AI_REQUEST_TEMPERATURE_ATTRIBUTE,\n GEN_AI_REQUEST_MAX_TOKENS: GEN_AI_REQUEST_MAX_TOKENS_ATTRIBUTE,\n GEN_AI_REQUEST_FREQUENCY_PENALTY: GEN_AI_REQUEST_FREQUENCY_PENALTY_ATTRIBUTE,\n GEN_AI_REQUEST_PRESENCE_PENALTY: GEN_AI_REQUEST_PRESENCE_PENALTY_ATTRIBUTE,\n GEN_AI_REQUEST_TOP_K: GEN_AI_REQUEST_TOP_K_ATTRIBUTE,\n GEN_AI_REQUEST_TOP_P: GEN_AI_REQUEST_TOP_P_ATTRIBUTE,\n GEN_AI_REQUEST_STOP_SEQUENCES: GEN_AI_REQUEST_STOP_SEQUENCES_ATTRIBUTE,\n GEN_AI_RESPONSE_FINISH_REASONS: GEN_AI_RESPONSE_FINISH_REASONS_ATTRIBUTE,\n GEN_AI_RESPONSE_MODEL: GEN_AI_RESPONSE_MODEL_ATTRIBUTE,\n GEN_AI_RESPONSE_ID: GEN_AI_RESPONSE_ID_ATTRIBUTE,\n GEN_AI_USAGE_INPUT_TOKENS: GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE,\n GEN_AI_USAGE_OUTPUT_TOKENS: GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE,\n} as const;\n\n/**\n * Attributes collected for `ai.streamText` span\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#streamtext-function\n */\nexport const AI_STREAM_TEXT_SPAN_ATTRIBUTES = {\n OPERATION_NAME: OPERATION_NAME_ATTRIBUTE,\n AI_OPERATION_ID: AI_OPERATION_ID_ATTRIBUTE,\n AI_PROMPT: AI_PROMPT_ATTRIBUTE,\n // Basic LLM span information\n RESOURCE_NAME: RESOURCE_NAME_ATTRIBUTE,\n AI_MODEL_ID: AI_MODEL_ID_ATTRIBUTE,\n AI_MODEL_PROVIDER: AI_MODEL_PROVIDER_ATTRIBUTE,\n AI_REQUEST_HEADERS: AI_REQUEST_HEADERS_ATTRIBUTE,\n AI_SETTINGS_MAX_RETRIES: AI_SETTINGS_MAX_RETRIES_ATTRIBUTE,\n AI_TELEMETRY_FUNCTION_ID: AI_TELEMETRY_FUNCTION_ID_ATTRIBUTE,\n AI_TELEMETRY_METADATA: AI_TELEMETRY_METADATA_ATTRIBUTE,\n AI_USAGE_COMPLETION_TOKENS: AI_USAGE_COMPLETION_TOKENS_ATTRIBUTE,\n AI_USAGE_PROMPT_TOKENS: AI_USAGE_PROMPT_TOKENS_ATTRIBUTE,\n} as const;\n\n/**\n * Attributes collected for `ai.streamText.doStream` span\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#streamtext-function\n */\nexport const AI_STREAM_TEXT_DO_STREAM_SPAN_ATTRIBUTES = {\n OPERATION_NAME: OPERATION_NAME_ATTRIBUTE,\n AI_OPERATION_ID: AI_OPERATION_ID_ATTRIBUTE,\n AI_RESPONSE_MS_TO_FIRST_CHUNK: AI_RESPONSE_MS_TO_FIRST_CHUNK_ATTRIBUTE,\n AI_RESPONSE_MS_TO_FINISH: AI_RESPONSE_MS_TO_FINISH_ATTRIBUTE,\n AI_RESPONSE_AVG_COMPLETION_TOKENS_PER_SECOND: AI_RESPONSE_AVG_COMPLETION_TOKENS_PER_SECOND_ATTRIBUTE,\n // Basic LLM span information\n RESOURCE_NAME: RESOURCE_NAME_ATTRIBUTE,\n AI_MODEL_ID: AI_MODEL_ID_ATTRIBUTE,\n AI_MODEL_PROVIDER: AI_MODEL_PROVIDER_ATTRIBUTE,\n AI_REQUEST_HEADERS: AI_REQUEST_HEADERS_ATTRIBUTE,\n AI_SETTINGS_MAX_RETRIES: AI_SETTINGS_MAX_RETRIES_ATTRIBUTE,\n AI_TELEMETRY_FUNCTION_ID: AI_TELEMETRY_FUNCTION_ID_ATTRIBUTE,\n AI_TELEMETRY_METADATA: AI_TELEMETRY_METADATA_ATTRIBUTE,\n AI_USAGE_COMPLETION_TOKENS: AI_USAGE_COMPLETION_TOKENS_ATTRIBUTE,\n AI_USAGE_PROMPT_TOKENS: AI_USAGE_PROMPT_TOKENS_ATTRIBUTE,\n // Call LLM span information\n AI_RESPONSE_MODEL: AI_RESPONSE_MODEL_ATTRIBUTE,\n AI_RESPONSE_ID: AI_RESPONSE_ID_ATTRIBUTE,\n AI_RESPONSE_TIMESTAMP: AI_RESPONSE_TIMESTAMP_ATTRIBUTE,\n // Semantic Conventions for GenAI operations\n GEN_AI_SYSTEM: GEN_AI_SYSTEM_ATTRIBUTE,\n GEN_AI_REQUEST_MODEL: GEN_AI_REQUEST_MODEL_ATTRIBUTE,\n GEN_AI_REQUEST_TEMPERATURE: GEN_AI_REQUEST_TEMPERATURE_ATTRIBUTE,\n GEN_AI_REQUEST_MAX_TOKENS: GEN_AI_REQUEST_MAX_TOKENS_ATTRIBUTE,\n GEN_AI_REQUEST_FREQUENCY_PENALTY: GEN_AI_REQUEST_FREQUENCY_PENALTY_ATTRIBUTE,\n GEN_AI_REQUEST_PRESENCE_PENALTY: GEN_AI_REQUEST_PRESENCE_PENALTY_ATTRIBUTE,\n GEN_AI_REQUEST_TOP_K: GEN_AI_REQUEST_TOP_K_ATTRIBUTE,\n GEN_AI_REQUEST_TOP_P: GEN_AI_REQUEST_TOP_P_ATTRIBUTE,\n GEN_AI_REQUEST_STOP_SEQUENCES: GEN_AI_REQUEST_STOP_SEQUENCES_ATTRIBUTE,\n GEN_AI_RESPONSE_FINISH_REASONS: GEN_AI_RESPONSE_FINISH_REASONS_ATTRIBUTE,\n GEN_AI_RESPONSE_MODEL: GEN_AI_RESPONSE_MODEL_ATTRIBUTE,\n GEN_AI_RESPONSE_ID: GEN_AI_RESPONSE_ID_ATTRIBUTE,\n GEN_AI_USAGE_INPUT_TOKENS: GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE,\n GEN_AI_USAGE_OUTPUT_TOKENS: GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE,\n} as const;\n\n/**\n * Attributes collected for `ai.generateObject` span\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#generateobject-function\n */\nexport const AI_GENERATE_OBJECT_SPAN_ATTRIBUTES = {\n OPERATION_NAME: OPERATION_NAME_ATTRIBUTE,\n AI_OPERATION_ID: AI_OPERATION_ID_ATTRIBUTE,\n AI_SCHEMA: AI_SCHEMA_ATTRIBUTE,\n AI_SCHEMA_NAME: AI_SCHEMA_NAME_ATTRIBUTE,\n AI_SCHEMA_DESCRIPTION: AI_SCHEMA_DESCRIPTION_ATTRIBUTE,\n AI_RESPONSE_OBJECT: AI_RESPONSE_OBJECT_ATTRIBUTE,\n AI_SETTINGS_MODE: AI_SETTINGS_MODE_ATTRIBUTE,\n AI_SETTINGS_OUTPUT: AI_SETTINGS_OUTPUT_ATTRIBUTE,\n // Basic LLM span information\n RESOURCE_NAME: RESOURCE_NAME_ATTRIBUTE,\n AI_MODEL_ID: AI_MODEL_ID_ATTRIBUTE,\n AI_MODEL_PROVIDER: AI_MODEL_PROVIDER_ATTRIBUTE,\n AI_REQUEST_HEADERS: AI_REQUEST_HEADERS_ATTRIBUTE,\n AI_SETTINGS_MAX_RETRIES: AI_SETTINGS_MAX_RETRIES_ATTRIBUTE,\n AI_TELEMETRY_FUNCTION_ID: AI_TELEMETRY_FUNCTION_ID_ATTRIBUTE,\n AI_TELEMETRY_METADATA: AI_TELEMETRY_METADATA_ATTRIBUTE,\n AI_USAGE_COMPLETION_TOKENS: AI_USAGE_COMPLETION_TOKENS_ATTRIBUTE,\n AI_USAGE_PROMPT_TOKENS: AI_USAGE_PROMPT_TOKENS_ATTRIBUTE,\n} as const;\n\n/**\n * Attributes collected for `ai.streamObject` span\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#streamobject-function\n */\nexport const AI_STREAM_OBJECT_SPAN_ATTRIBUTES = {\n OPERATION_NAME: OPERATION_NAME_ATTRIBUTE,\n AI_OPERATION_ID: AI_OPERATION_ID_ATTRIBUTE,\n AI_SCHEMA: AI_SCHEMA_ATTRIBUTE,\n AI_SCHEMA_NAME: AI_SCHEMA_NAME_ATTRIBUTE,\n AI_SCHEMA_DESCRIPTION: AI_SCHEMA_DESCRIPTION_ATTRIBUTE,\n AI_RESPONSE_OBJECT: AI_RESPONSE_OBJECT_ATTRIBUTE,\n AI_SETTINGS_MODE: AI_SETTINGS_MODE_ATTRIBUTE,\n AI_SETTINGS_OUTPUT: AI_SETTINGS_OUTPUT_ATTRIBUTE,\n // Basic LLM span information\n RESOURCE_NAME: RESOURCE_NAME_ATTRIBUTE,\n AI_MODEL_ID: AI_MODEL_ID_ATTRIBUTE,\n AI_MODEL_PROVIDER: AI_MODEL_PROVIDER_ATTRIBUTE,\n AI_REQUEST_HEADERS: AI_REQUEST_HEADERS_ATTRIBUTE,\n AI_SETTINGS_MAX_RETRIES: AI_SETTINGS_MAX_RETRIES_ATTRIBUTE,\n AI_TELEMETRY_FUNCTION_ID: AI_TELEMETRY_FUNCTION_ID_ATTRIBUTE,\n AI_TELEMETRY_METADATA: AI_TELEMETRY_METADATA_ATTRIBUTE,\n AI_USAGE_COMPLETION_TOKENS: AI_USAGE_COMPLETION_TOKENS_ATTRIBUTE,\n AI_USAGE_PROMPT_TOKENS: AI_USAGE_PROMPT_TOKENS_ATTRIBUTE,\n} as const;\n\n/**\n * Attributes collected for `ai.embed` span\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#embed-function\n */\nexport const AI_EMBED_SPAN_ATTRIBUTES = {\n OPERATION_NAME: OPERATION_NAME_ATTRIBUTE,\n AI_OPERATION_ID: AI_OPERATION_ID_ATTRIBUTE,\n AI_VALUE: AI_VALUE_ATTRIBUTE,\n AI_EMBEDDING: AI_EMBEDDING_ATTRIBUTE,\n // Basic LLM span information\n RESOURCE_NAME: RESOURCE_NAME_ATTRIBUTE,\n AI_MODEL_ID: AI_MODEL_ID_ATTRIBUTE,\n AI_MODEL_PROVIDER: AI_MODEL_PROVIDER_ATTRIBUTE,\n AI_REQUEST_HEADERS: AI_REQUEST_HEADERS_ATTRIBUTE,\n AI_SETTINGS_MAX_RETRIES: AI_SETTINGS_MAX_RETRIES_ATTRIBUTE,\n AI_TELEMETRY_FUNCTION_ID: AI_TELEMETRY_FUNCTION_ID_ATTRIBUTE,\n AI_TELEMETRY_METADATA: AI_TELEMETRY_METADATA_ATTRIBUTE,\n // Basic embedding span information\n AI_USAGE_TOKENS: AI_USAGE_TOKENS_ATTRIBUTE,\n} as const;\n\n/**\n * Attributes collected for `ai.embed.doEmbed` span\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#embed-function\n */\nexport const AI_EMBED_DO_EMBED_SPAN_ATTRIBUTES = {\n OPERATION_NAME: OPERATION_NAME_ATTRIBUTE,\n AI_OPERATION_ID: AI_OPERATION_ID_ATTRIBUTE,\n AI_VALUES: AI_VALUES_ATTRIBUTE,\n AI_EMBEDDINGS: AI_EMBEDDINGS_ATTRIBUTE,\n // Basic LLM span information\n RESOURCE_NAME: RESOURCE_NAME_ATTRIBUTE,\n AI_MODEL_ID: AI_MODEL_ID_ATTRIBUTE,\n AI_MODEL_PROVIDER: AI_MODEL_PROVIDER_ATTRIBUTE,\n AI_REQUEST_HEADERS: AI_REQUEST_HEADERS_ATTRIBUTE,\n AI_SETTINGS_MAX_RETRIES: AI_SETTINGS_MAX_RETRIES_ATTRIBUTE,\n AI_TELEMETRY_FUNCTION_ID: AI_TELEMETRY_FUNCTION_ID_ATTRIBUTE,\n AI_TELEMETRY_METADATA: AI_TELEMETRY_METADATA_ATTRIBUTE,\n // Basic embedding span information\n AI_USAGE_TOKENS: AI_USAGE_TOKENS_ATTRIBUTE,\n} as const;\n\n/**\n * Attributes collected for `ai.embedMany` span\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#embedmany-function\n */\nexport const AI_EMBED_MANY_SPAN_ATTRIBUTES = {\n OPERATION_NAME: OPERATION_NAME_ATTRIBUTE,\n AI_OPERATION_ID: AI_OPERATION_ID_ATTRIBUTE,\n AI_VALUES: AI_VALUES_ATTRIBUTE,\n AI_EMBEDDINGS: AI_EMBEDDINGS_ATTRIBUTE,\n // Basic LLM span information\n RESOURCE_NAME: RESOURCE_NAME_ATTRIBUTE,\n AI_MODEL_ID: AI_MODEL_ID_ATTRIBUTE,\n AI_MODEL_PROVIDER: AI_MODEL_PROVIDER_ATTRIBUTE,\n AI_REQUEST_HEADERS: AI_REQUEST_HEADERS_ATTRIBUTE,\n AI_SETTINGS_MAX_RETRIES: AI_SETTINGS_MAX_RETRIES_ATTRIBUTE,\n AI_TELEMETRY_FUNCTION_ID: AI_TELEMETRY_FUNCTION_ID_ATTRIBUTE,\n AI_TELEMETRY_METADATA: AI_TELEMETRY_METADATA_ATTRIBUTE,\n // Basic embedding span information\n AI_USAGE_TOKENS: AI_USAGE_TOKENS_ATTRIBUTE,\n} as const;\n\n/**\n * Attributes collected for `ai.toolCall` span\n * @see https://ai-sdk.dev/docs/ai-sdk-core/telemetry#tool-call-spans\n */\nexport const AI_TOOL_CALL_SPAN_ATTRIBUTES = {\n OPERATION_NAME: OPERATION_NAME_ATTRIBUTE,\n AI_OPERATION_ID: AI_OPERATION_ID_ATTRIBUTE,\n AI_TOOL_CALL_NAME: AI_TOOL_CALL_NAME_ATTRIBUTE,\n AI_TOOL_CALL_ID: AI_TOOL_CALL_ID_ATTRIBUTE,\n AI_TOOL_CALL_ARGS: AI_TOOL_CALL_ARGS_ATTRIBUTE,\n AI_TOOL_CALL_RESULT: AI_TOOL_CALL_RESULT_ATTRIBUTE,\n // Basic LLM span information\n RESOURCE_NAME: RESOURCE_NAME_ATTRIBUTE,\n AI_MODEL_ID: AI_MODEL_ID_ATTRIBUTE,\n AI_MODEL_PROVIDER: AI_MODEL_PROVIDER_ATTRIBUTE,\n AI_REQUEST_HEADERS: AI_REQUEST_HEADERS_ATTRIBUTE,\n AI_SETTINGS_MAX_RETRIES: AI_SETTINGS_MAX_RETRIES_ATTRIBUTE,\n AI_TELEMETRY_FUNCTION_ID: AI_TELEMETRY_FUNCTION_ID_ATTRIBUTE,\n AI_TELEMETRY_METADATA: AI_TELEMETRY_METADATA_ATTRIBUTE,\n} as const;\n\n// =============================================================================\n// PROVIDER METADATA\n// =============================================================================\n\n/**\n * OpenAI Provider Metadata\n * @see https://ai-sdk.dev/providers/ai-sdk-providers/openai\n * @see https://github.com/vercel/ai/blob/65e042afde6aad4da9d7a62526ece839eb34f9a5/packages/openai/src/openai-chat-language-model.ts#L397-L416\n * @see https://github.com/vercel/ai/blob/65e042afde6aad4da9d7a62526ece839eb34f9a5/packages/openai/src/responses/openai-responses-language-model.ts#L377C7-L384\n */\ninterface OpenAiProviderMetadata {\n /**\n * The number of predicted output tokens that were accepted.\n * @see https://ai-sdk.dev/providers/ai-sdk-providers/openai#predicted-outputs\n */\n acceptedPredictionTokens?: number;\n\n /**\n * The number of predicted output tokens that were rejected.\n * @see https://ai-sdk.dev/providers/ai-sdk-providers/openai#predicted-outputs\n */\n rejectedPredictionTokens?: number;\n\n /**\n * The number of reasoning tokens that the model generated.\n * @see https://ai-sdk.dev/providers/ai-sdk-providers/openai#responses-models\n */\n reasoningTokens?: number;\n\n /**\n * The number of prompt tokens that were a cache hit.\n * @see https://ai-sdk.dev/providers/ai-sdk-providers/openai#responses-models\n */\n cachedPromptTokens?: number;\n\n /**\n * @see https://ai-sdk.dev/providers/ai-sdk-providers/openai#responses-models\n *\n * The ID of the response. Can be used to continue a conversation.\n */\n responseId?: string;\n}\n\n/**\n * Anthropic Provider Metadata\n * @see https://ai-sdk.dev/providers/ai-sdk-providers/anthropic\n * @see https://github.com/vercel/ai/blob/65e042afde6aad4da9d7a62526ece839eb34f9a5/packages/anthropic/src/anthropic-messages-language-model.ts#L346-L352\n */\ninterface AnthropicProviderMetadata {\n /**\n * The number of tokens that were used to create the cache.\n * @see https://ai-sdk.dev/providers/ai-sdk-providers/anthropic#cache-control\n */\n cacheCreationInputTokens?: number;\n\n /**\n * The number of tokens that were read from the cache.\n * @see https://ai-sdk.dev/providers/ai-sdk-providers/anthropic#cache-control\n */\n cacheReadInputTokens?: number;\n}\n\n/**\n * Amazon Bedrock Provider Metadata\n * @see https://ai-sdk.dev/providers/ai-sdk-providers/amazon-bedrock\n * @see https://github.com/vercel/ai/blob/65e042afde6aad4da9d7a62526ece839eb34f9a5/packages/amazon-bedrock/src/bedrock-chat-language-model.ts#L263-L280\n */\ninterface AmazonBedrockProviderMetadata {\n /**\n * @see https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseTrace.html\n */\n trace?: {\n /**\n * The guardrail trace object.\n * @see https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GuardrailTraceAssessment.html\n *\n * This was purposely left as unknown as it's a complex object. This can be typed in the future\n * if the SDK decides to support bedrock in a more advanced way.\n */\n guardrail?: unknown;\n /**\n * The request's prompt router.\n * @see https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_PromptRouterTrace.html\n */\n promptRouter?: {\n /**\n * The ID of the invoked model.\n */\n invokedModelId?: string;\n };\n };\n usage?: {\n /**\n * The number of tokens that were read from the cache.\n * @see https://ai-sdk.dev/providers/ai-sdk-providers/amazon-bedrock#cache-points\n */\n cacheReadInputTokens?: number;\n\n /**\n * The number of tokens that were written to the cache.\n * @see https://ai-sdk.dev/providers/ai-sdk-providers/amazon-bedrock#cache-points\n */\n cacheWriteInputTokens?: number;\n };\n}\n\n/**\n * Google Generative AI Provider Metadata\n * @see https://ai-sdk.dev/providers/ai-sdk-providers/google-generative-ai\n */\nexport interface GoogleGenerativeAIProviderMetadata {\n /**\n * @see https://github.com/vercel/ai/blob/65e042afde6aad4da9d7a62526ece839eb34f9a5/packages/google/src/google-generative-ai-prompt.ts#L28-L30\n */\n groundingMetadata: null | {\n /**\n * Array of search queries used to retrieve information\n * @example [\"What's the weather in Chicago this weekend?\"]\n *\n * @see https://ai-sdk.dev/providers/ai-sdk-providers/google-generative-ai#search-grounding\n */\n webSearchQueries: string[] | null;\n /**\n * Contains the main search result content used as an entry point\n * The `renderedContent` field contains the formatted content\n * @see https://ai-sdk.dev/providers/ai-sdk-providers/google-generative-ai#search-grounding\n */\n searchEntryPoint?: {\n renderedContent: string;\n } | null;\n /**\n * Contains details about how specific response parts are supported by search results\n * @see https://ai-sdk.dev/providers/ai-sdk-providers/google-generative-ai#search-grounding\n */\n groundingSupports: Array<{\n /**\n * Information about the grounded text segment.\n */\n segment: {\n /**\n * The start index of the text segment.\n */\n startIndex?: number | null;\n /**\n * The end index of the text segment.\n */\n endIndex?: number | null;\n /**\n * The actual text segment.\n */\n text?: string | null;\n };\n /**\n * References to supporting search result chunks.\n */\n groundingChunkIndices?: number[] | null;\n /**\n * Confidence scores (0-1) for each supporting chunk.\n */\n confidenceScores?: number[] | null;\n }> | null;\n };\n /**\n * @see https://github.com/vercel/ai/blob/65e042afde6aad4da9d7a62526ece839eb34f9a5/packages/google/src/google-generative-ai-language-model.ts#L620-L627\n * @see https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/configure-safety-filters\n */\n safetyRatings?: null | unknown;\n}\n\n/**\n * DeepSeek Provider Metadata\n * @see https://ai-sdk.dev/providers/ai-sdk-providers/deepseek\n */\ninterface DeepSeekProviderMetadata {\n /**\n * The number of tokens that were cache hits.\n * @see https://ai-sdk.dev/providers/ai-sdk-providers/deepseek#cache-token-usage\n */\n promptCacheHitTokens?: number;\n\n /**\n * The number of tokens that were cache misses.\n * @see https://ai-sdk.dev/providers/ai-sdk-providers/deepseek#cache-token-usage\n */\n promptCacheMissTokens?: number;\n}\n\n/**\n * Perplexity Provider Metadata\n * @see https://ai-sdk.dev/providers/ai-sdk-providers/perplexity\n */\ninterface PerplexityProviderMetadata {\n /**\n * Object containing citationTokens and numSearchQueries metrics\n */\n usage?: {\n citationTokens?: number;\n numSearchQueries?: number;\n };\n /**\n * Array of image URLs when return_images is enabled.\n *\n * You can enable image responses by setting return_images: true in the provider options.\n * This feature is only available to Perplexity Tier-2 users and above.\n */\n images?: Array<{\n imageUrl?: string;\n originUrl?: string;\n height?: number;\n width?: number;\n }>;\n}\n\nexport interface ProviderMetadata {\n openai?: OpenAiProviderMetadata;\n anthropic?: AnthropicProviderMetadata;\n bedrock?: AmazonBedrockProviderMetadata;\n google?: GoogleGenerativeAIProviderMetadata;\n deepseek?: DeepSeekProviderMetadata;\n perplexity?: PerplexityProviderMetadata;\n}\n","/**\n * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,\n * you must either a) use `console.log` rather than the `debug` singleton, or b) put your function elsewhere.\n *\n * Note: This file was originally called `global.ts`, but was changed to unblock users which might be doing\n * string replaces with bundlers like Vite for `global` (would break imports that rely on importing from utils/src/global).\n *\n * Why worldwide?\n *\n * Why not?\n */\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type { Carrier } from '../carrier';\nimport type { SdkSource } from './env';\n\n/** Internal global with common properties and Sentry extensions */\nexport type InternalGlobal = {\n navigator?: { userAgent?: string; maxTouchPoints?: number };\n console: Console;\n PerformanceObserver?: any;\n Sentry?: any;\n onerror?: {\n (event: object | string, source?: string, lineno?: number, colno?: number, error?: Error): any;\n __SENTRY_INSTRUMENTED__?: true;\n };\n onunhandledrejection?: {\n (event: unknown): boolean;\n __SENTRY_INSTRUMENTED__?: true;\n };\n SENTRY_ENVIRONMENT?: string;\n SENTRY_DSN?: string;\n SENTRY_RELEASE?: {\n id?: string;\n };\n SENTRY_SDK_SOURCE?: SdkSource;\n /**\n * Debug IDs are indirectly injected by Sentry CLI or bundler plugins to directly reference a particular source map\n * for resolving of a source file. The injected code will place an entry into the record for each loaded bundle/JS\n * file.\n */\n _sentryDebugIds?: Record;\n /**\n * Raw module metadata that is injected by bundler plugins.\n *\n * Keys are `error.stack` strings, values are the metadata.\n */\n _sentryModuleMetadata?: Record;\n _sentryEsmLoaderHookRegistered?: boolean;\n _sentryInjectLoaderHookRegister?: () => void;\n _sentryInjectLoaderHookRegistered?: boolean;\n} & Carrier;\n\n/** Get's the global object for the current JavaScript runtime */\nexport const GLOBAL_OBJ = globalThis as unknown as InternalGlobal;\n","import { rejectedSyncPromise, resolvedSyncPromise } from './syncpromise';\n\nexport interface PromiseBuffer {\n // exposes the internal array so tests can assert on the state of it.\n // XXX: this really should not be public api.\n $: PromiseLike[];\n add(taskProducer: () => PromiseLike): PromiseLike;\n drain(timeout?: number): PromiseLike;\n}\n\nexport const SENTRY_BUFFER_FULL_ERROR = Symbol.for('SentryBufferFullError');\n\n/**\n * Creates an new PromiseBuffer object with the specified limit\n * @param limit max number of promises that can be stored in the buffer\n */\nexport function makePromiseBuffer(limit: number = 100): PromiseBuffer {\n const buffer: Set> = new Set();\n\n function isReady(): boolean {\n return buffer.size < limit;\n }\n\n /**\n * Remove a promise from the queue.\n *\n * @param task Can be any PromiseLike\n * @returns Removed promise.\n */\n function remove(task: PromiseLike): void {\n buffer.delete(task);\n }\n\n /**\n * Add a promise (representing an in-flight action) to the queue, and set it to remove itself on fulfillment.\n *\n * @param taskProducer A function producing any PromiseLike; In previous versions this used to be `task:\n * PromiseLike`, but under that model, Promises were instantly created on the call-site and their executor\n * functions therefore ran immediately. Thus, even if the buffer was full, the action still happened. By\n * requiring the promise to be wrapped in a function, we can defer promise creation until after the buffer\n * limit check.\n * @returns The original promise.\n */\n function add(taskProducer: () => PromiseLike): PromiseLike {\n if (!isReady()) {\n return rejectedSyncPromise(SENTRY_BUFFER_FULL_ERROR);\n }\n\n // start the task and add its promise to the queue\n const task = taskProducer();\n buffer.add(task);\n void task.then(\n () => remove(task),\n () => remove(task),\n );\n return task;\n }\n\n /**\n * Wait for all promises in the queue to resolve or for timeout to expire, whichever comes first.\n *\n * @param timeout The time, in ms, after which to resolve to `false` if the queue is still non-empty. Passing `0` (or\n * not passing anything) will make the promise wait as long as it takes for the queue to drain before resolving to\n * `true`.\n * @returns A promise which will resolve to `true` if the queue is already empty or drains before the timeout, and\n * `false` otherwise\n */\n function drain(timeout?: number): PromiseLike {\n if (!buffer.size) {\n return resolvedSyncPromise(true);\n }\n\n // We want to resolve even if one of the promises rejects\n const drainPromise = Promise.allSettled(Array.from(buffer)).then(() => true);\n\n if (!timeout) {\n return drainPromise;\n }\n\n const promises = [drainPromise, new Promise(resolve => setTimeout(() => resolve(false), timeout))];\n\n // Promise.race will resolve to the first promise that resolves or rejects\n // So if the drainPromise resolves, the timeout promise will be ignored\n return Promise.race(promises);\n }\n\n return {\n get $(): PromiseLike[] {\n return Array.from(buffer);\n },\n add,\n drain,\n };\n}\n","import { GLOBAL_OBJ } from './worldwide';\n\nconst ONE_SECOND_IN_MS = 1000;\n\n/**\n * A partial definition of the [Performance Web API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance}\n * for accessing a high-resolution monotonic clock.\n */\ninterface Performance {\n /**\n * The millisecond timestamp at which measurement began, measured in Unix time.\n */\n timeOrigin: number;\n /**\n * Returns the current millisecond timestamp, where 0 represents the start of measurement.\n */\n now(): number;\n}\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using the Date API.\n */\nexport function dateTimestampInSeconds(): number {\n return Date.now() / ONE_SECOND_IN_MS;\n}\n\n/**\n * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not\n * support the API.\n *\n * Wrapping the native API works around differences in behavior from different browsers.\n */\nfunction createUnixTimestampInSecondsFunc(): () => number {\n const { performance } = GLOBAL_OBJ as typeof GLOBAL_OBJ & { performance?: Performance };\n // Some browser and environments don't have a performance or timeOrigin, so we fallback to\n // using Date.now() to compute the starting time.\n if (!performance?.now || !performance.timeOrigin) {\n return dateTimestampInSeconds;\n }\n\n const timeOrigin = performance.timeOrigin;\n\n // performance.now() is a monotonic clock, which means it starts at 0 when the process begins. To get the current\n // wall clock time (actual UNIX timestamp), we need to add the starting time origin and the current time elapsed.\n //\n // TODO: This does not account for the case where the monotonic clock that powers performance.now() drifts from the\n // wall clock time, which causes the returned timestamp to be inaccurate. We should investigate how to detect and\n // correct for this.\n // See: https://github.com/getsentry/sentry-javascript/issues/2590\n // See: https://github.com/mdn/content/issues/4713\n // See: https://dev.to/noamr/when-a-millisecond-is-not-a-millisecond-3h6\n return () => {\n return (timeOrigin + performance.now()) / ONE_SECOND_IN_MS;\n };\n}\n\nlet _cachedTimestampInSeconds: (() => number) | undefined;\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the\n * availability of the Performance API.\n *\n * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is\n * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The\n * skew can grow to arbitrary amounts like days, weeks or months.\n * See https://github.com/getsentry/sentry-javascript/issues/2590.\n */\nexport function timestampInSeconds(): number {\n // We store this in a closure so that we don't have to create a new function every time this is called.\n const func = _cachedTimestampInSeconds ?? (_cachedTimestampInSeconds = createUnixTimestampInSecondsFunc());\n return func();\n}\n\n/**\n * Cached result of getBrowserTimeOrigin.\n */\nlet cachedTimeOrigin: [number | undefined, string] | undefined;\n\n/**\n * Gets the time origin and the mode used to determine it.\n */\nfunction getBrowserTimeOrigin(): [number | undefined, string] {\n // Unfortunately browsers may report an inaccurate time origin data, through either performance.timeOrigin or\n // performance.timing.navigationStart, which results in poor results in performance data. We only treat time origin\n // data as reliable if they are within a reasonable threshold of the current time.\n\n const { performance } = GLOBAL_OBJ as typeof GLOBAL_OBJ & Window;\n if (!performance?.now) {\n return [undefined, 'none'];\n }\n\n const threshold = 3600 * 1000;\n const performanceNow = performance.now();\n const dateNow = Date.now();\n\n // if timeOrigin isn't available set delta to threshold so it isn't used\n const timeOriginDelta = performance.timeOrigin\n ? Math.abs(performance.timeOrigin + performanceNow - dateNow)\n : threshold;\n const timeOriginIsReliable = timeOriginDelta < threshold;\n\n // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin\n // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.\n // Also as of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always\n // a valid fallback. In the absence of an initial time provided by the browser, fallback to the current time from the\n // Date API.\n // eslint-disable-next-line deprecation/deprecation\n const navigationStart = performance.timing?.navigationStart;\n const hasNavigationStart = typeof navigationStart === 'number';\n // if navigationStart isn't available set delta to threshold so it isn't used\n const navigationStartDelta = hasNavigationStart ? Math.abs(navigationStart + performanceNow - dateNow) : threshold;\n const navigationStartIsReliable = navigationStartDelta < threshold;\n\n if (timeOriginIsReliable || navigationStartIsReliable) {\n // Use the more reliable time origin\n if (timeOriginDelta <= navigationStartDelta) {\n return [performance.timeOrigin, 'timeOrigin'];\n } else {\n return [navigationStart, 'navigationStart'];\n }\n }\n\n // Either both timeOrigin and navigationStart are skewed or neither is available, fallback to Date.\n return [dateNow, 'dateNow'];\n}\n\n/**\n * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the\n * performance API is available.\n */\nexport function browserPerformanceTimeOrigin(): number | undefined {\n if (!cachedTimeOrigin) {\n cachedTimeOrigin = getBrowserTimeOrigin();\n }\n\n return cachedTimeOrigin[0];\n}\n","import {\n SEMANTIC_ATTRIBUTE_HTTP_REQUEST_METHOD,\n SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,\n SEMANTIC_ATTRIBUTE_URL_FULL,\n} from '../semanticAttributes';\nimport type { SpanAttributes } from '../types-hoist/span';\n\ntype PartialURL = {\n host?: string;\n path?: string;\n protocol?: string;\n relative?: string;\n search?: string;\n hash?: string;\n};\n\ninterface URLwithCanParse extends URL {\n canParse: (url: string, base?: string | URL | undefined) => boolean;\n}\n\n// A subset of the URL object that is valid for relative URLs\n// The URL object cannot handle relative URLs, so we need to handle them separately\ntype RelativeURL = {\n isRelative: true;\n pathname: URL['pathname'];\n search: URL['search'];\n hash: URL['hash'];\n};\n\ntype URLObject = RelativeURL | URL;\n\n// Curious about `thismessage:/`? See: https://www.rfc-editor.org/rfc/rfc2557.html\n// > When the methods above do not yield an absolute URI, a base URL\n// > of \"thismessage:/\" MUST be employed. This base URL has been\n// > defined for the sole purpose of resolving relative references\n// > within a multipart/related structure when no other base URI is\n// > specified.\n//\n// We need to provide a base URL to `parseStringToURLObject` because the fetch API gives us a\n// relative URL sometimes.\n//\n// This is the only case where we need to provide a base URL to `parseStringToURLObject`\n// because the relative URL is not valid on its own.\nconst DEFAULT_BASE_URL = 'thismessage:/';\n\n/**\n * Checks if the URL object is relative\n *\n * @param url - The URL object to check\n * @returns True if the URL object is relative, false otherwise\n */\nexport function isURLObjectRelative(url: URLObject): url is RelativeURL {\n return 'isRelative' in url;\n}\n\n/**\n * Parses string to a URL object\n *\n * @param url - The URL to parse\n * @returns The parsed URL object or undefined if the URL is invalid\n */\nexport function parseStringToURLObject(url: string, urlBase?: string | URL | undefined): URLObject | undefined {\n const isRelative = url.indexOf('://') <= 0 && url.indexOf('//') !== 0;\n const base = urlBase ?? (isRelative ? DEFAULT_BASE_URL : undefined);\n try {\n // Use `canParse` to short-circuit the URL constructor if it's not a valid URL\n // This is faster than trying to construct the URL and catching the error\n // Node 20+, Chrome 120+, Firefox 115+, Safari 17+\n if ('canParse' in URL && !(URL as unknown as URLwithCanParse).canParse(url, base)) {\n return undefined;\n }\n\n const fullUrlObject = new URL(url, base);\n if (isRelative) {\n // Because we used a fake base URL, we need to return a relative URL object.\n // We cannot return anything about the origin, host, etc. because it will refer to the fake base URL.\n return {\n isRelative,\n pathname: fullUrlObject.pathname,\n search: fullUrlObject.search,\n hash: fullUrlObject.hash,\n };\n }\n return fullUrlObject;\n } catch {\n // empty body\n }\n\n return undefined;\n}\n\n/**\n * Takes a URL object and returns a sanitized string which is safe to use as span name\n * see: https://develop.sentry.dev/sdk/data-handling/#structuring-data\n */\nexport function getSanitizedUrlStringFromUrlObject(url: URLObject): string {\n if (isURLObjectRelative(url)) {\n return url.pathname;\n }\n\n const newUrl = new URL(url);\n newUrl.search = '';\n newUrl.hash = '';\n if (['80', '443'].includes(newUrl.port)) {\n newUrl.port = '';\n }\n if (newUrl.password) {\n newUrl.password = '%filtered%';\n }\n if (newUrl.username) {\n newUrl.username = '%filtered%';\n }\n\n return newUrl.toString();\n}\n\ntype PartialRequest = {\n method?: string;\n};\n\nfunction getHttpSpanNameFromUrlObject(\n urlObject: URLObject | undefined,\n kind: 'server' | 'client',\n request?: PartialRequest,\n routeName?: string,\n): string {\n const method = request?.method?.toUpperCase() ?? 'GET';\n const route = routeName\n ? routeName\n : urlObject\n ? kind === 'client'\n ? getSanitizedUrlStringFromUrlObject(urlObject)\n : urlObject.pathname\n : '/';\n\n return `${method} ${route}`;\n}\n\n/**\n * Takes a parsed URL object and returns a set of attributes for the span\n * that represents the HTTP request for that url. This is used for both server\n * and client http spans.\n *\n * Follows https://opentelemetry.io/docs/specs/semconv/http/.\n *\n * @param urlObject - see {@link parseStringToURLObject}\n * @param kind - The type of HTTP operation (server or client)\n * @param spanOrigin - The origin of the span\n * @param request - The request object, see {@link PartialRequest}\n * @param routeName - The name of the route, must be low cardinality\n * @returns The span name and attributes for the HTTP operation\n */\nexport function getHttpSpanDetailsFromUrlObject(\n urlObject: URLObject | undefined,\n kind: 'server' | 'client',\n spanOrigin: string,\n request?: PartialRequest,\n routeName?: string,\n): [name: string, attributes: SpanAttributes] {\n const attributes: SpanAttributes = {\n [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: spanOrigin,\n [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'url',\n };\n\n if (routeName) {\n // This is based on https://opentelemetry.io/docs/specs/semconv/http/http-spans/#name\n attributes[kind === 'server' ? 'http.route' : 'url.template'] = routeName;\n attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE] = 'route';\n }\n\n if (request?.method) {\n attributes[SEMANTIC_ATTRIBUTE_HTTP_REQUEST_METHOD] = request.method.toUpperCase();\n }\n\n if (urlObject) {\n if (urlObject.search) {\n attributes['url.query'] = urlObject.search;\n }\n if (urlObject.hash) {\n attributes['url.fragment'] = urlObject.hash;\n }\n if (urlObject.pathname) {\n attributes['url.path'] = urlObject.pathname;\n if (urlObject.pathname === '/') {\n attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE] = 'route';\n }\n }\n\n if (!isURLObjectRelative(urlObject)) {\n attributes[SEMANTIC_ATTRIBUTE_URL_FULL] = urlObject.href;\n if (urlObject.port) {\n attributes['url.port'] = urlObject.port;\n }\n if (urlObject.protocol) {\n attributes['url.scheme'] = urlObject.protocol;\n }\n if (urlObject.hostname) {\n attributes[kind === 'server' ? 'server.address' : 'url.domain'] = urlObject.hostname;\n }\n }\n }\n\n return [getHttpSpanNameFromUrlObject(urlObject, kind, request, routeName), attributes];\n}\n\n/**\n * Parses string form of URL into an object\n * // borrowed from https://tools.ietf.org/html/rfc3986#appendix-B\n * // intentionally using regex and not href parsing trick because React Native and other\n * // environments where DOM might not be available\n * @returns parsed URL object\n */\nexport function parseUrl(url: string): PartialURL {\n if (!url) {\n return {};\n }\n\n const match = url.match(/^(([^:/?#]+):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$/);\n\n if (!match) {\n return {};\n }\n\n // coerce to undefined values to empty string so we don't get 'undefined'\n const query = match[6] || '';\n const fragment = match[8] || '';\n return {\n host: match[4],\n path: match[5],\n protocol: match[2],\n search: query,\n hash: fragment,\n relative: match[5] + query + fragment, // everything minus origin\n };\n}\n\n/**\n * Strip the query string and fragment off of a given URL or path (if present)\n *\n * @param urlPath Full URL or path, including possible query string and/or fragment\n * @returns URL or path without query string or fragment\n */\nexport function stripUrlQueryAndFragment(urlPath: string): string {\n return (urlPath.split(/[?#]/, 1) as [string, ...string[]])[0];\n}\n\n/**\n * Takes a URL object and returns a sanitized string which is safe to use as span name\n * see: https://develop.sentry.dev/sdk/data-handling/#structuring-data\n */\nexport function getSanitizedUrlString(url: PartialURL): string {\n const { protocol, host, path } = url;\n\n const filteredHost =\n host\n // Always filter out authority\n ?.replace(/^.*@/, '[filtered]:[filtered]@')\n // Don't show standard :80 (http) and :443 (https) ports to reduce the noise\n // TODO: Use new URL global if it exists\n .replace(/(:80)$/, '')\n .replace(/(:443)$/, '') || '';\n\n return `${protocol ? `${protocol}://` : ''}${filteredHost}${path}`;\n}\n","import type { SeverityLevel } from '../types-hoist/severity';\n\n/**\n * Converts a string-based level into a `SeverityLevel`, normalizing it along the way.\n *\n * @param level String representation of desired `SeverityLevel`.\n * @returns The `SeverityLevel` corresponding to the given string, or 'log' if the string isn't a valid level.\n */\nexport function severityLevelFromString(level: SeverityLevel | string): SeverityLevel {\n return (\n level === 'warn' ? 'warning' : ['fatal', 'error', 'warning', 'log', 'info', 'debug'].includes(level) ? level : 'log'\n ) as SeverityLevel;\n}\n","import type { Span } from '../../types-hoist/span';\n\n// Global Map to track tool call IDs to their corresponding spans\n// This allows us to capture tool errors and link them to the correct span\nexport const toolCallSpanMap = new Map();\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { isThenable } from './is';\n\n/** SyncPromise internal states */\nconst STATE_PENDING = 0;\nconst STATE_RESOLVED = 1;\nconst STATE_REJECTED = 2;\n\ntype State = typeof STATE_PENDING | typeof STATE_RESOLVED | typeof STATE_REJECTED;\n\n// Overloads so we can call resolvedSyncPromise without arguments and generic argument\nexport function resolvedSyncPromise(): PromiseLike;\nexport function resolvedSyncPromise(value: T | PromiseLike): PromiseLike;\n\n/**\n * Creates a resolved sync promise.\n *\n * @param value the value to resolve the promise with\n * @returns the resolved sync promise\n */\nexport function resolvedSyncPromise(value?: T | PromiseLike): PromiseLike {\n return new SyncPromise(resolve => {\n resolve(value);\n });\n}\n\n/**\n * Creates a rejected sync promise.\n *\n * @param value the value to reject the promise with\n * @returns the rejected sync promise\n */\nexport function rejectedSyncPromise(reason?: any): PromiseLike {\n return new SyncPromise((_, reject) => {\n reject(reason);\n });\n}\n\ntype Executor = (resolve: (value?: T | PromiseLike | null) => void, reject: (reason?: any) => void) => void;\n\n/**\n * Thenable class that behaves like a Promise and follows it's interface\n * but is not async internally\n */\nexport class SyncPromise implements PromiseLike {\n private _state: State;\n private _handlers: Array<[boolean, (value: T) => void, (reason: any) => any]>;\n private _value: any;\n\n public constructor(executor: Executor) {\n this._state = STATE_PENDING;\n this._handlers = [];\n\n this._runExecutor(executor);\n }\n\n /** @inheritdoc */\n public then(\n onfulfilled?: ((value: T) => TResult1 | PromiseLike) | null,\n onrejected?: ((reason: any) => TResult2 | PromiseLike) | null,\n ): PromiseLike {\n return new SyncPromise((resolve, reject) => {\n this._handlers.push([\n false,\n result => {\n if (!onfulfilled) {\n // TODO: ¯\\_(ツ)_/¯\n // TODO: FIXME\n resolve(result as any);\n } else {\n try {\n resolve(onfulfilled(result));\n } catch (e) {\n reject(e);\n }\n }\n },\n reason => {\n if (!onrejected) {\n reject(reason);\n } else {\n try {\n resolve(onrejected(reason));\n } catch (e) {\n reject(e);\n }\n }\n },\n ]);\n this._executeHandlers();\n });\n }\n\n /** @inheritdoc */\n public catch(\n onrejected?: ((reason: any) => TResult | PromiseLike) | null,\n ): PromiseLike {\n return this.then(val => val, onrejected);\n }\n\n /** @inheritdoc */\n public finally(onfinally?: (() => void) | null): PromiseLike {\n return new SyncPromise((resolve, reject) => {\n let val: TResult | any;\n let isRejected: boolean;\n\n return this.then(\n value => {\n isRejected = false;\n val = value;\n if (onfinally) {\n onfinally();\n }\n },\n reason => {\n isRejected = true;\n val = reason;\n if (onfinally) {\n onfinally();\n }\n },\n ).then(() => {\n if (isRejected) {\n reject(val);\n return;\n }\n\n resolve(val as unknown as any);\n });\n });\n }\n\n /** Excute the resolve/reject handlers. */\n private _executeHandlers(): void {\n if (this._state === STATE_PENDING) {\n return;\n }\n\n const cachedHandlers = this._handlers.slice();\n this._handlers = [];\n\n cachedHandlers.forEach(handler => {\n if (handler[0]) {\n return;\n }\n\n if (this._state === STATE_RESOLVED) {\n handler[1](this._value as unknown as any);\n }\n\n if (this._state === STATE_REJECTED) {\n handler[2](this._value);\n }\n\n handler[0] = true;\n });\n }\n\n /** Run the executor for the SyncPromise. */\n private _runExecutor(executor: Executor): void {\n const setResult = (state: State, value?: T | PromiseLike | any): void => {\n if (this._state !== STATE_PENDING) {\n return;\n }\n\n if (isThenable(value)) {\n void (value as PromiseLike).then(resolve, reject);\n return;\n }\n\n this._state = state;\n this._value = value;\n\n this._executeHandlers();\n };\n\n const resolve = (value: unknown): void => {\n setResult(STATE_RESOLVED, value);\n };\n\n const reject = (reason: unknown): void => {\n setResult(STATE_REJECTED, reason);\n };\n\n try {\n executor(resolve, reject);\n } catch (e) {\n reject(e);\n }\n }\n}\n","import { GLOBAL_OBJ } from './worldwide';\n\ninterface VercelRequestContextGlobal {\n get?():\n | {\n waitUntil?: (task: Promise) => void;\n }\n | undefined;\n}\n\n/**\n * Function that delays closing of a Vercel lambda until the provided promise is resolved.\n *\n * Vendored from https://www.npmjs.com/package/@vercel/functions\n */\nexport function vercelWaitUntil(task: Promise): void {\n const vercelRequestContextGlobal: VercelRequestContextGlobal | undefined =\n // @ts-expect-error This is not typed\n GLOBAL_OBJ[Symbol.for('@vercel/request-context')];\n\n const ctx = vercelRequestContextGlobal?.get?.();\n\n if (ctx?.waitUntil) {\n ctx.waitUntil(task);\n }\n}\n","import { DEBUG_BUILD } from '../debug-build';\nimport { debug } from './debug-logger';\nimport { GLOBAL_OBJ } from './worldwide';\n\nconst WINDOW = GLOBAL_OBJ as unknown as Window;\n\ndeclare const EdgeRuntime: string | undefined;\n\n/**\n * Tells whether current environment supports ErrorEvent objects\n * {@link supportsErrorEvent}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsErrorEvent(): boolean {\n try {\n new ErrorEvent('');\n return true;\n } catch {\n return false;\n }\n}\n\n/**\n * Tells whether current environment supports DOMError objects\n * {@link supportsDOMError}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsDOMError(): boolean {\n try {\n // Chrome: VM89:1 Uncaught TypeError: Failed to construct 'DOMError':\n // 1 argument required, but only 0 present.\n // @ts-expect-error It really needs 1 argument, not 0.\n new DOMError('');\n return true;\n } catch {\n return false;\n }\n}\n\n/**\n * Tells whether current environment supports DOMException objects\n * {@link supportsDOMException}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsDOMException(): boolean {\n try {\n new DOMException('');\n return true;\n } catch {\n return false;\n }\n}\n\n/**\n * Tells whether current environment supports History API\n * {@link supportsHistory}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsHistory(): boolean {\n return 'history' in WINDOW && !!WINDOW.history;\n}\n\n/**\n * Tells whether current environment supports Fetch API\n * {@link supportsFetch}.\n *\n * @returns Answer to the given question.\n * @deprecated This is no longer used and will be removed in a future major version.\n */\nexport const supportsFetch = _isFetchSupported;\n\nfunction _isFetchSupported(): boolean {\n if (!('fetch' in WINDOW)) {\n return false;\n }\n\n try {\n new Headers();\n new Request('http://www.example.com');\n new Response();\n return true;\n } catch {\n return false;\n }\n}\n\n/**\n * isNative checks if the given function is a native implementation\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nexport function isNativeFunction(func: Function): boolean {\n return func && /^function\\s+\\w+\\(\\)\\s+\\{\\s+\\[native code\\]\\s+\\}$/.test(func.toString());\n}\n\n/**\n * Tells whether current environment supports Fetch API natively\n * {@link supportsNativeFetch}.\n *\n * @returns true if `window.fetch` is natively implemented, false otherwise\n */\nexport function supportsNativeFetch(): boolean {\n if (typeof EdgeRuntime === 'string') {\n return true;\n }\n\n if (!_isFetchSupported()) {\n return false;\n }\n\n // Fast path to avoid DOM I/O\n // eslint-disable-next-line @typescript-eslint/unbound-method\n if (isNativeFunction(WINDOW.fetch)) {\n return true;\n }\n\n // window.fetch is implemented, but is polyfilled or already wrapped (e.g: by a chrome extension)\n // so create a \"pure\" iframe to see if that has native fetch\n let result = false;\n const doc = WINDOW.document;\n // eslint-disable-next-line deprecation/deprecation\n if (doc && typeof (doc.createElement as unknown) === 'function') {\n try {\n const sandbox = doc.createElement('iframe');\n sandbox.hidden = true;\n doc.head.appendChild(sandbox);\n if (sandbox.contentWindow?.fetch) {\n // eslint-disable-next-line @typescript-eslint/unbound-method\n result = isNativeFunction(sandbox.contentWindow.fetch);\n }\n doc.head.removeChild(sandbox);\n } catch (err) {\n DEBUG_BUILD && debug.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);\n }\n }\n\n return result;\n}\n\n/**\n * Tells whether current environment supports ReportingObserver API\n * {@link supportsReportingObserver}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsReportingObserver(): boolean {\n return 'ReportingObserver' in WINDOW;\n}\n\n/**\n * Tells whether current environment supports Referrer Policy API\n * {@link supportsReferrerPolicy}.\n *\n * @returns Answer to the given question.\n * @deprecated This is no longer used and will be removed in a future major version.\n */\nexport function supportsReferrerPolicy(): boolean {\n // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default'\n // (see https://caniuse.com/#feat=referrer-policy),\n // it doesn't. And it throws an exception instead of ignoring this parameter...\n // REF: https://github.com/getsentry/raven-js/issues/1233\n\n if (!_isFetchSupported()) {\n return false;\n }\n\n try {\n new Request('_', {\n referrerPolicy: 'origin' as ReferrerPolicy,\n });\n return true;\n } catch {\n return false;\n }\n}\n","import type { DataCategory } from '../types-hoist/datacategory';\nimport type { TransportMakeRequestResponse } from '../types-hoist/transport';\n\n// Intentionally keeping the key broad, as we don't know for sure what rate limit headers get returned from backend\nexport type RateLimits = Record;\n\nexport const DEFAULT_RETRY_AFTER = 60 * 1000; // 60 seconds\n\n/**\n * Extracts Retry-After value from the request header or returns default value\n * @param header string representation of 'Retry-After' header\n * @param now current unix timestamp\n *\n */\nexport function parseRetryAfterHeader(header: string, now: number = Date.now()): number {\n const headerDelay = parseInt(`${header}`, 10);\n if (!isNaN(headerDelay)) {\n return headerDelay * 1000;\n }\n\n const headerDate = Date.parse(`${header}`);\n if (!isNaN(headerDate)) {\n return headerDate - now;\n }\n\n return DEFAULT_RETRY_AFTER;\n}\n\n/**\n * Gets the time that the given category is disabled until for rate limiting.\n * In case no category-specific limit is set but a general rate limit across all categories is active,\n * that time is returned.\n *\n * @return the time in ms that the category is disabled until or 0 if there's no active rate limit.\n */\nexport function disabledUntil(limits: RateLimits, dataCategory: DataCategory): number {\n return limits[dataCategory] || limits.all || 0;\n}\n\n/**\n * Checks if a category is rate limited\n */\nexport function isRateLimited(limits: RateLimits, dataCategory: DataCategory, now: number = Date.now()): boolean {\n return disabledUntil(limits, dataCategory) > now;\n}\n\n/**\n * Update ratelimits from incoming headers.\n *\n * @return the updated RateLimits object.\n */\nexport function updateRateLimits(\n limits: RateLimits,\n { statusCode, headers }: TransportMakeRequestResponse,\n now: number = Date.now(),\n): RateLimits {\n const updatedRateLimits: RateLimits = {\n ...limits,\n };\n\n // \"The name is case-insensitive.\"\n // https://developer.mozilla.org/en-US/docs/Web/API/Headers/get\n const rateLimitHeader = headers?.['x-sentry-rate-limits'];\n const retryAfterHeader = headers?.['retry-after'];\n\n if (rateLimitHeader) {\n /**\n * rate limit headers are of the form\n *
,
,..\n * where each
is of the form\n * : : : : \n * where\n * is a delay in seconds\n * is the event type(s) (error, transaction, etc) being rate limited and is of the form\n * ;;...\n * is what's being limited (org, project, or key) - ignored by SDK\n * is an arbitrary string like \"org_quota\" - ignored by SDK\n * Semicolon-separated list of metric namespace identifiers. Defines which namespace(s) will be affected.\n * Only present if rate limit applies to the metric_bucket data category.\n */\n for (const limit of rateLimitHeader.trim().split(',')) {\n const [retryAfter, categories, , , namespaces] = limit.split(':', 5) as [string, ...string[]];\n const headerDelay = parseInt(retryAfter, 10);\n const delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default\n if (!categories) {\n updatedRateLimits.all = now + delay;\n } else {\n for (const category of categories.split(';')) {\n if (category === 'metric_bucket') {\n // namespaces will be present when category === 'metric_bucket'\n if (!namespaces || namespaces.split(';').includes('custom')) {\n updatedRateLimits[category] = now + delay;\n }\n } else {\n updatedRateLimits[category] = now + delay;\n }\n }\n }\n }\n } else if (retryAfterHeader) {\n updatedRateLimits.all = now + parseRetryAfterHeader(retryAfterHeader, now);\n } else if (statusCode === 429) {\n updatedRateLimits.all = now + 60 * 1000;\n }\n\n return updatedRateLimits;\n}\n","import { getAsyncContextStrategy } from '../asyncContext';\nimport { getMainCarrier } from '../carrier';\nimport { getCurrentScope } from '../currentScopes';\nimport {\n SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME,\n SEMANTIC_ATTRIBUTE_SENTRY_OP,\n SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,\n} from '../semanticAttributes';\nimport type { SentrySpan } from '../tracing/sentrySpan';\nimport { SPAN_STATUS_OK, SPAN_STATUS_UNSET } from '../tracing/spanstatus';\nimport { getCapturedScopesOnSpan } from '../tracing/utils';\nimport type { TraceContext } from '../types-hoist/context';\nimport type { SpanLink, SpanLinkJSON } from '../types-hoist/link';\nimport type { Span, SpanAttributes, SpanJSON, SpanOrigin, SpanTimeInput } from '../types-hoist/span';\nimport type { SpanStatus } from '../types-hoist/spanStatus';\nimport { addNonEnumerableProperty } from '../utils/object';\nimport { generateSpanId } from '../utils/propagationContext';\nimport { timestampInSeconds } from '../utils/time';\nimport { generateSentryTraceHeader, generateTraceparentHeader } from '../utils/tracing';\nimport { consoleSandbox } from './debug-logger';\nimport { _getSpanForScope } from './spanOnScope';\n\n// These are aligned with OpenTelemetry trace flags\nexport const TRACE_FLAG_NONE = 0x0;\nexport const TRACE_FLAG_SAMPLED = 0x1;\n\nlet hasShownSpanDropWarning = false;\n\n/**\n * Convert a span to a trace context, which can be sent as the `trace` context in an event.\n * By default, this will only include trace_id, span_id & parent_span_id.\n * If `includeAllData` is true, it will also include data, op, status & origin.\n */\nexport function spanToTransactionTraceContext(span: Span): TraceContext {\n const { spanId: span_id, traceId: trace_id } = span.spanContext();\n const { data, op, parent_span_id, status, origin, links } = spanToJSON(span);\n\n return {\n parent_span_id,\n span_id,\n trace_id,\n data,\n op,\n status,\n origin,\n links,\n };\n}\n\n/**\n * Convert a span to a trace context, which can be sent as the `trace` context in a non-transaction event.\n */\nexport function spanToTraceContext(span: Span): TraceContext {\n const { spanId, traceId: trace_id, isRemote } = span.spanContext();\n\n // If the span is remote, we use a random/virtual span as span_id to the trace context,\n // and the remote span as parent_span_id\n const parent_span_id = isRemote ? spanId : spanToJSON(span).parent_span_id;\n const scope = getCapturedScopesOnSpan(span).scope;\n\n const span_id = isRemote ? scope?.getPropagationContext().propagationSpanId || generateSpanId() : spanId;\n\n return {\n parent_span_id,\n span_id,\n trace_id,\n };\n}\n\n/**\n * Convert a Span to a Sentry trace header.\n */\nexport function spanToTraceHeader(span: Span): string {\n const { traceId, spanId } = span.spanContext();\n const sampled = spanIsSampled(span);\n return generateSentryTraceHeader(traceId, spanId, sampled);\n}\n\n/**\n * Convert a Span to a W3C traceparent header.\n */\nexport function spanToTraceparentHeader(span: Span): string {\n const { traceId, spanId } = span.spanContext();\n const sampled = spanIsSampled(span);\n return generateTraceparentHeader(traceId, spanId, sampled);\n}\n\n/**\n * Converts the span links array to a flattened version to be sent within an envelope.\n *\n * If the links array is empty, it returns `undefined` so the empty value can be dropped before it's sent.\n */\nexport function convertSpanLinksForEnvelope(links?: SpanLink[]): SpanLinkJSON[] | undefined {\n if (links && links.length > 0) {\n return links.map(({ context: { spanId, traceId, traceFlags, ...restContext }, attributes }) => ({\n span_id: spanId,\n trace_id: traceId,\n sampled: traceFlags === TRACE_FLAG_SAMPLED,\n attributes,\n ...restContext,\n }));\n } else {\n return undefined;\n }\n}\n\n/**\n * Convert a span time input into a timestamp in seconds.\n */\nexport function spanTimeInputToSeconds(input: SpanTimeInput | undefined): number {\n if (typeof input === 'number') {\n return ensureTimestampInSeconds(input);\n }\n\n if (Array.isArray(input)) {\n // See {@link HrTime} for the array-based time format\n return input[0] + input[1] / 1e9;\n }\n\n if (input instanceof Date) {\n return ensureTimestampInSeconds(input.getTime());\n }\n\n return timestampInSeconds();\n}\n\n/**\n * Converts a timestamp to second, if it was in milliseconds, or keeps it as second.\n */\nfunction ensureTimestampInSeconds(timestamp: number): number {\n const isMs = timestamp > 9999999999;\n return isMs ? timestamp / 1000 : timestamp;\n}\n\n/**\n * Convert a span to a JSON representation.\n */\n// Note: Because of this, we currently have a circular type dependency (which we opted out of in package.json).\n// This is not avoidable as we need `spanToJSON` in `spanUtils.ts`, which in turn is needed by `span.ts` for backwards compatibility.\n// And `spanToJSON` needs the Span class from `span.ts` to check here.\nexport function spanToJSON(span: Span): SpanJSON {\n if (spanIsSentrySpan(span)) {\n return span.getSpanJSON();\n }\n\n const { spanId: span_id, traceId: trace_id } = span.spanContext();\n\n // Handle a span from @opentelemetry/sdk-base-trace's `Span` class\n if (spanIsOpenTelemetrySdkTraceBaseSpan(span)) {\n const { attributes, startTime, name, endTime, status, links } = span;\n\n // In preparation for the next major of OpenTelemetry, we want to support\n // looking up the parent span id according to the new API\n // In OTel v1, the parent span id is accessed as `parentSpanId`\n // In OTel v2, the parent span id is accessed as `spanId` on the `parentSpanContext`\n const parentSpanId =\n 'parentSpanId' in span\n ? span.parentSpanId\n : 'parentSpanContext' in span\n ? (span.parentSpanContext as { spanId?: string } | undefined)?.spanId\n : undefined;\n\n return {\n span_id,\n trace_id,\n data: attributes,\n description: name,\n parent_span_id: parentSpanId,\n start_timestamp: spanTimeInputToSeconds(startTime),\n // This is [0,0] by default in OTEL, in which case we want to interpret this as no end time\n timestamp: spanTimeInputToSeconds(endTime) || undefined,\n status: getStatusMessage(status),\n op: attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP],\n origin: attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] as SpanOrigin | undefined,\n links: convertSpanLinksForEnvelope(links),\n };\n }\n\n // Finally, at least we have `spanContext()`....\n // This should not actually happen in reality, but we need to handle it for type safety.\n return {\n span_id,\n trace_id,\n start_timestamp: 0,\n data: {},\n };\n}\n\nfunction spanIsOpenTelemetrySdkTraceBaseSpan(span: Span): span is OpenTelemetrySdkTraceBaseSpan {\n const castSpan = span as Partial;\n return !!castSpan.attributes && !!castSpan.startTime && !!castSpan.name && !!castSpan.endTime && !!castSpan.status;\n}\n\n/** Exported only for tests. */\nexport interface OpenTelemetrySdkTraceBaseSpan extends Span {\n attributes: SpanAttributes;\n startTime: SpanTimeInput;\n name: string;\n status: SpanStatus;\n endTime: SpanTimeInput;\n parentSpanId?: string;\n links?: SpanLink[];\n}\n\n/**\n * Sadly, due to circular dependency checks we cannot actually import the Span class here and check for instanceof.\n * :( So instead we approximate this by checking if it has the `getSpanJSON` method.\n */\nfunction spanIsSentrySpan(span: Span): span is SentrySpan {\n return typeof (span as SentrySpan).getSpanJSON === 'function';\n}\n\n/**\n * Returns true if a span is sampled.\n * In most cases, you should just use `span.isRecording()` instead.\n * However, this has a slightly different semantic, as it also returns false if the span is finished.\n * So in the case where this distinction is important, use this method.\n */\nexport function spanIsSampled(span: Span): boolean {\n // We align our trace flags with the ones OpenTelemetry use\n // So we also check for sampled the same way they do.\n const { traceFlags } = span.spanContext();\n return traceFlags === TRACE_FLAG_SAMPLED;\n}\n\n/** Get the status message to use for a JSON representation of a span. */\nexport function getStatusMessage(status: SpanStatus | undefined): string | undefined {\n if (!status || status.code === SPAN_STATUS_UNSET) {\n return undefined;\n }\n\n if (status.code === SPAN_STATUS_OK) {\n return 'ok';\n }\n\n return status.message || 'unknown_error';\n}\n\nconst CHILD_SPANS_FIELD = '_sentryChildSpans';\nconst ROOT_SPAN_FIELD = '_sentryRootSpan';\n\ntype SpanWithPotentialChildren = Span & {\n [CHILD_SPANS_FIELD]?: Set;\n [ROOT_SPAN_FIELD]?: Span;\n};\n\n/**\n * Adds an opaque child span reference to a span.\n */\nexport function addChildSpanToSpan(span: SpanWithPotentialChildren, childSpan: Span): void {\n // We store the root span reference on the child span\n // We need this for `getRootSpan()` to work\n const rootSpan = span[ROOT_SPAN_FIELD] || span;\n addNonEnumerableProperty(childSpan as SpanWithPotentialChildren, ROOT_SPAN_FIELD, rootSpan);\n\n // We store a list of child spans on the parent span\n // We need this for `getSpanDescendants()` to work\n if (span[CHILD_SPANS_FIELD]) {\n span[CHILD_SPANS_FIELD].add(childSpan);\n } else {\n addNonEnumerableProperty(span, CHILD_SPANS_FIELD, new Set([childSpan]));\n }\n}\n\n/** This is only used internally by Idle Spans. */\nexport function removeChildSpanFromSpan(span: SpanWithPotentialChildren, childSpan: Span): void {\n if (span[CHILD_SPANS_FIELD]) {\n span[CHILD_SPANS_FIELD].delete(childSpan);\n }\n}\n\n/**\n * Returns an array of the given span and all of its descendants.\n */\nexport function getSpanDescendants(span: SpanWithPotentialChildren): Span[] {\n const resultSet = new Set();\n\n function addSpanChildren(span: SpanWithPotentialChildren): void {\n // This exit condition is required to not infinitely loop in case of a circular dependency.\n if (resultSet.has(span)) {\n return;\n // We want to ignore unsampled spans (e.g. non recording spans)\n } else if (spanIsSampled(span)) {\n resultSet.add(span);\n const childSpans = span[CHILD_SPANS_FIELD] ? Array.from(span[CHILD_SPANS_FIELD]) : [];\n for (const childSpan of childSpans) {\n addSpanChildren(childSpan);\n }\n }\n }\n\n addSpanChildren(span);\n\n return Array.from(resultSet);\n}\n\n/**\n * Returns the root span of a given span.\n */\nexport function getRootSpan(span: SpanWithPotentialChildren): Span {\n return span[ROOT_SPAN_FIELD] || span;\n}\n\n/**\n * Returns the currently active span.\n */\nexport function getActiveSpan(): Span | undefined {\n const carrier = getMainCarrier();\n const acs = getAsyncContextStrategy(carrier);\n if (acs.getActiveSpan) {\n return acs.getActiveSpan();\n }\n\n return _getSpanForScope(getCurrentScope());\n}\n\n/**\n * Logs a warning once if `beforeSendSpan` is used to drop spans.\n */\nexport function showSpanDropWarning(): void {\n if (!hasShownSpanDropWarning) {\n consoleSandbox(() => {\n // eslint-disable-next-line no-console\n console.warn(\n '[Sentry] Returning null from `beforeSendSpan` is disallowed. To drop certain spans, configure the respective integrations directly or use `ignoreSpans`.',\n );\n });\n hasShownSpanDropWarning = true;\n }\n}\n\n/**\n * Updates the name of the given span and ensures that the span name is not\n * overwritten by the Sentry SDK.\n *\n * Use this function instead of `span.updateName()` if you want to make sure that\n * your name is kept. For some spans, for example root `http.server` spans the\n * Sentry SDK would otherwise overwrite the span name with a high-quality name\n * it infers when the span ends.\n *\n * Use this function in server code or when your span is started on the server\n * and on the client (browser). If you only update a span name on the client,\n * you can also use `span.updateName()` the SDK does not overwrite the name.\n *\n * @param span - The span to update the name of.\n * @param name - The name to set on the span.\n */\nexport function updateSpanName(span: Span, name: string): void {\n span.updateName(name);\n span.setAttributes({\n [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'custom',\n [SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME]: name,\n });\n}\n"],"sourceRoot":""}