@dash0/sdk-web 0.10.1 → 0.11.1

package/src/utils/otel/span.ts

@@ -1,13 +1,15 @@
 import { KeyValue, Span, SpanStatus } from "../../../types/otlp";
 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 type InProgressSpan = Omit<Span, "endTimeUnixNano">;
 
 export function startSpan(name: string): InProgressSpan {
   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/src/utils/otel/trace-context.ts

@@ -75,10 +75,12 @@ export function addTraceContextHttpHeaders(
    * 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/src/utils/session-id.ts

@@ -0,0 +1,27 @@
+import * as localStorage from "./local-storage";
+import { generateUniqueId, SESSION_ID_BYTES } from "./id";
+
+type SessionFlags = {
+  ephemeralSession: boolean;
+};
+
+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
+} as const;
+
+function encodeSessionFlags(flags: SessionFlags): string {
+  let byte = 0;
+  if (flags.ephemeralSession) {
+    byte |= SESSION_FLAGS.EPHEMERAL_SESSION;
+  }
+
+  return byte.toString(16).padStart(2, "0");
+}
+
+export function generateSessionId(): string {
+  const sessionFlags = {
+    ephemeralSession: !localStorage.isSupported,
+  };
+
+  return `${encodeSessionFlags(sessionFlags)}${generateUniqueId(SESSION_ID_BYTES - 1)}`;
+}

package/src/utils/session-id_test.ts

@@ -0,0 +1,33 @@
+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/src/utils/trace-id.ts

@@ -0,0 +1,27 @@
+import { generateUniqueId, SESSION_ID_BYTES, TRACE_ID_BYTES } from "./id";
+
+type TraceFlags = {
+  withoutSession: boolean;
+};
+
+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
+} as const;
+
+function encodeTraceFlags(flags: TraceFlags): string {
+  let byte = 0;
+  if (flags.withoutSession) {
+    byte |= TRACE_FLAGS.WITHOUT_SESSION;
+  }
+
+  return byte.toString(16).padStart(2, "0");
+}
+
+export function generateTraceId(sessionId: string | null): string {
+  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/src/utils/trace-id_test.ts

@@ -0,0 +1,42 @@
+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);
+  });
+});