@dash0/sdk-web 0.6.2

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

@@ -0,0 +1,164 @@
+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 { isSameOrigin, wrap, parseUrl } from "../../utils";
+import { vars } from "../../vars";
+import { httpRequestHeaderKey, httpResponseHeaderKey } from "../../utils/otel/http";
+import { sendSpan } from "../../transport";
+import { addResourceNetworkEvents, addResourceSize, HTTP_METHOD_OTHER, isWellKnownHttpMethod } from "./utils";
+import { addCommonAttributes } from "../../attributes";
+export function instrumentFetch() {
+    if (!win || !win.fetch || !win.Request) {
+        debug("Browser does not support the Fetch API, skipping instrumentation");
+        return;
+    }
+    wrap(win, "fetch", wrapFetch);
+}
+// eslint-disable-next-line no-restricted-globals -- only used as type here
+function wrapFetch(original) {
+    return async function fetchWithInstrumentation(input, init) {
+        let copyOfInit = init ? Object.assign({}, init) : init;
+        let body = null;
+        if (copyOfInit?.body) {
+            body = copyOfInit.body;
+            copyOfInit.body = undefined;
+        }
+        const request = new Request(input, copyOfInit);
+        if (body && copyOfInit) {
+            copyOfInit.body = body;
+        }
+        const url = request.url;
+        if (isUrlIgnored(url)) {
+            debug(`Not creating span for fetch call because the url is ignored, URL: ${url}`);
+            return original(input instanceof Request ? request : input, init);
+        }
+        // https://fetch.spec.whatwg.org/#concept-request-method
+        // We'll match methods case insensitive here to make the user experience a bit less painful
+        const originalMethod = request.method ?? "GET";
+        const isWellKnownMethod = isWellKnownHttpMethod(originalMethod);
+        const isWellKnownMethodMatchingLeniently = isWellKnownHttpMethod(originalMethod.toUpperCase());
+        const method = isWellKnownMethodMatchingLeniently ? originalMethod.toUpperCase() : HTTP_METHOD_OTHER;
+        const span = startSpan(`HTTP ${method}`);
+        // The url namespace of a http span has a different meaning than for common rum signals.
+        addCommonAttributes(span.attributes, { url });
+        addGraphQlProperties(input, init, span);
+        addAttribute(span.attributes, HTTP_REQUEST_METHOD, method);
+        if (!isWellKnownMethod) {
+            addAttribute(span.attributes, HTTP_REQUEST_METHOD_ORIGINAL, originalMethod);
+        }
+        const shouldSetCorrelationHeaders = isSameOrigin(url) || matchesAny(vars.propagateTraceHeadersCorsURLs, url);
+        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);
+            }
+            else if (input instanceof Request) {
+                addTraceContextHttpHeaders(request.headers.append, request.headers, span);
+            }
+            else {
+                if (!copyOfInit) {
+                    copyOfInit = {};
+                }
+                copyOfInit.headers = new Headers();
+                addTraceContextHttpHeaders(copyOfInit.headers.append, copyOfInit.headers, span);
+            }
+        }
+        tryCaptureHttpHeaders(request.headers, span, (k) => httpRequestHeaderKey(k));
+        const performanceObserver = observeResourcePerformance({
+            // We match on both fetch and XHR here to support polyfills
+            resourceMatcher: ({ initiatorType, name }) => (initiatorType === "fetch" || initiatorType === "xmlhttprequest") && name === parseUrl(url).href,
+            maxWaitForResourceMillis: vars.maxWaitForResourceTimingsMillis,
+            maxToleranceForResourceTimingsMillis: vars.maxToleranceForResourceTimingsMillis,
+            onEnd: ({ duration, resource }) => {
+                if (resource) {
+                    addResourceNetworkEvents(span, resource);
+                    addResourceSize(span, resource);
+                }
+                // duration is millis we need to convert to nanos
+                sendSpan(endSpan(span, undefined, duration * 1000000));
+            },
+        });
+        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) => {
+                performanceObserver.cancel();
+                endSpanOnError(span, e);
+            });
+            return response;
+        }
+        catch (e) {
+            performanceObserver.cancel();
+            endSpanOnError(span, e);
+            throw e;
+        }
+    };
+}
+// @ts-expect-error -- WIP
+// eslint-disable-next-line @typescript-eslint/no-unused-vars -- WIP
+function addGraphQlProperties(input, init, span) {
+    try {
+        if (!isGraphQLQuery(input, init))
+            return;
+    }
+    catch (e) {
+        debug("failed to analyze request for GraphQL insights", e, input, init);
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-unused-vars -- WIP
+function isGraphQLQuery(input, init) {
+    /**
+     * TODO: Add GraphQL support.
+     * GraphQL queries are either POST or GET requests.
+     * Identified by either setting Accept=application/graphql-response+json or the url matching a config field for graphql urls.
+     * See: https://graphql.github.io/graphql-over-http/draft/
+     * GET requests are queries carrying a query search param
+     * POST requests are either queries or mutations, See: https://graphql.org/learn/serving-over-http/#post-request-and-body
+     * and https://github.com/instana/weasel/blob/main/lib/hooks/Fetch.ts#L201
+     */
+    return false;
+}
+function tryCaptureHttpHeaders(headers, span, getAttributeKey) {
+    try {
+        headers.forEach((value, key) => {
+            if (vars.headersToCapture.some((rxp) => rxp.test(key))) {
+                addAttribute(span.attributes, getAttributeKey(key), value);
+            }
+        });
+    }
+    catch (_e) {
+        debug("unable to capture http headers due to CORS policy");
+    }
+}
+function addResponseData(span, response) {
+    const status = response.status;
+    setSpanStatus(span, status >= 200 && status < 400 ? SPAN_STATUS_UNSET : SPAN_STATUS_ERROR, response.statusText);
+    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();
+    });
+}
+function endSpanOnError(span, error) {
+    recordException(span, error);
+    sendSpan(endSpan(span, errorToSpanStatus(error), undefined));
+}

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

