@dash0/sdk-web 0.22.1 → 0.24.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dash0/sdk-web",
-  "version": "0.22.1",
+  "version": "0.24.0",
   "description": "Dash0's Web SDK to collect telemetry from end-users' web browsers",
   "type": "module",
   "main": "dist/dash0.umd.cjs",
@@ -92,6 +92,7 @@
     "@wdio/mocha-framework": "^9.12.5",
     "@wdio/sauce-service": "^9.12.5",
     "@wdio/spec-reporter": "^9.12.3",
+    "axios": "^1.18.1",
     "body-parser": "^2.2.0",
     "dotenv-cli": "^8.0.0",
     "eslint": "^9.24.0",
@@ -116,7 +117,7 @@
   "resolutions": {
     "conventional-changelog-conventionalcommits": "8.0.0"
   },
-  "packageManager": "pnpm@9.15.1",
+  "packageManager": "pnpm@10.33.4",
   "publishConfig": {
     "access": "public"
   }

package/src/api/init.ts

@@ -29,6 +29,7 @@ import { startWebVitalsInstrumentation } from "../instrumentations/web-vitals";
 import { startErrorInstrumentation } from "../instrumentations/errors";
 import { addAttribute } from "../utils/otel";
 import { instrumentFetch } from "../instrumentations/http/fetch";
+import { instrumentXhr } from "../instrumentations/http/xhr";
 import { startNavigationInstrumentation } from "../instrumentations/navigation";
 import { initializeTabId } from "../utils/tab-id";
 import { InitOptions, InstrumentationName } from "../types/options";
@@ -120,6 +121,9 @@ export function init(opts: InitOptions) {
   if (isInstrumentationEnabled("@dash0/fetch", opts)) {
     instrumentFetch();
   }
+  if (isInstrumentationEnabled("@dash0/xhr", opts)) {
+    instrumentXhr();
+  }
 
   hasBeenInitialised = true;
 }

package/src/api/init_test.ts

@@ -30,6 +30,10 @@ vi.mock("../instrumentations/http/fetch", () => ({
   instrumentFetch: vi.fn(),
 }));
 
+vi.mock("../instrumentations/http/xhr", () => ({
+  instrumentXhr: vi.fn(),
+}));
+
 vi.mock("../instrumentations/navigation", () => ({
   startNavigationInstrumentation: vi.fn(),
 }));
