@opentelemetry/browser-instrumentation 0.7.0 → 0.8.1

package/dist/utils/request.js

@@ -0,0 +1,131 @@
+import { diag } from "@opentelemetry/api";
+//#region src/utils/request.ts
+const DIAG_LOGGER = diag.createComponentLogger({ namespace: "@opentelemetry/browser-instrumentation/utils/request" });
+function isDocument(value) {
+	return typeof Document !== "undefined" && value instanceof Document;
+}
+/**
+* Helper function to determine payload content length for fetch requests
+*
+* The fetch API is kinda messy: there are a couple of ways the body can be passed in.
+*
+* In all cases, the body param can be some variation of ReadableStream,
+* and ReadableStreams can only be read once! We want to avoid consuming the body here,
+* because that would mean that the body never gets sent with the actual fetch request.
+*
+* Either the first arg is a Request object, which can be cloned
+*   so we can clone that object and read the body of the clone
+*   without disturbing the original argument
+*   However, reading the body here can only be done async; the body() method returns a promise
+*   this means this entire function has to return a promise
+*
+* OR the first arg is a url/string
+*   in which case the second arg has type RequestInit
+*   RequestInit is NOT cloneable, but RequestInit.body is writable
+*   so we can chain it into ReadableStream.pipeThrough()
+*
+*   ReadableStream.pipeThrough() lets us process a stream and returns a new stream
+*   So we can measure the body length as it passes through the pipe, but need to attach
+*   the new stream to the original request
+*   so that the browser still has access to the body.
+*/
+async function getFetchBodyLength(...args) {
+	if (args[0] instanceof URL || typeof args[0] === "string") {
+		const requestInit = args[1];
+		if (!requestInit?.body) return;
+		if (requestInit.body instanceof ReadableStream) {
+			const { body, length } = _getBodyNonDestructively(requestInit.body);
+			requestInit.body = body;
+			return await length;
+		} else return getXHRBodyLength(requestInit.body);
+	} else {
+		const info = args[0];
+		if (!info?.body) return;
+		return getByteLength(await info.clone().text());
+	}
+}
+function _getBodyNonDestructively(body) {
+	if (!body.pipeThrough) {
+		DIAG_LOGGER.warn("Platform has ReadableStream but not pipeThrough!");
+		return {
+			body,
+			length: Promise.resolve(void 0)
+		};
+	}
+	let length = 0;
+	let resolveLength;
+	const lengthPromise = new Promise((resolve) => {
+		resolveLength = resolve;
+	});
+	const bodyReader = body.getReader();
+	return {
+		body: new ReadableStream({
+			async pull(controller) {
+				const { value, done } = await bodyReader.read();
+				length += value?.byteLength || 0;
+				if (done) {
+					controller.close();
+					bodyReader.releaseLock();
+					resolveLength(length);
+					return;
+				}
+				controller.enqueue(value);
+			},
+			cancel(reason) {
+				resolveLength(void 0);
+				bodyReader.cancel(reason);
+			}
+		}),
+		length: lengthPromise
+	};
+}
+/**
+* Helper function to determine payload content length for XHR requests
+*/
+function getXHRBodyLength(body) {
+	if (isDocument(body)) return new XMLSerializer().serializeToString(body).length;
+	if (typeof body === "string") return getByteLength(body);
+	if (body instanceof Blob) return body.size;
+	if (body instanceof FormData) return getFormDataSize(body);
+	if (body instanceof URLSearchParams) return getByteLength(body.toString());
+	if (body.byteLength !== void 0) return body.byteLength;
+	DIAG_LOGGER.warn("unknown body type");
+}
+const TEXT_ENCODER = new TextEncoder();
+function getByteLength(s) {
+	return TEXT_ENCODER.encode(s).byteLength;
+}
+function getFormDataSize(formData) {
+	let size = 0;
+	for (const [key, value] of formData.entries()) {
+		size += key.length;
+		if (value instanceof Blob) size += value.size;
+		else size += value.length;
+	}
+	return size;
+}
+const DEFAULT_KNOWN_METHODS = {
+	CONNECT: true,
+	DELETE: true,
+	GET: true,
+	HEAD: true,
+	OPTIONS: true,
+	PATCH: true,
+	POST: true,
+	PUT: true,
+	TRACE: true,
+	QUERY: true
+};
+/**
+* Normalize an HTTP request method string per `http.request.method` spec
+* https://github.com/open-telemetry/semantic-conventions/blob/main/docs/http/http-spans.md#http-client-span
+*/
+function normalizeHttpRequestMethod(method) {
+	const methUpper = method.toUpperCase();
+	if (Object.hasOwn(DEFAULT_KNOWN_METHODS, methUpper)) return methUpper;
+	return "_OTHER";
+}
+//#endregion
+export { getFetchBodyLength, getXHRBodyLength, normalizeHttpRequestMethod };
+
+//# sourceMappingURL=request.js.map

