@dash0/sdk-web 0.10.0 → 0.11.0

package/dist/modules/api/session.js

@@ -1,6 +1,7 @@
-import { isSupported, getItem, setItem, removeItem, SESSION_ID_BYTES } from "../utils";
-import { debug, generateUniqueId, now } from "../utils";
+import { isSupported, getItem, setItem, removeItem } from "../utils";
+import { debug, now } from "../utils";
 import { info, warn } from "../utils";
+import { generateSessionId } from "../utils/session-id";
 const SESSION_STORAGE_KEY = "d0_session";
 const STORAGE_SEPARATOR_KEY = "#";
 const DEFAULT_SESSION_INACTIVITY_TIMEOUT_MILLIS = 1000 * 60 * 60 * 3;
@@ -10,6 +11,8 @@ export let sessionId = null;
 export function trackSessions(sessionInactivityTimeoutMillis, sessionTerminationTimeoutMillis) {
     if (!isSupported) {
         debug("Storage API is not available and session tracking is therefore not supported.");
+        // we still generate a session ID to ensure that the session ID is always available
+        sessionId = generateSessionId();
         return;
     }
     if (!sessionInactivityTimeoutMillis) {
@@ -31,7 +34,7 @@ export function trackSessions(sessionInactivityTimeoutMillis, sessionTermination
         }
         else {
             session = {
-                id: generateUniqueId(SESSION_ID_BYTES),
+                id: generateSessionId(),
                 startTime: now(),
                 lastActivityTime: now(),
             };
@@ -43,8 +46,10 @@ export function trackSessions(sessionInactivityTimeoutMillis, sessionTermination
         warn("Failed to record session information", e);
     }
 }
+/**
+ * The session will be terminated. This only takes effect on the next physical page load.
+ */
 export function terminateSession() {
-    sessionId = null;
     if (!isSupported) {
         return;
     }

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

@@ -5,9 +5,9 @@ import { sendLog } from "../transport";
 import { addAttribute } from "../utils/otel";
 import { addCommonAttributes } from "../attributes";
 export function startWebVitalsInstrumentation() {
-    onLCP(onWebVital);
-    onINP(onWebVital);
-    onCLS(onWebVital);
+    onLCP(onWebVital, { reportAllChanges: true });
+    onINP(onWebVital, { reportAllChanges: true });
+    onCLS(onWebVital, { reportAllChanges: true });
 }
 function onWebVital(metric) {
     const attributes = [];

package/dist/modules/utils/id.js

@@ -1,7 +1,7 @@
 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 SESSION_ID_BYTES = SPAN_ID_BYTES;
 export const TAB_ID_BYTES = SPAN_ID_BYTES;
 const SHARED_CHAR_CODES_ARRAY = Array(32);
 export function generateUniqueId(byteCount) {

package/dist/modules/utils/id_test.js

@@ -10,7 +10,7 @@ function generateId(length) {
     }
     return generateUniqueId(Math.ceil(length / 2)).substring(0, length);
 }
-describe("generateId", () => {
+describe("generateUniqueId", () => {
     it("returns a string of the expected length", () => {
         const id = generateId(10);
         expect(id).toHaveLength(10);

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

@@ -1,9 +1,11 @@
 import { nowNanos } from "../time";
-import { generateUniqueId, SPAN_ID_BYTES, TRACE_ID_BYTES } from "../id";
+import { generateUniqueId, SPAN_ID_BYTES } from "../id";
 import { SPAN_KIND_CLIENT, SPAN_STATUS_UNSET } from "../../semantic-conventions";
+import { sessionId } from "../../api/session";
+import { generateTraceId } from "../trace-id";
 export function startSpan(name) {
     return {
-        traceId: generateUniqueId(TRACE_ID_BYTES),
+        traceId: generateTraceId(sessionId),
         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

package/dist/modules/utils/otel/trace-context.js

@@ -51,10 +51,12 @@ export function addTraceContextHttpHeaders(fn, ctx, span) {
      * Random Trace ID: 00000010 - IF set the component guarantees that the seven right most bytes of the trace-id
      * are randomly generated. Downstream processors are then able to rely on this for technical things like shard keys.
      *
+     * NOTE: For now we just send the "sampled" flag because not all components support the random trace ID flag.
+     *
      * References:
      * https://www.w3.org/TR/trace-context-2/#traceparent-header
      * https://www.w3.org/TR/trace-context-2/#trace-flags
      * https://www.w3.org/TR/trace-context-2/#random-trace-id-flag
      */
-    fn.call(ctx, "traceparent", `00-${span.traceId}-${span.spanId}-03`);
+    fn.call(ctx, "traceparent", `00-${span.traceId}-${span.spanId}-01`);
 }

package/dist/modules/utils/session-id.js

@@ -0,0 +1,18 @@
+import * as localStorage from "./local-storage";
+import { generateUniqueId, SESSION_ID_BYTES } from "./id";
+const SESSION_FLAGS = {
+    EPHEMERAL_SESSION: 0x01, // 00000001 - if the browser does NOT support local storage we count the session as ephemeral because we cannot persist it
+};
+function encodeSessionFlags(flags) {
+    let byte = 0;
+    if (flags.ephemeralSession) {
+        byte |= SESSION_FLAGS.EPHEMERAL_SESSION;
+    }
+    return byte.toString(16).padStart(2, "0");
+}
+export function generateSessionId() {
+    const sessionFlags = {
+        ephemeralSession: !localStorage.isSupported,
+    };
+    return `${encodeSessionFlags(sessionFlags)}${generateUniqueId(SESSION_ID_BYTES - 1)}`;
+}

package/dist/modules/utils/session-id_test.js

@@ -0,0 +1,26 @@
+import { describe, expect, it, vi } from "vitest";
+import { generateSessionId } from "./session-id";
+import * as localStorage from "./local-storage";
+describe("generateSessionId", () => {
+    it("returns a session ID of the expected length", () => {
+        const sessionId = generateSessionId();
+        expect(sessionId).toHaveLength(16);
+    });
+    it("returns a session ID with proper flags when storage is supported", () => {
+        vi.spyOn(localStorage, "isSupported", "get").mockReturnValue(true);
+        const sessionId = generateSessionId();
+        console.log(sessionId);
+        expect(sessionId.startsWith("00")).toBe(true);
+    });
+    it("returns a session ID with proper flags when storage is NOT supported", () => {
+        vi.spyOn(localStorage, "isSupported", "get").mockReturnValue(false);
+        const sessionId = generateSessionId();
+        console.log(sessionId);
+        expect(sessionId.startsWith("01")).toBe(true);
+    });
+    it("returns a unique session ID on each call", () => {
+        const sessionId1 = generateSessionId();
+        const sessionId2 = generateSessionId();
+        expect(sessionId1).not.toBe(sessionId2);
+    });
+});

package/dist/modules/utils/trace-id.js

@@ -0,0 +1,18 @@
+import { generateUniqueId, SESSION_ID_BYTES, TRACE_ID_BYTES } from "./id";
+const TRACE_ID_PREFIX = "d042";
+const TRACE_FLAGS = {
+    WITHOUT_SESSION: 0x01, // 00000001 - in some edge cases we do not have a session ID, so we need to mark the trace as such
+};
+function encodeTraceFlags(flags) {
+    let byte = 0;
+    if (flags.withoutSession) {
+        byte |= TRACE_FLAGS.WITHOUT_SESSION;
+    }
+    return byte.toString(16).padStart(2, "0");
+}
+export function generateTraceId(sessionId) {
+    if (!sessionId) {
+        return `${TRACE_ID_PREFIX}${encodeTraceFlags({ withoutSession: true })}${generateUniqueId(TRACE_ID_BYTES - 3)}`;
+    }
+    return `${TRACE_ID_PREFIX}${encodeTraceFlags({ withoutSession: false })}${sessionId}${generateUniqueId(TRACE_ID_BYTES - SESSION_ID_BYTES - 3)}`;
+}

package/dist/modules/utils/trace-id_test.js

@@ -0,0 +1,32 @@
+import { expect, describe, it } from "vitest";
+import { generateTraceId } from "./trace-id";
+describe("generateTraceId", () => {
+    it("returns a trace ID of the expected length", () => {
+        const traceId = generateTraceId(null);
+        expect(traceId).toHaveLength(32);
+    });
+    it("returns a trace ID with correct prefix when a session id is set", () => {
+        const traceId = generateTraceId("abcdef1234567890");
+        expect(traceId.substring(0, 6)).toEqual("d04200");
+    });
+    it("returns a trace ID with correct prefix when NOT session is set", () => {
+        const traceId = generateTraceId(null);
+        expect(traceId.substring(0, 6)).toEqual("d04201");
+    });
+    it("returns a unique trace ID on each call", () => {
+        const sessiondId = "abcdef1234567890";
+        const traceId1 = generateTraceId("abcdef1234567890");
+        const traceId2 = generateTraceId("abcdef1234567890");
+        expect(traceId1).not.toBe(traceId2);
+        expect(traceId1.substring(6, 22)).toBe(sessiondId);
+        expect(traceId2.substring(6, 22)).toBe(sessiondId);
+    });
+    it("returns a unique trace ID when session id is not set", () => {
+        const traceId1 = generateTraceId(null);
+        const sessionId1 = traceId1.substring(6, 22);
+        const traceId2 = generateTraceId(null);
+        const sessionId2 = traceId2.substring(6, 22);
+        expect(traceId1).not.toBe(traceId2);
+        expect(sessionId1).not.toBe(sessionId2);
+    });
+});