@dash0/sdk-web 0.6.2

package/dist/modules/transport/index.js

@@ -0,0 +1,66 @@
+import { newBatcher } from "./batcher";
+import { send } from "./fetch";
+import { vars } from "../vars";
+import { createRateLimiter } from "../utils/rate-limit";
+import { debug, error } from "../utils";
+const logBatcher = newBatcher(sendLogs);
+const spanBatcher = newBatcher(sendSpans);
+let rateLimiter;
+function isRateLimited() {
+    if (!rateLimiter) {
+        rateLimiter = createRateLimiter({
+            maxCalls: 8096,
+            maxCallsPerTenMinutes: 4096,
+            maxCallsPerTenSeconds: 128,
+        });
+    }
+    return rateLimiter();
+}
+export function sendLog(log) {
+    if (isRateLimited()) {
+        debug("Transport rate limit. Will not send item.", log);
+        return;
+    }
+    logBatcher.send(log);
+}
+function sendLogs(logs) {
+    send("/v1/logs", {
+        resourceLogs: [
+            {
+                resource: vars.resource,
+                scopeLogs: [
+                    {
+                        scope: vars.scope,
+                        logRecords: logs,
+                    },
+                ],
+            },
+        ],
+    }).catch((err) => {
+        error("Failed to transmit logs", err);
+    });
+}
+export function sendSpan(span) {
+    if (isRateLimited()) {
+        debug("Transport rate limit. Will not send item.", span);
+        return;
+    }
+    spanBatcher.send(span);
+}
+function sendSpans(spans) {
+    send("/v1/traces", {
+        resourceSpans: [
+            {
+                resource: vars.resource,
+                scopeSpans: [
+                    {
+                        scope: vars.scope,
+                        spans: spans,
+                    },
+                ],
+            },
+        ],
+    }).catch((err) => {
+        error("Failed to transmit spans", err);
+    });
+}

package/dist/modules/utils/constants.js

@@ -0,0 +1,2 @@
+export const NO_VALUE_FALLBACK = "undefined";
+export const INIT_MESSAGE = "Initializing Dash0 Web SDK";

package/dist/modules/utils/debug.js

@@ -0,0 +1,19 @@
+import { noop } from "./fn";
+export const log = createLogger("log");
+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") {
+        return function () {
+            console[method].apply(console, arguments);
+        };
+    }
+    return function () {
+        console.log.apply(console, arguments);
+    };
+}

package/dist/modules/utils/fn.js

@@ -0,0 +1,3 @@
+export function noop() {
+    // This function is intentionally empty.
+}

package/dist/modules/utils/globals.js

@@ -0,0 +1,36 @@
+// aliasing globals for improved minification
+// Avoid blowing up in an ssr context. It is important to check via typeof here because window might not even be declared when imported in ssr.
+export const win = typeof window !== "undefined" ? window : undefined;
+export const doc = win?.document;
+export const nav = win?.navigator;
+export const loc = typeof location !== "undefined" ? location : undefined;
+export const perf = win?.performance || win?.webkitPerformance || win?.msPerformance || win?.mozPerformance;
+export const encodeURIComponent = win?.encodeURIComponent;
+export const fetch = win?.fetch;
+export const localStorage = (function () {
+    try {
+        return win?.localStorage ?? null;
+    }
+    catch {
+        // localStorage access is not permitted in certain security modes, e.g.
+        // when cookies are completely disabled in web browsers.
+        return null;
+    }
+})();
+export const sessionStorage = (function () {
+    try {
+        return win?.sessionStorage ?? null;
+    }
+    catch {
+        // sessionStorage access is not permitted in certain security modes, e.g.
+        // when cookies are completely disabled in web browsers.
+        return null;
+    }
+})();
+/**
+ * Exposed via this module to enable testing.
+ */
+export function sendBeacon(url, data) {
+    return nav?.sendBeacon(url, data) ?? false;
+}
+/* eslint-enable no-restricted-globals */