package/dist/utils/request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.js","names":[],"sources":["../../src/utils/request.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { diag } from '@opentelemetry/api';\n\nconst DIAG_LOGGER = diag.createComponentLogger({\n  namespace: '@opentelemetry/browser-instrumentation/utils/request',\n});\n\nfunction isDocument(value: unknown): value is Document {\n  return typeof Document !== 'undefined' && value instanceof Document;\n}\n\n/**\n * Helper function to determine payload content length for fetch requests\n *\n * The fetch API is kinda messy: there are a couple of ways the body can be passed in.\n *\n * In all cases, the body param can be some variation of ReadableStream,\n * and ReadableStreams can only be read once! We want to avoid consuming the body here,\n * because that would mean that the body never gets sent with the actual fetch request.\n *\n * Either the first arg is a Request object, which can be cloned\n *   so we can clone that object and read the body of the clone\n *   without disturbing the original argument\n *   However, reading the body here can only be done async; the body() method returns a promise\n *   this means this entire function has to return a promise\n *\n * OR the first arg is a url/string\n *   in which case the second arg has type RequestInit\n *   RequestInit is NOT cloneable, but RequestInit.body is writable\n *   so we can chain it into ReadableStream.pipeThrough()\n *\n *   ReadableStream.pipeThrough() lets us process a stream and returns a new stream\n *   So we can measure the body length as it passes through the pipe, but need to attach\n *   the new stream to the original request\n *   so that the browser still has access to the body.\n */\nexport async function getFetchBodyLength(\n  ...args: Parameters<typeof fetch>\n): Promise<number | undefined> {\n  if (args[0] instanceof URL || typeof args[0] === 'string') {\n    const requestInit = args[1];\n    if (!requestInit?.body) {\n      return undefined;\n    }\n    if (requestInit.body instanceof ReadableStream) {\n      const { body, length } = _getBodyNonDestructively(requestInit.body);\n      requestInit.body = body;\n\n      return await length;\n    } else {\n      return getXHRBodyLength(requestInit.body);\n    }\n  } else {\n    const info = args[0];\n    // Request.body has limited availability. ref: https://developer.mozilla.org/en-US/docs/Web/API/Request/body\n    // Accessing it here triggers a eslint error from the baseline plugin\n    /* eslint-disable baseline-js/use-baseline */\n    if (!info?.body) {\n      return undefined;\n    }\n    /* eslint-enable baseline-js/use-baseline */\n\n    const text = await info.clone().text();\n    return getByteLength(text);\n  }\n}\n\n// This function returns the body right away piped to a transform stream\n// if available. The length is returned as a promise because the original\n// fetch logic has to consume the body to get the final value.\nfunction _getBodyNonDestructively(body: ReadableStream): {\n  body: ReadableStream;\n  length: Promise<number | undefined>;\n} {\n  // can't read a ReadableStream without destroying it\n  // but we CAN pipe it through and return a new ReadableStream\n\n  // some (older) platforms don't expose the pipeThrough method and in that scenario, we're out of luck;\n  //   there's no way to read the stream without consuming it.\n  if (!body.pipeThrough) {\n    DIAG_LOGGER.warn('Platform has ReadableStream but not pipeThrough!');\n    return {\n      body,\n      length: Promise.resolve(undefined),\n    };\n  }\n\n  let length = 0;\n  let resolveLength: (l: number | undefined) => void;\n  const lengthPromise = new Promise<number | undefined>((resolve) => {\n    resolveLength = resolve;\n  });\n\n  const bodyReader = (body as ReadableStream<Uint8Array>).getReader();\n  const bodyWrapper = new ReadableStream<Uint8Array>({\n    async pull(controller) {\n      const { value, done } = await bodyReader.read();\n\n      length += value?.byteLength || 0;\n      if (done) {\n        controller.close();\n        bodyReader.releaseLock();\n        resolveLength(length);\n        return;\n      }\n      controller.enqueue(value);\n    },\n    cancel(reason) {\n      resolveLength(undefined);\n      bodyReader.cancel(reason);\n    },\n  });\n\n  return {\n    body: bodyWrapper,\n    length: lengthPromise,\n  };\n}\n\n/**\n * Helper function to determine payload content length for XHR requests\n */\nexport function getXHRBodyLength(\n  body: Document | XMLHttpRequestBodyInit,\n): number | undefined {\n  if (isDocument(body)) {\n    return new XMLSerializer().serializeToString(body).length;\n  }\n\n  // XMLHttpRequestBodyInit expands to the following:\n  if (typeof body === 'string') {\n    return getByteLength(body);\n  }\n\n  if (body instanceof Blob) {\n    return body.size;\n  }\n\n  if (body instanceof FormData) {\n    return getFormDataSize(body);\n  }\n\n  if (body instanceof URLSearchParams) {\n    return getByteLength(body.toString());\n  }\n\n  // ArrayBuffer | ArrayBufferView\n  if (body.byteLength !== undefined) {\n    return body.byteLength;\n  }\n\n  DIAG_LOGGER.warn('unknown body type');\n  return undefined;\n}\n\nconst TEXT_ENCODER = new TextEncoder();\nfunction getByteLength(s: string): number {\n  return TEXT_ENCODER.encode(s).byteLength;\n}\n\nfunction getFormDataSize(formData: FormData): number {\n  let size = 0;\n  for (const [key, value] of formData.entries()) {\n    size += key.length;\n    if (value instanceof Blob) {\n      size += value.size;\n    } else {\n      size += value.length;\n    }\n  }\n  return size;\n}\n\nconst DEFAULT_KNOWN_METHODS = {\n  CONNECT: true,\n  DELETE: true,\n  GET: true,\n  HEAD: true,\n  OPTIONS: true,\n  PATCH: true,\n  POST: true,\n  PUT: true,\n  TRACE: true,\n  // QUERY from https://datatracker.ietf.org/doc/draft-ietf-httpbis-safe-method-w-body/\n  QUERY: true,\n};\n/**\n * Normalize an HTTP request method string per `http.request.method` spec\n * https://github.com/open-telemetry/semantic-conventions/blob/main/docs/http/http-spans.md#http-client-span\n */\nexport function normalizeHttpRequestMethod(method: string): string {\n  const methUpper = method.toUpperCase();\n  if (Object.hasOwn(DEFAULT_KNOWN_METHODS, methUpper)) {\n    return methUpper;\n  }\n  return '_OTHER';\n}\n"],"mappings":";;AAOA,MAAM,cAAc,KAAK,sBAAsB,EAC7C,WAAW,uDACb,CAAC;AAED,SAAS,WAAW,OAAmC;CACrD,OAAO,OAAO,aAAa,eAAe,iBAAiB;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,eAAsB,mBACpB,GAAG,MAC0B;CAC7B,IAAI,KAAK,cAAc,OAAO,OAAO,KAAK,OAAO,UAAU;EACzD,MAAM,cAAc,KAAK;EACzB,IAAI,CAAC,aAAa,MAChB;EAEF,IAAI,YAAY,gBAAgB,gBAAgB;GAC9C,MAAM,EAAE,MAAM,WAAW,yBAAyB,YAAY,IAAI;GAClE,YAAY,OAAO;GAEnB,OAAO,MAAM;EACf,OACE,OAAO,iBAAiB,YAAY,IAAI;CAE5C,OAAO;EACL,MAAM,OAAO,KAAK;EAIlB,IAAI,CAAC,MAAM,MACT;EAKF,OAAO,cAAc,MADF,KAAK,MAAM,CAAC,CAAC,KAAK,CACZ;CAC3B;AACF;AAKA,SAAS,yBAAyB,MAGhC;CAMA,IAAI,CAAC,KAAK,aAAa;EACrB,YAAY,KAAK,kDAAkD;EACnE,OAAO;GACL;GACA,QAAQ,QAAQ,QAAQ,KAAA,CAAS;EACnC;CACF;CAEA,IAAI,SAAS;CACb,IAAI;CACJ,MAAM,gBAAgB,IAAI,SAA6B,YAAY;EACjE,gBAAgB;CAClB,CAAC;CAED,MAAM,aAAc,KAAoC,UAAU;CAoBlE,OAAO;EACL,MAAM,IApBgB,eAA2B;GACjD,MAAM,KAAK,YAAY;IACrB,MAAM,EAAE,OAAO,SAAS,MAAM,WAAW,KAAK;IAE9C,UAAU,OAAO,cAAc;IAC/B,IAAI,MAAM;KACR,WAAW,MAAM;KACjB,WAAW,YAAY;KACvB,cAAc,MAAM;KACpB;IACF;IACA,WAAW,QAAQ,KAAK;GAC1B;GACA,OAAO,QAAQ;IACb,cAAc,KAAA,CAAS;IACvB,WAAW,OAAO,MAAM;GAC1B;EACF,CAGkB;EAChB,QAAQ;CACV;AACF;;;;AAKA,SAAgB,iBACd,MACoB;CACpB,IAAI,WAAW,IAAI,GACjB,OAAO,IAAI,cAAc,CAAC,CAAC,kBAAkB,IAAI,CAAC,CAAC;CAIrD,IAAI,OAAO,SAAS,UAClB,OAAO,cAAc,IAAI;CAG3B,IAAI,gBAAgB,MAClB,OAAO,KAAK;CAGd,IAAI,gBAAgB,UAClB,OAAO,gBAAgB,IAAI;CAG7B,IAAI,gBAAgB,iBAClB,OAAO,cAAc,KAAK,SAAS,CAAC;CAItC,IAAI,KAAK,eAAe,KAAA,GACtB,OAAO,KAAK;CAGd,YAAY,KAAK,mBAAmB;AAEtC;AAEA,MAAM,eAAe,IAAI,YAAY;AACrC,SAAS,cAAc,GAAmB;CACxC,OAAO,aAAa,OAAO,CAAC,CAAC,CAAC;AAChC;AAEA,SAAS,gBAAgB,UAA4B;CACnD,IAAI,OAAO;CACX,KAAK,MAAM,CAAC,KAAK,UAAU,SAAS,QAAQ,GAAG;EAC7C,QAAQ,IAAI;EACZ,IAAI,iBAAiB,MACnB,QAAQ,MAAM;OAEd,QAAQ,MAAM;CAElB;CACA,OAAO;AACT;AAEA,MAAM,wBAAwB;CAC5B,SAAS;CACT,QAAQ;CACR,KAAK;CACL,MAAM;CACN,SAAS;CACT,OAAO;CACP,MAAM;CACN,KAAK;CACL,OAAO;CAEP,OAAO;AACT;;;;;AAKA,SAAgB,2BAA2B,QAAwB;CACjE,MAAM,YAAY,OAAO,YAAY;CACrC,IAAI,OAAO,OAAO,uBAAuB,SAAS,GAChD,OAAO;CAET,OAAO;AACT"}

package/dist/utils/url.js

@@ -0,0 +1,36 @@
+//#region src/utils/url.ts
+/**
+* Parses a URL, resolving relative URLs against document.baseURI (or location.href)
+* @param url
+*/
+function parseUrl(url) {
+	return new URL(url, document?.baseURI || location?.href);
+}
+/**
+* Tells if the given URL matches any of the string|RegExp provided in the list
+* @param url
+* @param urlsToMatch
+*/
+function matchesUrl(url, urlsToMatch) {
+	if (!urlsToMatch) return false;
+	for (const urlToMatch of urlsToMatch) if (typeof urlToMatch === "string") {
+		if (url === urlToMatch) return true;
+	} else if (url.match(urlToMatch)) return true;
+	return false;
+}
+const HTTP_PORT_FROM_PROTOCOL = {
+	"https:": "443",
+	"http:": "80"
+};
+/**
+* Extracts the server port from the given URL object
+*/
+function serverPortFromUrl(url) {
+	const serverPort = Number(url.port || HTTP_PORT_FROM_PROTOCOL[url.protocol]);
+	if (serverPort && !Number.isNaN(serverPort)) return serverPort;
+	else return;
+}
+//#endregion
+export { matchesUrl, parseUrl, serverPortFromUrl };
+
+//# sourceMappingURL=url.js.map

package/dist/utils/url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.js","names":[],"sources":["../../src/utils/url.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nconst SENSITIVE_PARAMS = [\n  'password',\n  'passwd',\n  'secret',\n  'api_key',\n  'apikey',\n  'auth',\n  'authorization',\n  'token',\n  'access_token',\n  'refresh_token',\n  'jwt',\n  'session',\n  'sessionid',\n  'key',\n  'private_key',\n  'client_secret',\n  'client_id',\n  'signature',\n  'hash',\n];\n\n/**\n * Default URL sanitization function that redacts credentials and sensitive query parameters.\n * This is the default implementation used when no custom sanitizeUrl callback is provided.\n *\n * @param url - The URL to sanitize\n * @returns The sanitized URL with credentials and sensitive parameters redacted\n */\nexport function defaultSanitizeUrl(url: string): string {\n  try {\n    const urlObj = new URL(url);\n    if (urlObj.username || urlObj.password) {\n      urlObj.username = 'REDACTED';\n      urlObj.password = 'REDACTED';\n    }\n    for (const param of SENSITIVE_PARAMS) {\n      if (urlObj.searchParams.has(param)) {\n        urlObj.searchParams.set(param, 'REDACTED');\n      }\n    }\n    return urlObj.toString();\n  } catch {\n    let sanitized = url.replace(/\\/\\/[^:/@]+:[^/@]+@/, '//REDACTED:REDACTED@');\n    for (const param of SENSITIVE_PARAMS) {\n      const regex = new RegExp(`([?&]${param}(?:%3D|=))[^&]*`, 'gi');\n      sanitized = sanitized.replace(regex, '$1REDACTED');\n    }\n    return sanitized;\n  }\n}\n\n/**\n * Parses a URL, resolving relative URLs against document.baseURI (or location.href)\n * @param url\n */\nexport function parseUrl(url: string): URL {\n  return new URL(url, document?.baseURI || location?.href);\n}\n\n/**\n * Tells if the given URL matches any of the string|RegExp provided in the list\n * @param url\n * @param urlsToMatch\n */\nexport function matchesUrl(\n  url: string,\n  urlsToMatch?: Array<string | RegExp>,\n): boolean {\n  if (!urlsToMatch) {\n    return false;\n  }\n\n  for (const urlToMatch of urlsToMatch) {\n    if (typeof urlToMatch === 'string') {\n      if (url === urlToMatch) {\n        return true;\n      }\n    } else if (url.match(urlToMatch)) {\n      return true;\n    }\n  }\n  return false;\n}\n\nconst HTTP_PORT_FROM_PROTOCOL: { [key: string]: string } = {\n  'https:': '443',\n  'http:': '80',\n};\n/**\n * Extracts the server port from the given URL object\n */\nexport function serverPortFromUrl(url: URL): number | undefined {\n  const serverPort = Number(url.port || HTTP_PORT_FROM_PROTOCOL[url.protocol]);\n  // Guard with `if (serverPort)` because `Number('') === 0`.\n  if (serverPort && !Number.isNaN(serverPort)) {\n    return serverPort;\n  } else {\n    return undefined;\n  }\n}\n"],"mappings":";;;;;AA6DA,SAAgB,SAAS,KAAkB;CACzC,OAAO,IAAI,IAAI,KAAK,UAAU,WAAW,UAAU,IAAI;AACzD;;;;;;AAOA,SAAgB,WACd,KACA,aACS;CACT,IAAI,CAAC,aACH,OAAO;CAGT,KAAK,MAAM,cAAc,aACvB,IAAI,OAAO,eAAe,UACpB;MAAA,QAAQ,YACV,OAAO;CAAA,OAEJ,IAAI,IAAI,MAAM,UAAU,GAC7B,OAAO;CAGX,OAAO;AACT;AAEA,MAAM,0BAAqD;CACzD,UAAU;CACV,SAAS;AACX;;;;AAIA,SAAgB,kBAAkB,KAA8B;CAC9D,MAAM,aAAa,OAAO,IAAI,QAAQ,wBAAwB,IAAI,SAAS;CAE3E,IAAI,cAAc,CAAC,OAAO,MAAM,UAAU,GACxC,OAAO;MAEP;AAEJ"}

package/dist/web-vitals/instrumentation.d.ts

@@ -9,7 +9,7 @@ import { InstrumentationBase } from "@opentelemetry/instrumentation";
  * registered. Calling `disable()` will stop emitting logs, but the underlying
  * listeners remain active. Calling `enable()` again will resume emission.
  */
-declare class WebVitalsInstrumentation extends InstrumentationBase<WebVitalsInstrumentationConfig> {
+export declare class WebVitalsInstrumentation extends InstrumentationBase<WebVitalsInstrumentationConfig> {
   private _isEnabled;
   private _listenersRegistered;
   private _applyCustomLogRecordData?;
@@ -35,5 +35,4 @@ declare class WebVitalsInstrumentation extends InstrumentationBase<WebVitalsInst
   private _emitWebVital;
 }
 //#endregion
-export { WebVitalsInstrumentation };
 //# sourceMappingURL=instrumentation.d.ts.map

package/dist/web-vitals/instrumentation.js.map

@@ -1 +1 @@
-{"version":3,"file":"instrumentation.js","names":[],"sources":["../../src/web-vitals/instrumentation.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type { Attributes } from '@opentelemetry/api';\nimport type { LogRecord } from '@opentelemetry/api-logs';\nimport { SeverityNumber } from '@opentelemetry/api-logs';\nimport {\n  InstrumentationBase,\n  safeExecuteInTheMiddle,\n} from '@opentelemetry/instrumentation';\nimport type {\n  CLSMetricWithAttribution,\n  INPMetricWithAttribution,\n  MetricWithAttribution,\n} from 'web-vitals/attribution';\nimport { onCLS, onFCP, onINP, onLCP, onTTFB } from 'web-vitals/attribution';\nimport { version } from '../../package.json' with { type: 'json' };\nimport {\n  ATTR_WEB_VITAL_DELTA,\n  ATTR_WEB_VITAL_ID,\n  ATTR_WEB_VITAL_NAME,\n  ATTR_WEB_VITAL_NAVIGATION_TYPE,\n  ATTR_WEB_VITAL_RATING,\n  ATTR_WEB_VITAL_VALUE,\n  WEB_VITAL_EVENT_NAME,\n} from './semconv.ts';\nimport type { WebVitalsInstrumentationConfig } from './types.ts';\n\n/**\n * Instrumentation for Core Web Vitals using the `web-vitals` library.\n * https://github.com/GoogleChrome/web-vitals\n *\n * Note: The `web-vitals` library does not support removing listeners once\n * registered. Calling `disable()` will stop emitting logs, but the underlying\n * listeners remain active. Calling `enable()` again will resume emission.\n */\nexport class WebVitalsInstrumentation extends InstrumentationBase<WebVitalsInstrumentationConfig> {\n  // Using `declare` is required here: InstrumentationBase calls enable() during\n  // construction, and standard field initialization would reset this flag after\n  // super() returns, breaking the duplicate-registration guard.\n  private declare _isEnabled: boolean;\n  private declare _listenersRegistered: boolean;\n  private _applyCustomLogRecordData?: (logRecord: LogRecord) => void;\n  private _includeRawAttribution: boolean;\n\n  constructor(config: WebVitalsInstrumentationConfig = {}) {\n    super('@opentelemetry/browser-instrumentation/web-vitals', version, config);\n    this._applyCustomLogRecordData = config.applyCustomLogRecordData;\n    this._includeRawAttribution = config.includeRawAttribution ?? false;\n  }\n\n  protected override init() {\n    return [];\n  }\n\n  /**\n   * Enables the instrumentation and registers web-vitals listeners.\n   * Listeners are registered only once. If disabled, subsequent calls resume emission.\n   */\n  override enable(): void {\n    if (typeof PerformanceObserver === 'undefined') {\n      this._diag.debug(\n        'PerformanceObserver not supported, web vitals will not be collected',\n      );\n      return;\n    }\n\n    this._isEnabled = true;\n\n    if (this._listenersRegistered) {\n      this._diag.debug('Listeners already registered, resuming emission');\n      return;\n    }\n\n    this._listenersRegistered = true;\n    this._diag.debug(`Registering listeners`);\n    // CLS is only supported in Chromium. See:\n    // https://github.com/GoogleChrome/web-vitals?tab=readme-ov-file#browser-support\n    onCLS((metric) => this._emitWebVital(metric));\n    onINP((metric) => this._emitWebVital(metric));\n    onLCP((metric) => this._emitWebVital(metric));\n    onFCP((metric) => this._emitWebVital(metric));\n    onTTFB((metric) => this._emitWebVital(metric));\n  }\n\n  /**\n   * Disables the instrumentation, pausing log emission.\n   * Listeners remain active due to web-vitals library limitations.\n   */\n  override disable(): void {\n    this._isEnabled = false;\n    this._diag.debug('Instrumentation disabled, pausing emission');\n  }\n\n  /**\n   * Gets the timestamp for a metric based on attribution timing.\n   * Returns undefined to let OTel use the current time for metrics without\n   * specific timing information.\n   */\n  private _getTimestampForMetric(\n    metric: MetricWithAttribution,\n  ): number | undefined {\n    if (metric.name === 'CLS') {\n      const { attribution } = metric as CLSMetricWithAttribution;\n      if (attribution.largestShiftTime !== undefined) {\n        return attribution.largestShiftTime;\n      }\n      return undefined;\n    }\n    if (metric.name === 'INP') {\n      const { attribution } = metric as INPMetricWithAttribution;\n      return attribution.interactionTime;\n    }\n    // FCP, LCP, TTFB: metric.value is already DOMHighResTimeStamp of the event\n    return metric.value;\n  }\n\n  private _emitWebVital(metric: MetricWithAttribution): void {\n    if (!this._isEnabled) {\n      return;\n    }\n    const attributes: Attributes = {\n      [ATTR_WEB_VITAL_NAME]: metric.name.toLowerCase(),\n      [ATTR_WEB_VITAL_VALUE]: metric.value,\n      // `delta` equals `value` on the first emission; subsequent emissions report only the change\n      [ATTR_WEB_VITAL_DELTA]: metric.delta,\n      [ATTR_WEB_VITAL_RATING]: metric.rating,\n      [ATTR_WEB_VITAL_ID]: metric.id,\n      [ATTR_WEB_VITAL_NAVIGATION_TYPE]: metric.navigationType,\n    };\n\n    const timestamp = this._getTimestampForMetric(metric);\n\n    const logRecord: LogRecord = {\n      eventName: WEB_VITAL_EVENT_NAME,\n      severityNumber: SeverityNumber.INFO,\n      attributes,\n      ...(this._includeRawAttribution\n        ? { body: JSON.stringify(metric.attribution) }\n        : {}),\n      ...(timestamp !== undefined ? { timestamp } : {}),\n    };\n\n    if (this._applyCustomLogRecordData) {\n      safeExecuteInTheMiddle(\n        () => this._applyCustomLogRecordData?.(logRecord),\n        (error) => {\n          if (error) {\n            this._diag.error('applyCustomLogRecordData hook failed', error);\n          }\n        },\n        true,\n      );\n    }\n\n    this.logger.emit(logRecord);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAsCA,IAAa,2BAAb,cAA8C,oBAAoD;CAMhG;CACA;CAEA,YAAY,SAAyC,CAAC,GAAG;EACvD,MAAM,qDAAqD,SAAS,MAAM;EAC1E,KAAK,4BAA4B,OAAO;EACxC,KAAK,yBAAyB,OAAO,yBAAyB;CAChE;CAEA,OAA0B;EACxB,OAAO,CAAC;CACV;;;;;CAMA,SAAwB;EACtB,IAAI,OAAO,wBAAwB,aAAa;GAC9C,KAAK,MAAM,MACT,qEACF;GACA;EACF;EAEA,KAAK,aAAa;EAElB,IAAI,KAAK,sBAAsB;GAC7B,KAAK,MAAM,MAAM,iDAAiD;GAClE;EACF;EAEA,KAAK,uBAAuB;EAC5B,KAAK,MAAM,MAAM,uBAAuB;EAGxC,OAAO,WAAW,KAAK,cAAc,MAAM,CAAC;EAC5C,OAAO,WAAW,KAAK,cAAc,MAAM,CAAC;EAC5C,OAAO,WAAW,KAAK,cAAc,MAAM,CAAC;EAC5C,OAAO,WAAW,KAAK,cAAc,MAAM,CAAC;EAC5C,QAAQ,WAAW,KAAK,cAAc,MAAM,CAAC;CAC/C;;;;;CAMA,UAAyB;EACvB,KAAK,aAAa;EAClB,KAAK,MAAM,MAAM,4CAA4C;CAC/D;;;;;;CAOA,uBACE,QACoB;EACpB,IAAI,OAAO,SAAS,OAAO;GACzB,MAAM,EAAE,gBAAgB;GACxB,IAAI,YAAY,qBAAqB,KAAA,GACnC,OAAO,YAAY;GAErB;EACF;EACA,IAAI,OAAO,SAAS,OAAO;GACzB,MAAM,EAAE,gBAAgB;GACxB,OAAO,YAAY;EACrB;EAEA,OAAO,OAAO;CAChB;CAEA,cAAsB,QAAqC;EACzD,IAAI,CAAC,KAAK,YACR;EAEF,MAAM,aAAyB;IAC5B,sBAAsB,OAAO,KAAK,YAAY;IAC9C,uBAAuB,OAAO;IAE9B,uBAAuB,OAAO;IAC9B,wBAAwB,OAAO;IAC/B,oBAAoB,OAAO;IAC3B,iCAAiC,OAAO;EAC3C;EAEA,MAAM,YAAY,KAAK,uBAAuB,MAAM;EAEpD,MAAM,YAAuB;GAC3B,WAAW;GACX,gBAAgB,eAAe;GAC/B;GACA,GAAI,KAAK,yBACL,EAAE,MAAM,KAAK,UAAU,OAAO,WAAW,EAAE,IAC3C,CAAC;GACL,GAAI,cAAc,KAAA,IAAY,EAAE,UAAU,IAAI,CAAC;EACjD;EAEA,IAAI,KAAK,2BACP,6BACQ,KAAK,4BAA4B,SAAS,IAC/C,UAAU;GACT,IAAI,OACF,KAAK,MAAM,MAAM,wCAAwC,KAAK;EAElE,GACA,IACF;EAGF,KAAK,OAAO,KAAK,SAAS;CAC5B;AACF"}
+{"version":3,"file":"instrumentation.js","names":[],"sources":["../../src/web-vitals/instrumentation.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type { Attributes } from '@opentelemetry/api';\nimport type { LogRecord } from '@opentelemetry/api-logs';\nimport { SeverityNumber } from '@opentelemetry/api-logs';\nimport {\n  InstrumentationBase,\n  safeExecuteInTheMiddle,\n} from '@opentelemetry/instrumentation';\nimport type {\n  CLSMetricWithAttribution,\n  INPMetricWithAttribution,\n  MetricWithAttribution,\n} from 'web-vitals/attribution';\nimport { onCLS, onFCP, onINP, onLCP, onTTFB } from 'web-vitals/attribution';\nimport { version } from '../../package.json' with { type: 'json' };\nimport {\n  ATTR_WEB_VITAL_DELTA,\n  ATTR_WEB_VITAL_ID,\n  ATTR_WEB_VITAL_NAME,\n  ATTR_WEB_VITAL_NAVIGATION_TYPE,\n  ATTR_WEB_VITAL_RATING,\n  ATTR_WEB_VITAL_VALUE,\n  WEB_VITAL_EVENT_NAME,\n} from './semconv.ts';\nimport type { WebVitalsInstrumentationConfig } from './types.ts';\n\n/**\n * Instrumentation for Core Web Vitals using the `web-vitals` library.\n * https://github.com/GoogleChrome/web-vitals\n *\n * Note: The `web-vitals` library does not support removing listeners once\n * registered. Calling `disable()` will stop emitting logs, but the underlying\n * listeners remain active. Calling `enable()` again will resume emission.\n */\nexport class WebVitalsInstrumentation extends InstrumentationBase<WebVitalsInstrumentationConfig> {\n  // Using `declare` is required here: InstrumentationBase calls enable() during\n  // construction, and standard field initialization would reset this flag after\n  // super() returns, breaking the duplicate-registration guard.\n  declare private _isEnabled: boolean;\n  declare private _listenersRegistered: boolean;\n  private _applyCustomLogRecordData?: (logRecord: LogRecord) => void;\n  private _includeRawAttribution: boolean;\n\n  constructor(config: WebVitalsInstrumentationConfig = {}) {\n    super('@opentelemetry/browser-instrumentation/web-vitals', version, config);\n    this._applyCustomLogRecordData = config.applyCustomLogRecordData;\n    this._includeRawAttribution = config.includeRawAttribution ?? false;\n  }\n\n  protected override init() {\n    return [];\n  }\n\n  /**\n   * Enables the instrumentation and registers web-vitals listeners.\n   * Listeners are registered only once. If disabled, subsequent calls resume emission.\n   */\n  override enable(): void {\n    if (typeof PerformanceObserver === 'undefined') {\n      this._diag.debug(\n        'PerformanceObserver not supported, web vitals will not be collected',\n      );\n      return;\n    }\n\n    this._isEnabled = true;\n\n    if (this._listenersRegistered) {\n      this._diag.debug('Listeners already registered, resuming emission');\n      return;\n    }\n\n    this._listenersRegistered = true;\n    this._diag.debug(`Registering listeners`);\n    // CLS is only supported in Chromium. See:\n    // https://github.com/GoogleChrome/web-vitals?tab=readme-ov-file#browser-support\n    onCLS((metric) => this._emitWebVital(metric));\n    onINP((metric) => this._emitWebVital(metric));\n    onLCP((metric) => this._emitWebVital(metric));\n    onFCP((metric) => this._emitWebVital(metric));\n    onTTFB((metric) => this._emitWebVital(metric));\n  }\n\n  /**\n   * Disables the instrumentation, pausing log emission.\n   * Listeners remain active due to web-vitals library limitations.\n   */\n  override disable(): void {\n    this._isEnabled = false;\n    this._diag.debug('Instrumentation disabled, pausing emission');\n  }\n\n  /**\n   * Gets the timestamp for a metric based on attribution timing.\n   * Returns undefined to let OTel use the current time for metrics without\n   * specific timing information.\n   */\n  private _getTimestampForMetric(\n    metric: MetricWithAttribution,\n  ): number | undefined {\n    if (metric.name === 'CLS') {\n      const { attribution } = metric as CLSMetricWithAttribution;\n      if (attribution.largestShiftTime !== undefined) {\n        return attribution.largestShiftTime;\n      }\n      return undefined;\n    }\n    if (metric.name === 'INP') {\n      const { attribution } = metric as INPMetricWithAttribution;\n      return attribution.interactionTime;\n    }\n    // FCP, LCP, TTFB: metric.value is already DOMHighResTimeStamp of the event\n    return metric.value;\n  }\n\n  private _emitWebVital(metric: MetricWithAttribution): void {\n    if (!this._isEnabled) {\n      return;\n    }\n    const attributes: Attributes = {\n      [ATTR_WEB_VITAL_NAME]: metric.name.toLowerCase(),\n      [ATTR_WEB_VITAL_VALUE]: metric.value,\n      // `delta` equals `value` on the first emission; subsequent emissions report only the change\n      [ATTR_WEB_VITAL_DELTA]: metric.delta,\n      [ATTR_WEB_VITAL_RATING]: metric.rating,\n      [ATTR_WEB_VITAL_ID]: metric.id,\n      [ATTR_WEB_VITAL_NAVIGATION_TYPE]: metric.navigationType,\n    };\n\n    const timestamp = this._getTimestampForMetric(metric);\n\n    const logRecord: LogRecord = {\n      eventName: WEB_VITAL_EVENT_NAME,\n      severityNumber: SeverityNumber.INFO,\n      attributes,\n      ...(this._includeRawAttribution\n        ? { body: JSON.stringify(metric.attribution) }\n        : {}),\n      ...(timestamp !== undefined ? { timestamp } : {}),\n    };\n\n    if (this._applyCustomLogRecordData) {\n      safeExecuteInTheMiddle(\n        () => this._applyCustomLogRecordData?.(logRecord),\n        (error) => {\n          if (error) {\n            this._diag.error('applyCustomLogRecordData hook failed', error);\n          }\n        },\n        true,\n      );\n    }\n\n    this.logger.emit(logRecord);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAsCA,IAAa,2BAAb,cAA8C,oBAAoD;CAMhG;CACA;CAEA,YAAY,SAAyC,CAAC,GAAG;EACvD,MAAM,qDAAqD,SAAS,MAAM;EAC1E,KAAK,4BAA4B,OAAO;EACxC,KAAK,yBAAyB,OAAO,yBAAyB;CAChE;CAEA,OAA0B;EACxB,OAAO,CAAC;CACV;;;;;CAMA,SAAwB;EACtB,IAAI,OAAO,wBAAwB,aAAa;GAC9C,KAAK,MAAM,MACT,qEACF;GACA;EACF;EAEA,KAAK,aAAa;EAElB,IAAI,KAAK,sBAAsB;GAC7B,KAAK,MAAM,MAAM,iDAAiD;GAClE;EACF;EAEA,KAAK,uBAAuB;EAC5B,KAAK,MAAM,MAAM,uBAAuB;EAGxC,OAAO,WAAW,KAAK,cAAc,MAAM,CAAC;EAC5C,OAAO,WAAW,KAAK,cAAc,MAAM,CAAC;EAC5C,OAAO,WAAW,KAAK,cAAc,MAAM,CAAC;EAC5C,OAAO,WAAW,KAAK,cAAc,MAAM,CAAC;EAC5C,QAAQ,WAAW,KAAK,cAAc,MAAM,CAAC;CAC/C;;;;;CAMA,UAAyB;EACvB,KAAK,aAAa;EAClB,KAAK,MAAM,MAAM,4CAA4C;CAC/D;;;;;;CAOA,uBACE,QACoB;EACpB,IAAI,OAAO,SAAS,OAAO;GACzB,MAAM,EAAE,gBAAgB;GACxB,IAAI,YAAY,qBAAqB,KAAA,GACnC,OAAO,YAAY;GAErB;EACF;EACA,IAAI,OAAO,SAAS,OAAO;GACzB,MAAM,EAAE,gBAAgB;GACxB,OAAO,YAAY;EACrB;EAEA,OAAO,OAAO;CAChB;CAEA,cAAsB,QAAqC;EACzD,IAAI,CAAC,KAAK,YACR;EAEF,MAAM,aAAyB;IAC5B,sBAAsB,OAAO,KAAK,YAAY;IAC9C,uBAAuB,OAAO;IAE9B,uBAAuB,OAAO;IAC9B,wBAAwB,OAAO;IAC/B,oBAAoB,OAAO;IAC3B,iCAAiC,OAAO;EAC3C;EAEA,MAAM,YAAY,KAAK,uBAAuB,MAAM;EAEpD,MAAM,YAAuB;GAC3B,WAAW;GACX,gBAAgB,eAAe;GAC/B;GACA,GAAI,KAAK,yBACL,EAAE,MAAM,KAAK,UAAU,OAAO,WAAW,EAAE,IAC3C,CAAC;GACL,GAAI,cAAc,KAAA,IAAY,EAAE,UAAU,IAAI,CAAC;EACjD;EAEA,IAAI,KAAK,2BACP,6BACQ,KAAK,4BAA4B,SAAS,IAC/C,UAAU;GACT,IAAI,OACF,KAAK,MAAM,MAAM,wCAAwC,KAAK;EAElE,GACA,IACF;EAGF,KAAK,OAAO,KAAK,SAAS;CAC5B;AACF"}

package/dist/web-vitals/types.d.ts

@@ -4,7 +4,7 @@ import { InstrumentationConfig } from "@opentelemetry/instrumentation";
 /**
  * WebVitalsInstrumentation Configuration
  */
-interface WebVitalsInstrumentationConfig extends InstrumentationConfig {
+export interface WebVitalsInstrumentationConfig extends InstrumentationConfig {
   /**
    * @experimental
    * When true, sets the log record body to the JSON-stringified
@@ -21,5 +21,4 @@ interface WebVitalsInstrumentationConfig extends InstrumentationConfig {
   applyCustomLogRecordData?: (logRecord: LogRecord) => void;
 }
 //#endregion
-export { WebVitalsInstrumentationConfig };
 //# sourceMappingURL=types.d.ts.map

package/dist/xhr/index.d.ts

@@ -0,0 +1,3 @@
+import { XhrInstrumentationConfig } from "./types.js";
+import { XhrInstrumentation } from "./instrumentation.js";
+export { XhrInstrumentation, type XhrInstrumentationConfig };

package/dist/xhr/index.js

@@ -0,0 +1,2 @@
+import { XhrInstrumentation } from "./instrumentation.js";
+export { XhrInstrumentation };

package/dist/xhr/instrumentation.d.ts

@@ -0,0 +1,38 @@
+import { XhrInstrumentationConfig } from "./types.js";
+import { InstrumentationBase } from "@opentelemetry/instrumentation";
+//#region src/xhr/instrumentation.d.ts
+export declare class XhrInstrumentation extends InstrumentationBase<XhrInstrumentationConfig> {
+  private _isEnabled;
+  private _isXhrPatched;
+  private _xhrSpanMap;
+  constructor(config?: XhrInstrumentationConfig);
+  protected init(): never[];
+  enable(): void;
+  disable(): void;
+  /**
+   * Patches the "open" method of XmlHttpRequest
+   */
+  private _patchOpen;
+  /**
+   * Patches the "open" method of XmlHttpRequest
+   */
+  private _patchSend;
+  /**
+   * Creates a new span when method "send" is called
+   */
+  private _createSpan;
+  /**
+   * Finish span, add attributes, network events etc.
+   */
+  private _endSpan;
+  /**
+   * Runs the user provided `applyCustomAttributesOnSpan` function
+   */
+  private _applyAttributesAfterSend;
+  /**
+   * Adds custom headers to XMLHttpRequest
+   */
+  private _addHeaders;
+}
+//#endregion
+//# sourceMappingURL=instrumentation.d.ts.map

package/dist/xhr/instrumentation.js

@@ -0,0 +1,187 @@
+import { version } from "../package.js";
+import { getNetworkContextRegistry } from "../utils/NetworkContextRegistry.js";
+import { getXHRBodyLength, normalizeHttpRequestMethod } from "../utils/request.js";
+import { matchesUrl, parseUrl, serverPortFromUrl } from "../utils/url.js";
+import { ATTR_HTTP_REQUEST_BODY_SIZE } from "./semconv.js";
+import { SpanKind, SpanStatusCode, context, propagation, trace } from "@opentelemetry/api";
+import { InstrumentationBase, safeExecuteInTheMiddle } from "@opentelemetry/instrumentation";
+import { ATTR_ERROR_TYPE, ATTR_HTTP_REQUEST_METHOD, ATTR_HTTP_REQUEST_METHOD_ORIGINAL, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_SERVER_ADDRESS, ATTR_SERVER_PORT, ATTR_URL_FULL } from "@opentelemetry/semantic-conventions";
+//#region src/xhr/instrumentation.ts
+var XhrInstrumentation = class extends InstrumentationBase {
+	_xhrSpanMap = /* @__PURE__ */ new WeakMap();
+	constructor(config = {}) {
+		super("@opentelemetry/browser-instrumentation/xhr", version, config);
+	}
+	init() {
+		return [];
+	}
+	enable() {
+		if (this._isEnabled) return;
+		if (this._isXhrPatched) {
+			this._diag.debug("XMLHttpRequest prototype already patched");
+			this._isEnabled = true;
+			return;
+		}
+		try {
+			this._wrap(XMLHttpRequest.prototype, "open", this._patchOpen());
+		} catch (err) {
+			this._diag.warn("Failed to patch XMLHttpRequest.prototype.open; instrumentation will not be enabled. Another script may have locked XMLHttpRequest.prototype.open via Object.defineProperty.", err);
+			return;
+		}
+		try {
+			this._wrap(XMLHttpRequest.prototype, "send", this._patchSend());
+			this._isXhrPatched = true;
+			this._isEnabled = true;
+		} catch (err) {
+			this._unwrap(XMLHttpRequest.prototype, "open");
+			this._diag.warn("Failed to patch XMLHttpRequest.prototype.send; instrumentation will not be enabled. Another script may have locked XMLHttpRequest.prototype.send via Object.defineProperty.", err);
+		}
+	}
+	disable() {
+		if (!this._isEnabled) return;
+		this._isEnabled = false;
+	}
+	/**
+	* Patches the "open" method of XmlHttpRequest
+	*/
+	_patchOpen() {
+		return (original) => {
+			const instrumentation = this;
+			return function patchedOpen(...args) {
+				if (!instrumentation._isEnabled) return original.apply(this, args);
+				try {
+					const method = args[0];
+					const urlArgument = typeof args[1] === "string" ? args[1] : args[1].toString();
+					const url = parseUrl(urlArgument);
+					if (matchesUrl(url.href, instrumentation.getConfig().ignoreUrls)) return original.apply(this, args);
+					instrumentation._xhrSpanMap.set(this, {
+						method,
+						url
+					});
+				} catch (e) {
+					instrumentation._diag.error("Failed to instrument XmlHttpRequest.open", e);
+				}
+				return original.apply(this, args);
+			};
+		};
+	}
+	/**
+	* Patches the "open" method of XmlHttpRequest
+	*/
+	_patchSend() {
+		return (original) => {
+			const instrumentation = this;
+			return function patchedSend(...args) {
+				if (!instrumentation._isEnabled) return original.apply(this, args);
+				const xhrRecord = instrumentation._xhrSpanMap.get(this);
+				if (xhrRecord) try {
+					const { method, url } = xhrRecord;
+					const span = instrumentation._createSpan(url, method);
+					xhrRecord.span = span;
+					xhrRecord.start = performance.now();
+					if (instrumentation.getConfig().measureRequestSize && args?.[0]) {
+						const bodyLength = getXHRBodyLength(args[0]);
+						if (bodyLength) span.setAttribute(ATTR_HTTP_REQUEST_BODY_SIZE, bodyLength);
+					}
+					const onAbort = () => instrumentation._endSpan(this, "abort");
+					const onError = () => instrumentation._endSpan(this, "error");
+					const onTimeout = () => instrumentation._endSpan(this, "timeout");
+					const onLoad = () => instrumentation._endSpan(this, "load");
+					xhrRecord.listeners = {
+						abort: onAbort,
+						error: onError,
+						timeout: onTimeout,
+						load: onLoad
+					};
+					const xhrContext = trace.setSpan(context.active(), span);
+					context.with(xhrContext, () => {
+						this.addEventListener("abort", onAbort);
+						this.addEventListener("error", onError);
+						this.addEventListener("timeout", onTimeout);
+						this.addEventListener("load", onLoad);
+						instrumentation._addHeaders(this, url, xhrContext);
+					});
+				} catch (e) {
+					instrumentation._diag.error("Failed to instrument fetch request", e);
+					instrumentation._xhrSpanMap.delete(this);
+				}
+				return original.apply(this, args);
+			};
+		};
+	}
+	/**
+	* Creates a new span when method "send" is called
+	*/
+	_createSpan(url, method) {
+		const origMethod = method;
+		const normMethod = normalizeHttpRequestMethod(method);
+		const attributes = {};
+		const { sanitizeUrl } = this.getConfig();
+		attributes[ATTR_HTTP_REQUEST_METHOD] = normMethod;
+		if (normMethod !== origMethod) attributes[ATTR_HTTP_REQUEST_METHOD_ORIGINAL] = origMethod;
+		attributes[ATTR_URL_FULL] = sanitizeUrl ? sanitizeUrl(url.href) : url.href;
+		attributes[ATTR_SERVER_ADDRESS] = url.hostname;
+		const serverPort = serverPortFromUrl(url);
+		if (serverPort) attributes[ATTR_SERVER_PORT] = serverPort;
+		return this.tracer.startSpan(normMethod, {
+			kind: SpanKind.CLIENT,
+			attributes
+		});
+	}
+	/**
+	* Finish span, add attributes, network events etc.
+	*/
+	_endSpan(xhr, eventName) {
+		const xhrRecord = this._xhrSpanMap.get(xhr);
+		if (xhrRecord?.listeners) for (const k of Object.keys(xhrRecord.listeners)) xhr.removeEventListener(k, xhrRecord.listeners[k]);
+		if (xhrRecord?.span) {
+			const { span, url, start } = xhrRecord;
+			if (eventName === "load") span.setAttribute(ATTR_HTTP_RESPONSE_STATUS_CODE, xhr.status);
+			if (eventName !== "abort") {
+				if (xhr.status >= 400 || eventName === "error" || eventName === "timeout") {
+					span.setStatus({ code: SpanStatusCode.ERROR });
+					const errorType = xhr.status >= 400 ? String(xhr.status) : eventName === "error" ? "Error" : "TimeoutError";
+					span.setAttribute(ATTR_ERROR_TYPE, errorType);
+				}
+			}
+			this._xhrSpanMap.delete(xhr);
+			this._applyAttributesAfterSend(span, xhr);
+			span.end();
+			getNetworkContextRegistry().register(span, {
+				key: url.href,
+				startPerfNow: Number(start),
+				endPerfNow: performance.now()
+			});
+		}
+	}
+	/**
+	* Runs the user provided `applyCustomAttributesOnSpan` function
+	*/
+	_applyAttributesAfterSend(span, xhr) {
+		const applyCustomAttributesOnSpan = this.getConfig().applyCustomAttributesOnSpan;
+		if (applyCustomAttributesOnSpan) safeExecuteInTheMiddle(() => applyCustomAttributesOnSpan(span, xhr), (error) => {
+			if (!error) return;
+			this._diag.error("applyCustomAttributesOnSpan", error);
+		}, true);
+	}
+	/**
+	* Adds custom headers to XMLHttpRequest
+	*/
+	_addHeaders(xhr, url, ctx) {
+		const urlsToPropagate = this.getConfig().propagateTraceHeaderCorsUrls;
+		if (location.origin === url.origin || matchesUrl(url.href, urlsToPropagate)) propagation.inject(ctx, xhr, { set: (x, k, v) => {
+			x.setRequestHeader(k, typeof v === "string" ? v : String(v));
+		} });
+		else {
+			const headers = {};
+			propagation.inject(ctx, headers, { set: (h, k, v) => {
+				h[k] = v;
+			} });
+			if (Object.keys(headers).length > 0) this._diag.debug("headers inject skipped due to CORS policy");
+		}
+	}
+};
+//#endregion
+export { XhrInstrumentation };
+
+//# sourceMappingURL=instrumentation.js.map

package/dist/xhr/instrumentation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.js","names":[],"sources":["../../src/xhr/instrumentation.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type { Attributes, Context, Span } from '@opentelemetry/api';\nimport {\n  context,\n  propagation,\n  SpanKind,\n  SpanStatusCode,\n  trace,\n} from '@opentelemetry/api';\nimport {\n  InstrumentationBase,\n  safeExecuteInTheMiddle,\n} from '@opentelemetry/instrumentation';\nimport {\n  ATTR_ERROR_TYPE,\n  ATTR_HTTP_REQUEST_METHOD,\n  ATTR_HTTP_REQUEST_METHOD_ORIGINAL,\n  ATTR_HTTP_RESPONSE_STATUS_CODE,\n  ATTR_SERVER_ADDRESS,\n  ATTR_SERVER_PORT,\n  ATTR_URL_FULL,\n} from '@opentelemetry/semantic-conventions';\nimport { version } from '../../package.json' with { type: 'json' };\nimport { getNetworkContextRegistry } from '../utils/NetworkContextRegistry.ts';\nimport {\n  getXHRBodyLength,\n  normalizeHttpRequestMethod,\n} from '../utils/request.ts';\nimport { matchesUrl, parseUrl, serverPortFromUrl } from '../utils/url.ts';\nimport { ATTR_HTTP_REQUEST_BODY_SIZE } from './semconv.ts';\nimport type { XhrInstrumentationConfig } from './types.ts';\n\ntype XhrOpenFunction = typeof XMLHttpRequest.prototype.open;\ntype XhrSendFunction = typeof XMLHttpRequest.prototype.send;\ntype XhrEventName = 'abort' | 'timeout' | 'error' | 'load';\ntype XhrRecord = {\n  method: string;\n  url: URL;\n  start?: number;\n  span?: Span;\n  listeners?: Record<XhrEventName, (...args: unknown[]) => unknown>;\n};\n\nexport class XhrInstrumentation extends InstrumentationBase<XhrInstrumentationConfig> {\n  // Note: Intentionally *not* using `_enabled` as the field name to avoid\n  // any possible confusion with the `_enabled` field used on the *Node.js*\n  // InstrumentationBase class.\n  // Also not initializing the fields to `false` because the base class\n  // constructor already call `enable` modifying their values and it will\n  // set the instrumentaitons in a base state (enabled, patched but with flags set to false)\n  declare private _isEnabled: boolean;\n  declare private _isXhrPatched: boolean;\n\n  // To keep references to span/xhr tuples across XHR events and stores\n  // init data like URL and method\n  private _xhrSpanMap: WeakMap<XMLHttpRequest, XhrRecord> = new WeakMap();\n\n  constructor(config: XhrInstrumentationConfig = {}) {\n    super('@opentelemetry/browser-instrumentation/xhr', version, config);\n  }\n\n  protected override init() {\n    return [];\n  }\n\n  override enable(): void {\n    if (this._isEnabled) {\n      return;\n    }\n\n    if (this._isXhrPatched) {\n      this._diag.debug('XMLHttpRequest prototype already patched');\n      this._isEnabled = true;\n      return;\n    }\n\n    // `_wrap` throws if a third-party script has locked the target methods via\n    // Object.defineProperty(XMLHttpRequest.prototype, 'open', { writable: false, ... }).\n    try {\n      this._wrap(XMLHttpRequest.prototype, 'open', this._patchOpen());\n    } catch (err) {\n      this._diag.warn(\n        'Failed to patch XMLHttpRequest.prototype.open; instrumentation will not be enabled. ' +\n          'Another script may have locked XMLHttpRequest.prototype.open via Object.defineProperty.',\n        err,\n      );\n      return;\n    }\n\n    // If 1st patch has succeded try the second. Unpatch `open` if error\n    // here to avoid having multiple patches of `open`\n    try {\n      this._wrap(XMLHttpRequest.prototype, 'send', this._patchSend());\n      this._isXhrPatched = true;\n      this._isEnabled = true;\n    } catch (err) {\n      this._unwrap(XMLHttpRequest.prototype, 'open');\n      this._diag.warn(\n        'Failed to patch XMLHttpRequest.prototype.send; instrumentation will not be enabled. ' +\n          'Another script may have locked XMLHttpRequest.prototype.send via Object.defineProperty.',\n        err,\n      );\n    }\n  }\n\n  override disable(): void {\n    if (!this._isEnabled) {\n      return;\n    }\n    this._isEnabled = false;\n  }\n\n  /**\n   * Patches the \"open\" method of XmlHttpRequest\n   */\n  private _patchOpen(): (original: XhrOpenFunction) => XhrOpenFunction {\n    return (original) => {\n      const instrumentation = this;\n\n      return function patchedOpen(\n        this: XMLHttpRequest,\n        ...args: Parameters<XhrOpenFunction>\n      ): ReturnType<XhrOpenFunction> {\n        if (!instrumentation._isEnabled) {\n          return original.apply(this, args);\n        }\n        try {\n          const method = args[0];\n          const urlArgument =\n            typeof args[1] === 'string' ? args[1] : args[1].toString();\n          const url = parseUrl(urlArgument);\n          const shouldIgnoreUrl = matchesUrl(\n            url.href,\n            instrumentation.getConfig().ignoreUrls,\n          );\n          if (shouldIgnoreUrl) {\n            return original.apply(this, args);\n          }\n          instrumentation._xhrSpanMap.set(this, { method, url });\n        } catch (e: unknown) {\n          instrumentation._diag.error(\n            'Failed to instrument XmlHttpRequest.open',\n            e,\n          );\n        }\n        return original.apply(this, args);\n      } as XhrOpenFunction;\n    };\n  }\n\n  /**\n   * Patches the \"open\" method of XmlHttpRequest\n   */\n  private _patchSend(): (original: XhrSendFunction) => XhrSendFunction {\n    return (original) => {\n      const instrumentation = this;\n\n      return function patchedSend(\n        this: XMLHttpRequest,\n        ...args: Parameters<XhrSendFunction>\n      ): ReturnType<XhrSendFunction> {\n        if (!instrumentation._isEnabled) {\n          return original.apply(this, args);\n        }\n\n        // Instrument the method if the XHR was previously picked in `open`\n        const xhrRecord = instrumentation._xhrSpanMap.get(this);\n        if (xhrRecord) {\n          try {\n            const { method, url } = xhrRecord;\n            const span = instrumentation._createSpan(url, method);\n            xhrRecord.span = span;\n            xhrRecord.start = performance.now();\n\n            if (instrumentation.getConfig().measureRequestSize && args?.[0]) {\n              const bodyLength = getXHRBodyLength(args[0]);\n              if (bodyLength) {\n                span.setAttribute(ATTR_HTTP_REQUEST_BODY_SIZE, bodyLength);\n              }\n            }\n\n            const onAbort = () => instrumentation._endSpan(this, 'abort');\n            const onError = () => instrumentation._endSpan(this, 'error');\n            const onTimeout = () => instrumentation._endSpan(this, 'timeout');\n            const onLoad = () => instrumentation._endSpan(this, 'load');\n            xhrRecord.listeners = {\n              abort: onAbort,\n              error: onError,\n              timeout: onTimeout,\n              load: onLoad,\n            };\n\n            const xhrContext = trace.setSpan(context.active(), span);\n            context.with(xhrContext, () => {\n              this.addEventListener('abort', onAbort);\n              this.addEventListener('error', onError);\n              this.addEventListener('timeout', onTimeout);\n              this.addEventListener('load', onLoad);\n              instrumentation._addHeaders(this, url, xhrContext);\n            });\n          } catch (e: unknown) {\n            // failed to instrument request, remove span\n            instrumentation._diag.error(\n              'Failed to instrument fetch request',\n              e,\n            );\n            instrumentation._xhrSpanMap.delete(this);\n          }\n        }\n        return original.apply(this, args);\n      } as XhrSendFunction;\n    };\n  }\n\n  /**\n   * Creates a new span when method \"send\" is called\n   */\n  private _createSpan(url: URL, method: string): Span {\n    const origMethod = method;\n    const normMethod = normalizeHttpRequestMethod(method);\n    const attributes = {} as Attributes;\n    const { sanitizeUrl } = this.getConfig();\n\n    attributes[ATTR_HTTP_REQUEST_METHOD] = normMethod;\n    if (normMethod !== origMethod) {\n      attributes[ATTR_HTTP_REQUEST_METHOD_ORIGINAL] = origMethod;\n    }\n    attributes[ATTR_URL_FULL] = sanitizeUrl ? sanitizeUrl(url.href) : url.href;\n    attributes[ATTR_SERVER_ADDRESS] = url.hostname;\n    const serverPort = serverPortFromUrl(url);\n    if (serverPort) {\n      attributes[ATTR_SERVER_PORT] = serverPort;\n    }\n\n    return this.tracer.startSpan(normMethod, {\n      kind: SpanKind.CLIENT,\n      attributes,\n    });\n  }\n\n  /**\n   * Finish span, add attributes, network events etc.\n   */\n  private _endSpan(xhr: XMLHttpRequest, eventName: XhrEventName) {\n    const xhrRecord = this._xhrSpanMap.get(xhr);\n\n    if (xhrRecord?.listeners) {\n      for (const k of Object.keys(xhrRecord.listeners)) {\n        xhr.removeEventListener(\n          k as XhrEventName,\n          xhrRecord.listeners[k as XhrEventName],\n        );\n      }\n    }\n\n    if (xhrRecord?.span) {\n      const { span, url, start } = xhrRecord;\n\n      // Status code only has a meaningful value if request got a response\n      if (eventName === 'load') {\n        span.setAttribute(ATTR_HTTP_RESPONSE_STATUS_CODE, xhr.status);\n      }\n\n      if (eventName !== 'abort') {\n        // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/http/http-spans.md#status\n        // 1xx/2xx/3xx MUST be left unset UNLESS there was another error (e.g. a\n        // network error receiving the response body)\n        const isErrorStatus =\n          xhr.status >= 400 || eventName === 'error' || eventName === 'timeout';\n\n        if (isErrorStatus) {\n          span.setStatus({ code: SpanStatusCode.ERROR });\n          const errorType =\n            xhr.status >= 400\n              ? String(xhr.status)\n              : eventName === 'error'\n                ? 'Error'\n                : 'TimeoutError';\n          span.setAttribute(ATTR_ERROR_TYPE, errorType);\n        }\n      }\n\n      this._xhrSpanMap.delete(xhr);\n      this._applyAttributesAfterSend(span, xhr);\n      span.end();\n\n      getNetworkContextRegistry().register(span, {\n        key: url.href,\n        startPerfNow: Number(start),\n        endPerfNow: performance.now(),\n      });\n    }\n  }\n\n  /**\n   * Runs the user provided `applyCustomAttributesOnSpan` function\n   */\n  private _applyAttributesAfterSend(span: Span, xhr: XMLHttpRequest) {\n    const applyCustomAttributesOnSpan =\n      this.getConfig().applyCustomAttributesOnSpan;\n    if (applyCustomAttributesOnSpan) {\n      safeExecuteInTheMiddle(\n        () => applyCustomAttributesOnSpan(span, xhr),\n        (error) => {\n          if (!error) {\n            return;\n          }\n          this._diag.error('applyCustomAttributesOnSpan', error);\n        },\n        true,\n      );\n    }\n  }\n\n  /**\n   * Adds custom headers to XMLHttpRequest\n   */\n  private _addHeaders(xhr: XMLHttpRequest, url: URL, ctx: Context) {\n    // Propagate only if in request goes to same origin or is in the allow list\n    const urlsToPropagate = this.getConfig().propagateTraceHeaderCorsUrls;\n    const sameOrigin = location.origin === url.origin;\n    const shouldPropagate = sameOrigin || matchesUrl(url.href, urlsToPropagate);\n\n    if (shouldPropagate) {\n      propagation.inject(ctx, xhr, {\n        set: (x, k, v) => {\n          x.setRequestHeader(k, typeof v === 'string' ? v : String(v));\n        },\n      });\n    } else {\n      const headers: Partial<Record<string, unknown>> = {};\n      propagation.inject(ctx, headers, {\n        set: (h, k, v) => {\n          h[k] = v;\n        },\n      });\n      if (Object.keys(headers).length > 0) {\n        this._diag.debug('headers inject skipped due to CORS policy');\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;AA+CA,IAAa,qBAAb,cAAwC,oBAA8C;CAYpF,8BAA0D,IAAI,QAAQ;CAEtE,YAAY,SAAmC,CAAC,GAAG;EACjD,MAAM,8CAA8C,SAAS,MAAM;CACrE;CAEA,OAA0B;EACxB,OAAO,CAAC;CACV;CAEA,SAAwB;EACtB,IAAI,KAAK,YACP;EAGF,IAAI,KAAK,eAAe;GACtB,KAAK,MAAM,MAAM,0CAA0C;GAC3D,KAAK,aAAa;GAClB;EACF;EAIA,IAAI;GACF,KAAK,MAAM,eAAe,WAAW,QAAQ,KAAK,WAAW,CAAC;EAChE,SAAS,KAAK;GACZ,KAAK,MAAM,KACT,+KAEA,GACF;GACA;EACF;EAIA,IAAI;GACF,KAAK,MAAM,eAAe,WAAW,QAAQ,KAAK,WAAW,CAAC;GAC9D,KAAK,gBAAgB;GACrB,KAAK,aAAa;EACpB,SAAS,KAAK;GACZ,KAAK,QAAQ,eAAe,WAAW,MAAM;GAC7C,KAAK,MAAM,KACT,+KAEA,GACF;EACF;CACF;CAEA,UAAyB;EACvB,IAAI,CAAC,KAAK,YACR;EAEF,KAAK,aAAa;CACpB;;;;CAKA,aAAqE;EACnE,QAAQ,aAAa;GACnB,MAAM,kBAAkB;GAExB,OAAO,SAAS,YAEd,GAAG,MAC0B;IAC7B,IAAI,CAAC,gBAAgB,YACnB,OAAO,SAAS,MAAM,MAAM,IAAI;IAElC,IAAI;KACF,MAAM,SAAS,KAAK;KACpB,MAAM,cACJ,OAAO,KAAK,OAAO,WAAW,KAAK,KAAK,KAAK,EAAE,CAAC,SAAS;KAC3D,MAAM,MAAM,SAAS,WAAW;KAKhC,IAJwB,WACtB,IAAI,MACJ,gBAAgB,UAAU,CAAC,CAAC,UAEZ,GAChB,OAAO,SAAS,MAAM,MAAM,IAAI;KAElC,gBAAgB,YAAY,IAAI,MAAM;MAAE;MAAQ;KAAI,CAAC;IACvD,SAAS,GAAY;KACnB,gBAAgB,MAAM,MACpB,4CACA,CACF;IACF;IACA,OAAO,SAAS,MAAM,MAAM,IAAI;GAClC;EACF;CACF;;;;CAKA,aAAqE;EACnE,QAAQ,aAAa;GACnB,MAAM,kBAAkB;GAExB,OAAO,SAAS,YAEd,GAAG,MAC0B;IAC7B,IAAI,CAAC,gBAAgB,YACnB,OAAO,SAAS,MAAM,MAAM,IAAI;IAIlC,MAAM,YAAY,gBAAgB,YAAY,IAAI,IAAI;IACtD,IAAI,WACF,IAAI;KACF,MAAM,EAAE,QAAQ,QAAQ;KACxB,MAAM,OAAO,gBAAgB,YAAY,KAAK,MAAM;KACpD,UAAU,OAAO;KACjB,UAAU,QAAQ,YAAY,IAAI;KAElC,IAAI,gBAAgB,UAAU,CAAC,CAAC,sBAAsB,OAAO,IAAI;MAC/D,MAAM,aAAa,iBAAiB,KAAK,EAAE;MAC3C,IAAI,YACF,KAAK,aAAa,6BAA6B,UAAU;KAE7D;KAEA,MAAM,gBAAgB,gBAAgB,SAAS,MAAM,OAAO;KAC5D,MAAM,gBAAgB,gBAAgB,SAAS,MAAM,OAAO;KAC5D,MAAM,kBAAkB,gBAAgB,SAAS,MAAM,SAAS;KAChE,MAAM,eAAe,gBAAgB,SAAS,MAAM,MAAM;KAC1D,UAAU,YAAY;MACpB,OAAO;MACP,OAAO;MACP,SAAS;MACT,MAAM;KACR;KAEA,MAAM,aAAa,MAAM,QAAQ,QAAQ,OAAO,GAAG,IAAI;KACvD,QAAQ,KAAK,kBAAkB;MAC7B,KAAK,iBAAiB,SAAS,OAAO;MACtC,KAAK,iBAAiB,SAAS,OAAO;MACtC,KAAK,iBAAiB,WAAW,SAAS;MAC1C,KAAK,iBAAiB,QAAQ,MAAM;MACpC,gBAAgB,YAAY,MAAM,KAAK,UAAU;KACnD,CAAC;IACH,SAAS,GAAY;KAEnB,gBAAgB,MAAM,MACpB,sCACA,CACF;KACA,gBAAgB,YAAY,OAAO,IAAI;IACzC;IAEF,OAAO,SAAS,MAAM,MAAM,IAAI;GAClC;EACF;CACF;;;;CAKA,YAAoB,KAAU,QAAsB;EAClD,MAAM,aAAa;EACnB,MAAM,aAAa,2BAA2B,MAAM;EACpD,MAAM,aAAa,CAAC;EACpB,MAAM,EAAE,gBAAgB,KAAK,UAAU;EAEvC,WAAW,4BAA4B;EACvC,IAAI,eAAe,YACjB,WAAW,qCAAqC;EAElD,WAAW,iBAAiB,cAAc,YAAY,IAAI,IAAI,IAAI,IAAI;EACtE,WAAW,uBAAuB,IAAI;EACtC,MAAM,aAAa,kBAAkB,GAAG;EACxC,IAAI,YACF,WAAW,oBAAoB;EAGjC,OAAO,KAAK,OAAO,UAAU,YAAY;GACvC,MAAM,SAAS;GACf;EACF,CAAC;CACH;;;;CAKA,SAAiB,KAAqB,WAAyB;EAC7D,MAAM,YAAY,KAAK,YAAY,IAAI,GAAG;EAE1C,IAAI,WAAW,WACb,KAAK,MAAM,KAAK,OAAO,KAAK,UAAU,SAAS,GAC7C,IAAI,oBACF,GACA,UAAU,UAAU,EACtB;EAIJ,IAAI,WAAW,MAAM;GACnB,MAAM,EAAE,MAAM,KAAK,UAAU;GAG7B,IAAI,cAAc,QAChB,KAAK,aAAa,gCAAgC,IAAI,MAAM;GAG9D,IAAI,cAAc,SAKd;QAAA,IAAI,UAAU,OAAO,cAAc,WAAW,cAAc,WAE3C;KACjB,KAAK,UAAU,EAAE,MAAM,eAAe,MAAM,CAAC;KAC7C,MAAM,YACJ,IAAI,UAAU,MACV,OAAO,IAAI,MAAM,IACjB,cAAc,UACZ,UACA;KACR,KAAK,aAAa,iBAAiB,SAAS;IAC9C;;GAGF,KAAK,YAAY,OAAO,GAAG;GAC3B,KAAK,0BAA0B,MAAM,GAAG;GACxC,KAAK,IAAI;GAET,0BAA0B,CAAC,CAAC,SAAS,MAAM;IACzC,KAAK,IAAI;IACT,cAAc,OAAO,KAAK;IAC1B,YAAY,YAAY,IAAI;GAC9B,CAAC;EACH;CACF;;;;CAKA,0BAAkC,MAAY,KAAqB;EACjE,MAAM,8BACJ,KAAK,UAAU,CAAC,CAAC;EACnB,IAAI,6BACF,6BACQ,4BAA4B,MAAM,GAAG,IAC1C,UAAU;GACT,IAAI,CAAC,OACH;GAEF,KAAK,MAAM,MAAM,+BAA+B,KAAK;EACvD,GACA,IACF;CAEJ;;;;CAKA,YAAoB,KAAqB,KAAU,KAAc;EAE/D,MAAM,kBAAkB,KAAK,UAAU,CAAC,CAAC;EAIzC,IAHmB,SAAS,WAAW,IAAI,UACL,WAAW,IAAI,MAAM,eAAe,GAGxE,YAAY,OAAO,KAAK,KAAK,EAC3B,MAAM,GAAG,GAAG,MAAM;GAChB,EAAE,iBAAiB,GAAG,OAAO,MAAM,WAAW,IAAI,OAAO,CAAC,CAAC;EAC7D,EACF,CAAC;OACI;GACL,MAAM,UAA4C,CAAC;GACnD,YAAY,OAAO,KAAK,SAAS,EAC/B,MAAM,GAAG,GAAG,MAAM;IAChB,EAAE,KAAK;GACT,EACF,CAAC;GACD,IAAI,OAAO,KAAK,OAAO,CAAC,CAAC,SAAS,GAChC,KAAK,MAAM,MAAM,2CAA2C;EAEhE;CACF;AACF"}

package/dist/xhr/semconv.js

@@ -0,0 +1,13 @@
+//#region src/xhr/semconv.ts
+/**
+* The size of the request payload body in bytes. This is the number of bytes transferred excluding headers and is often, but not always, present as the [Content-Length](https://www.rfc-editor.org/rfc/rfc9110.html#field.content-length) header. For requests using transport encoding, this should be the compressed size.
+*
+* @example 3495
+*
+* @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+*/
+const ATTR_HTTP_REQUEST_BODY_SIZE = "http.request.body.size";
+//#endregion
+export { ATTR_HTTP_REQUEST_BODY_SIZE };
+
+//# sourceMappingURL=semconv.js.map

package/dist/xhr/semconv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"semconv.js","names":[],"sources":["../../src/xhr/semconv.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\n/*\n * This file contains a copy of unstable semantic convention definitions\n * used by this package.\n * @see https://github.com/open-telemetry/opentelemetry-js/tree/main/semantic-conventions#unstable-semconv\n */\n\n/**\n * The size of the request payload body in bytes. This is the number of bytes transferred excluding headers and is often, but not always, present as the [Content-Length](https://www.rfc-editor.org/rfc/rfc9110.html#field.content-length) header. For requests using transport encoding, this should be the compressed size.\n *\n * @example 3495\n *\n * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.\n */\nexport const ATTR_HTTP_REQUEST_BODY_SIZE = 'http.request.body.size' as const;\n"],"mappings":";;;;;;;;AAkBA,MAAa,8BAA8B"}

package/dist/xhr/types.d.ts

@@ -0,0 +1,22 @@
+import { Span } from "@opentelemetry/api";
+import { InstrumentationConfig } from "@opentelemetry/instrumentation";
+//#region src/xhr/types.d.ts
+type XhrCustomAttributeFunction = (span: Span, xhr: XMLHttpRequest) => void;
+export interface XhrInstrumentationConfig extends InstrumentationConfig {
+  /** URLs which should include trace headers when origin doesn't match */
+  propagateTraceHeaderCorsUrls?: Array<string | RegExp>;
+  /**
+   * URLs that partially match any regex in ignoreUrls will not be traced.
+   * In addition, URLs that are _exact matches_ of strings in ignoreUrls will
+   * also not be traced.
+   */
+  ignoreUrls?: Array<string | RegExp>;
+  /** Function for adding custom attributes on the span */
+  applyCustomAttributesOnSpan?: XhrCustomAttributeFunction;
+  /** Measure outgoing request size */
+  measureRequestSize?: boolean;
+  /** Custom function to sanitize URLs before adding to log records. */
+  sanitizeUrl?: (url: string) => string;
+}
+//#endregion
+//# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opentelemetry/browser-instrumentation",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "OpenTelemetry browser instrumentations.",
   "keywords": [
     "opentelemetry",
@@ -13,7 +13,9 @@
     "navigation-timing",
     "resource-timing",
     "user-action",
-    "web-vitals"
+    "web-vitals",
+    "fetch",
+    "xhr"
   ],
   "homepage": "https://github.com/open-telemetry/opentelemetry-browser",
   "bugs": "https://github.com/open-telemetry/opentelemetry-browser/issues",
@@ -36,7 +38,9 @@
     "./experimental/navigation-timing": "./dist/navigation-timing/index.js",
     "./experimental/resource-timing": "./dist/resource-timing/index.js",
     "./experimental/user-action": "./dist/user-action/index.js",
-    "./experimental/web-vitals": "./dist/web-vitals/index.js"
+    "./experimental/web-vitals": "./dist/web-vitals/index.js",
+    "./experimental/fetch": "./dist/fetch/index.js",
+    "./experimental/xhr": "./dist/xhr/index.js"
   },
   "sideEffects": false,
   "files": [
@@ -46,24 +50,33 @@
     "build": "tsdown",
     "watch": "tsdown --watch --no-clean",
     "check-types": "tsc",
+    "msw:init": "msw init public --save",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest --coverage"
   },
   "dependencies": {
-    "@opentelemetry/api-logs": "^0.221.0",
-    "@opentelemetry/core": "^2.10.0",
-    "@opentelemetry/instrumentation": "^0.221.0",
+    "@opentelemetry/api-logs": "^0.222.0",
+    "@opentelemetry/instrumentation": "^0.222.0",
     "@opentelemetry/semantic-conventions": "^1.43.0",
-    "web-vitals": "^5.3.0"
+    "web-vitals": "^6.2.1"
   },
   "peerDependencies": {
     "@opentelemetry/api": "^1.9.1"
   },
   "devDependencies": {
-    "@opentelemetry/sdk-logs": "0.221.0"
+    "@opentelemetry/core": "2.11.0",
+    "@opentelemetry/propagator-b3": "2.11.0",
+    "@opentelemetry/sdk-logs": "0.222.0",
+    "@opentelemetry/sdk-trace-base": "2.11.0",
+    "msw": "2.15.0"
   },
   "publishConfig": {
     "access": "public"
+  },
+  "msw": {
+    "workerDirectory": [
+      "public"
+    ]
   }
 }