@dash0/sdk-web 0.15.0 → 0.16.1

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

@@ -39,6 +39,8 @@ function sendLogs(logs) {
     });
 }
 export function sendSpan(span) {
+    if (!span)
+        return;
     if (isRateLimited()) {
         debug("Transport rate limit. Will not send item.", span);
         return;

package/dist/modules/utils/index.js

@@ -8,6 +8,7 @@ export * from "./local-storage";
 export * from "./performance";
 export * from "./rate-limit";
 export * from "./time";
+export * from "./timers";
 export * from "./constants";
 export * from "./math";
 export * from "./origin";

package/dist/modules/utils/otel/span.js

@@ -4,6 +4,7 @@ import { sessionId } from "../../api/session";
 import { generateTraceId } from "../trace-id";
 import { generateSpanId } from "../span-id";
 import { addAttribute } from "./attributes";
+import { debug } from "../debug";
 export function startSpan(name) {
     const traceId = generateTraceId(sessionId);
     const spanId = generateSpanId(traceId);
@@ -23,9 +24,17 @@ export function startSpan(name) {
         status: { code: SPAN_STATUS_UNSET },
     };
 }
+/**
+ * Ends the span by setting status and endTimeUnixNano on it. If the spand was already previously ended, this returns undefined
+ * to prevent the span from being ended multiple times on accident.
+ */
 export function endSpan(span, status, durationNano) {
     // We cast here to avoid having to instantiate a copy of the span
     const s = span;
+    if (s.endTimeUnixNano) {
+        debug("Attempting to end already ended span. Dropping...", s);
+        return undefined;
+    }
     if (status) {
         s.status = status;
     }

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/performance.js

@@ -6,6 +6,7 @@ import { addEventListener, removeEventListener } from "./listeners";
 const TEN_MINUTES_IN_MILLIS = 1000 * 60 * 10;
 const ONE_DAY_IN_MILLIS = 1000 * 60 * 60 * 24;
 const OBSERVER_WAIT_TIME_MS = 300;
+const MAX_RESOURCES_ENTRIES = 100;
 export const isResourceTimingAvailable = !!(perf && perf.getEntriesByType);
 export const isPerformanceObserverAvailable = perf && typeof win["PerformanceObserver"] === "function" && typeof perf["now"] === "function";
 export const PerformanceTimingNames = Object.freeze({
@@ -69,8 +70,11 @@ export function observeResourcePerformance(opts) {
         }
         fallbackEndNeverCalledTimerHandle = setTimeout(disposeGlobalResources, TEN_MINUTES_IN_MILLIS);
     }
-    function onEnd() {
-        endTime = perf.now();
+    function onEnd(endTs) {
+        // If endTime is already set, we are already terminating and should not do so again
+        if (endTime)
+            return;
+        endTime = endTs ?? perf.now();
         cancelFallbackEndNeverCalledTimer();
         if (!isWaitingAcceptable()) {
             return end();
@@ -101,7 +105,16 @@ export function observeResourcePerformance(opts) {
             const entry = e;
             return entry.startTime >= startTime && opts.resourceMatcher(entry);
         })
-            .forEach((entry) => resources.push(entry));
+            .forEach((entry) => {
+            // Limit array size to prevent memory leaks on high-traffic pages
+            if (resources.length >= MAX_RESOURCES_ENTRIES) {
+                // Remove oldest entry (FIFO)
+                // Timings are only reported once the resource is fully recorded (i.e. the request has ended), so timings ending
+                // way before the `onEnd` is called are less likely to be good matches and we can ignore them.
+                resources.shift();
+            }
+            resources.push(entry);
+        });
     }
     function onVisibilityChanged() {
         if (!isWaitingAcceptable())