package/dist/modules/utils/id.js

@@ -0,0 +1,16 @@
+export const SPAN_ID_BYTES = 8;
+export const TRACE_ID_BYTES = 16;
+export const PAGE_LOAD_ID_BYTES = TRACE_ID_BYTES;
+export const SESSION_ID_BYTES = TRACE_ID_BYTES;
+export const TAB_ID_BYTES = SPAN_ID_BYTES;
+const SHARED_CHAR_CODES_ARRAY = Array(32);
+export function generateUniqueId(byteCount) {
+    for (let i = 0; i < byteCount * 2; i++) {
+        SHARED_CHAR_CODES_ARRAY[i] = Math.floor(Math.random() * 16) + 48;
+        // valid hex characters in the range 48-57 and 97-102
+        if (SHARED_CHAR_CODES_ARRAY[i] >= 58) {
+            SHARED_CHAR_CODES_ARRAY[i] += 39;
+        }
+    }
+    return String.fromCharCode.apply(null, SHARED_CHAR_CODES_ARRAY.slice(0, byteCount * 2));
+}

package/dist/modules/utils/id_test.js

@@ -0,0 +1,33 @@
+import { expect, describe, it } from "vitest";
+import { generateUniqueId } from "./id";
+// Create a wrapper function for testing
+function generateId(length) {
+    if (typeof length !== "number") {
+        throw new Error("Length must be a number");
+    }
+    if (length < 1) {
+        throw new Error("Length must be greater than 0");
+    }
+    return generateUniqueId(Math.ceil(length / 2)).substring(0, length);
+}
+describe("generateId", () => {
+    it("returns a string of the expected length", () => {
+        const id = generateId(10);
+        expect(id).toHaveLength(10);
+    });
+    it("returns a unique ID on each call", () => {
+        const id1 = generateId(10);
+        const id2 = generateId(10);
+        expect(id1).not.toBe(id2);
+    });
+    it("throws an error if length is less than 1", () => {
+        expect(() => generateId(0)).toThrow("Length must be greater than 0");
+    });
+    it("throws an error if length is not a number", () => {
+        expect(() => generateId("abc")).toThrow("Length must be a number");
+    });
+    it("handles large lengths without errors", () => {
+        const id = generateId(1000);
+        expect(id).toHaveLength(1000);
+    });
+});

package/dist/modules/utils/ignore-rules.js

