@opentelemetry/browser-instrumentation 0.7.0 → 0.8.0

package/dist/utils/ContextRegistry.js

@@ -0,0 +1,77 @@
+import { ROOT_CONTEXT, trace } from "@opentelemetry/api";
+//#region src/utils/ContextRegistry.ts
+const MAX_CAPACITY = 1e3;
+/**
+* Base class for sharing OTel span context between two instrumentations that
+* observe the same events from different angles.
+*
+* The producing instrumentation calls `register()` when a span ends; the
+* consuming instrumentation calls `getContext()` to retrieve the span context
+* associated with the event it is processing.
+*
+* @typeParam TData - Registration payload. Must include enough info to derive a `key` string
+*   which will be used as the primary index, plus any implementation-specific fields needed to
+*   disambiguate concurrent operations (e.g. timing windows for network spans).
+* @typeParam TLookup - The object the consuming instrumentation passes to
+*   `getContext` and `unregister` (e.g. a `PerformanceResourceTiming` entry).
+*/
+var ContextRegistry = class {
+	_recordsByKey = /* @__PURE__ */ new Map();
+	_recordsList = [];
+	/** Store the span context for the given data, key is resolved by getDataKey(). */
+	register(span, data) {
+		const ctx = trace.setSpan(ROOT_CONTEXT, span);
+		const key = this.getDataKey(data);
+		const list = this._recordsByKey.get(key) ?? [];
+		const record = {
+			...data,
+			ctx
+		};
+		list.push(record);
+		this._recordsByKey.set(key, list);
+		this._recordsList.push(record);
+		if (this._recordsList.length > MAX_CAPACITY) {
+			const oldestRecord = this._recordsList.shift();
+			if (oldestRecord) {
+				const oldestKey = this.getDataKey(oldestRecord);
+				const oldestCtx = oldestRecord.ctx;
+				this.removeByKey(oldestKey, oldestCtx);
+			}
+		}
+	}
+	/**
+	* Remove the record that matches `lookup`. If no matching record exists this
+	* is a no-op. Deletes the key entirely once all records under it are removed.
+	*/
+	unregister(lookup) {
+		const key = this.getLookupKey(lookup);
+		const ctx = this.getContext(lookup);
+		if (ctx === void 0) return;
+		this.removeByKey(key, ctx);
+		const index = this._recordsList.findIndex((r) => {
+			const k = this.getDataKey(r);
+			return key === k && ctx === r.ctx;
+		});
+		if (index > -1) this._recordsList.splice(index, 1);
+	}
+	/**
+	* Remove a record from the records sub-list of the given key
+	*/
+	removeByKey(key, ctx) {
+		const list = this._recordsByKey.get(key);
+		if (!list) return;
+		const filtered = list.filter((r) => r.ctx !== ctx);
+		if (filtered.length === 0) this._recordsByKey.delete(key);
+		else this._recordsByKey.set(key, filtered);
+	}
+	/**
+	* Return the size number of records stored in the registry
+	*/
+	size() {
+		return this._recordsList.length;
+	}
+};
+//#endregion
+export { ContextRegistry };
+
+//# sourceMappingURL=ContextRegistry.js.map

