@dash0/sdk-web 0.16.0 → 0.16.2

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, 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";
@@ -83,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();
@@ -146,20 +141,81 @@ 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;
+    // For some reason browsers return a response body on responses that can't be constructed with one. In that case we can't wrap the body stream
+    if (!body || !responseCanHaveBody(originalResponse)) {
+        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) {
@@ -207,3 +263,7 @@ function addTraceContextHttpHeaders(fn, ctx, span, types) {
         }
     }
 }
+function responseCanHaveBody(response) {
+    const status = response.status;
+    return status >= 200 && status != 204 && status != 205 && status != 304;
+}

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/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())