@@ -45,6 +49,7 @@ vi.mock("../utils", async () => {
 
 import { startErrorInstrumentation } from "../instrumentations/errors";
 import { instrumentFetch } from "../instrumentations/http/fetch";
+import { instrumentXhr } from "../instrumentations/http/xhr";
 import { startNavigationInstrumentation } from "../instrumentations/navigation";
 import { startWebVitalsInstrumentation } from "../instrumentations/web-vitals";
 
@@ -84,6 +89,7 @@ describe("init", () => {
       expect(startWebVitalsInstrumentation).toHaveBeenCalled();
       expect(startErrorInstrumentation).toHaveBeenCalled();
       expect(instrumentFetch).toHaveBeenCalled();
+      expect(instrumentXhr).toHaveBeenCalled();
     });
 
     const instrumentations: InstrumentationName[] = [
@@ -91,12 +97,14 @@ describe("init", () => {
       "@dash0/web-vitals",
       "@dash0/error",
       "@dash0/fetch",
+      "@dash0/xhr",
     ];
     const instrumentationMocks = {
       "@dash0/navigation": startNavigationInstrumentation,
       "@dash0/web-vitals": startWebVitalsInstrumentation,
       "@dash0/error": startErrorInstrumentation,
       "@dash0/fetch": instrumentFetch,
+      "@dash0/xhr": instrumentXhr,
     };
 
     instrumentations.forEach((instrumentation) => {

package/src/api/start-view.ts

@@ -0,0 +1,68 @@
+import { transmitManualPageViewEvent } from "../instrumentations/navigation/event";
+import { AttributeValueType } from "../utils/otel";
+import { AnyValue } from "../types/otlp";
+import { debug, nowNanos, win } from "../utils";
+import { vars } from "../vars";
+
+export type StartViewOptions = {
+  /**
+   * Optionally override the url reflected in `page.url.*` attributes for this view.
+   * Accepts an absolute or relative url; relative urls are resolved against the current
+   * `location.href`. Falls back to the real `location.href` if omitted or invalid.
+   * This is display-only: calling startView never navigates or mutates history/location.
+   */
+  url?: string;
+
+  /**
+   * Additional attributes to include with the page view.
+   * Added after the SDK-generated attributes, so they can override them.
+   */
+  attributes?: Record<string, AttributeValueType | AnyValue>;
+};
+
+/**
+ * Manually records a page view, side-effect free: this never calls `history.pushState` /
+ * `history.replaceState` and never mutates `location`. Intended for single-page applications
+ * that own their own router and cannot let the SDK touch navigation state (e.g. Electron apps
+ * serving the whole app from one root URL, where automatic page-view tracking would report
+ * every screen as "/").
+ *
+ * The emitted event is indistinguishable from an automatic virtual page view downstream
+ * (same `browser.page_view` event name, same `type` value), with two differences: it is never
+ * accompanied by a `change_state` value, since no history mutation occurred, and the
+ * `pageViewInstrumentation`'s `generateMetadata` callback is not invoked for manual views —
+ * supply title and attributes directly instead.
+ *
+ * @param name The name of the view, e.g. "/settings". Transmitted as the page view's title.
+ * @param opts Additional page view details.
+ */
+export function startView(name: string, opts?: StartViewOptions) {
+  if (vars.endpoints.length === 0) {
+    debug("Dash0 SDK has not been initialized. Ignoring startView call.");
+    return;
+  }
+
+  // The script entrypoint forwards dash0("startView", ...) arguments without type checking,
+  // so malformed calls must degrade to a logged no-op instead of throwing. An uncaught throw
+  // here would abort the command-queue drain and drop all subsequently queued api calls.
+  if (typeof name !== "string" || name.length === 0) {
+    debug("startView requires a non-empty view name. Ignoring startView call.");
+    return;
+  }
+
+  let url: URL | undefined;
+  if (opts?.url != null) {
+    try {
+      url = new URL(opts.url, win?.location.href);
+    } catch (e) {
+      debug("Failed to parse startView url option. Falling back to the current location.", e);
+    }
+  }
+
+  transmitManualPageViewEvent({
+    timeUnixNano: nowNanos(),
+    title: name,
+    url,
+    attributes: opts?.attributes,
+  });
+}

package/src/api/start-view_test.ts

@@ -0,0 +1,125 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { KeyValue, LogRecord } from "../types/otlp";
+
+vi.mock("../transport", () => ({
+  sendLog: vi.fn(),
+}));
+
+import { sendLog } from "../transport";
+import { startView } from "./start-view";
+import { vars } from "../vars";
+
+const sendLogMock = sendLog as unknown as ReturnType<typeof vi.fn>;
+
+describe("startView", () => {
+  beforeEach(() => {
+    sendLogMock.mockClear();
+    vars.endpoints = [{ url: "https://example.com", authToken: "auth_abc123" }];
+    vars.pageViewInstrumentation = { trackVirtualPageViews: true, includeParts: [] };
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+    vars.endpoints = [];
+  });
+
+  it("accepts a string shorthand and uses it as the title", () => {
+    startView("/settings");
+
+    expect(sendLogMock).toHaveBeenCalledTimes(1);
+    const log = sendLogMock.mock.calls[0]![0] as LogRecord;
+    const bodyValues = log.body?.kvlistValue?.values as KeyValue[];
+    expect(bodyValues).toEqual(expect.arrayContaining([{ key: "title", value: { stringValue: "/settings" } }]));
+  });
+
+  it("accepts an options object with attributes", () => {
+    startView("/settings", { attributes: { "app.screen": "settings" } });
+
+    const log = sendLogMock.mock.calls[0]![0] as LogRecord;
+    const bodyValues = log.body?.kvlistValue?.values as KeyValue[];
+    expect(bodyValues).toEqual(expect.arrayContaining([{ key: "title", value: { stringValue: "/settings" } }]));
+    expect(log.attributes).toEqual(expect.arrayContaining([{ key: "app.screen", value: { stringValue: "settings" } }]));
+  });
+
+  it("parses a relative url option and reflects it in page.url.path", () => {
+    startView("/settings", { url: "/settings" });
+
+    const log = sendLogMock.mock.calls[0]![0] as LogRecord;
+    expect(log.attributes).toEqual(
+      expect.arrayContaining([{ key: "page.url.path", value: { stringValue: "/settings" } }])
+    );
+  });
+
+  it("falls back to the current location on an invalid url", () => {
+    startView("/settings", { url: "http://" });
+
+    expect(sendLogMock).toHaveBeenCalledTimes(1);
+    const log = sendLogMock.mock.calls[0]![0] as LogRecord;
+    expect(log.attributes).toEqual(
+      expect.arrayContaining([
+        // eslint-disable-next-line no-restricted-globals
+        { key: "page.url.full", value: { stringValue: window.location.href } },
+        // eslint-disable-next-line no-restricted-globals
+        { key: "page.url.domain", value: { stringValue: window.location.hostname } },
+      ])
+    );
+  });
+
+  it("resolves an absolute cross-origin url override", () => {
+    startView("/settings", { url: "https://other-origin.example/path" });
+
+    const log = sendLogMock.mock.calls[0]![0] as LogRecord;
+    expect(log.attributes).toEqual(
+      expect.arrayContaining([
+        { key: "page.url.full", value: { stringValue: "https://other-origin.example/path" } },
+        { key: "page.url.domain", value: { stringValue: "other-origin.example" } },
+        { key: "page.url.path", value: { stringValue: "/path" } },
+      ])
+    );
+  });
+
+  it("does not touch history or location", () => {
+    // eslint-disable-next-line no-restricted-globals
+    const originalHref = window.location.href;
+    // eslint-disable-next-line no-restricted-globals
+    const originalLength = window.history.length;
+
+    startView("/settings");
+
+    // eslint-disable-next-line no-restricted-globals
+    expect(window.location.href).toBe(originalHref);
+    // eslint-disable-next-line no-restricted-globals
+    expect(window.history.length).toBe(originalLength);
+  });
+
+  it("ignores calls without a name, as they can arrive via the untyped script entrypoint", () => {
+    // @ts-expect-error deliberately calling without arguments, mirroring dash0("startView")
+    startView();
+    startView(undefined as unknown as string);
+    startView(null as unknown as string);
+
+    expect(sendLogMock).not.toHaveBeenCalled();
+  });
+
+  it("ignores calls with a non-string or empty name", () => {
+    startView(123 as unknown as string);
+    startView({ name: "/settings" } as unknown as string);
+    startView("");
+
+    expect(sendLogMock).not.toHaveBeenCalled();
+  });
+
+  it("tolerates a nullish options argument", () => {
+    startView("/settings", null as unknown as undefined);
+
+    expect(sendLogMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("is a no-op before init (no endpoints configured)", () => {
+    vars.endpoints = [];
+
+    startView("/settings");
+
+    expect(sendLogMock).not.toHaveBeenCalled();
+  });
+});

package/src/entrypoint/npm-package.ts

@@ -9,12 +9,14 @@ export * from "../api/events";
 export * from "../api/log-level";
 export { terminateSession } from "../api/session";
 export { reportError } from "../api/report-error";
+export { startView } from "../api/start-view";
 
 // Additional utility types
 export type { AttributeValueType } from "../utils/otel";
 export type { AnyValue } from "../types/otlp";
 export type { PageViewMeta, PropagatorConfig, PropagatorType } from "../vars";
 export type { UrlAttributeScrubber, UrlAttributeRecord } from "../attributes/url";
+export type { StartViewOptions } from "../api/start-view";
 
 export function init(opts: InitOptions): void {
   debug(`${INIT_MESSAGE} (via package)`);

package/src/entrypoint/npm-package_test.ts

@@ -0,0 +1,8 @@
+import { describe, expect, it } from "vitest";
+import * as npmPackage from "./npm-package";
+
+describe("npm-package entrypoint", () => {
+  it("exports startView", () => {
+    expect(typeof npmPackage.startView).toBe("function");
+  });
+});

package/src/entrypoint/script.ts

@@ -8,6 +8,7 @@ import { terminateSession } from "../api/session";
 import { addSignalAttribute, removeSignalAttribute } from "../api/attributes";
 import { sendEvent } from "../api/events";
 import { setActiveLogLevel } from "../api/log-level";
+import { startView } from "../api/start-view";
 
 /**
  * All the APIs exposed through the script tag via `dash0('{{api name}}')`
@@ -22,6 +23,7 @@ const scriptApis = {
   removeSignalAttribute,
   setActiveLogLevel,
   sendEvent,
+  startView,
 } as const;
 
 type GlobalObject = {

package/src/instrumentations/http/fetch.ts

@@ -1,27 +1,6 @@
-import {
-  debug,
-  observeResourcePerformance,
-  perf,
-  win,
-  setTimeout,
-  isSameOrigin,
-  wrap,
-  parseUrl,
-  clearTimeout,
-} from "../../utils";
-import { isUrlIgnored, matchesAny } from "../../utils/ignore-rules";
-import {
-  addAttribute,
-  setSpanStatus,
-  addW3CTraceContextHttpHeaders,
-  addXRayTraceContextHttpHeaders,
-  endSpan,
-  errorToSpanStatus,
-  Exception,
-  InProgressSpan,
-  recordException,
-  startSpan,
-} from "../../utils/otel";
+import { debug, observeResourcePerformance, perf, win, setTimeout, wrap, parseUrl, clearTimeout } from "../../utils";
+import { isUrlIgnored } from "../../utils/ignore-rules";
+import { addAttribute, endSpan, setSpanStatus, Exception, InProgressSpan, startSpan } from "../../utils/otel";
 import {
   ERROR_TYPE,
   HTTP_REQUEST_METHOD,
@@ -29,12 +8,20 @@ import {
   HTTP_RESPONSE_STATUS_CODE,
   SPAN_STATUS_ERROR,
   SPAN_STATUS_UNSET,
-  WEB_REQUEST_CANCELLED,
 } from "../../semantic-conventions";
-import { vars, PropagatorType } from "../../vars";
+import { vars } from "../../vars";
 import { httpRequestHeaderKey, httpResponseHeaderKey } from "../../utils/otel/http";
 import { sendSpan } from "../../transport";
-import { addResourceNetworkEvents, addResourceSize, HTTP_METHOD_OTHER, isWellKnownHttpMethod } from "./utils";
+import {
+  addResourceNetworkEvents,
+  addResourceSize,
+  addTraceContextHttpHeaders,
+  determinePropagatorTypes,
+  endSpanOnAbort,
+  endSpanOnError,
+  HTTP_METHOD_OTHER,
+  isWellKnownHttpMethod,
+} from "./utils";
 import { addCommonAttributes, addUrlAttributes } from "../../attributes";
 
 export function instrumentFetch() {
@@ -45,83 +32,53 @@ export function instrumentFetch() {
   wrap(win, "fetch", wrapFetch);
 }
 
+type FetchInstrumentation = {
+  copyOfInit?: RequestInit;
+  span: InProgressSpan;
+  performanceObserver: ReturnType<typeof observeResourcePerformance>;
+};
+
 // eslint-disable-next-line no-restricted-globals -- only used as type here
 function wrapFetch(original: typeof fetch) {
   return async function fetchWithInstrumentation(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
-    let copyOfInit = init ? Object.assign({}, init) : init;
-
-    let body: BodyInit | null = null;
-    if (copyOfInit?.body) {
-      body = copyOfInit.body;
-      copyOfInit.body = undefined;
-    }
-
-    const request = new Request(input, copyOfInit);
-    if (body && copyOfInit) {
-      copyOfInit.body = body;
-    }
-
-    const url = request.url;
-    if (isUrlIgnored(url)) {
-      debug(`Not creating span for fetch call because the url is ignored, URL: ${url}`);
-      return original(input instanceof Request ? request : input, init);
-    }
-
-    // https://fetch.spec.whatwg.org/#concept-request-method
-    // We'll match methods case insensitive here to make the user experience a bit less painful
-    const originalMethod = request.method ?? "GET";
-    const isWellKnownMethod = isWellKnownHttpMethod(originalMethod);
-    const isWellKnownMethodMatchingLeniently = isWellKnownHttpMethod(originalMethod.toUpperCase());
-    const method = isWellKnownMethodMatchingLeniently ? originalMethod.toUpperCase() : HTTP_METHOD_OTHER;
+    let fetchInput: RequestInfo | URL = input;
+    let request: Request | undefined;
+    let instrumentation: FetchInstrumentation | undefined;
+    try {
+      let copyOfInit = init ? Object.assign({}, init) : init;
 
-    const span = startSpan(`HTTP ${method}`);
-    addCommonAttributes(span.attributes);
-    addUrlAttributes(span.attributes, url);
-    addGraphQlProperties(input, init, span);
-    addAttribute(span.attributes, HTTP_REQUEST_METHOD, method);
-    if (!isWellKnownMethod) {
-      addAttribute(span.attributes, HTTP_REQUEST_METHOD_ORIGINAL, originalMethod);
-    }
+      let body: BodyInit | null = null;
+      if (copyOfInit?.body) {
+        body = copyOfInit.body;
+        copyOfInit.body = undefined;
+      }
 
-    const propagatorTypes = determinePropagatorTypes(url);
-    const shouldSetCorrelationHeaders = propagatorTypes.length > 0;
-    if (shouldSetCorrelationHeaders) {
-      if (copyOfInit?.headers) {
-        // ensure we have a unified container for the headers
-        copyOfInit.headers = new Headers(copyOfInit.headers);
-        addTraceContextHttpHeaders(copyOfInit.headers.append, copyOfInit.headers, span, propagatorTypes);
-      } else if (input instanceof Request) {
-        addTraceContextHttpHeaders(request.headers.append, request.headers, span, propagatorTypes);
-      } else {
-        if (!copyOfInit) {
-          copyOfInit = {};
-        }
-        copyOfInit.headers = new Headers();
-        addTraceContextHttpHeaders(copyOfInit.headers.append, copyOfInit.headers, span, propagatorTypes);
+      request = new Request(input, copyOfInit);
+      if (body && copyOfInit) {
+        copyOfInit.body = body;
+      }
+      // Constructing the Request above disturbs the body of a Request input, so from here on the
+      // copy has to be handed to the original fetch in place of the input -- including on the
+      // ignored and instrumentation-failure paths below.
+      fetchInput = input instanceof Request ? request : input;
+
+      if (isUrlIgnored(request.url)) {
+        debug(`Not creating span for fetch call because the url is ignored, URL: ${request.url}`);
+        // Note: the rejection of the returned promise does not route through the catch below --
+        // only synchronous throws do, so the original fetch cannot be invoked twice.
+        return original(fetchInput, init);
       }
-    }
 
-    tryCaptureHttpHeaders(request.headers, span, (k) => httpRequestHeaderKey(k));
+      instrumentation = onFetchStart(input, init, request, copyOfInit);
+    } catch (e) {
+      debug("failed to instrument fetch call", e);
+      return original(fetchInput, init);
+    }
 
-    const performanceObserver = observeResourcePerformance({
-      // We match on both fetch and XHR here to support polyfills
-      resourceMatcher: ({ initiatorType, name }) =>
-        (initiatorType === "fetch" || initiatorType === "xmlhttprequest") && name === parseUrl(url).href,
-      maxWaitForResourceMillis: vars.maxWaitForResourceTimingsMillis,
-      maxToleranceForResourceTimingsMillis: vars.maxToleranceForResourceTimingsMillis,
-      onEnd: ({ duration, resource }) => {
-        if (resource) {
-          addResourceNetworkEvents(span, resource);
-          addResourceSize(span, resource);
-        }
-        // duration is millis we need to convert to nanos
-        sendSpan(endSpan(span, undefined, duration * 1000000));
-      },
-    });
+    const { copyOfInit, span, performanceObserver } = instrumentation;
 
-    performanceObserver.start();
     try {
-      const origResponse = await original(input instanceof Request ? request : input, copyOfInit);
+      const origResponse = await original(fetchInput, copyOfInit);
       addResponseData(span, origResponse);
 
       return wrapResponse(
@@ -130,7 +87,7 @@ function wrapFetch(original: typeof fetch) {
         () => performanceObserver.end(),
         (e) => {
           performanceObserver.cancel();
-          if (request.signal?.aborted) {
+          if (request?.signal?.aborted) {
             endSpanOnAbort(span);
           } else {
             endSpanOnError(span, e);
@@ -139,7 +96,7 @@ function wrapFetch(original: typeof fetch) {
       );
     } catch (e) {
       performanceObserver.cancel();
-      if (request.signal?.aborted) {
+      if (request?.signal?.aborted) {
         endSpanOnAbort(span);
       } else {
         endSpanOnError(span, e as Exception);
@@ -149,6 +106,71 @@ function wrapFetch(original: typeof fetch) {
   };
 }
 
+function onFetchStart(
+  input: RequestInfo | URL,
+  init: RequestInit | undefined,
+  request: Request,
+  copyOfInit: RequestInit | undefined
+): FetchInstrumentation {
+  const url = request.url;
+
+  // https://fetch.spec.whatwg.org/#concept-request-method
+  // We'll match methods case insensitive here to make the user experience a bit less painful
+  const originalMethod = request.method ?? "GET";
+  const isWellKnownMethod = isWellKnownHttpMethod(originalMethod);
+  const isWellKnownMethodMatchingLeniently = isWellKnownHttpMethod(originalMethod.toUpperCase());
+  const method = isWellKnownMethodMatchingLeniently ? originalMethod.toUpperCase() : HTTP_METHOD_OTHER;
+
+  const span = startSpan(`HTTP ${method}`);
+  addCommonAttributes(span.attributes);
+  addUrlAttributes(span.attributes, url);
+  addGraphQlProperties(input, init, span);
+  addAttribute(span.attributes, HTTP_REQUEST_METHOD, method);
+  if (!isWellKnownMethod) {
+    addAttribute(span.attributes, HTTP_REQUEST_METHOD_ORIGINAL, originalMethod);
+  }
+
+  const propagatorTypes = determinePropagatorTypes(url);
+  const shouldSetCorrelationHeaders = propagatorTypes.length > 0;
+  if (shouldSetCorrelationHeaders) {
+    if (copyOfInit?.headers) {
+      // ensure we have a unified container for the headers
+      copyOfInit.headers = new Headers(copyOfInit.headers);
+      addTraceContextHttpHeaders(copyOfInit.headers.append, copyOfInit.headers, span, propagatorTypes);
+    } else if (input instanceof Request) {
+      addTraceContextHttpHeaders(request.headers.append, request.headers, span, propagatorTypes);
+    } else {
+      if (!copyOfInit) {
+        copyOfInit = {};
+      }
+      copyOfInit.headers = new Headers();
+      addTraceContextHttpHeaders(copyOfInit.headers.append, copyOfInit.headers, span, propagatorTypes);
+    }
+  }
+
+  tryCaptureHttpHeaders(request.headers, span, (k) => httpRequestHeaderKey(k));
+
+  const performanceObserver = observeResourcePerformance({
+    // We match on both fetch and XHR here to support polyfills
+    resourceMatcher: ({ initiatorType, name }) =>
+      (initiatorType === "fetch" || initiatorType === "xmlhttprequest") && name === parseUrl(url).href,
+    maxWaitForResourceMillis: vars.maxWaitForResourceTimingsMillis,
+    maxToleranceForResourceTimingsMillis: vars.maxToleranceForResourceTimingsMillis,
+    onEnd: ({ duration, resource }) => {
+      if (resource) {
+        addResourceNetworkEvents(span, resource);
+        addResourceSize(span, resource);
+      }
+      // duration is millis we need to convert to nanos
+      sendSpan(endSpan(span, undefined, duration * 1000000));
+    },
+  });
+
+  performanceObserver.start();
+
+  return { copyOfInit, span, performanceObserver };
+}
+
 // @ts-expect-error -- WIP
 // eslint-disable-next-line @typescript-eslint/no-unused-vars -- WIP
 function addGraphQlProperties(input: RequestInfo | URL, init?: RequestInit, span: InProgressSpan) {
@@ -182,8 +204,8 @@ function tryCaptureHttpHeaders(headers: Headers, span: InProgressSpan, getAttrib
         addAttribute(span.attributes, getAttributeKey(key), value);
       }
     });
-  } catch (_e) {
-    debug("unable to capture http headers due to CORS policy");
+  } catch (e) {
+    debug("unable to capture http headers", e);
   }
 }
 
@@ -281,67 +303,6 @@ function wrapResponse(
   });
 }
 
-function endSpanOnError(span: InProgressSpan, error: Exception) {
-  recordException(span, error);
-  sendSpan(endSpan(span, errorToSpanStatus(error), undefined));
-}
-
-function endSpanOnAbort(span: InProgressSpan) {
-  addAttribute(span.attributes, WEB_REQUEST_CANCELLED, true);
-  sendSpan(endSpan(span, undefined, undefined));
-}
-
-function determinePropagatorTypes(url: string): PropagatorType[] {
-  const matchingTypes: PropagatorType[] = [];
-  const isUrlSameOrigin = isSameOrigin(url);
-
-  // For same-origin requests, always include traceparent + all configured propagators
-  if (isUrlSameOrigin) {
-    // Always add traceparent for same-origin requests
-    matchingTypes.push("traceparent");
-
-    // Add all other configured propagator types for same-origin requests
-    if (vars.propagators) {
-      for (const propagator of vars.propagators) {
-        if (propagator.type !== "traceparent" && !matchingTypes.includes(propagator.type)) {
-          matchingTypes.push(propagator.type);
-        }
-      }
-    }
-    return matchingTypes;
-  }
-
-  // For cross-origin requests, use new propagators config if available
-  if (vars.propagators) {
-    for (const propagator of vars.propagators) {
-      if (matchesAny(propagator.match, url)) {
-        // Avoid duplicates
-        if (!matchingTypes.includes(propagator.type)) {
-          matchingTypes.push(propagator.type);
-        }
-      }
-    }
-    return matchingTypes;
-  }
-
-  return [];
-}
-
-function addTraceContextHttpHeaders(
-  fn: (name: string, value: string) => void,
-  ctx: unknown,
-  span: InProgressSpan,
-  types: PropagatorType[]
-) {
-  for (const type of types) {
-    if (type === "xray") {
-      addXRayTraceContextHttpHeaders(fn, ctx, span);
-    } else {
-      addW3CTraceContextHttpHeaders(fn, ctx, span);
-    }
-  }
-}
-
 function responseCanHaveBody(response: Response) {
   const status = response.status;
   return status >= 200 && status != 204 && status != 205 && status != 304;