UNPKG

@sentry/browser

Version:
216 lines (215 loc) • 10.2 kB
import { WINDOW } from "../helpers.js"; import { baggageHeaderHasSentryValues, createHeadersSafely, getFullURL, isPerformanceResourceTiming } from "./utils.js"; import { SentryNonRecordingSpan, addFetchInstrumentationHandler, filterCollectedUrl, filterCollectedUrlQuery, getActiveSpan, getClient, getTraceData, getUrlDomain, getUrlFragment, getUrlQuery, hasSpanStreamingEnabled, hasSpansEnabled, instrumentFetchRequest, matchesTracePropagationTargets, parseUrl, setHttpStatus, spanIsIgnored, spanToJSON, stripDataUrlContent, stripUrlQueryAndFragment, timestampInSeconds } from "@sentry/core"; import { SENTRY_XHR_DATA_KEY, addPerformanceInstrumentationHandler, addXhrInstrumentationHandler, getLocationHref, parseXhrResponseHeaders, resourceTimingToSpanAttributes } from "@sentry/browser-utils"; import { HTTP_REQUEST_METHOD, SENTRY_OP, SENTRY_ORIGIN, SERVER_ADDRESS, URL_DOMAIN, URL_FRAGMENT, URL_FULL, URL_QUERY } from "@sentry/conventions/attributes"; import { HTTP_CLIENT } from "@sentry/conventions/op"; import { startInactiveSpan } from "@sentry/core/browser"; // src/tracing/request.ts const defaultRequestInstrumentationOptions = { traceFetch: true, traceXHR: true, enableHTTPTimings: true }; /** Registers span creators for xhr and fetch requests */ function instrumentOutgoingRequests(client, _options) { const options = { ...defaultRequestInstrumentationOptions, ..._options }; if (options.traceFetch) instrumentFetchRequests(client, options); if (options.traceXHR) instrumentXhrRequests(client, options); } /** * Registers the span creator for fetch requests. */ function instrumentFetchRequests(client, options) { const { enableHTTPTimings = true, onRequestSpanStart, onRequestSpanEnd } = options; const { shouldCreateSpan, shouldAttachHeadersWithTargets, spans, propagateTraceparent } = getRequestSpanContext(client, options); addFetchInstrumentationHandler((handlerData) => { const createdSpan = instrumentFetchRequest(handlerData, shouldCreateSpan, shouldAttachHeadersWithTargets, spans, { propagateTraceparent, onRequestSpanEnd, urlBase: WINDOW.location?.href }); if (createdSpan) { const fullUrl = getFullURL(handlerData.fetchData.url); const host = fullUrl ? parseUrl(fullUrl).host?.replace(/^.*@/, "") : void 0; const sanitizedFullUrl = fullUrl ? stripDataUrlContent(fullUrl) : void 0; createdSpan.setAttributes({ [URL_FULL]: filterCollectedUrl(sanitizedFullUrl), [SERVER_ADDRESS]: host }); if (enableHTTPTimings) addHTTPTimings(createdSpan, client); onRequestSpanStart?.(createdSpan, { headers: handlerData.headers }); } }); } /** * Registers the span creator for XHR requests. */ function instrumentXhrRequests(client, options) { const { enableHTTPTimings = true, onRequestSpanStart, onRequestSpanEnd } = options; const { shouldCreateSpan, shouldAttachHeadersWithTargets, spans, propagateTraceparent } = getRequestSpanContext(client, options); addXhrInstrumentationHandler((handlerData) => { const createdSpan = xhrCallback(handlerData, shouldCreateSpan, shouldAttachHeadersWithTargets, spans, propagateTraceparent, onRequestSpanEnd); if (createdSpan) { if (enableHTTPTimings) addHTTPTimings(createdSpan, client); onRequestSpanStart?.(createdSpan, { headers: createHeadersSafely(handlerData.xhr.__sentry_xhr_v3__?.request_headers) }); } }); } function getRequestSpanContext(client, { shouldCreateSpanForRequest, tracePropagationTargets }) { return { shouldCreateSpan: typeof shouldCreateSpanForRequest === "function" ? shouldCreateSpanForRequest : () => true, shouldAttachHeadersWithTargets: (url) => shouldAttachHeaders(url, tracePropagationTargets), spans: {}, propagateTraceparent: client.getOptions().propagateTraceparent }; } /** * The maximum time (ms) to wait for PerformanceResourceTiming data before ending the span. * Same approach is used by OTel's browser fetch instrumentation: * See {@link https://github.com/open-telemetry/opentelemetry-js/blob/30f94fe99339287b1e4d3c8bb90172c2523f06f4/experimental/packages/opentelemetry-instrumentation-fetch/src/fetch.ts#L352-L372} */ const HTTP_TIMING_WAIT_MS = 300; /** * Creates a temporary observer to listen to the next fetch/xhr resourcing timings, * so that when timings hit their per-browser limit they don't need to be removed. * * @param span A span that has yet to be finished, must contain `url.full` on data. */ function addHTTPTimings(span, client) { const url = spanToJSON(span).attributes[URL_FULL]; if (!url || typeof url !== "string") return; let onEntryFound = () => void setTimeout(unsubscribePerformanceObsever); if (hasSpanStreamingEnabled(client)) { const originalEnd = span.end.bind(span); span.end = (endTimestamp) => { const capturedEndTimestamp = endTimestamp ?? timestampInSeconds(); let isEnded = false; const endSpanAndCleanup = () => { if (isEnded) return; isEnded = true; setTimeout(unsubscribePerformanceObsever); originalEnd(capturedEndTimestamp); clearTimeout(fallbackTimeout); }; onEntryFound = endSpanAndCleanup; const fallbackTimeout = setTimeout(endSpanAndCleanup, HTTP_TIMING_WAIT_MS); }; } const unsubscribePerformanceObsever = addPerformanceInstrumentationHandler("resource", ({ entries }) => { entries.forEach((entry) => { if (isPerformanceResourceTiming(entry) && entry.name.endsWith(url)) { span.setAttributes(resourceTimingToSpanAttributes(entry)); onEntryFound(); } }); }); } /** * A function that determines whether to attach tracing headers to a request. * We only export this function for testing purposes. */ function shouldAttachHeaders(targetUrl, tracePropagationTargets) { const href = getLocationHref(); if (!href) { const isRelativeSameOriginRequest = !!targetUrl.match(/^\/(?!\/)/); if (!tracePropagationTargets) return isRelativeSameOriginRequest; else return matchesTracePropagationTargets(targetUrl, tracePropagationTargets); } else { let resolvedUrl; let currentOrigin; try { resolvedUrl = new URL(targetUrl, href); currentOrigin = new URL(href).origin; } catch { return false; } const isSameOriginRequest = resolvedUrl.origin === currentOrigin; if (!tracePropagationTargets) return isSameOriginRequest; else return matchesTracePropagationTargets(resolvedUrl.toString(), tracePropagationTargets) || isSameOriginRequest && matchesTracePropagationTargets(resolvedUrl.pathname, tracePropagationTargets); } } /** * Create and track xhr request spans * * @returns Span if a span was created, otherwise void. */ function xhrCallback(handlerData, shouldCreateSpan, shouldAttachHeaders, spans, propagateTraceparent, onRequestSpanEnd) { const xhr = handlerData.xhr; const sentryXhrData = xhr?.[SENTRY_XHR_DATA_KEY]; if (!xhr || xhr.__sentry_own_request__ || !sentryXhrData) return; const { url, method } = sentryXhrData; const shouldCreateSpanResult = hasSpansEnabled() && shouldCreateSpan(url); if (handlerData.endTimestamp) { const spanId = xhr.__sentry_xhr_span_id__; if (!spanId) return; const span = spans[spanId]; if (span) { if (shouldCreateSpanResult && sentryXhrData.status_code !== void 0) { setHttpStatus(span, sentryXhrData.status_code); span.end(); onRequestSpanEnd?.(span, { headers: createHeadersSafely(parseXhrResponseHeaders(xhr)), error: handlerData.error }); } delete spans[spanId]; } return; } const fullUrl = getFullURL(url); const parsedUrl = fullUrl ? parseUrl(fullUrl) : parseUrl(url); const sanitizedFullUrl = fullUrl ? stripDataUrlContent(fullUrl) : void 0; const urlForSpanName = stripDataUrlContent(stripUrlQueryAndFragment(url)); const client = getClient(); const hasParent = !!getActiveSpan(); const shouldEmitSpan = hasParent || !!client && hasSpanStreamingEnabled(client); const host = parsedUrl?.host?.replace(/^.*@/, ""); const domain = getUrlDomain(fullUrl || url); const streamedName = domain ? `${method} ${domain}` : method; const span = shouldCreateSpanResult && shouldEmitSpan ? startInactiveSpan({ name: !!client && hasSpanStreamingEnabled(client) ? streamedName : `${method} ${urlForSpanName}`, attributes: { type: "xhr", [HTTP_REQUEST_METHOD]: method, [URL_FULL]: filterCollectedUrl(sanitizedFullUrl), [SERVER_ADDRESS]: host, [URL_DOMAIN]: domain, [SENTRY_ORIGIN]: "auto.http.browser", [SENTRY_OP]: HTTP_CLIENT, [URL_QUERY]: filterCollectedUrlQuery(getUrlQuery(parsedUrl?.search)), [URL_FRAGMENT]: getUrlFragment(parsedUrl?.hash) } }) : new SentryNonRecordingSpan(); const spanForTraceHeaders = spanIsIgnored(span) && hasParent ? void 0 : span; if (shouldCreateSpanResult && !shouldEmitSpan) client?.recordDroppedEvent("no_parent_span", "span"); xhr.__sentry_xhr_span_id__ = span.spanContext().spanId; spans[xhr.__sentry_xhr_span_id__] = span; if (shouldAttachHeaders(url)) addTracingHeadersToXhrRequest(xhr, hasSpansEnabled() && shouldEmitSpan ? spanForTraceHeaders : void 0, propagateTraceparent); if (client) client.emit("beforeOutgoingRequestSpan", span, handlerData); return span; } function addTracingHeadersToXhrRequest(xhr, span, propagateTraceparent) { const { "sentry-trace": sentryTrace, baggage, traceparent } = getTraceData({ span, propagateTraceparent }); if (sentryTrace) setHeaderOnXhr(xhr, sentryTrace, baggage, traceparent); } function setHeaderOnXhr(xhr, sentryTraceHeader, sentryBaggageHeader, traceparentHeader) { const originalHeaders = xhr.__sentry_xhr_v3__?.request_headers; if (originalHeaders?.["sentry-trace"] || !xhr.setRequestHeader) return; try { xhr.setRequestHeader("sentry-trace", sentryTraceHeader); if (traceparentHeader && !originalHeaders?.["traceparent"]) xhr.setRequestHeader("traceparent", traceparentHeader); if (sentryBaggageHeader) { const originalBaggageHeader = originalHeaders?.["baggage"]; if (!originalBaggageHeader || !baggageHeaderHasSentryValues(originalBaggageHeader)) xhr.setRequestHeader("baggage", sentryBaggageHeader); } } catch {} } export { defaultRequestInstrumentationOptions, instrumentFetchRequests, instrumentOutgoingRequests, instrumentXhrRequests, shouldAttachHeaders }; //# sourceMappingURL=request.js.map