@@ -0,0 +1,35 @@
+import { addAttribute, addSpanEvent } from "../../utils/otel";
+import { domHRTimestampToNanos, hasKey, PerformanceTimingNames } from "../../utils";
+import { HTTP_RESPONSE_BODY_SIZE } from "../../semantic-conventions";
+// SEE: https://github.com/open-telemetry/semantic-conventions/blob/main/docs/attributes-registry/http.md?plain=1#L67
+const KNOWN_HTTP_METHODS = ["GET", "HEAD", "POST", "PUT", "DELETE", "CONNECT", "OPTIONS", "TRACE", "PATCH"];
+export const HTTP_METHOD_OTHER = "_OTHER";
+export function isWellKnownHttpMethod(method) {
+    return KNOWN_HTTP_METHODS.includes(method);
+}
+export function addResourceNetworkEvents(span, resource) {
+    const ignoreZeros = resource.startTime !== 0;
+    addSpanNetworkEvent(span, PerformanceTimingNames.FETCH_START, resource, ignoreZeros);
+    addSpanNetworkEvent(span, PerformanceTimingNames.DOMAIN_LOOKUP_START, resource, ignoreZeros);
+    addSpanNetworkEvent(span, PerformanceTimingNames.DOMAIN_LOOKUP_END, resource, ignoreZeros);
+    addSpanNetworkEvent(span, PerformanceTimingNames.CONNECT_START, resource, ignoreZeros);
+    addSpanNetworkEvent(span, PerformanceTimingNames.SECURE_CONNECTION_START, resource, ignoreZeros);
+    addSpanNetworkEvent(span, PerformanceTimingNames.CONNECT_END, resource, ignoreZeros);
+    addSpanNetworkEvent(span, PerformanceTimingNames.REQUEST_START, resource, ignoreZeros);
+    addSpanNetworkEvent(span, PerformanceTimingNames.RESPONSE_START, resource, ignoreZeros);
+    addSpanNetworkEvent(span, PerformanceTimingNames.RESPONSE_END, resource, ignoreZeros);
+}
+function addSpanNetworkEvent(span, propertyName, resource, ignoreZeros = true) {
+    if (!hasKey(resource, propertyName) ||
+        typeof resource[propertyName] !== "number" ||
+        (ignoreZeros && resource[propertyName] === 0)) {
+        return;
+    }
+    addSpanEvent(span, propertyName, domHRTimestampToNanos(resource[propertyName]));
+}
+export function addResourceSize(span, resource) {
+    const encodedLength = resource.encodedBodySize;
+    if (encodedLength != undefined) {
+        addAttribute(span.attributes, HTTP_RESPONSE_BODY_SIZE, encodedLength);
+    }
+}

