@sentry/browser
Version:
Official Sentry SDK for browsers
252 lines (251 loc) • 8.81 kB
JavaScript
const require_debug_build = require("../debug-build.js");
let _sentry_core = require("@sentry/core");
let _sentry_browser_utils = require("@sentry/browser-utils");
// src/integrations/httpclient.ts
const INTEGRATION_NAME = "HttpClient";
const _httpClientIntegration = ((options = {}) => {
const _options = {
failedRequestStatusCodes: [[500, 599]],
failedRequestTargets: [/.*/],
...options
};
return {
name: INTEGRATION_NAME,
setup(client) {
_wrapFetch(client, _options);
_wrapXHR(client, _options);
}
};
});
/**
* Create events for failed client side HTTP requests.
*/
const httpClientIntegration = (0, _sentry_core.defineIntegration)(_httpClientIntegration);
/**
* Interceptor function for fetch requests
*
* @param requestInfo The Fetch API request info
* @param response The Fetch API response
* @param requestInit The request init object
*/
function _fetchResponseHandler(options, requestInfo, response, requestInit, error) {
if (_shouldCaptureResponse(options, response.status, response.url)) {
const request = _getRequest(requestInfo, requestInit);
let requestHeaders, responseHeaders, requestCookies, responseCookies;
const dc = _getDataCollectionSettings();
if (dc.requestHeaders !== false) requestHeaders = (0, _sentry_core._INTERNAL_filterKeyValueData)(_extractFetchHeaders(request.headers), dc.requestHeaders);
if (dc.responseHeaders !== false) responseHeaders = (0, _sentry_core._INTERNAL_filterKeyValueData)(_extractFetchHeaders(response.headers), dc.responseHeaders);
if (dc.cookies !== false) {
const reqCookieStr = request.headers.get("Cookie") || void 0;
if (reqCookieStr) requestCookies = (0, _sentry_core._INTERNAL_filterCookies)(reqCookieStr, dc.cookies, "cookie");
const resCookieStr = response.headers.get("Set-Cookie") || void 0;
if (resCookieStr) responseCookies = (0, _sentry_core._INTERNAL_filterCookies)(resCookieStr, dc.cookies, "set-cookie");
}
const event = _createEvent({
url: request.url,
method: request.method,
status: response.status,
requestHeaders,
responseHeaders,
requestCookies,
responseCookies,
error,
type: "fetch"
});
(0, _sentry_core.captureEvent)(event);
}
}
/**
* Interceptor function for XHR requests
*
* @param xhr The XHR request
* @param method The HTTP method
* @param headers The HTTP headers
*/
function _xhrResponseHandler(options, xhr, method, headers, error) {
if (_shouldCaptureResponse(options, xhr.status, xhr.responseURL)) {
let requestHeaders, responseCookies, responseHeaders;
const dc = _getDataCollectionSettings();
if (dc.cookies !== false) try {
const cookieString = xhr.getResponseHeader("Set-Cookie") || xhr.getResponseHeader("set-cookie") || void 0;
if (cookieString) responseCookies = (0, _sentry_core._INTERNAL_filterCookies)(cookieString, dc.cookies, "set-cookie");
} catch {}
if (dc.responseHeaders !== false) try {
responseHeaders = (0, _sentry_core._INTERNAL_filterKeyValueData)(_getXHRResponseHeaders(xhr), dc.responseHeaders);
} catch {}
if (dc.requestHeaders !== false) requestHeaders = (0, _sentry_core._INTERNAL_filterKeyValueData)(headers, dc.requestHeaders);
const event = _createEvent({
url: xhr.responseURL,
method,
status: xhr.status,
requestHeaders,
responseHeaders,
responseCookies,
error,
type: "xhr"
});
(0, _sentry_core.captureEvent)(event);
}
}
/**
* Extracts response size from `Content-Length` header when possible
*
* @param headers
* @returns The response size in bytes or undefined
*/
function _getResponseSizeFromHeaders(headers) {
if (headers) {
const contentLength = headers["Content-Length"] || headers["content-length"];
if (contentLength) return parseInt(contentLength, 10);
}
}
/**
* Extracts the headers as an object from the given Fetch API request or response object
*
* @param headers The headers to extract
* @returns The extracted headers as an object
*/
function _extractFetchHeaders(headers) {
const result = {};
headers.forEach((value, key) => {
result[key] = value;
});
return result;
}
/**
* Extracts the response headers as an object from the given XHR object
*
* @param xhr The XHR object to extract the response headers from
* @returns The response headers as an object
*/
function _getXHRResponseHeaders(xhr) {
const headers = xhr.getAllResponseHeaders();
if (!headers) return {};
return headers.split("\r\n").reduce((acc, line) => {
const [key, value] = line.split(": ");
if (key && value) acc[key] = value;
return acc;
}, {});
}
/**
* Checks if the given target url is in the given list of targets
*
* @param target The target url to check
* @returns true if the target url is in the given list of targets, false otherwise
*/
function _isInGivenRequestTargets(failedRequestTargets, target) {
return failedRequestTargets.some((givenRequestTarget) => {
if (typeof givenRequestTarget === "string") return target.includes(givenRequestTarget);
return givenRequestTarget.test(target);
});
}
/**
* Checks if the given status code is in the given range
*
* @param status The status code to check
* @returns true if the status code is in the given range, false otherwise
*/
function _isInGivenStatusRanges(failedRequestStatusCodes, status) {
return failedRequestStatusCodes.some((range) => {
if (typeof range === "number") return range === status;
return status >= range[0] && status <= range[1];
});
}
/**
* Wraps `fetch` function to capture request and response data
*/
function _wrapFetch(client, options) {
(0, _sentry_core.addFetchInstrumentationHandler)((handlerData) => {
if ((0, _sentry_core.getClient)() !== client) return;
const { response, args, error, virtualError } = handlerData;
const [requestInfo, requestInit] = args;
if (!response) return;
_fetchResponseHandler(options, requestInfo, response, requestInit, error || virtualError);
});
}
/**
* Wraps XMLHttpRequest to capture request and response data
*/
function _wrapXHR(client, options) {
if (!("XMLHttpRequest" in _sentry_core.GLOBAL_OBJ)) return;
(0, _sentry_browser_utils.addXhrInstrumentationHandler)((handlerData) => {
if ((0, _sentry_core.getClient)() !== client) return;
const { error, virtualError } = handlerData;
const xhr = handlerData.xhr;
const sentryXhrData = xhr[_sentry_browser_utils.SENTRY_XHR_DATA_KEY];
if (!sentryXhrData) return;
const { method, request_headers: headers } = sentryXhrData;
try {
_xhrResponseHandler(options, xhr, method, headers, error || virtualError);
} catch (e) {
require_debug_build.DEBUG_BUILD && _sentry_core.debug.warn("Error while extracting response event form XHR response", e);
}
});
}
/**
* Checks whether to capture given response as an event
*
* @param status response status code
* @param url response url
*/
function _shouldCaptureResponse(options, status, url) {
return _isInGivenStatusRanges(options.failedRequestStatusCodes, status) && _isInGivenRequestTargets(options.failedRequestTargets, url) && !(0, _sentry_core.isSentryRequestUrl)(url, (0, _sentry_core.getClient)());
}
/**
* Creates a synthetic Sentry event from given response data
*
* @param data response data
* @returns event
*/
function _createEvent(data) {
const client = (0, _sentry_core.getClient)();
const virtualStackTrace = client && data.error && data.error instanceof Error ? data.error.stack : void 0;
const stack = virtualStackTrace && client ? client.getOptions().stackParser(virtualStackTrace, 0, 1) : void 0;
const message = `HTTP Client Error with status code: ${data.status}`;
const event = {
message,
exception: { values: [{
type: "Error",
value: message,
stacktrace: stack ? { frames: stack } : void 0
}] },
request: {
url: data.url,
method: data.method,
headers: data.requestHeaders,
cookies: data.requestCookies
},
contexts: { response: {
status_code: data.status,
headers: data.responseHeaders,
cookies: data.responseCookies,
body_size: _getResponseSizeFromHeaders(data.responseHeaders)
} }
};
(0, _sentry_core.addExceptionMechanism)(event, {
type: `auto.http.client.${data.type}`,
handled: false
});
return event;
}
function _getRequest(requestInfo, requestInit) {
if (!requestInit && requestInfo instanceof Request) return requestInfo;
if (requestInfo instanceof Request && requestInfo.bodyUsed) return requestInfo;
return new Request(requestInfo, requestInit);
}
function _getDataCollectionSettings() {
const client = (0, _sentry_core.getClient)();
if (!client) return {
cookies: false,
requestHeaders: false,
responseHeaders: false
};
const { cookies, httpHeaders } = client.getDataCollectionOptions();
return {
cookies,
requestHeaders: httpHeaders.request,
responseHeaders: httpHeaders.response
};
}
exports.httpClientIntegration = httpClientIntegration;
//# sourceMappingURL=httpclient.js.map