@dash0/sdk-web 0.14.1 → 0.16.0

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/instrumentations/http/fetch.js

@@ -1,6 +1,6 @@
 import { debug, observeResourcePerformance, win } 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";
@@ -47,22 +47,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));
@@ -165,3 +166,44 @@ 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();
+    });
+});

package/dist/modules/instrumentations/http/propagator-integration_test.js

@@ -0,0 +1,77 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { addW3CTraceContextHttpHeaders, addXRayTraceContextHttpHeaders } from "../../utils/otel/trace-context";
+describe("Multiple propagator integration", () => {
+    let headers;
+    let mockAppend;
+    let mockSpan;
+    beforeEach(() => {
+        headers = {};
+        mockAppend = (name, value) => {
+            headers[name] = value;
+        };
+        mockSpan = {
+            traceId: "4efaaf4d1e8720b39541901950019ee5",
+            spanId: "53995c3f42cd8ad8",
+            attributes: [],
+        };
+    });
+    it("should add both W3C traceparent and X-Ray headers when both propagators match", () => {
+        // Simulate what happens when both propagator types are matched
+        const propagatorTypes = ["traceparent", "xray"];
+        // Add headers for each type (this simulates addHeadersBasedOnTypes)
+        for (const type of propagatorTypes) {
+            if (type === "xray") {
+                addXRayTraceContextHttpHeaders(mockAppend, {}, mockSpan);
+            }
+            else if (type === "traceparent") {
+                addW3CTraceContextHttpHeaders(mockAppend, {}, mockSpan);
+            }
+        }
+        // Verify both headers were added
+        expect(headers).toHaveProperty("traceparent");
+        expect(headers).toHaveProperty("X-Amzn-Trace-Id");
+        // Verify header formats
+        expect(headers["traceparent"]).toBe("00-4efaaf4d1e8720b39541901950019ee5-53995c3f42cd8ad8-01");
+        expect(headers["X-Amzn-Trace-Id"]).toBe("Root=1-4efaaf4d-1e8720b39541901950019ee5;Parent=53995c3f42cd8ad8;Sampled=1");
+    });
+    it("should only add W3C header when only traceparent propagator matches", () => {
+        const propagatorTypes = ["traceparent"];
+        for (const type of propagatorTypes) {
+            if (type === "xray") {
+                addXRayTraceContextHttpHeaders(mockAppend, {}, mockSpan);
+            }
+            else if (type === "traceparent") {
+                addW3CTraceContextHttpHeaders(mockAppend, {}, mockSpan);
+            }
+        }
+        expect(headers).toHaveProperty("traceparent");
+        expect(headers).not.toHaveProperty("X-Amzn-Trace-Id");
+    });
+    it("should only add X-Ray header when only xray propagator matches", () => {
+        const propagatorTypes = ["xray"];
+        for (const type of propagatorTypes) {
+            if (type === "xray") {
+                addXRayTraceContextHttpHeaders(mockAppend, {}, mockSpan);
+            }
+            else if (type === "traceparent") {
+                addW3CTraceContextHttpHeaders(mockAppend, {}, mockSpan);
+            }
+        }
+        expect(headers).not.toHaveProperty("traceparent");
+        expect(headers).toHaveProperty("X-Amzn-Trace-Id");
+    });
+    it("should handle Headers object correctly", () => {
+        const headersObj = new Headers();
+        const propagatorTypes = ["traceparent", "xray"];
+        for (const type of propagatorTypes) {
+            if (type === "xray") {
+                addXRayTraceContextHttpHeaders(headersObj.append.bind(headersObj), headersObj, mockSpan);
+            }
+            else if (type === "traceparent") {
+                addW3CTraceContextHttpHeaders(headersObj.append.bind(headersObj), headersObj, mockSpan);
+            }
+        }
+        expect(headersObj.get("traceparent")).toBe("00-4efaaf4d1e8720b39541901950019ee5-53995c3f42cd8ad8-01");
+        expect(headersObj.get("X-Amzn-Trace-Id")).toBe("Root=1-4efaaf4d-1e8720b39541901950019ee5;Parent=53995c3f42cd8ad8;Sampled=1");
+    });
+});

package/dist/modules/transport/index.js

@@ -1,15 +1,13 @@
 import { newBatcher } from "./batcher";
 import { send } from "./fetch";
 import { vars } from "../vars";