package/dist/modules/instrumentations/navigation/event.js

@@ -0,0 +1,44 @@
+import { addAttribute, getTraceContextForPageLoad } from "../../utils/otel";
+import { EVENT_NAME, EVENT_NAMES, LOG_SEVERITIES, PAGE_VIEW_CHANGE_STATE, PAGE_VIEW_CHANGE_STATE_VALUES, PAGE_VIEW_TYPE, PAGE_VIEW_TYPE_VALUES, } from "../../semantic-conventions";
+import { doc, NO_VALUE_FALLBACK } from "../../utils";
+import { addCommonAttributes } from "../../attributes";
+import { sendLog } from "../../transport";
+import { vars } from "../../vars";
+function getPageViewMeta(url) {
+    if (!url)
+        return {};
+    return vars.pageViewInstrumentation.generateMetadata?.(url) ?? {};
+}
+export function transmitPageViewEvent(timeUnixNano, url, virtual, replaced) {
+    const meta = getPageViewMeta(url);
+    const attributes = [];
+    addAttribute(attributes, EVENT_NAME, EVENT_NAMES.PAGE_VIEW);
+    if (meta.attributes) {
+        Object.entries(meta.attributes).forEach(([key, value]) => addAttribute(attributes, key, value));
+    }
+    addCommonAttributes(attributes, { url });
+    const bodyAttributes = [];
+    addAttribute(bodyAttributes, "title", meta.title ?? doc?.title ?? NO_VALUE_FALLBACK);
+    if (doc?.referrer) {
+        addAttribute(bodyAttributes, "referrer", doc.referrer);
+    }
+    addAttribute(bodyAttributes, PAGE_VIEW_TYPE, virtual ? PAGE_VIEW_TYPE_VALUES.VIRTUAL : PAGE_VIEW_TYPE_VALUES.INITIAL);
+    addAttribute(bodyAttributes, PAGE_VIEW_CHANGE_STATE, replaced ? PAGE_VIEW_CHANGE_STATE_VALUES.REPLACE : PAGE_VIEW_CHANGE_STATE_VALUES.PUSH);
+    const log = {
+        timeUnixNano: timeUnixNano,
+        attributes: attributes,
+        severityNumber: LOG_SEVERITIES.INFO,
+        severityText: "INFO",
+        body: {
+            kvlistValue: {
+                values: bodyAttributes,
+            },
+        },
+    };
+    const traceContext = getTraceContextForPageLoad();
+    if (traceContext) {
+        log.traceId = traceContext.traceId;
+        log.spanId = traceContext.spanId;
+    }
+    sendLog(log);
+}

package/dist/modules/instrumentations/navigation/index.js

@@ -0,0 +1,6 @@
+import { startPageLoadInstrumentation } from "./page-load";
+import { startPageTransitionInstrumentation } from "./page-transition";
+export function startNavigationInstrumentation() {
+    startPageLoadInstrumentation();
+    startPageTransitionInstrumentation();
+}

package/dist/modules/instrumentations/navigation/page-load.js

