@dash0/sdk-web 0.13.1 → 0.13.3

package/dist/modules/api/log-level.js

@@ -0,0 +1 @@
+export { setActiveLogLevel } from "../utils/debug";

package/dist/modules/entrypoint/npm-package.js

@@ -4,6 +4,7 @@ export * from "../api/identify";
 export * from "../api/debug";
 export * from "../api/attributes";
 export * from "../api/events";
+export * from "../api/log-level";
 export { terminateSession } from "../api/session";
 export { reportError } from "../api/report-error";
 export function init(opts) {

package/dist/modules/entrypoint/script.js

@@ -6,6 +6,7 @@ import { init as initApi } from "../api/init";
 import { terminateSession } from "../api/session";
 import { addSignalAttribute, removeSignalAttribute } from "../api/attributes";
 import { sendEvent } from "../api/events";
+import { setActiveLogLevel } from "../api/log-level";
 /**
  * All the APIs exposed through the script tag via `dash0('{{api name}}')`
  */
@@ -17,6 +18,7 @@ const scriptApis = {
     reportError,
     addSignalAttribute,
     removeSignalAttribute,
+    setActiveLogLevel,
     sendEvent,
 };
 init();

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

@@ -1,7 +1,7 @@
 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 { HTTP_REQUEST_METHOD, HTTP_REQUEST_METHOD_ORIGINAL, HTTP_RESPONSE_STATUS_CODE, SPAN_STATUS_ERROR, SPAN_STATUS_UNSET, } from "../../semantic-conventions";
+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";
@@ -138,7 +138,10 @@ function tryCaptureHttpHeaders(headers, span, getAttributeKey) {
 }
 function addResponseData(span, response) {
     const status = response.status;
-    setSpanStatus(span, status >= 200 && status < 400 ? SPAN_STATUS_UNSET : SPAN_STATUS_ERROR, response.statusText);
+    setSpanStatus(span, status >= 200 && status < 400 ? SPAN_STATUS_UNSET : SPAN_STATUS_ERROR);
+    if (status === 0) {
+        addAttribute(span.attributes, ERROR_TYPE, response.type);
+    }
     addAttribute(span.attributes, HTTP_RESPONSE_STATUS_CODE, String(status));
     tryCaptureHttpHeaders(response.headers, span, (k) => httpResponseHeaderKey(k));
 }

package/dist/modules/semantic-conventions.js

@@ -27,6 +27,8 @@ export const USER_ROLES = "user.roles";
 export const EXCEPTION_MESSAGE = "exception.message";
 export const EXCEPTION_TYPE = "exception.type";
 export const EXCEPTION_STACKTRACE = "exception.stacktrace";
+// Error Attribute Keys
+export const ERROR_TYPE = "error.type";
 // URL Attribute Keys
 export const URL_DOMAIN = "url.domain";
 export const URL_FRAGMENT = "url.fragment";

package/dist/modules/transport/fetch.js

@@ -1,7 +1,8 @@
 import { vars } from "../vars";
-import { noop, warn, fetch } from "../utils";
+import { noop, warn, fetch, debug } from "../utils";
 const BEACON_BODY_SIZE_LIMIT = 60000;
 export async function send(path, body) {
+    debug("Transmitting telemetry to endpoints", body);
     const jsonString = JSON.stringify(body);
     let requestBody = jsonString;
     let byteLength = jsonString.length;

package/dist/modules/utils/debug.js

@@ -1,19 +1,29 @@
 import { noop } from "./fn";
-export const log = createLogger("log");
+const logLevels = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+let activeLogLevel = logLevels.warn;
+/**
+ * Changes the logging verbosity of Dash0's web SDK. By default, only warnings and errors are logged.
+ */
+export function setActiveLogLevel(level) {
+    activeLogLevel = logLevels[level] ?? logLevels.warn;
+}
 export const info = createLogger("info");
 export const warn = createLogger("warn");
 export const error = createLogger("error");
 export const debug = createLogger("debug");
-function createLogger(method) {
-    if (typeof console === "undefined" || typeof console.log !== "function" || typeof console.log.apply !== "function") {
-        return noop;
-    }
-    if (console[method] && typeof console[method].apply === "function") {
+function createLogger(logLevel) {
+    if (typeof console !== "undefined" && console[logLevel] && typeof console[logLevel].apply === "function") {
+        const numericLogLevel = logLevels[logLevel];
         return function () {
-            console[method].apply(console, arguments);
+            if (numericLogLevel >= activeLogLevel) {
+                console[logLevel].apply(console, arguments);
+            }
         };
     }
-    return function () {
-        console.log.apply(console, arguments);
-    };
+    return noop;
 }

package/dist/modules/utils/performance.js

@@ -5,6 +5,7 @@ import { setTimeout } from "./timers";
 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;
 export const isResourceTimingAvailable = !!(perf && perf.getEntriesByType);
 export const isPerformanceObserverAvailable = perf && typeof win["PerformanceObserver"] === "function" && typeof perf["now"] === "function";
 export const PerformanceTimingNames = Object.freeze({
@@ -32,13 +33,14 @@ export const PerformanceTimingNames = Object.freeze({
     UNLOAD_EVENT_END: "unloadEventEnd",
     UNLOAD_EVENT_START: "unloadEventStart",
 });
+const usedResources = new WeakSet();
 export function observeResourcePerformance(opts) {
     if (!isPerformanceObserverAvailable)
         return observeWithoutPerformanceObserverSupport(opts.onEnd);
     // Used to calculate the duration when no resource was found.
     let startTime;
     let endTime;
-    let resource;
+    const resources = [];
     // Global resources that will need to be disposed
     let observer;
     let fallbackNoResourceFoundTimerHandle;
@@ -70,40 +72,36 @@ export function observeResourcePerformance(opts) {
     function onEnd() {
         endTime = perf.now();
         cancelFallbackEndNeverCalledTimer();
-        if (resource || !isWaitingAcceptable()) {
-            end();
-        }
-        else {
-            addEventListener(doc, "visibilitychange", onVisibilityChanged);
-            fallbackNoResourceFoundTimerHandle = setTimeout(end, opts.maxWaitForResourceMillis);
+        if (!isWaitingAcceptable()) {
+            return end();
         }
+        setTimeout(() => end(), Math.min(OBSERVER_WAIT_TIME_MS, opts.maxWaitForResourceMillis));
+        addEventListener(doc, "visibilitychange", onVisibilityChanged);
+        fallbackNoResourceFoundTimerHandle = setTimeout(end, opts.maxWaitForResourceMillis);
     }
     function end() {
         disposeGlobalResources();
+        const resource = findBestMatchingResource();
         // In some old web browsers, e.g. Chrome 31, the value provided as the duration
         // can be very wrong. We have seen cases where this value is measured in years.
         // If this does seem be the case, then we will ignore the duration property and
         // instead prefer our approximation.
         if (resource?.duration && resource.duration < ONE_DAY_IN_MILLIS) {
-            opts.onEnd({ resource, duration: Math.round(resource.duration) });
+            opts.onEnd({ resource, duration: resource.duration });
         }
         else {
-            opts.onEnd({ resource, duration: Math.round(endTime - startTime) });
+            opts.onEnd({ resource, duration: endTime - startTime });
         }
     }
     function onResourceFound(list) {
-        const r = list.getEntriesByType("resource").find((e) => {
+        list
+            .getEntriesByType("resource")
+            .filter((e) => {
             // This polymorphism is not properly represented in the api types. The cast is safe since we're only accessing the resource timings.
             const entry = e;
-            return (entry.startTime >= startTime &&
-                (!endTime || endTime + opts.maxToleranceForResourceTimingsMillis >= entry.responseEnd) &&
-                opts.resourceMatcher(entry));
-        });
-        if (!r)
-            return;
-        resource = r;
-        if (endTime)
-            end();
+            return entry.startTime >= startTime && opts.resourceMatcher(entry);
+        })
+            .forEach((entry) => resources.push(entry));
     }
     function onVisibilityChanged() {
         if (!isWaitingAcceptable())
@@ -143,6 +141,32 @@ export function observeResourcePerformance(opts) {
             return;
         removeEventListener(doc, "visibilitychange", onVisibilityChanged);
     }
+    function findBestMatchingResource() {
+        if (!resources.length)
+            return undefined;
+        let bestMatch;
+        const matchingResources = resources.filter((res) => res.responseEnd <= endTime + opts.maxToleranceForResourceTimingsMillis && !usedResources.has(res));
+        if (!matchingResources.length) {
+            return undefined;
+        }
+        if (matchingResources.length === 1) {
+            bestMatch = matchingResources[0];
+        }
+        let bestScore;
+        if (!bestMatch) {
+            for (const res of matchingResources) {
+                const score = Math.abs(endTime - startTime - res.duration) + Math.abs(res.responseEnd - endTime);
+                if (bestScore === undefined || score < bestScore) {
+                    bestScore = score;
+                    bestMatch = res;
+                }
+            }
+        }
+        if (!bestMatch)
+            return;
+        usedResources.add(bestMatch);
+        return bestMatch;
+    }
 }
 // We may only wait for resource data to arrive as long as the document is visible or in the process
 // of becoming visible. In all other cases we might lose data when waiting, e.g. when the document

package/dist/modules/vars.js

@@ -16,7 +16,7 @@ export const vars = {
     wrapTimers: true,
     propagateTraceHeadersCorsURLs: [],
     maxWaitForResourceTimingsMillis: 10000,
-    maxToleranceForResourceTimingsMillis: 3000,
+    maxToleranceForResourceTimingsMillis: 50,
     headersToCapture: [],
     pageViewInstrumentation: {
         trackVirtualPageViews: true,