-import { createRateLimiter } from "../utils/rate-limit";
-import { debug, error } from "../utils";
+import { debug, error, createRateLimiter } from "../utils";
 const logBatcher = newBatcher(sendLogs);
 const spanBatcher = newBatcher(sendSpans);
 let rateLimiter;
 function isRateLimited() {
     if (!rateLimiter) {
         rateLimiter = createRateLimiter({
-            maxCalls: 8096,
             maxCallsPerTenMinutes: 4096,
             maxCallsPerTenSeconds: 128,
         });

package/dist/modules/utils/otel/trace-context.js

@@ -39,7 +39,7 @@ function getTraceparentFromServerTiming(serverTimings) {
     }
     return "";
 }
-export function addTraceContextHttpHeaders(fn, ctx, span) {
+export function addW3CTraceContextHttpHeaders(fn, ctx, span) {
     /**
      * W3C Traceparent header.
      * General format is ${version}-${trace-id}-${parent-id}-${trace-flags}
@@ -60,3 +60,26 @@ export function addTraceContextHttpHeaders(fn, ctx, span) {
      */
     fn.call(ctx, "traceparent", `00-${span.traceId}-${span.spanId}-01`);
 }
+export function addXRayTraceContextHttpHeaders(fn, ctx, span) {
+    /**
+     * AWS X-Ray trace header.
+     * General format is Root=${trace-id};Parent=${span-id};Sampled=${sampling-flag}
+     *
+     * Converts W3C trace ID format to X-Ray format:
+     * W3C: 4efaaf4d1e8720b39541901950019ee5 (32 hex chars)
+     * X-Ray: 1-4efaaf4d-1e8720b39541901950019ee5 (1-{8chars}-{24chars})
+     *
+     * References:
+     * https://docs.aws.amazon.com/xray/latest/devguide/xray-concepts.html#xray-concepts-tracingheader
+     */
+    const xrayTraceId = convertW3CTraceIdToXRay(span.traceId);
+    const xrayHeader = `Root=${xrayTraceId};Parent=${span.spanId};Sampled=1`;
+    fn.call(ctx, "X-Amzn-Trace-Id", xrayHeader);
+}
+function convertW3CTraceIdToXRay(w3cTraceId) {
+    // X-Ray trace ID format: 1-{timestamp}-{unique-id}
+    // Split the 32-char W3C trace ID into 8-char timestamp and 24-char unique ID
+    const timestamp = w3cTraceId.substring(0, 8);
+    const uniqueId = w3cTraceId.substring(8, 32);
+    return `1-${timestamp}-${uniqueId}`;
+}

package/dist/modules/utils/otel/trace-context_test.js

@@ -0,0 +1,40 @@
+import { describe, it, expect } from "vitest";
+import { addXRayTraceContextHttpHeaders } from "./trace-context";
+describe("X-Ray trace context", () => {
+    it("should generate X-Ray header with correct format", () => {
+        const span = {
+            traceId: "4efaaf4d1e8720b39541901950019ee5",
+            spanId: "53995c3f42cd8ad8",
+        };
+        const headers = {};
+        const mockAppend = (name, value) => {
+            headers[name] = value;
+        };
+        addXRayTraceContextHttpHeaders(mockAppend, {}, span);
+        expect(headers["X-Amzn-Trace-Id"]).toBe("Root=1-4efaaf4d-1e8720b39541901950019ee5;Parent=53995c3f42cd8ad8;Sampled=1");
+    });
+    it("should convert W3C trace ID to X-Ray format correctly", () => {
+        const span = {
+            traceId: "5759e988bd862e3fe1be46a994272793",
+            spanId: "53995c3f42cd8ad8",
+        };
+        const headers = {};
+        const mockAppend = (name, value) => {
+            headers[name] = value;
+        };
+        addXRayTraceContextHttpHeaders(mockAppend, {}, span);
+        expect(headers["X-Amzn-Trace-Id"]).toBe("Root=1-5759e988-bd862e3fe1be46a994272793;Parent=53995c3f42cd8ad8;Sampled=1");
+    });
+    it("should handle different span IDs", () => {
+        const span = {
+            traceId: "4efaaf4d1e8720b39541901950019ee5",
+            spanId: "1234567890abcdef",
+        };
+        const headers = {};
+        const mockAppend = (name, value) => {
+            headers[name] = value;
+        };
+        addXRayTraceContextHttpHeaders(mockAppend, {}, span);
+        expect(headers["X-Amzn-Trace-Id"]).toBe("Root=1-4efaaf4d-1e8720b39541901950019ee5;Parent=1234567890abcdef;Sampled=1");
+    });
+});

package/dist/modules/utils/rate-limit.js

@@ -1,9 +1,7 @@
 import { setInterval } from "./timers";
 export function createRateLimiter(opts) {
-    const maxCalls = opts.maxCalls || 4096;
     const maxCallsPerTenMinutes = opts.maxCallsPerTenMinutes || 128;
     const maxCallsPerTenSeconds = opts.maxCallsPerTenSeconds || 32;
-    let totalCalls = 0;
     let totalCallsInLastTenMinutes = 0;
     let totalCallsInLastTenSeconds = 0;
     setInterval(function () {
@@ -13,8 +11,6 @@ export function createRateLimiter(opts) {
         totalCallsInLastTenSeconds = 0;
     }, 1000 * 10);
     return function isExcessiveUsage() {
-        return (++totalCalls > maxCalls ||
-            ++totalCallsInLastTenMinutes > maxCallsPerTenMinutes ||
-            ++totalCallsInLastTenSeconds > maxCallsPerTenSeconds);
+        return ++totalCallsInLastTenMinutes > maxCallsPerTenMinutes || ++totalCallsInLastTenSeconds > maxCallsPerTenSeconds;
     };
 }