@sentry/browser
Version:
Official Sentry SDK for browsers
216 lines (215 loc) • 10.2 kB
JavaScript
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 { startInactiveSpan } from "@sentry/core/browser";
import { HTTP_CLIENT } from "@sentry/conventions/op";
// 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