@@ -0,0 +1,83 @@
+import { addEventListener, debug, doc, win, roundToTwoDecimals, error, toNanosTs, getTimeOrigin } from "../../utils";
+import { EVENT_NAME, EVENT_NAMES, LOG_SEVERITIES } from "../../semantic-conventions";
+import { sendLog } from "../../transport";
+import { getTraceContextForPageLoad, addAttribute } from "../../utils/otel";
+import { addCommonAttributes } from "../../attributes";
+import { transmitPageViewEvent } from "./event";
+/**
+ * Tracks page loads as per this OTel spec:
+ * https://github.com/open-telemetry/semantic-conventions/pull/1910/files
+ *
+ * Notable difference: The full URL is transmitted as a signal attribute.
+ */
+export function startPageLoadInstrumentation() {
+    try {
+        transmitPageViewEvent(getStartTimeUnixNanos(), win?.location.href ? new URL(win?.location.href) : undefined);
+    }
+    catch (e) {
+        error("Failed to transmit initial page view event", e);
+    }
+    if (doc?.readyState === "complete") {
+        return onLoaded();
+    }
+    if (win) {
+        addEventListener(win, "load", function () {
+            // we want to get timing data for loadEventEnd,
+            // so asynchronously process this
+            setTimeout(onLoaded, 0);
+        });
+    }
+}
+/**
+ * See https://github.com/open-telemetry/semantic-conventions/pull/1919
+ */
+function onLoaded() {
+    const nt = win?.performance.getEntriesByType("navigation")[0];
+    if (!nt) {
+        debug("Navigation timings not available. Cannot emit navigation timing log");
+        return;
+    }
+    const attributes = [];
+    addAttribute(attributes, EVENT_NAME, EVENT_NAMES.NAVIGATION_TIMING);
+    const bodyAttributes = [];
+    addAttribute(bodyAttributes, "name", nt.name);
+    addNavigationTiming(bodyAttributes, nt, "responseStatus");
+    addNavigationTiming(bodyAttributes, nt, "fetchStart");
+    addNavigationTiming(bodyAttributes, nt, "requestStart");
+    addNavigationTiming(bodyAttributes, nt, "responseStart");
+    addNavigationTiming(bodyAttributes, nt, "domInteractive");
+    addNavigationTiming(bodyAttributes, nt, "domContentLoadedEventEnd");
+    addNavigationTiming(bodyAttributes, nt, "domComplete");
+    addNavigationTiming(bodyAttributes, nt, "loadEventEnd");
+    addNavigationTiming(bodyAttributes, nt, "transferSize");
+    addNavigationTiming(bodyAttributes, nt, "encodedBodySize");
+    addNavigationTiming(bodyAttributes, nt, "decodedBodySize");
+    const log = {
+        timeUnixNano: getStartTimeUnixNanos(),
+        attributes: attributes,
+        severityNumber: LOG_SEVERITIES.INFO,
+        severityText: "INFO",
+        body: {
+            kvlistValue: {
+                values: bodyAttributes,
+            },
+        },
+    };
+    addCommonAttributes(log.attributes);
+    const traceContext = getTraceContextForPageLoad();
+    if (traceContext) {
+        log.traceId = traceContext.traceId;
+        log.spanId = traceContext.spanId;
+    }
+    sendLog(log);
+}
+function addNavigationTiming(attributes, nt, field) {
+    // @ts-expect-error index access not recognized by TS, but this makes the code more reusable
+    const value = nt[field];
+    if (typeof value === "number" && !isNaN(value)) {
+        addAttribute(attributes, field, Number.isInteger(value) ? value : roundToTwoDecimals(value));
+    }
+}
+function getStartTimeUnixNanos() {
+    return toNanosTs(Math.round(getTimeOrigin()));
+}

package/dist/modules/instrumentations/navigation/page-transition.js