@@ -0,0 +1,48 @@
+import { vars } from "../vars";
+export function matchesAny(regexp, s) {
+    for (let i = 0, len = regexp.length; i < len; i++) {
+        if (regexp[i].test(s)) {
+            return true;
+        }
+    }
+    return false;
+}
+const DATA_URL_PREFIX = "data:";
+export function isUrlIgnored(url) {
+    if (!url) {
+        return true;
+    }
+    // Force string conversion. During runtime we have seen that some URLs passed into this code path aren't actually
+    // strings. Reason currently unknown.
+    url = String(url);
+    if (!url) {
+        return true;
+    }
+    // We never want to track data URLs. Instead of matching these via regular expressions (which might be expensive),
+    // we are explicitly doing a startsWith ignore case check
+    // https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs
+    if (url.substring == null || url.substring(0, DATA_URL_PREFIX.length).toLowerCase() === DATA_URL_PREFIX) {
+        return true;
+    }
+    // Disable monitoring of data transmission requests. The data transmission strategy already ensures
+    // that data transmission requests are not picked up internally. However, we have seen some users
+    // leverage custom (broken) XMLHttpRequest instrumentation to implement application code which
+    // then break the detection of data transmission requests.
+    if (isTransportRequest(url)) {
+        return true;
+    }
+    return matchesAny(vars.ignoreUrls, url);
+}
+function isTransportRequest(url) {
+    const lowerCaseUrl = url.toLowerCase();
+    for (let i = 0, len = vars.endpoints.length; i < len; i++) {
+        const endpoint = vars.endpoints[i];
+        if (lowerCaseUrl.startsWith(endpoint.url)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function isErrorMessageIgnored(message) {
+    return !message || matchesAny(vars.ignoreErrorMessages, message);
+}

package/dist/modules/utils/index.js

@@ -0,0 +1,16 @@
+export * from "./debug";
+export * from "./obj";
+export * from "./fn";
+export * from "./globals";
+export * from "./id";
+export * from "./listeners";
+export * from "./local-storage";
+export * from "./performance";
+export * from "./rate-limit";
+export * from "./time";
+export * from "./constants";
+export * from "./math";
+export * from "./origin";
+export * from "./url";
+export * from "./pick";
+export * from "./wrap";

package/dist/modules/utils/listeners.js

@@ -0,0 +1,18 @@
+// aliasing the global function for improved minification and
+// protection against hasOwnProperty overrides.
+export function addEventListener(target, eventType, callback) {
+    if (target.addEventListener) {
+        target.addEventListener(eventType, callback, false);
+    }
+    else if (target.attachEvent) {
+        target.attachEvent("on" + eventType, callback);
+    }
+}
+export function removeEventListener(target, eventType, callback) {
+    if (target.removeEventListener) {
+        target.removeEventListener(eventType, callback, false);
+    }
+    else if (target.detachEvent) {
+        target.detachEvent("on" + eventType, callback);
+    }
+}

package/dist/modules/utils/local-storage.js

@@ -0,0 +1,19 @@
+// localStorage API re-exposed to allow testing.
+import { localStorage } from "./globals";
+export const isSupported = localStorage != null && typeof localStorage.getItem === "function" && typeof localStorage.setItem === "function";
+export function getItem(k) {
+    if (isSupported && localStorage) {
+        return localStorage.getItem(k);
+    }
+    return null;
+}
+export function setItem(k, v) {
+    if (isSupported && localStorage) {
+        localStorage.setItem(k, v);
+    }
+}
+export function removeItem(k) {
+    if (isSupported && localStorage) {
+        localStorage.removeItem(k);
+    }
+}

package/dist/modules/utils/math.js

@@ -0,0 +1,3 @@
+export function roundToTwoDecimals(n) {
+    return Math.round(n * 100) / 100;
+}

package/dist/modules/utils/obj.js

@@ -0,0 +1,10 @@
+const globalHasOwnProperty = Object.prototype.hasOwnProperty;
+/**
+ * protection against hasOwnProperty overrides.
+ */
+export function hasOwnProperty(obj, key) {
+    return globalHasOwnProperty.call(obj, key);
+}
+export function hasKey(obj, key) {
+    return key in obj;
+}

package/dist/modules/utils/on-last-chance.js

@@ -0,0 +1,31 @@
+import { addEventListener } from "./listeners";
+import { doc, win } from "./globals";
+let isUnloading = false;
+/**
+ * Triggers the `fn` when the HTML document is getting unloaded
+ * (or when it looks like it might be). Useful to flush batch activities.
+ */
+export function onLastChance(fn) {
+    if (isUnloading) {
+        fn();
+    }
+    if (!doc || !win)
+        return;
+    addEventListener(doc, "visibilitychange", function () {
+        if (doc.visibilityState !== "visible") {
+            fn();
+        }
+    });
+    addEventListener(win, "pagehide", function () {
+        isUnloading = true;
+        fn();
+    });
+    // According to the spec visibilitychange should be a replacement for
+    // beforeunload, but the reality is different (as of 2019-04-17). Chrome will
+    // close tabs without firing visibilitychange. beforeunload on the other hand
+    // is fired.
+    addEventListener(win, "beforeunload", function () {
+        isUnloading = true;
+        fn();
+    });
+}

package/dist/modules/utils/origin.js

@@ -0,0 +1,14 @@
+import { parseUrl } from "./url";
+/** Returns the origin if present (if in browser context). */
+function getOrigin() {
+    return typeof location !== "undefined" ? location.origin : undefined;
+}
+export function isSameOrigin(url) {
+    try {
+        const parsedUrl = parseUrl(url);
+        return parsedUrl.origin === getOrigin();
+    }
+    catch (_e) {
+        return false;
+    }
+}

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

@@ -0,0 +1,55 @@
+const ANY_VALUE_KEYS = [
+    "stringValue",
+    "boolValue",
+    "intValue",
+    "doubleValue",
+    "arrayValue",
+    "kvlistValue",
+    "bytesValue",
+];
+function isAnyValue(value) {
+    if (value == null || typeof value !== "object")
+        return false;
+    const keys = Object.keys(value);
+    return keys.length === 1 && ANY_VALUE_KEYS.includes(keys[0]);
+}
+export function toAnyValue(value) {
+    if (value == null) {
+        return undefined;
+    }
+    let anyValue = {};
+    if (Array.isArray(value)) {
+        anyValue["arrayValue"] = { values: value.map((e) => toAnyValue(e)) };
+    }
+    else if (typeof value === "string") {
+        anyValue["stringValue"] = value;
+    }
+    else if (typeof value === "number") {
+        anyValue["doubleValue"] = value;
+    }
+    else if (typeof value === "boolean") {
+        anyValue["boolValue"] = value;
+    }
+    else if (isAnyValue(value)) {
+        anyValue = value;
+    }
+    else if (typeof value === "object") {
+        anyValue["kvlistValue"] = { values: Object.entries(value).map(([key, value]) => toKeyValue(key, value)) };
+    }
+    return anyValue;
+}
+export function toKeyValue(key, value) {
+    return {
+        key: key,
+        value: toAnyValue(value),
+    };
+}
+export function addAttribute(attributes, key, value) {
+    attributes.push(toKeyValue(key, value));
+}
+export function removeAttribute(attributes, key) {
+    const index = attributes.findIndex((attr) => attr["key"] === key);
+    if (index !== -1) {
+        attributes.splice(index, 1);
+    }
+}

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

@@ -0,0 +1,158 @@
+import { expect, describe, it } from "vitest";
+import { toAnyValue } from "./attributes";
+describe("toAnyValue", () => {
+    describe("primitive values", () => {
+        it("converts string values to stringValue", () => {
+            const result = toAnyValue("hello");
+            expect(result).toEqual({ stringValue: "hello" });
+        });
+        it("converts number values to doubleValue", () => {
+            const result = toAnyValue(42);
+            expect(result).toEqual({ doubleValue: 42 });
+        });
+        it("converts boolean true to boolValue", () => {
+            const result = toAnyValue(true);
+            expect(result).toEqual({ boolValue: true });
+        });
+        it("converts boolean false to boolValue", () => {
+            const result = toAnyValue(false);
+            expect(result).toEqual({ boolValue: false });
+        });
+        it("converts zero to doubleValue", () => {
+            const result = toAnyValue(0);
+            expect(result).toEqual({ doubleValue: 0 });
+        });
+        it("converts negative numbers to doubleValue", () => {
+            const result = toAnyValue(-123.45);
+            expect(result).toEqual({ doubleValue: -123.45 });
+        });
+        it("converts empty string to stringValue", () => {
+            const result = toAnyValue("");
+            expect(result).toEqual({ stringValue: "" });
+        });
+    });
+    describe("array values", () => {
+        it("converts array of strings to arrayValue", () => {
+            const result = toAnyValue(["a", "b", "c"]);
+            expect(result).toEqual({
+                arrayValue: {
+                    values: [{ stringValue: "a" }, { stringValue: "b" }, { stringValue: "c" }],
+                },
+            });
+        });
+        it("converts array of numbers to arrayValue", () => {
+            const result = toAnyValue([1, 2, 3]);
+            expect(result).toEqual({
+                arrayValue: {
+                    values: [{ doubleValue: 1 }, { doubleValue: 2 }, { doubleValue: 3 }],
+                },
+            });
+        });
+        it("converts array of booleans to arrayValue", () => {
+            const result = toAnyValue([true, false]);
+            expect(result).toEqual({
+                arrayValue: {
+                    values: [{ boolValue: true }, { boolValue: false }],
+                },
+            });
+        });
+        it("converts mixed array to arrayValue", () => {
+            const result = toAnyValue([1, "hello", true]);
+            expect(result).toEqual({
+                arrayValue: {
+                    values: [{ doubleValue: 1 }, { stringValue: "hello" }, { boolValue: true }],
+                },
+            });
+        });
+        it("converts empty array to arrayValue", () => {
+            const result = toAnyValue([]);
+            expect(result).toEqual({
+                arrayValue: {
+                    values: [],
+                },
+            });
+        });
+    });
+    describe("object values", () => {
+        it("converts simple object to kvlistValue", () => {
+            const result = toAnyValue({ name: "John", age: 30 });
+            expect(result).toEqual({
+                kvlistValue: {
+                    values: [
+                        { key: "name", value: { stringValue: "John" } },
+                        { key: "age", value: { doubleValue: 30 } },
+                    ],
+                },
+            });
+        });
+        it("converts empty object to kvlistValue", () => {
+            const result = toAnyValue({});
+            expect(result).toEqual({
+                kvlistValue: {
+                    values: [],
+                },
+            });
+        });
+        it("converts object with mixed value types", () => {
+            const result = toAnyValue({
+                str: "text",
+                num: 42,
+                bool: true,
+            });
+            expect(result).toEqual({
+                kvlistValue: {
+                    values: [
+                        { key: "str", value: { stringValue: "text" } },
+                        { key: "num", value: { doubleValue: 42 } },
+                        { key: "bool", value: { boolValue: true } },
+                    ],
+                },
+            });
+        });
+    });
+    describe("AnyValue passthrough", () => {
+        it("returns existing AnyValue unchanged", () => {
+            const anyValue = { stringValue: "test" };
+            const result = toAnyValue(anyValue);
+            expect(result).toBe(anyValue);
+        });
+        it("returns existing doubleValue AnyValue unchanged", () => {
+            const anyValue = { doubleValue: 123 };
+            const result = toAnyValue(anyValue);
+            expect(result).toBe(anyValue);
+        });
+        it("returns existing boolValue AnyValue unchanged", () => {
+            const anyValue = { boolValue: false };
+            const result = toAnyValue(anyValue);
+            expect(result).toBe(anyValue);
+        });
+        it("returns existing arrayValue AnyValue unchanged", () => {
+            const anyValue = {
+                arrayValue: {
+                    values: [{ stringValue: "test" }],
+                },
+            };
+            const result = toAnyValue(anyValue);
+            expect(result).toBe(anyValue);
+        });
+        it("returns existing kvlistValue AnyValue unchanged", () => {
+            const anyValue = {
+                kvlistValue: {
+                    values: [{ key: "test", value: { stringValue: "value" } }],
+                },
+            };
+            const result = toAnyValue(anyValue);
+            expect(result).toBe(anyValue);
+        });
+    });
+    describe("undefined and null handling", () => {
+        it("returns undefined for undefined", () => {
+            const result = toAnyValue(undefined);
+            expect(result).toBeUndefined();
+        });
+        it("returns undefined for null", () => {
+            const result = toAnyValue(null);
+            expect(result).toBeUndefined();
+        });
+    });
+});

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

@@ -0,0 +1,30 @@
+import { addSpanEvent } from "./span";
+import { addAttribute } from "./attributes";
+import { SPAN_EVENT_NAME_EXCEPTION, EXCEPTION_MESSAGE, EXCEPTION_STACKTRACE, EXCEPTION_TYPE, SPAN_STATUS_ERROR, } from "../../semantic-conventions";
+export function recordException(span, exception) {
+    const attributes = [];
+    if (typeof exception === "string") {
+        addAttribute(attributes, EXCEPTION_MESSAGE, exception);
+    }
+    else if (exception) {
+        if (exception.code) {
+            addAttribute(attributes, EXCEPTION_TYPE, exception.code.toString());
+        }
+        else if (exception.name) {
+            addAttribute(attributes, EXCEPTION_TYPE, exception.name);
+        }
+        if (exception.message) {
+            addAttribute(attributes, EXCEPTION_MESSAGE, exception.message);
+        }
+        if (exception.stack) {
+            addAttribute(attributes, EXCEPTION_STACKTRACE, exception.stack);
+        }
+        addSpanEvent(span, SPAN_EVENT_NAME_EXCEPTION, attributes);
+    }
+}
+export function errorToSpanStatus(e) {
+    return {
+        code: SPAN_STATUS_ERROR,
+        message: e && typeof e === "object" && "message" in e ? e.message : String(e),
+    };
+}

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

@@ -0,0 +1,7 @@
+import { HTTP_REQUEST_HEADER, HTTP_RESPONSE_HEADER } from "../../semantic-conventions";
+export function httpRequestHeaderKey(key) {
+    return `${HTTP_REQUEST_HEADER}.${key.toLowerCase()}`;
+}
+export function httpResponseHeaderKey(key) {
+    return `${HTTP_RESPONSE_HEADER}.${key.toLowerCase()}`;
+}

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

@@ -0,0 +1,4 @@
+export * from "./attributes";
+export * from "./trace-context";
+export * from "./span";
+export * from "./error";

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

@@ -0,0 +1,56 @@
+import { nowNanos } from "../time";
+import { generateUniqueId, SPAN_ID_BYTES, TRACE_ID_BYTES } from "../id";
+import { SPAN_KIND_CLIENT, SPAN_STATUS_UNSET } from "../../semantic-conventions";
+export function startSpan(name) {
+    return {
+        traceId: generateUniqueId(TRACE_ID_BYTES),
+        spanId: generateUniqueId(SPAN_ID_BYTES),
+        name,
+        // Always CLIENT for now https://github.com/open-telemetry/opentelemetry-proto/blob/ac3242b03157295e4ee9e616af53b81517b06559/opentelemetry/proto/trace/v1/trace.proto#L143-L169
+        // Note: we directly define otlp here, this differs from the values used by oteljs internally.
+        kind: SPAN_KIND_CLIENT,
+        startTimeUnixNano: nowNanos(),
+        attributes: [],
+        events: [],
+        links: [],
+        status: { code: SPAN_STATUS_UNSET },
+    };
+}
+export function endSpan(span, status, durationNano) {
+    // We cast here to avoid having to instantiate a copy of the span
+    const s = span;
+    if (status) {
+        s.status = status;
+    }
+    s.endTimeUnixNano =
+        durationNano != null ? String(Math.round(parseInt(s.startTimeUnixNano) + durationNano)) : nowNanos();
+    return s;
+}
+/**
+ * Adds an event to a span. Can optionally accept the events timestamp and attributes for the event.
+ * The timestamp needs to be specified as nanoseconds since unix epoch in string format.
+ */
+export function addSpanEvent(span, name, attributesOrTs, attributes) {
+    let ts = undefined;
+    let attr = undefined;
+    if (typeof attributesOrTs === "string") {
+        ts = attributesOrTs;
+    }
+    else if (Array.isArray(attributesOrTs)) {
+        attr = attributesOrTs;
+    }
+    if (attributes) {
+        attr = attributes;
+    }
+    span.events.push({
+        name,
+        timeUnixNano: ts != null ? ts : nowNanos(),
+        attributes: attr ?? [],
+    });
+}
+export function setSpanStatus(span, code, message) {
+    span.status = {
+        code,
+        message,
+    };
+}