package/dist/utils/ContextRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContextRegistry.js","names":[],"sources":["../../src/utils/ContextRegistry.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type { Context, Span } from '@opentelemetry/api';\nimport { ROOT_CONTEXT, trace } from '@opentelemetry/api';\n\ntype StoredRecord<TData> = TData & { ctx: Context };\n\nconst MAX_CAPACITY = 1000;\n\n/**\n * Base class for sharing OTel span context between two instrumentations that\n * observe the same events from different angles.\n *\n * The producing instrumentation calls `register()` when a span ends; the\n * consuming instrumentation calls `getContext()` to retrieve the span context\n * associated with the event it is processing.\n *\n * @typeParam TData - Registration payload. Must include enough info to derive a `key` string\n *   which will be used as the primary index, plus any implementation-specific fields needed to\n *   disambiguate concurrent operations (e.g. timing windows for network spans).\n * @typeParam TLookup - The object the consuming instrumentation passes to\n *   `getContext` and `unregister` (e.g. a `PerformanceResourceTiming` entry).\n */\nexport abstract class ContextRegistry<TData, TLookup> {\n  protected _recordsByKey = new Map<string, StoredRecord<TData>[]>();\n  private _recordsList: StoredRecord<TData>[] = [];\n\n  /** Store the span context for the given data, key is resolved by getDataKey(). */\n  register(span: Span, data: TData): void {\n    const ctx = trace.setSpan(ROOT_CONTEXT, span);\n    const key = this.getDataKey(data);\n    const list = this._recordsByKey.get(key) ?? [];\n    const record = { ...data, ctx };\n\n    // Set record into the map for faster lookup and in the\n    // list to track the size\n    list.push(record);\n    this._recordsByKey.set(key, list);\n    this._recordsList.push(record);\n\n    // If capacity is exceeded remove the oldest (1st in the array)\n    if (this._recordsList.length > MAX_CAPACITY) {\n      const oldestRecord = this._recordsList.shift();\n      if (oldestRecord) {\n        const oldestKey = this.getDataKey(oldestRecord);\n        const oldestCtx = oldestRecord.ctx;\n        this.removeByKey(oldestKey, oldestCtx);\n      }\n    }\n  }\n\n  /**\n   * Remove the record that matches `lookup`. If no matching record exists this\n   * is a no-op. Deletes the key entirely once all records under it are removed.\n   */\n  unregister(lookup: TLookup): void {\n    const key = this.getLookupKey(lookup);\n    const ctx = this.getContext(lookup);\n    if (ctx === undefined) {\n      return;\n    }\n\n    // Remove from the lookup map and from the global list\n    // to keep size up to date\n    this.removeByKey(key, ctx);\n    const index = this._recordsList.findIndex((r) => {\n      const k = this.getDataKey(r);\n      return key === k && ctx === r.ctx;\n    });\n    if (index > -1) {\n      this._recordsList.splice(index, 1);\n    }\n  }\n\n  /**\n   * Remove a record from the records sub-list of the given key\n   */\n  private removeByKey(key: string, ctx: Context): void {\n    const list = this._recordsByKey.get(key);\n    if (!list) {\n      return;\n    }\n\n    const filtered = list.filter((r) => r.ctx !== ctx);\n    if (filtered.length === 0) {\n      this._recordsByKey.delete(key);\n    } else {\n      this._recordsByKey.set(key, filtered);\n    }\n  }\n\n  /**\n   * Return the size number of records stored in the registry\n   */\n  size(): number {\n    return this._recordsList.length;\n  }\n\n  /** Return the index key for the given data object. */\n  abstract getDataKey(data: TData): string;\n\n  /** Return the index key for the given lookup object. */\n  abstract getLookupKey(lookup: TLookup): string;\n\n  /**\n   * Return the OTel context for the record that matches `lookup`, or\n   * `undefined` if no match is found.\n   */\n  abstract getContext(lookup: TLookup): Context | undefined;\n}\n"],"mappings":";;AAUA,MAAM,eAAe;;;;;;;;;;;;;;;AAgBrB,IAAsB,kBAAtB,MAAsD;CACpD,gCAA0B,IAAI,IAAmC;CACjE,eAA8C,CAAC;;CAG/C,SAAS,MAAY,MAAmB;EACtC,MAAM,MAAM,MAAM,QAAQ,cAAc,IAAI;EAC5C,MAAM,MAAM,KAAK,WAAW,IAAI;EAChC,MAAM,OAAO,KAAK,cAAc,IAAI,GAAG,KAAK,CAAC;EAC7C,MAAM,SAAS;GAAE,GAAG;GAAM;EAAI;EAI9B,KAAK,KAAK,MAAM;EAChB,KAAK,cAAc,IAAI,KAAK,IAAI;EAChC,KAAK,aAAa,KAAK,MAAM;EAG7B,IAAI,KAAK,aAAa,SAAS,cAAc;GAC3C,MAAM,eAAe,KAAK,aAAa,MAAM;GAC7C,IAAI,cAAc;IAChB,MAAM,YAAY,KAAK,WAAW,YAAY;IAC9C,MAAM,YAAY,aAAa;IAC/B,KAAK,YAAY,WAAW,SAAS;GACvC;EACF;CACF;;;;;CAMA,WAAW,QAAuB;EAChC,MAAM,MAAM,KAAK,aAAa,MAAM;EACpC,MAAM,MAAM,KAAK,WAAW,MAAM;EAClC,IAAI,QAAQ,KAAA,GACV;EAKF,KAAK,YAAY,KAAK,GAAG;EACzB,MAAM,QAAQ,KAAK,aAAa,WAAW,MAAM;GAC/C,MAAM,IAAI,KAAK,WAAW,CAAC;GAC3B,OAAO,QAAQ,KAAK,QAAQ,EAAE;EAChC,CAAC;EACD,IAAI,QAAQ,IACV,KAAK,aAAa,OAAO,OAAO,CAAC;CAErC;;;;CAKA,YAAoB,KAAa,KAAoB;EACnD,MAAM,OAAO,KAAK,cAAc,IAAI,GAAG;EACvC,IAAI,CAAC,MACH;EAGF,MAAM,WAAW,KAAK,QAAQ,MAAM,EAAE,QAAQ,GAAG;EACjD,IAAI,SAAS,WAAW,GACtB,KAAK,cAAc,OAAO,GAAG;OAE7B,KAAK,cAAc,IAAI,KAAK,QAAQ;CAExC;;;;CAKA,OAAe;EACb,OAAO,KAAK,aAAa;CAC3B;AAaF"}

package/dist/utils/NetworkContextRegistry.js

@@ -0,0 +1,23 @@
+import { ContextRegistry } from "./ContextRegistry.js";
+//#region src/utils/NetworkContextRegistry.ts
+var NetworkContextRegistry = class extends ContextRegistry {
+	getDataKey(data) {
+		return data.key;
+	}
+	getLookupKey(entry) {
+		return entry.name;
+	}
+	getContext(entry) {
+		const key = this.getLookupKey(entry);
+		return this._recordsByKey.get(key)?.find((r) => entry.fetchStart >= r.startPerfNow && entry.responseEnd <= r.endPerfNow)?.ctx;
+	}
+};
+let _instance;
+function getNetworkContextRegistry() {
+	if (!_instance) _instance = new NetworkContextRegistry();
+	return _instance;
+}
+//#endregion
+export { NetworkContextRegistry, getNetworkContextRegistry };
+
+//# sourceMappingURL=NetworkContextRegistry.js.map

package/dist/utils/NetworkContextRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkContextRegistry.js","names":[],"sources":["../../src/utils/NetworkContextRegistry.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type { Context } from '@opentelemetry/api';\nimport { ContextRegistry } from './ContextRegistry.ts';\n\nexport interface NetworkSpanData {\n  key: string;\n  startPerfNow: number;\n  endPerfNow: number;\n}\n\nexport class NetworkContextRegistry extends ContextRegistry<\n  NetworkSpanData,\n  PerformanceResourceTiming\n> {\n  getDataKey(data: NetworkSpanData): string {\n    return data.key;\n  }\n\n  getLookupKey(entry: PerformanceResourceTiming): string {\n    return entry.name;\n  }\n\n  getContext(entry: PerformanceResourceTiming): Context | undefined {\n    const key = this.getLookupKey(entry);\n    const list = this._recordsByKey.get(key);\n    return list?.find(\n      (r) =>\n        entry.fetchStart >= r.startPerfNow && entry.responseEnd <= r.endPerfNow,\n    )?.ctx;\n  }\n}\n\nlet _instance: NetworkContextRegistry | undefined;\n\nexport function getNetworkContextRegistry(): NetworkContextRegistry {\n  if (!_instance) {\n    _instance = new NetworkContextRegistry();\n  }\n\n  return _instance;\n}\n"],"mappings":";;AAcA,IAAa,yBAAb,cAA4C,gBAG1C;CACA,WAAW,MAA+B;EACxC,OAAO,KAAK;CACd;CAEA,aAAa,OAA0C;EACrD,OAAO,MAAM;CACf;CAEA,WAAW,OAAuD;EAChE,MAAM,MAAM,KAAK,aAAa,KAAK;EAEnC,OADa,KAAK,cAAc,IAAI,GAC1B,CAAC,EAAE,MACV,MACC,MAAM,cAAc,EAAE,gBAAgB,MAAM,eAAe,EAAE,UACjE,CAAC,EAAE;CACL;AACF;AAEA,IAAI;AAEJ,SAAgB,4BAAoD;CAClE,IAAI,CAAC,WACH,YAAY,IAAI,uBAAuB;CAGzC,OAAO;AACT"}

package/dist/utils/getElementCSSSelector.js.map

@@ -1 +1 @@
-{"version":3,"file":"getElementCSSSelector.js","names":[],"sources":["../../src/utils/getElementCSSSelector.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\ntype GetElementCSSSelectorOptions = {\n  /**\n   * If true, the function will attempt to use element ID to create condensed CSS selector.\n   */\n  useIdForTargetElement?: boolean;\n  /**\n   * If true, the function will attempt to use element ID for all ancestor elements to create condensed CSS selector.\n   */\n  useIdForAncestors?: boolean;\n};\n\n/**\n * Generates the CSS selector of a given element in the DOM tree.\n *\n * @example #main > div:nth-child(2) > button.submit\n * @example #unique-id\n */\nexport const getElementCSSSelector = (\n  element: Node,\n  {\n    useIdForTargetElement = false,\n    useIdForAncestors = false,\n  }: GetElementCSSSelectorOptions = {},\n): string => {\n  // Handle document node\n  if (element.nodeType === Node.DOCUMENT_NODE) {\n    return '';\n  }\n\n  const htmlElement = element as HTMLElement;\n  const nodeValue = getNodeSelector(\n    htmlElement,\n    useIdForTargetElement || useIdForAncestors,\n  );\n\n  // If optimized and found an ID selector, stop recursion early\n  if (nodeValue.startsWith('#')) {\n    return nodeValue;\n  }\n\n  const parent = htmlElement.parentElement;\n  const parentSelector = parent\n    ? getElementCSSSelector(parent, {\n        useIdForAncestors,\n        useIdForTargetElement: false,\n      })\n    : '';\n\n  return parentSelector ? `${parentSelector} > ${nodeValue}` : nodeValue;\n};\n\nconst getNodeSelector = (element: Node, useElementId = false): string => {\n  if (element.nodeType !== Node.ELEMENT_NODE) {\n    return '';\n  }\n\n  const htmlElement = element as HTMLElement;\n  const id = htmlElement.getAttribute('id');\n\n  // Use ID if requested and it's unique\n  if (useElementId && id) {\n    // Check if ID is unique in the document\n    const elementsWithSameId = htmlElement.ownerDocument.querySelectorAll(\n      `#${CSS.escape(id)}`,\n    );\n\n    if (elementsWithSameId.length === 1) {\n      return `#${CSS.escape(id)}`;\n    }\n  }\n\n  let selector = getFullClassSelector(htmlElement);\n  // Add nth-child if there are siblings with the same tag and classes\n  const index = getNthChild(htmlElement);\n\n  if (index > 0) {\n    selector += `:nth-child(${index})`;\n  }\n\n  return selector;\n};\n\nconst getNthChild = (element: HTMLElement): number => {\n  // parentElement is needed to access children\n  if (!element.parentElement) {\n    return 0;\n  }\n\n  const selector = getFullClassSelector(element);\n\n  // Get all siblings that match the same selector\n  const siblings = Array.from(element.parentElement.children).filter(\n    (sibling) => getFullClassSelector(sibling) === selector,\n  );\n\n  // Only add nth-child if there are multiple matching siblings\n  if (siblings.length > 1) {\n    return siblings.indexOf(element) + 1;\n  }\n\n  return 0;\n};\n\nconst getFullClassSelector = (element: Element): string =>\n  element.localName +\n  (element.classList.length > 0\n    ? Array.from(element.classList)\n        .map((cls) => `.${CSS.escape(cls)}`)\n        .join('')\n    : '');\n"],"mappings":";;;;;;;AAsBA,MAAa,yBACX,SACA,EACE,wBAAwB,OACxB,oBAAoB,UACY,CAAC,MACxB;CAEX,IAAI,QAAQ,aAAa,KAAK,eAC5B,OAAO;CAGT,MAAM,cAAc;CACpB,MAAM,YAAY,gBAChB,aACA,yBAAyB,iBAC3B;CAGA,IAAI,UAAU,WAAW,GAAG,GAC1B,OAAO;CAGT,MAAM,SAAS,YAAY;CAC3B,MAAM,iBAAiB,SACnB,sBAAsB,QAAQ;EAC5B;EACA,uBAAuB;CACzB,CAAC,IACD;CAEJ,OAAO,iBAAiB,GAAG,eAAe,KAAK,cAAc;AAC/D;AAEA,MAAM,mBAAmB,SAAe,eAAe,UAAkB;CACvE,IAAI,QAAQ,aAAa,KAAK,cAC5B,OAAO;CAGT,MAAM,cAAc;CACpB,MAAM,KAAK,YAAY,aAAa,IAAI;CAGxC,IAAI,gBAAgB;MAES,YAAY,cAAc,iBACnD,IAAI,IAAI,OAAO,EAAE,GAGE,CAAC,CAAC,WAAW,GAChC,OAAO,IAAI,IAAI,OAAO,EAAE;CAAA;CAI5B,IAAI,WAAW,qBAAqB,WAAW;CAE/C,MAAM,QAAQ,YAAY,WAAW;CAErC,IAAI,QAAQ,GACV,YAAY,cAAc,MAAM;CAGlC,OAAO;AACT;AAEA,MAAM,eAAe,YAAiC;CAEpD,IAAI,CAAC,QAAQ,eACX,OAAO;CAGT,MAAM,WAAW,qBAAqB,OAAO;CAG7C,MAAM,WAAW,MAAM,KAAK,QAAQ,cAAc,QAAQ,CAAC,CAAC,QACzD,YAAY,qBAAqB,OAAO,MAAM,QACjD;CAGA,IAAI,SAAS,SAAS,GACpB,OAAO,SAAS,QAAQ,OAAO,IAAI;CAGrC,OAAO;AACT;AAEA,MAAM,wBAAwB,YAC5B,QAAQ,aACP,QAAQ,UAAU,SAAS,IACxB,MAAM,KAAK,QAAQ,SAAS,CAAC,CAC1B,KAAK,QAAQ,IAAI,IAAI,OAAO,GAAG,GAAG,CAAC,CACnC,KAAK,EAAE,IACV"}
+{"version":3,"file":"getElementCSSSelector.js","names":[],"sources":["../../src/utils/getElementCSSSelector.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\ntype GetElementCSSSelectorOptions = {\n  /**\n   * If true, the function will attempt to use element ID to create condensed CSS selector.\n   */\n  useIdForTargetElement?: boolean;\n  /**\n   * If true, the function will attempt to use element ID for all ancestor elements to create condensed CSS selector.\n   */\n  useIdForAncestors?: boolean;\n};\n\n/**\n * Generates the CSS selector of a given element in the DOM tree.\n *\n * @example #main > div:nth-child(2) > button.submit\n * @example #unique-id\n */\nexport const getElementCSSSelector = (\n  element: Node,\n  {\n    useIdForTargetElement = false,\n    useIdForAncestors = false,\n  }: GetElementCSSSelectorOptions = {},\n): string => {\n  // Handle document node\n  if (element.nodeType === Node.DOCUMENT_NODE) {\n    return '';\n  }\n\n  const htmlElement = element as HTMLElement;\n  const nodeValue = getNodeSelector(\n    htmlElement,\n    useIdForTargetElement || useIdForAncestors,\n  );\n\n  // If optimized and found an ID selector, stop recursion early\n  if (nodeValue.startsWith('#')) {\n    return nodeValue;\n  }\n\n  const parent = htmlElement.parentElement;\n  const parentSelector = parent\n    ? getElementCSSSelector(parent, {\n        useIdForAncestors,\n        useIdForTargetElement: false,\n      })\n    : '';\n\n  return parentSelector ? `${parentSelector} > ${nodeValue}` : nodeValue;\n};\n\nconst getNodeSelector = (element: Node, useElementId = false): string => {\n  if (element.nodeType !== Node.ELEMENT_NODE) {\n    return '';\n  }\n\n  const htmlElement = element as HTMLElement;\n  const id = htmlElement.getAttribute('id');\n\n  // Use ID if requested and it's unique\n  if (useElementId && id) {\n    // Check if ID is unique in the document\n    const elementsWithSameId = htmlElement.ownerDocument.querySelectorAll(\n      `#${CSS.escape(id)}`,\n    );\n\n    if (elementsWithSameId.length === 1) {\n      return `#${CSS.escape(id)}`;\n    }\n  }\n\n  let selector = getFullClassSelector(htmlElement);\n  // Add nth-child if there are siblings with the same tag and classes\n  const index = getNthChild(htmlElement);\n\n  if (index > 0) {\n    selector += `:nth-child(${index})`;\n  }\n\n  return selector;\n};\n\nconst getNthChild = (element: HTMLElement): number => {\n  // parentElement is needed to access children\n  if (!element.parentElement) {\n    return 0;\n  }\n\n  const selector = getFullClassSelector(element);\n\n  // Get all siblings that match the same selector\n  const siblings = Array.from(element.parentElement.children).filter(\n    (sibling) => getFullClassSelector(sibling) === selector,\n  );\n\n  // Only add nth-child if there are multiple matching siblings\n  if (siblings.length > 1) {\n    return siblings.indexOf(element) + 1;\n  }\n\n  return 0;\n};\n\nconst getFullClassSelector = (element: Element): string =>\n  element.localName +\n  (element.classList.length > 0\n    ? Array.from(element.classList)\n        .map((cls) => `.${CSS.escape(cls)}`)\n        .join('')\n    : '');\n"],"mappings":";;;;;;;AAsBA,MAAa,yBACX,SACA,EACE,wBAAwB,OACxB,oBAAoB,UACY,CAAC,MACxB;CAEX,IAAI,QAAQ,aAAa,KAAK,eAC5B,OAAO;CAGT,MAAM,cAAc;CACpB,MAAM,YAAY,gBAChB,aACA,yBAAyB,iBAC3B;CAGA,IAAI,UAAU,WAAW,GAAG,GAC1B,OAAO;CAGT,MAAM,SAAS,YAAY;CAC3B,MAAM,iBAAiB,SACnB,sBAAsB,QAAQ;EAC5B;EACA,uBAAuB;CACzB,CAAC,IACD;CAEJ,OAAO,iBAAiB,GAAG,eAAe,KAAK,cAAc;AAC/D;AAEA,MAAM,mBAAmB,SAAe,eAAe,UAAkB;CACvE,IAAI,QAAQ,aAAa,KAAK,cAC5B,OAAO;CAGT,MAAM,cAAc;CACpB,MAAM,KAAK,YAAY,aAAa,IAAI;CAGxC,IAAI,gBAAgB,IAES;MAAA,YAAY,cAAc,iBACnD,IAAI,IAAI,OAAO,EAAE,GAGE,CAAC,CAAC,WAAW,GAChC,OAAO,IAAI,IAAI,OAAO,EAAE;CAAA;CAI5B,IAAI,WAAW,qBAAqB,WAAW;CAE/C,MAAM,QAAQ,YAAY,WAAW;CAErC,IAAI,QAAQ,GACV,YAAY,cAAc,MAAM;CAGlC,OAAO;AACT;AAEA,MAAM,eAAe,YAAiC;CAEpD,IAAI,CAAC,QAAQ,eACX,OAAO;CAGT,MAAM,WAAW,qBAAqB,OAAO;CAG7C,MAAM,WAAW,MAAM,KAAK,QAAQ,cAAc,QAAQ,CAAC,CAAC,QACzD,YAAY,qBAAqB,OAAO,MAAM,QACjD;CAGA,IAAI,SAAS,SAAS,GACpB,OAAO,SAAS,QAAQ,OAAO,IAAI;CAGrC,OAAO;AACT;AAEA,MAAM,wBAAwB,YAC5B,QAAQ,aACP,QAAQ,UAAU,SAAS,IACxB,MAAM,KAAK,QAAQ,SAAS,CAAC,CAC1B,KAAK,QAAQ,IAAI,IAAI,OAAO,GAAG,GAAG,CAAC,CACnC,KAAK,EAAE,IACV"}

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/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,39 @@
+import { XhrInstrumentationConfig } from "./types.js";
+import { InstrumentationBase } from "@opentelemetry/instrumentation";
+//#region src/xhr/instrumentation.d.ts
+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
+export { XhrInstrumentation };
+//# 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  private declare _isEnabled: boolean;\n  private declare _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":"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"}

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"}