@@ -0,0 +1,72 @@
+import { debug, nowNanos, win, wrap } from "../../utils";
+import { vars } from "../../vars";
+import { transmitPageViewEvent } from "./event";
+let currentLocation = {};
+let shouldIncludeHashChanges = false;
+let shouldIncludeSearchChanges = false;
+/**
+ * Tracks page transitions (virtual page views) as per this OTel spec:
+ * https://github.com/open-telemetry/semantic-conventions/pull/1910/files
+ *
+ * Notable difference: The full URL is transmitted as a signal attribute.
+ */
+export function startPageTransitionInstrumentation() {
+    if (!win || !win.history) {
+        debug("Browser does not support history API, skipping instrumentation");
+        return;
+    }
+    if (!vars.pageViewInstrumentation.trackVirtualPageViews) {
+        return;
+    }
+    shouldIncludeSearchChanges = vars.pageViewInstrumentation.includeParts?.includes("SEARCH") ?? false;
+    shouldIncludeHashChanges = vars.pageViewInstrumentation.includeParts?.includes("HASH") ?? false;
+    /**
+     * Not wrapping history.go, history.backward and history.forward here, because their call signatures don't receive
+     * url information. For these cases we can use the popstate and hashchange events.
+     */
+    wrap(win.history, "replaceState", (original) => function (state, unused, url) {
+        onUrlChange(url ? String(url) : undefined, true);
+        return original.apply(this, [state, unused, url]);
+    });
+    wrap(win.history, "pushState", (original) => function (state, unused, url) {
+        onUrlChange(url ? String(url) : undefined);
+        return original.apply(this, [state, unused, url]);
+    });
+    win.addEventListener("hashchange", onHashChange);
+    win.addEventListener("popstate", onPopState);
+    try {
+        updateCurrentLocation(new URL(win.location.href));
+    }
+    catch { }
+}
+function onPopState() {
+    // popState event is fired after the location entry has been updated, so the location should already contain the new url.
+    onUrlChange(win?.location.href);
+}
+function onHashChange(event) {
+    onUrlChange(event.newURL);
+}
+function onUrlChange(url, replaced) {
+    if (!url)
+        return;
+    try {
+        const parsedUrl = new URL(url, win?.location.href);
+        if (isLocationChange(parsedUrl)) {
+            updateCurrentLocation(parsedUrl);
+            transmitPageViewEvent(nowNanos(), parsedUrl, true, Boolean(replaced));
+        }
+    }
+    catch (e) {
+        debug("Failed to handle url change", e);
+    }
+}
+function updateCurrentLocation(url) {
+    currentLocation.path = url.pathname;
+    currentLocation.search = url.search;
+    currentLocation.hash = url.hash;
+}
+function isLocationChange(newUrl) {
+    return (newUrl.pathname !== currentLocation.path ||
+        (shouldIncludeSearchChanges && newUrl.search !== currentLocation.search) ||
+        (shouldIncludeHashChanges && newUrl.hash !== currentLocation.hash));
+}

package/dist/modules/instrumentations/web-vitals.js

@@ -0,0 +1,32 @@
+import { onLCP, onINP, onCLS } from "web-vitals";
+import { EVENT_NAME, EVENT_NAMES, LOG_SEVERITIES } from "../semantic-conventions";
+import { nowNanos, roundToTwoDecimals } from "../utils";
+import { sendLog } from "../transport";
+import { addAttribute } from "../utils/otel";
+import { addCommonAttributes } from "../attributes";
+export function startWebVitalsInstrumentation() {
+    onLCP(onWebVital);
+    onINP(onWebVital);
+    onCLS(onWebVital);
+}
+function onWebVital(metric) {
+    const attributes = [];
+    addAttribute(attributes, EVENT_NAME, EVENT_NAMES.WEB_VITAL);
+    const bodyAttributes = [];
+    addAttribute(bodyAttributes, "name", metric.name);
+    addAttribute(bodyAttributes, "value", roundToTwoDecimals(metric.value));
+    addAttribute(bodyAttributes, "delta", roundToTwoDecimals(metric.delta));
+    const log = {
+        timeUnixNano: nowNanos(),
+        attributes: attributes,
+        severityNumber: LOG_SEVERITIES.INFO,
+        severityText: "INFO",
+        body: {
+            kvlistValue: {
+                values: bodyAttributes,
+            },
+        },
+    };
+    addCommonAttributes(log.attributes);
+    sendLog(log);
+}

package/dist/modules/semantic-conventions.js

