@dash0/sdk-web 0.15.0 → 0.16.1

package/dist/modules/api/init.js

@@ -40,6 +40,7 @@ export function init(opts) {
         "urlAttributeScrubber",
         "pageViewInstrumentation",
     ])));
+    initializePropagators(opts);
     initializeResourceAttributes(opts);
     initializeSignalAttributes(opts);
     initializeTabId();
@@ -137,6 +138,35 @@ function detectDeploymentId(opts) {
         return undefined;
     }
 }
+function initializePropagators(opts) {
+    if (opts.propagators) {
+        if (opts.propagateTraceHeadersCorsURLs) {
+            warn("Both 'propagators' and deprecated 'propagateTraceHeadersCorsURLs' were provided. Using 'propagators' configuration. Please migrate to the new 'propagators' config.");
+        }
+        vars.propagators = opts.propagators;
+    }
+    // Handle legacy configuration
+    else if (opts.propagateTraceHeadersCorsURLs && opts.propagateTraceHeadersCorsURLs.length > 0) {
+        warn("'propagateTraceHeadersCorsURLs' is deprecated. Please use the new 'propagators' configuration.");
+        // Convert legacy config to new format - only include cross-origin URLs since same-origin is automatic
+        vars.propagators = [
+            {
+                type: "traceparent",
+                match: [...opts.propagateTraceHeadersCorsURLs],
+            },
+        ];
+    }
+    // Default configuration - traceparent with empty match array
+    // Same-origin requests get ALL configured propagators, so this ensures traceparent for same-origin
+    else {
+        vars.propagators = [
+            {
+                type: "traceparent",
+                match: [],
+            },
+        ];
+    }
+}
 function isInstrumentationEnabled(name, opts) {
     const instrumentations = opts.enabledInstrumentations;
     if (!instrumentations)

package/dist/modules/api/init_test.js

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 // Mock all the instrumentation modules
 vi.mock("../instrumentations/web-vitals", () => ({
     startWebVitalsInstrumentation: vi.fn(),
@@ -12,26 +12,34 @@ vi.mock("../instrumentations/http/fetch", () => ({
 vi.mock("../instrumentations/navigation", () => ({
     startNavigationInstrumentation: vi.fn(),
 }));
-import { startWebVitalsInstrumentation } from "../instrumentations/web-vitals";
 import { startErrorInstrumentation } from "../instrumentations/errors";
 import { instrumentFetch } from "../instrumentations/http/fetch";
 import { startNavigationInstrumentation } from "../instrumentations/navigation";
+import { startWebVitalsInstrumentation } from "../instrumentations/web-vitals";
 describe("init", () => {
     const baseOptions = {
         serviceName: "test-service",
         endpoint: { url: "https://test-endpoint.com", authToken: "invalid" },
     };
-    beforeEach(() => {
+    let vars;
+    let init;
+    beforeEach(async () => {
         vi.clearAllMocks();
         // Reset the hasBeenInitialised flag by re-importing the module
         vi.resetModules();
+        // Reset vars state after module reset
+        // since init itself needs vars, this needs to imported again as well.
+        // Otherwise the tests that make assumptions on the vars fail because they use a different reference.
+        const { vars: importedVars } = await import("../vars");
+        const { init: importedInit } = await import("./init");
+        vars = importedVars;
+        init = importedInit;
     });
     afterEach(() => {
         vi.clearAllMocks();
     });
     describe("instrumentation enablement", () => {
         it("should enable all instrumentations when enabledInstrumentations is undefined", async () => {
-            const { init } = await import("./init");
             init({
                 ...baseOptions,
                 enabledInstrumentations: undefined,
@@ -55,7 +63,6 @@ describe("init", () => {
         };
         instrumentations.forEach((instrumentation) => {
             it(`should enable ${instrumentation} instrumentation when present in enabledInstrumentations array`, async () => {
-                const { init } = await import("./init");
                 init({
                     ...baseOptions,
                     enabledInstrumentations: [instrumentation],
@@ -69,7 +76,6 @@ describe("init", () => {
                 });
             });
             it(`should not enable ${instrumentation} instrumentation when not present in enabledInstrumentations array`, async () => {
-                const { init } = await import("./init");
                 const otherInstrumentations = instrumentations.filter((i) => i !== instrumentation);
                 init({
                     ...baseOptions,
@@ -83,4 +89,94 @@ describe("init", () => {
             });
         });
     });
+    describe("propagator configuration", () => {
+        it("should set propagators configuration when provided", async () => {
+            const propagators = [
+                { type: "traceparent", match: [/.*\/api\/.*/] },
+                { type: "xray", match: [/.*\.amazonaws\.com.*/] },
+            ];
+            init({
+                ...baseOptions,
+                propagators,
+            });
+            expect(vars.propagators).toEqual(propagators);
+        });
+        it("should warn when both propagators and legacy config are provided", async () => {
+            const spyOnWarn = vi.spyOn(console, "warn");
+            const propagators = [{ type: "traceparent", match: [/.*\/api\/.*/] }];
+            init({
+                ...baseOptions,
+                propagators,
+                propagateTraceHeadersCorsURLs: [/.*\.example\.com.*/],
+            });
+            expect(spyOnWarn).toHaveBeenCalledWith("Both 'propagators' and deprecated 'propagateTraceHeadersCorsURLs' were provided. Using 'propagators' configuration. Please migrate to the new 'propagators' config.");
+            expect(vars.propagators).toEqual(propagators);
+        });
+        it("should convert legacy config to new format with deprecation warning", async () => {
+            const spyOnWarn = vi.spyOn(console, "warn");
+            const legacyConfig = [/.*\.example\.com.*/, /.*\.test\.com.*/];
+            init({
+                ...baseOptions,
+                propagateTraceHeadersCorsURLs: legacyConfig,
+            });
+            expect(spyOnWarn).toHaveBeenCalledWith("'propagateTraceHeadersCorsURLs' is deprecated. Please use the new 'propagators' configuration.");
+            expect(vars.propagators).toEqual([
+                {
+                    type: "traceparent",
+                    match: [...legacyConfig],
+                },
+            ]);
+        });
+        it("should set default propagators when no configuration is provided", async () => {
+            init(baseOptions);
+            expect(vars.propagators).toEqual([
+                {
+                    type: "traceparent",
+                    match: [],
+                },
+            ]);
+        });
+        it("should not convert empty legacy config", async () => {
+            const spyOnWarn = vi.spyOn(console, "warn");
+            init({
+                ...baseOptions,
+                propagateTraceHeadersCorsURLs: [],
+            });
+            expect(spyOnWarn).not.toHaveBeenCalled();
+            expect(vars.propagators).toEqual([
+                {
+                    type: "traceparent",
+                    match: [],
+                },
+            ]);
+        });
+        it("should handle mixed pattern types in propagators", async () => {
+            const spyOnWarn = vi.spyOn(console, "warn");
+            const propagators = [
+                {
+                    type: "traceparent",
+                    match: [/.*\/api\/.*/],
+                },
+                {
+                    type: "xray",
+                    match: [/.*\.amazonaws\.com.*/, /.*\.aws\.com.*/],
+                },
+            ];
+            init({
+                ...baseOptions,
+                propagators,
+            });
+            expect(vars.propagators).toEqual(propagators);
+            expect(spyOnWarn).not.toHaveBeenCalled();
+        });
+        it("should handle empty propagators array", async () => {
+            const spyOnWarn = vi.spyOn(console, "warn");
+            init({
+                ...baseOptions,
+                propagators: [],
+            });
+            expect(vars.propagators).toEqual([]);
+            expect(spyOnWarn).not.toHaveBeenCalled();
+        });
+    });
 });

package/dist/modules/api/report-error.js

@@ -1,4 +1,4 @@
-import { reportError as reportErrorInternal } from "../instrumentations/errors/unhandled-error";
+import { reportUnhandledError as reportErrorInternal } from "../instrumentations/errors/unhandled-error";
 export function reportError(error, opts) {
     reportErrorInternal(error, opts);
 }

package/dist/modules/instrumentations/errors/event-handlers.js

@@ -1,7 +1,7 @@
 import { vars } from "../../vars";
 import { win } from "../../utils";
 import { addWrappedDomEventListener, popWrappedDomEventListener, } from "./async-function-wrapping";
-import { ignoreNextOnErrorEvent } from "./unhandled-error";
+import { ignoreNextOnErrorEvent, reportUnhandledError } from "./unhandled-error";
 export function startEventHandlerInstrumentation() {
     if (vars.wrapEventHandlers) {
         wrapEventTarget(win?.EventTarget);
@@ -29,7 +29,7 @@ function wrapEventTarget(EventTarget) {
                 return fn.apply(this, arguments);
             }
             catch (e) {
-                reportError(e);
+                reportUnhandledError(e);
                 ignoreNextOnErrorEvent();
                 throw e;
             }

package/dist/modules/instrumentations/errors/unhandled-error.js

@@ -44,7 +44,7 @@ export function startOnErrorInstrumentation() {
         }
     };
 }
-export function reportError(error, opts) {
+export function reportUnhandledError(error, opts) {
     if (!error) {
         return;
     }

package/dist/modules/instrumentations/errors/unhandled-promise-rejection.js

@@ -1,5 +1,5 @@
 import { win } from "../../utils";
-import { reportError } from "./unhandled-error";
+import { reportUnhandledError } from "./unhandled-error";
 const MESSAGE_PREFIX = "Unhandled promise rejection: ";
 const STACK_UNAVAILABLE_MESSAGE = "<unavailable because Promise wasn't rejected with an Error object>";
 export function startUnhandledRejectionInstrumentation() {
@@ -9,19 +9,19 @@ export function startUnhandledRejectionInstrumentation() {
 }
 export function onUnhandledRejection(event) {
     if (event.reason == null) {
-        reportError({
+        reportUnhandledError({
             message: MESSAGE_PREFIX + "<no reason defined>",
             stack: STACK_UNAVAILABLE_MESSAGE,
         });
     }
     else if (typeof event.reason.message === "string") {
-        reportError({
+        reportUnhandledError({
             message: MESSAGE_PREFIX + event.reason.message,
             stack: typeof event.reason.stack === "string" ? event.reason.stack : STACK_UNAVAILABLE_MESSAGE,
         });
     }
     else if (typeof event.reason !== "object") {
-        reportError({
+        reportUnhandledError({
             message: MESSAGE_PREFIX + event.reason,
             stack: STACK_UNAVAILABLE_MESSAGE,
         });

package/dist/modules/instrumentations/http/fetch.js

@@ -1,8 +1,7 @@
-import { debug, observeResourcePerformance, win } from "../../utils";
+import { debug, observeResourcePerformance, perf, win, setTimeout, isSameOrigin, wrap, parseUrl } from "../../utils";
 import { isUrlIgnored, matchesAny } from "../../utils/ignore-rules";
-import { addAttribute, setSpanStatus, addTraceContextHttpHeaders, endSpan, errorToSpanStatus, recordException, startSpan, } from "../../utils/otel";
+import { addAttribute, setSpanStatus, addW3CTraceContextHttpHeaders, addXRayTraceContextHttpHeaders, endSpan, errorToSpanStatus, recordException, startSpan, } from "../../utils/otel";
 import { ERROR_TYPE, HTTP_REQUEST_METHOD, HTTP_REQUEST_METHOD_ORIGINAL, HTTP_RESPONSE_STATUS_CODE, SPAN_STATUS_ERROR, SPAN_STATUS_UNSET, } from "../../semantic-conventions";
-import { isSameOrigin, wrap, parseUrl } from "../../utils";
 import { vars } from "../../vars";
 import { httpRequestHeaderKey, httpResponseHeaderKey } from "../../utils/otel/http";
 import { sendSpan } from "../../transport";
@@ -47,22 +46,23 @@ function wrapFetch(original) {
         if (!isWellKnownMethod) {
             addAttribute(span.attributes, HTTP_REQUEST_METHOD_ORIGINAL, originalMethod);
         }
-        const shouldSetCorrelationHeaders = isSameOrigin(url) || matchesAny(vars.propagateTraceHeadersCorsURLs, url);
+        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);
+                addTraceContextHttpHeaders(copyOfInit.headers.append, copyOfInit.headers, span, propagatorTypes);
             }
             else if (input instanceof Request) {
-                addTraceContextHttpHeaders(request.headers.append, request.headers, span);
+                addTraceContextHttpHeaders(request.headers.append, request.headers, span, propagatorTypes);
             }
             else {
                 if (!copyOfInit) {
                     copyOfInit = {};
                 }
                 copyOfInit.headers = new Headers();
-                addTraceContextHttpHeaders(copyOfInit.headers.append, copyOfInit.headers, span);
+                addTraceContextHttpHeaders(copyOfInit.headers.append, copyOfInit.headers, span, propagatorTypes);
             }
         }
         tryCaptureHttpHeaders(request.headers, span, (k) => httpRequestHeaderKey(k));
@@ -82,16 +82,12 @@ function wrapFetch(original) {
         });
         performanceObserver.start();
         try {
-            const response = await original(input instanceof Request ? request : input, copyOfInit);
-            addResponseData(span, response);
-            // We use a separate promise here because this needs to happen in parallel to application code consuming the response
-            waitForFullResponse(response)
-                .then(() => performanceObserver.end())
-                .catch((e) => {
+            const origResponse = await original(input instanceof Request ? request : input, copyOfInit);
+            addResponseData(span, origResponse);
+            return wrapResponse(origResponse, vars.maxToleranceForResourceTimingsMillis, () => performanceObserver.end(), (e) => {
                 performanceObserver.cancel();
                 endSpanOnError(span, e);
             });
-            return response;
         }
         catch (e) {
             performanceObserver.cancel();
@@ -145,23 +141,124 @@ function addResponseData(span, response) {
     addAttribute(span.attributes, HTTP_RESPONSE_STATUS_CODE, String(status));
     tryCaptureHttpHeaders(response.headers, span, (k) => httpResponseHeaderKey(k));
 }
-function waitForFullResponse(response) {
-    return new Promise((resolve) => {
-        const clonedResponse = response.clone();
-        const body = clonedResponse.body;
-        if (!body)
-            return resolve();
-        const reader = body.getReader();
-        const read = async () => {
-            const { done } = await reader.read();
-            if (done)
-                return resolve();
-            return read();
-        };
-        return read();
+/**
+ * Wraps the response to be able to detect when it is fully read
+ * @param originalResponse
+ * @param readTimeoutMs Timeout applied between reading of response chunks, if exceeded the response is considered abandoned and onDone is called.
+ * @param onDone Called when the response is completely read or with "fallbackEndTs" when reading timed out.
+ * @param onError
+ */
+function wrapResponse(originalResponse, readTimeoutMs, onDone, onError) {
+    // When the response was wrapped (i.e. first available to js) we use this to replace or find the actual end timestamp
+    // in case the response body is never read by js
+    let fallbackTs = perf.now();
+    const body = originalResponse.body;
+    if (!body) {
+        onDone();
+        return originalResponse;
+    }
+    let cbCalled = false;
+    const handleDone = (fallbackEndTs) => {
+        if (cbCalled)
+            return;
+        onDone(fallbackEndTs);
+        cbCalled = true;
+    };
+    const handleError = (e) => {
+        if (cbCalled)
+            return;
+        onError(e);
+        cbCalled = true;
+    };
+    let bodyNeverCompletelyReadTimeout = setTimeout(() => handleDone(fallbackTs), readTimeoutMs);
+    const reader = body.getReader();
+    const stream = new ReadableStream({
+        async pull(controller) {
+            try {
+                clearTimeout(bodyNeverCompletelyReadTimeout);
+                const { value, done } = await reader.read();
+                if (done) {
+                    reader.releaseLock();
+                    controller.close();
+                    handleDone();
+                }
+                else {
+                    fallbackTs = perf.now();
+                    bodyNeverCompletelyReadTimeout = setTimeout(() => handleDone(fallbackTs), readTimeoutMs);
+                    controller.enqueue(value);
+                }
+            }
+            catch (e) {
+                handleError(e);
+                controller.error(e);
+                try {
+                    reader.releaseLock();
+                }
+                catch {
+                    // Spec reference:
+                    // https://streams.spec.whatwg.org/#default-reader-release-lock
+                    //
+                    // releaseLock() only throws if called on an invalid reader
+                    // (i.e. reader.[[stream]] is undefined, meaning the lock is already released
+                    // or the reader was never associated). In normal use this cannot happen.
+                    // This catch is defensive only.
+                }
+            }
+        },
+        cancel(reason) {
+            clearTimeout(bodyNeverCompletelyReadTimeout);
+            handleDone();
+            return reader.cancel(reason);
+        },
+    });
+    return new Response(stream, {
+        status: originalResponse.status,
+        statusText: originalResponse.statusText,
+        headers: originalResponse.headers,
     });
 }
 function endSpanOnError(span, error) {
     recordException(span, error);
     sendSpan(endSpan(span, errorToSpanStatus(error), undefined));
 }
+function determinePropagatorTypes(url) {
+    const matchingTypes = [];
+    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, ctx, span, types) {
+    for (const type of types) {
+        if (type === "xray") {
+            addXRayTraceContextHttpHeaders(fn, ctx, span);
+        }
+        else {
+            addW3CTraceContextHttpHeaders(fn, ctx, span);
+        }
+    }
+}

package/dist/modules/instrumentations/http/fetch_test.js

@@ -0,0 +1,170 @@
+import { expect, vi, beforeEach, afterEach } from "vitest";
+import { vars } from "../../vars";
+import { instrumentFetch } from "./fetch";
+describe("fetch test", () => {
+    let fetchMock;
+    beforeEach(() => {
+        fetchMock = vi.fn(() => ({
+            ok: false,
+            headers: new Headers(),
+            status: 200,
+            clone: () => ({
+                body: null,
+            }),
+        }));
+        vi.stubGlobal("fetch", fetchMock);
+        vi.stubGlobal("location", { origin: "http://localhost:3000" });
+    });
+    afterEach(() => {
+        vi.resetAllMocks();
+        vars.propagators = undefined;
+    });
+    it("should inject traceparent header for cross-origin requests", async () => {
+        vars.propagators = [
+            {
+                type: "traceparent",
+                match: [new RegExp("http://foo.bar/")],
+            },
+        ];
+        instrumentFetch();
+        // eslint-disable-next-line no-restricted-globals
+        await fetch("http://foo.bar/foo");
+        expect(fetchMock).toHaveBeenCalledOnce();
+        const fetchHeaders = fetchMock.mock.calls[0].at(1).headers;
+        expect(fetchHeaders.get("traceparent")).not.toBeNull();
+    });
+    it("should inject xray header for cross-origin requests", async () => {
+        vars.propagators = [
+            {
+                type: "xray",
+                match: [new RegExp("http://foo.bar/")],
+            },
+        ];
+        instrumentFetch();
+        // eslint-disable-next-line no-restricted-globals
+        await fetch("http://foo.bar/foo");
+        expect(fetchMock).toHaveBeenCalledOnce();
+        const fetchHeaders = fetchMock.mock.calls[0].at(1).headers;
+        expect(fetchHeaders.get("X-Amzn-Trace-Id")).not.toBeNull();
+    });
+    it("should inject both headers for cross-origin requests when both match", async () => {
+        vars.propagators = [
+            {
+                type: "traceparent",
+                match: [new RegExp("http://foo.bar/")],
+            },
+            {
+                type: "xray",
+                match: [new RegExp("http://foo.bar/")],
+            },
+        ];
+        instrumentFetch();
+        // eslint-disable-next-line no-restricted-globals
+        await fetch("http://foo.bar/foo");
+        expect(fetchMock).toHaveBeenCalledOnce();
+        const fetchHeaders = fetchMock.mock.calls[0].at(1).headers;
+        expect(fetchHeaders.get("X-Amzn-Trace-Id")).not.toBeNull();
+        expect(fetchHeaders.get("traceparent")).not.toBeNull();
+    });
+    it("should inject no headers for non-matching cross-origin requests", async () => {
+        vars.propagators = [];
+        instrumentFetch();
+        // eslint-disable-next-line no-restricted-globals
+        await fetch("http://foo.bar/foo");
+        expect(fetchMock).toHaveBeenCalledOnce();
+        const expectedHeaders = undefined;
+        expect(fetchMock).toHaveBeenCalledWith("http://foo.bar/foo", expectedHeaders);
+    });
+    // New same-origin behavior tests
+    it("should inject all configured propagator headers for same-origin requests", async () => {
+        vars.propagators = [
+            {
+                type: "traceparent",
+                match: [new RegExp("http://foo.bar/")], // Doesn't match same-origin
+            },
+            {
+                type: "xray",
+                match: [new RegExp("http://baz.com/")], // Doesn't match same-origin
+            },
+        ];
+        instrumentFetch();
+        // Same-origin request
+        // eslint-disable-next-line no-restricted-globals
+        await fetch("http://localhost:3000/api/test");
+        expect(fetchMock).toHaveBeenCalledOnce();
+        const fetchHeaders = fetchMock.mock.calls[0].at(1).headers;
+        // Both headers should be present for same-origin, regardless of match patterns
+        expect(fetchHeaders.get("traceparent")).not.toBeNull();
+        expect(fetchHeaders.get("X-Amzn-Trace-Id")).not.toBeNull();
+    });
+    it("should inject only traceparent for same-origin when only traceparent propagator configured", async () => {
+        vars.propagators = [
+            {
+                type: "traceparent",
+                match: [new RegExp("http://foo.bar/")],
+            },
+        ];
+        instrumentFetch();
+        // Same-origin request
+        // eslint-disable-next-line no-restricted-globals
+        await fetch("http://localhost:3000/api/test");
+        expect(fetchMock).toHaveBeenCalledOnce();
+        const fetchHeaders = fetchMock.mock.calls[0].at(1).headers;
+        expect(fetchHeaders.get("traceparent")).not.toBeNull();
+        expect(fetchHeaders.get("X-Amzn-Trace-Id")).toBeNull();
+    });
+    it("should inject both traceparent and xray for same-origin when only xray propagator configured", async () => {
+        vars.propagators = [
+            {
+                type: "xray",
+                match: [new RegExp("http://foo.bar/")],
+            },
+        ];
+        instrumentFetch();
+        // Same-origin request
+        // eslint-disable-next-line no-restricted-globals
+        await fetch("http://localhost:3000/api/test");
+        expect(fetchMock).toHaveBeenCalledOnce();
+        const fetchHeaders = fetchMock.mock.calls[0].at(1).headers;
+        // Same-origin always gets traceparent + all configured propagator types
+        expect(fetchHeaders.get("traceparent")).not.toBeNull();
+        expect(fetchHeaders.get("X-Amzn-Trace-Id")).not.toBeNull();
+    });
+    it("should inject traceparent for same-origin when default traceparent propagator configured", async () => {
+        vars.propagators = [
+            {
+                type: "traceparent",
+                match: [], // Empty match array - matches no cross-origin URLs but same-origin gets all propagators
+            },
+        ];
+        instrumentFetch();
+        // Same-origin request
+        // eslint-disable-next-line no-restricted-globals
+        await fetch("http://localhost:3000/api/test");
+        expect(fetchMock).toHaveBeenCalledOnce();
+        const fetchHeaders = fetchMock.mock.calls[0].at(1).headers;
+        // Same-origin gets all configured propagator types
+        expect(fetchHeaders.get("traceparent")).not.toBeNull();
+        expect(fetchHeaders.get("X-Amzn-Trace-Id")).toBeNull();
+    });
+    it("should follow cross-origin pattern matching for non-same-origin requests", async () => {
+        vars.propagators = [
+            {
+                type: "traceparent",
+                match: [new RegExp("http://foo.bar/")],
+            },
+            {
+                type: "xray",
+                match: [new RegExp("http://baz.com/")],
+            },
+        ];
+        instrumentFetch();
+        // Cross-origin request that matches only traceparent pattern
+        // eslint-disable-next-line no-restricted-globals
+        await fetch("http://foo.bar/api");
+        expect(fetchMock).toHaveBeenCalledOnce();
+        const fetchHeaders = fetchMock.mock.calls[0].at(1).headers;
+        expect(fetchHeaders.get("traceparent")).not.toBeNull();
+        expect(fetchHeaders.get("X-Amzn-Trace-Id")).toBeNull();
+    });
+});