@@ -0,0 +1,79 @@
+// Resource Attribute Keys
+export const SERVICE_NAME = "service.name";
+export const SERVICE_VERSION = "service.version";
+export const DEPLOYMENT_ENVIRONMENT_NAME = "deployment.environment.name";
+export const DEPLOYMENT_NAME = "deployment.name";
+export const DEPLOYMENT_ID = "deployment.id";
+// Misc Signal Attribute Keys
+export const EVENT_NAME = "event.name";
+export const EVENT_TITLE = "dash0.event.title";
+export const PAGE_LOAD_ID = "page.load.id";
+export const SESSION_ID = "session.id";
+export const USER_AGENT = "user_agent.original";
+export const BROWSER_TAB_ID = "browser.tab.id";
+export const WINDOW_WIDTH = "browser.window.width";
+export const WINDOW_HEIGHT = "browser.window.height";
+export const NETWORK_CONNECTION_TYPE = "network.connection.subtype";
+export const EXCEPTION_COMPONENT_STACK = "exception.component_stack";
+// User Attribute Keys
+export const USER_ID = "user.id";
+export const USER_NAME = "user.name";
+export const USER_FULL_NAME = "user.full_name";
+export const USER_EMAIL = "user.email";
+export const USER_HASH = "user.hash";
+export const USER_ROLES = "user.roles";
+// Exception Attribute Keys
+export const EXCEPTION_MESSAGE = "exception.message";
+export const EXCEPTION_TYPE = "exception.type";
+export const EXCEPTION_STACKTRACE = "exception.stacktrace";
+// URL Attribute Keys
+export const URL_DOMAIN = "url.domain";
+export const URL_FRAGMENT = "url.fragment";
+export const URL_FULL = "url.full";
+export const URL_PATH = "url.path";
+export const URL_QUERY = "url.query";
+export const URL_SCHEME = "url.scheme";
+// Http Attribute Keys
+export const HTTP_REQUEST_METHOD = "http.request.method";
+export const HTTP_REQUEST_METHOD_ORIGINAL = "http.request.method_original";
+export const HTTP_REQUEST_HEADER = "http.request.header";
+export const HTTP_RESPONSE_STATUS_CODE = "http.response.status_code";
+export const HTTP_RESPONSE_HEADER = "http.response.header";
+export const HTTP_RESPONSE_BODY_SIZE = "http.response.body.size";
+// Event Names
+export const EVENT_NAMES = {
+    PAGE_VIEW: "browser.page_view",
+    NAVIGATION_TIMING: "browser.navigation_timing",
+    WEB_VITAL: "browser.web_vital",
+    ERROR: "browser.error",
+};
+export const SPAN_EVENT_NAME_EXCEPTION = "exception";
+// Log Severities
+export const LOG_SEVERITIES = {
+    UNSPECIFIED: 0,
+    TRACE: 1,
+    DEBUG: 5,
+    INFO: 9,
+    WARN: 13,
+    ERROR: 17,
+    FATAL: 21,
+};
+// Page View Event Attributes
+// SEE: https://github.com/open-telemetry/semantic-conventions/pull/1910/files
+export const PAGE_VIEW_TYPE = "type";
+export const PAGE_VIEW_TYPE_VALUES = {
+    INITIAL: 0,
+    VIRTUAL: 1,
+};
+export const PAGE_VIEW_CHANGE_STATE = "change_state";
+export const PAGE_VIEW_CHANGE_STATE_VALUES = {
+    PUSH: "pushState",
+    REPLACE: "replaceState",
+};
+// Span Status
+export const SPAN_STATUS_UNSET = 0;
+export const SPAN_STATUS_OK = 1; // This is here for completion, status ok is reserved for use by application developers
+export const SPAN_STATUS_ERROR = 2;
+// Span Kind
+// See: https://github.com/open-telemetry/opentelemetry-proto/blob/ac3242b03157295e4ee9e616af53b81517b06559/opentelemetry/proto/trace/v1/trace.proto#L143-L169
+export const SPAN_KIND_CLIENT = 3;

package/dist/modules/transport/batcher.js

@@ -0,0 +1,48 @@
+import { onLastChance } from "../utils/on-last-chance";
+import { doc } from "../utils";
+import { setTimeout } from "../utils/timers";
+const SCHEDULE_DELAY_MILLIS = 1000;
+const MAX_QUEUE_SIZE = 15;
+export function newBatcher(sendInternal) {
+    const queuedItems = [];
+    let pendingFlushTimeout;
+    // We attempt batching of messages to be more efficient on the client, network and
+    // server-side. While the connection is either a persistent HTTP 2 connection or
+    // an HTTP 1.1 connection with keep-alive, there is still some overhead involved
+    // in having many small messages.
+    //
+    // For this reason we attempt batching. When batching we must be careful to
+    // force a transmission when the document is unloaded.
+    onLastChance(flush);
+    return {
+        send(item) {
+            if (isWindowHidden()) {
+                // We cannot guarantee that we will ever get time to transmit data in a batched
+                // format when the window is hidden, as this might occur while the document is
+                // being unloaded. Immediately force a transmission in these cases.
+                sendInternal([item]);
+                return;
+            }
+            queuedItems.push(item);
+            if (queuedItems.length >= MAX_QUEUE_SIZE) {
+                flush();
+            }
+            else if (pendingFlushTimeout == null) {
+                pendingFlushTimeout = setTimeout(flush, SCHEDULE_DELAY_MILLIS);
+            }
+        },
+    };
+    function flush() {
+        if (pendingFlushTimeout != null) {
+            clearTimeout(pendingFlushTimeout);
+            pendingFlushTimeout = null;
+        }
+        if (queuedItems.length > 0) {
+            sendInternal(queuedItems.slice());
+            queuedItems.length = 0;
+        }
+    }
+}
+function isWindowHidden() {
+    return doc?.visibilityState !== "visible";
+}

package/dist/modules/transport/fetch.js

@@ -0,0 +1,58 @@
+import { vars } from "../vars";
+import { noop, warn, fetch } from "../utils";
+const BEACON_BODY_SIZE_LIMIT = 60000;
+export async function send(path, body) {
+    const jsonString = JSON.stringify(body);
+    let requestBody = jsonString;
+    let byteLength = jsonString.length;
+    let isCompressed = false;
+    // Try to compress if supported
+    if (typeof CompressionStream !== "undefined") {
+        requestBody = await compressWithGzip(jsonString);
+        byteLength = requestBody.byteLength;
+        isCompressed = true;
+    }
+    // Send to all endpoints in parallel
+    await Promise.all(vars.endpoints.map(async (endpoint) => {
+        try {
+            const url = new URL(endpoint["url"]);
+            url.pathname = url.pathname + (url.pathname.endsWith("/") ? path.substring(1) : path);
+            const headers = {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${endpoint["authToken"]}`,
+            };
+            if (endpoint.dataset) {
+                headers["Dash0-Dataset"] = endpoint["dataset"];
+            }
+            // Try to compress if supported
+            if (isCompressed) {
+                headers["Content-Encoding"] = "gzip";
+            }
+            if (!fetch) {
+                warn("Unable to send telemetry, fetch is not defined");
+                return;
+            }
+            const response = await fetch(url, {
+                method: "POST",
+                headers,
+                body: requestBody,
+                // The keepalive flag is related to the window.sendBeacon API. This in turn has size limitations.
+                keepalive: byteLength <= BEACON_BODY_SIZE_LIMIT,
+            });
+            // read the body so the connection can be closed
+            response.text().catch(noop);
+            if (!response.ok) {
+                warn(`Failed to send telemetry to ${url}: ${response.status} ${response.statusText}`);
+            }
+        }
+        catch (error) {
+            warn(`Error sending telemetry to ${endpoint.url}${path}:`, error);
+        }
+    }));
+}
+async function compressWithGzip(data) {
+    const blob = new Blob([data]);
+    const stream = blob.stream();
+    const compressedStream = stream.pipeThrough(new CompressionStream("gzip"));
+    return new Response(compressedStream).arrayBuffer();
+}