@dash0/sdk-web 0.23.0 → 0.25.0

package/src/instrumentations/session-recording/chunker_test.ts

@@ -0,0 +1,147 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { Chunk, newChunker } from "./chunker";
+
+// The SDK's timer wrapper captures window.setTimeout at import time, before vitest installs fake timers.
+// Resolve the globals lazily so vi.useFakeTimers() takes effect.
+vi.mock("../../utils/timers", () => ({
+  setTimeout: (...args: Parameters<typeof globalThis.setTimeout>) => globalThis.setTimeout(...args),
+  clearTimeout: (...args: Parameters<typeof globalThis.clearTimeout>) => globalThis.clearTimeout(...args),
+}));
+
+const META = 4;
+const FULL_SNAPSHOT = 2;
+const INCREMENTAL = 3;
+
+function event(type: number, timestamp: number, data: unknown = {}) {
+  return { type, timestamp, data };
+}
+
+describe("session recording chunker", () => {
+  let chunks: Chunk[];
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    chunks = [];
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  function create(maxBytes = 10_000, maxMillis = 5000) {
+    return newChunker({ maxBytes, maxMillis, onChunk: (c) => chunks.push(c) });
+  }
+
+  it("does nothing on flush when empty", () => {
+    const chunker = create();
+    chunker.flush();
+    expect(chunks).toEqual([]);
+  });
+
+  it("discards buffered events and the pending time-based flush", () => {
+    const chunker = create();
+    chunker.add(event(META, 1000));
+    chunker.add(event(FULL_SNAPSHOT, 1001));
+
+    chunker.discard();
+    vi.advanceTimersByTime(10_000);
+    expect(chunks).toEqual([]);
+
+    // The chunker stays usable, and the dropped events do not leak into the next chunk.
+    chunker.add(event(INCREMENTAL, 2000));
+    chunker.flush();
+    expect(chunks).toHaveLength(1);
+    expect(chunks[0]!.seq).toBe(0);
+    expect(chunks[0]!.eventCount).toBe(1);
+    expect(chunks[0]!.hasSnapshot).toBe(false);
+  });
+
+  it("flushes on explicit flush with a serialized JSON array body", () => {
+    const chunker = create();
+    chunker.add(event(META, 1000, { href: "http://x" }));
+    chunker.add(event(FULL_SNAPSHOT, 1001));
+    chunker.add(event(INCREMENTAL, 1002));
+    chunker.flush();
+
+    expect(chunks).toHaveLength(1);
+    const chunk = chunks[0]!;
+    expect(chunk.seq).toBe(0);
+    expect(chunk.eventCount).toBe(3);
+    expect(chunk.hasSnapshot).toBe(true);
+    expect(chunk.startTime).toBe(1000);
+    expect(chunk.endTime).toBe(1002);
+    expect(JSON.parse(chunk.body)).toEqual([
+      { type: META, timestamp: 1000, data: { href: "http://x" } },
+      { type: FULL_SNAPSHOT, timestamp: 1001, data: {} },
+      { type: INCREMENTAL, timestamp: 1002, data: {} },
+    ]);
+  });
+
+  it("flushes when maxMillis elapse after the first event", () => {
+    const chunker = create(10_000, 5000);
+    chunker.add(event(INCREMENTAL, 1));
+    vi.advanceTimersByTime(4999);
+    expect(chunks).toHaveLength(0);
+    chunker.add(event(INCREMENTAL, 2));
+    vi.advanceTimersByTime(1);
+    expect(chunks).toHaveLength(1);
+    expect(chunks[0]!.eventCount).toBe(2);
+  });
+
+  it("flushes when the serialized size reaches maxBytes", () => {
+    const chunker = create(100, 60_000);
+    const payload = "x".repeat(40);
+    chunker.add(event(INCREMENTAL, 1, payload)); // ~70 bytes
+    expect(chunks).toHaveLength(0);
+    chunker.add(event(INCREMENTAL, 2, payload)); // crosses 100
+    expect(chunks).toHaveLength(1);
+    expect(chunks[0]!.eventCount).toBe(2);
+  });
+
+  it("emits an oversized single event as its own chunk", () => {
+    const chunker = create(50, 60_000);
+    chunker.add(event(FULL_SNAPSHOT, 1, "y".repeat(500)));
+    expect(chunks).toHaveLength(1);
+    expect(chunks[0]!.eventCount).toBe(1);
+    expect(chunks[0]!.hasSnapshot).toBe(true);
+  });
+
+  it("closes the current chunk when a Meta event starts a new snapshot", () => {
+    const chunker = create();
+    chunker.add(event(META, 1));
+    chunker.add(event(FULL_SNAPSHOT, 2));
+    chunker.add(event(INCREMENTAL, 3));
+    expect(chunks).toHaveLength(0);
+
+    chunker.add(event(META, 4));
+    expect(chunks).toHaveLength(1);
+    expect(chunks[0]!.eventCount).toBe(3);
+
+    chunker.add(event(FULL_SNAPSHOT, 5));
+    chunker.flush();
+    expect(chunks).toHaveLength(2);
+    expect(chunks[1]!.eventCount).toBe(2);
+    expect(chunks[1]!.hasSnapshot).toBe(true);
+  });
+
+  it("increments seq across chunks and resets hasSnapshot", () => {
+    const chunker = create();
+    chunker.add(event(FULL_SNAPSHOT, 1));
+    chunker.flush();
+    chunker.add(event(INCREMENTAL, 2));
+    chunker.flush();
+    chunker.add(event(INCREMENTAL, 3));
+    chunker.flush();
+
+    expect(chunks.map((c) => c.seq)).toEqual([0, 1, 2]);
+    expect(chunks.map((c) => c.hasSnapshot)).toEqual([true, false, false]);
+  });
+
+  it("cancels the pending timer on flush so it does not fire twice", () => {
+    const chunker = create(10_000, 1000);
+    chunker.add(event(INCREMENTAL, 1));
+    chunker.flush();
+    vi.advanceTimersByTime(5000);
+    expect(chunks).toHaveLength(1);
+  });
+});

package/src/instrumentations/session-recording/index.ts

@@ -0,0 +1,175 @@
+import { vars } from "../../vars";
+import { sessionId } from "../../api/session";
+import { debug, generateUniqueId, isSessionSampledIn, TRACE_ID_BYTES, warn, win } from "../../utils";
+import { generateTraceId } from "../../utils/trace-id";
+import { generateSpanId } from "../../utils/span-id";
+import { isUrlIgnored } from "../../utils/ignore-rules";
+import { onLastChance } from "../../utils/on-last-chance";
+import { sendSessionRecordingChunk } from "../../transport";
+import { SessionRecorder, SessionRecordingEvent } from "../../types/session-recording";
+import { Chunker, newChunker } from "./chunker";
+import { buildSessionRecordingLog, RecordingStream } from "./log";
+
+/**
+ * Global set by `dash0-session-recording.iife.js`. Read by `armSessionRecording()` and by
+ * `startSessionRecording()` when called without a recorder.
+ */
+export const GLOBAL_RECORDER_KEY = "dash0Recorder";
+
+let recorder: SessionRecorder | undefined;
+let armed = false;
+let stopRecorder: (() => void) | undefined;
+let chunker: Chunker | undefined;
+let lastChanceRegistered = false;
+// True while the last-chance handler flushes. The chunk emitted then must be sent uncompressed: gzip is
+// asynchronous, and a document that is being unloaded may never get to the `fetch()` behind the await.
+let flushingOnLastChance = false;
+
+/**
+ * Makes a recorder available. Called from the public `startSessionRecording` API, which the
+ * `dash0-session-recording.iife.js` script and npm consumers use. Recording starts as soon as both a recorder
+ * is registered and `init()` has armed session recording, in either order.
+ */
+export function registerSessionRecorder(r: SessionRecorder): void {
+  recorder = r;
+  if (armed) {
+    start();
+  }
+}
+
+/**
+ * Called from `init()` once configuration is in place and the session is sampled.
+ *
+ * Recorder precedence: `sessionRecording.recorder` from the init options, then a recorder registered through
+ * `startSessionRecording(recorder)`, then `window.dash0Recorder`. The last one is set by
+ * `dash0-session-recording.iife.js`, and is the only handover that works when that script executes before the
+ * initializer snippet has defined the `dash0` command queue.
+ */
+export function armSessionRecording(): void {
+  armed = true;
+  if (vars.sessionRecording.recorder) {
+    recorder = vars.sessionRecording.recorder;
+  } else if (!recorder) {
+    const globalRecorder = (win as any)?.[GLOBAL_RECORDER_KEY];
+    if (typeof globalRecorder === "function") {
+      recorder = globalRecorder as SessionRecorder;
+    }
+  }
+  if (recorder) {
+    start();
+  }
+}
+
+export function stopSessionRecording(): void {
+  if (stopRecorder) {
+    try {
+      stopRecorder();
+    } catch (e) {
+      debug("Failed to stop session recorder", e);
+    }
+    stopRecorder = undefined;
+  }
+  chunker?.flush();
+  chunker = undefined;
+}
+
+export function isSessionRecording(): boolean {
+  return stopRecorder != null;
+}
+
+function start(): void {
+  if (stopRecorder) {
+    debug("Session recording already running. Ignoring start.");
+    return;
+  }
+  if (!recorder || !win) return;
+
+  const settings = vars.sessionRecording;
+
+  if (!vars.isSessionSampled) {
+    debug("Session is not sampled. Session recording will not start.");
+    return;
+  }
+  if (!isSessionSampledIn(sessionId ?? "", settings.samplingRate ?? 100)) {
+    debug("Session is not sampled for recording. Session recording will not start.");
+    return;
+  }
+  if (isUrlIgnored(win.location.href)) {
+    debug("Page URL is ignored. Session recording will not start.");
+    return;
+  }
+
+  const traceId = generateTraceId(sessionId);
+  const stream: RecordingStream = {
+    recordingId: generateUniqueId(TRACE_ID_BYTES),
+    traceId,
+    spanId: generateSpanId(traceId),
+  };
+
+  const c = newChunker({
+    maxBytes: settings.chunkMaxBytes ?? 48000,
+    maxMillis: settings.chunkMaxMillis ?? 5000,
+    onChunk: (chunk) => {
+      try {
+        sendSessionRecordingChunk(buildSessionRecordingLog(stream, chunk), { compress: !flushingOnLastChance });
+      } catch (e) {
+        warn("Failed to transmit session recording chunk", e);
+      }
+    },
+  });
+  chunker = c;
+
+  try {
+    stopRecorder = recorder({
+      // rrweb can still emit after its stop function ran (trailing throttle timers), and a recorder that failed
+      // to start may have emitted already. Only accept events while this chunker is the active one.
+      emit: (event: SessionRecordingEvent) => {
+        if (chunker === c) c.add(event);
+      },
+      checkoutEveryNms: settings.checkoutEveryNms,
+      maskAllInputs: settings.maskAllInputs,
+      maskTextClass: settings.maskTextClass,
+      maskTextSelector: settings.maskTextSelector,
+      maskInputFn: settings.maskInputFn,
+      maskTextFn: settings.maskTextFn,
+      blockClass: settings.blockClass,
+      blockSelector: settings.blockSelector,
+      recordCanvas: settings.recordCanvas,
+      collectFonts: settings.collectFonts,
+    });
+  } catch (e) {
+    warn("Failed to start session recorder", e);
+    abandonChunker(c);
+    return;
+  }
+
+  if (!stopRecorder) {
+    // rrweb returns undefined when it refuses to record, e.g. in an unsupported environment.
+    warn("Session recorder did not start.");
+    abandonChunker(c);
+    return;
+  }
+
+  if (!lastChanceRegistered) {
+    lastChanceRegistered = true;
+    onLastChance(() => {
+      flushingOnLastChance = true;
+      try {
+        chunker?.flush();
+      } finally {
+        flushingOnLastChance = false;
+      }
+    });
+  }
+
+  debug("Session recording started", stream);
+}
+
+/**
+ * The recorder did not start, but it may already have emitted events into `c` and armed its flush timer. Drop
+ * them so no chunk of a stream that never started is transmitted later.
+ */
+function abandonChunker(c: Chunker): void {
+  c.discard();
+  chunker = undefined;
+}

package/src/instrumentations/session-recording/index_test.ts

@@ -0,0 +1,273 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { SessionRecorder, SessionRecorderOptions } from "../../types/session-recording";
+import { win } from "../../utils";
+
+vi.mock("../../transport", () => ({
+  sendSessionRecordingChunk: vi.fn(),
+  sendLog: vi.fn(),
+  sendSpan: vi.fn(),
+}));
+
+vi.mock("../../api/session", () => ({
+  sessionId: "aabbccdd11223344",
+}));
+
+type Module = typeof import("./index");
+
+describe("session recording lifecycle", () => {
+  let mod: Module;
+  let vars: typeof import("../../vars").vars;
+  let sendSessionRecordingChunk: ReturnType<typeof vi.fn>;
+  let stopFn: ReturnType<typeof vi.fn>;
+  let recorder: ReturnType<typeof vi.fn> & SessionRecorder;
+  let capturedOptions: SessionRecorderOptions | undefined;
+
+  beforeEach(async () => {
+    vi.resetModules();
+    vi.useFakeTimers();
+    mod = await import("./index");
+    vars = (await import("../../vars")).vars;
+    sendSessionRecordingChunk = (await import("../../transport")).sendSessionRecordingChunk as any;
+    sendSessionRecordingChunk.mockClear();
+
+    vars.isSessionSampled = true;
+    vars.ignoreUrls = [];
+    vars.endpoints = [{ url: "https://ingress.example.com", authToken: "x" }];
+    vars.sessionRecording = { ...vars.sessionRecording, samplingRate: 100, recorder: undefined };
+
+    stopFn = vi.fn();
+    capturedOptions = undefined;
+    recorder = vi.fn((opts: SessionRecorderOptions) => {
+      capturedOptions = opts;
+      return stopFn;
+    }) as any;
+  });
+
+  afterEach(() => {
+    mod.stopSessionRecording();
+    vi.useRealTimers();
+  });
+
+  it("does not start before init arms recording", () => {
+    mod.registerSessionRecorder(recorder);
+    expect(recorder).not.toHaveBeenCalled();
+    expect(mod.isSessionRecording()).toBe(false);
+  });
+
+  it("starts when armed after the recorder was registered", () => {
+    mod.registerSessionRecorder(recorder);
+    mod.armSessionRecording();
+    expect(recorder).toHaveBeenCalledTimes(1);
+    expect(mod.isSessionRecording()).toBe(true);
+  });
+
+  it("starts when the recorder is registered after arming", () => {
+    mod.armSessionRecording();
+    expect(recorder).not.toHaveBeenCalled();
+    mod.registerSessionRecorder(recorder);
+    expect(recorder).toHaveBeenCalledTimes(1);
+  });
+
+  it("picks up window.dash0Recorder when arming, so the recorder script may run before the initializer", () => {
+    (win as any).dash0Recorder = recorder;
+    try {
+      mod.armSessionRecording();
+      expect(recorder).toHaveBeenCalledTimes(1);
+      expect(mod.isSessionRecording()).toBe(true);
+    } finally {
+      delete (win as any).dash0Recorder;
+    }
+  });
+
+  it("prefers an explicitly registered recorder over window.dash0Recorder", () => {
+    const globalRecorder = vi.fn(() => vi.fn());
+    (win as any).dash0Recorder = globalRecorder;
+    try {
+      mod.registerSessionRecorder(recorder);
+      mod.armSessionRecording();
+      expect(recorder).toHaveBeenCalledTimes(1);
+      expect(globalRecorder).not.toHaveBeenCalled();
+    } finally {
+      delete (win as any).dash0Recorder;
+    }
+  });
+
+  it("ignores a window.dash0Recorder that is not a function", () => {
+    (win as any).dash0Recorder = "nope";
+    try {
+      mod.armSessionRecording();
+      expect(mod.isSessionRecording()).toBe(false);
+    } finally {
+      delete (win as any).dash0Recorder;
+    }
+  });
+
+  it("uses the recorder from vars.sessionRecording.recorder", () => {
+    vars.sessionRecording.recorder = recorder;
+    mod.armSessionRecording();
+    expect(recorder).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not start twice", () => {
+    mod.armSessionRecording();
+    mod.registerSessionRecorder(recorder);
+    mod.registerSessionRecorder(recorder);
+    mod.armSessionRecording();
+    expect(recorder).toHaveBeenCalledTimes(1);
+  });
+
+  it("forwards privacy settings to the recorder with masking on by default", () => {
+    mod.armSessionRecording();
+    mod.registerSessionRecorder(recorder);
+
+    expect(capturedOptions).toMatchObject({
+      maskAllInputs: true,
+      maskTextClass: "dash0-mask",
+      blockClass: "dash0-block",
+      recordCanvas: false,
+      collectFonts: false,
+      checkoutEveryNms: 300000,
+    });
+    expect(typeof capturedOptions!.emit).toBe("function");
+  });
+
+  it("does not start when the session is not sampled", () => {
+    vars.isSessionSampled = false;
+    mod.armSessionRecording();
+    mod.registerSessionRecorder(recorder);
+    expect(recorder).not.toHaveBeenCalled();
+  });
+
+  it("does not start when the recording sampling rate excludes the session", () => {
+    vars.sessionRecording.samplingRate = 0;
+    mod.armSessionRecording();
+    mod.registerSessionRecorder(recorder);
+    expect(recorder).not.toHaveBeenCalled();
+  });
+
+  it("does not start when the page url is ignored", () => {
+    vars.ignoreUrls = [/localhost/];
+    mod.armSessionRecording();
+    mod.registerSessionRecorder(recorder);
+    expect(recorder).not.toHaveBeenCalled();
+  });
+
+  it("survives a recorder that throws", () => {
+    const throwing = vi.fn(() => {
+      throw new Error("boom");
+    }) as any;
+    mod.armSessionRecording();
+    mod.registerSessionRecorder(throwing);
+    expect(mod.isSessionRecording()).toBe(false);
+  });
+
+  it("discards events emitted by a recorder that then refuses to start", () => {
+    // rrweb emits Meta + FullSnapshot synchronously and returns undefined when it cannot record.
+    const refusing = vi.fn((opts: SessionRecorderOptions) => {
+      opts.emit({ type: 4, timestamp: 1000, data: {} });
+      opts.emit({ type: 2, timestamp: 1001, data: {} });
+      return undefined;
+    }) as any;
+    mod.armSessionRecording();
+    mod.registerSessionRecorder(refusing);
+
+    expect(mod.isSessionRecording()).toBe(false);
+    vi.advanceTimersByTime(10_000);
+    expect(sendSessionRecordingChunk).not.toHaveBeenCalled();
+
+    // stop must be a harmless no-op afterwards
+    expect(() => mod.stopSessionRecording()).not.toThrow();
+    expect(sendSessionRecordingChunk).not.toHaveBeenCalled();
+  });
+
+  it("swallows a stop function that throws and still resets its state", () => {
+    stopFn.mockImplementation(() => {
+      throw new Error("stop failed");
+    });
+    mod.armSessionRecording();
+    mod.registerSessionRecorder(recorder);
+    capturedOptions!.emit({ type: 3, timestamp: 1, data: {} });
+
+    expect(() => mod.stopSessionRecording()).not.toThrow();
+    expect(mod.isSessionRecording()).toBe(false);
+    // buffered events are still flushed
+    expect(sendSessionRecordingChunk).toHaveBeenCalledTimes(1);
+  });
+
+  it("ignores events the recorder emits after stop", () => {
+    mod.armSessionRecording();
+    mod.registerSessionRecorder(recorder);
+    mod.stopSessionRecording();
+    sendSessionRecordingChunk.mockClear();
+
+    // rrweb's trailing throttle timers can still call emit after its stop function ran.
+    capturedOptions!.emit({ type: 3, timestamp: 1, data: {} });
+    vi.advanceTimersByTime(10_000);
+    expect(sendSessionRecordingChunk).not.toHaveBeenCalled();
+  });
+
+  it("compresses periodic chunks but sends the last-chance flush uncompressed", () => {
+    mod.armSessionRecording();
+    mod.registerSessionRecorder(recorder);
+
+    capturedOptions!.emit({ type: 3, timestamp: 1, data: {} });
+    vi.advanceTimersByTime(5000);
+    expect(sendSessionRecordingChunk).toHaveBeenCalledTimes(1);
+    expect(sendSessionRecordingChunk.mock.calls[0]![1]).toEqual({ compress: true });
+
+    capturedOptions!.emit({ type: 3, timestamp: 2, data: {} });
+    globalThis.dispatchEvent(new Event("pagehide"));
+    expect(sendSessionRecordingChunk).toHaveBeenCalledTimes(2);
+    expect(sendSessionRecordingChunk.mock.calls[1]![1]).toEqual({ compress: false });
+
+    // back to normal once the page keeps running
+    capturedOptions!.emit({ type: 3, timestamp: 3, data: {} });
+    vi.advanceTimersByTime(5000);
+    expect(sendSessionRecordingChunk).toHaveBeenCalledTimes(3);
+    expect(sendSessionRecordingChunk.mock.calls[2]![1]).toEqual({ compress: true });
+  });
+
+  it("transmits chunks that share one trace id embedding the session id", () => {
+    mod.armSessionRecording();
+    mod.registerSessionRecorder(recorder);
+
+    capturedOptions!.emit({ type: 4, timestamp: 1000, data: {} });
+    capturedOptions!.emit({ type: 2, timestamp: 1001, data: {} });
+    vi.advanceTimersByTime(5000);
+    capturedOptions!.emit({ type: 3, timestamp: 7000, data: {} });
+    vi.advanceTimersByTime(5000);
+
+    expect(sendSessionRecordingChunk).toHaveBeenCalledTimes(2);
+    const [first, second] = sendSessionRecordingChunk.mock.calls.map((c) => c[0]);
+
+    expect(first.traceId).toMatch(/^d04200aabbccdd11223344[0-9a-f]{10}$/);
+    expect(second.traceId).toBe(first.traceId);
+    expect(second.spanId).toBe(first.spanId);
+    expect(first.attributes).toEqual(
+      expect.arrayContaining([
+        { key: "event.name", value: { stringValue: "browser.session_recording" } },
+        { key: "dash0.session_recording.seq", value: { intValue: "0" } },
+        { key: "dash0.session_recording.has_snapshot", value: { boolValue: true } },
+      ])
+    );
+    expect(second.attributes).toEqual(
+      expect.arrayContaining([
+        { key: "dash0.session_recording.seq", value: { intValue: "1" } },
+        { key: "dash0.session_recording.has_snapshot", value: { boolValue: false } },
+      ])
+    );
+  });
+
+  it("stops the recorder and flushes buffered events on stop", () => {
+    mod.armSessionRecording();
+    mod.registerSessionRecorder(recorder);
+    capturedOptions!.emit({ type: 3, timestamp: 1, data: {} });
+    expect(sendSessionRecordingChunk).not.toHaveBeenCalled();
+
+    mod.stopSessionRecording();
+
+    expect(stopFn).toHaveBeenCalledTimes(1);
+    expect(sendSessionRecordingChunk).toHaveBeenCalledTimes(1);
+    expect(mod.isSessionRecording()).toBe(false);
+  });
+});

package/src/instrumentations/session-recording/log.ts

@@ -0,0 +1,48 @@
+import { addAttribute } from "../../utils/otel";
+import {
+  EVENT_NAME,
+  EVENT_NAMES,
+  LOG_SEVERITIES,
+  SESSION_RECORDING_END_TIME_UNIX_NANO,
+  SESSION_RECORDING_EVENT_COUNT,
+  SESSION_RECORDING_HAS_SNAPSHOT,
+  SESSION_RECORDING_ID,
+  SESSION_RECORDING_SEQ,
+} from "../../semantic-conventions";
+import { addCommonAttributes } from "../../attributes";
+import { toNanosTs } from "../../utils";
+import { KeyValue, LogRecord } from "../../types/otlp";
+import { Chunk } from "./chunker";
+
+export type RecordingStream = {
+  /**
+   * Identifies one recorder run. All chunks of the run share it.
+   */
+  recordingId: string;
+  /**
+   * Trace context shared by all chunks of the run. The trace ID embeds the session ID.
+   */
+  traceId: string;
+  spanId: string;
+};
+
+export function buildSessionRecordingLog(stream: RecordingStream, chunk: Chunk): LogRecord {
+  const attributes: KeyValue[] = [];
+  addAttribute(attributes, EVENT_NAME, EVENT_NAMES.SESSION_RECORDING);
+  addCommonAttributes(attributes);
+  addAttribute(attributes, SESSION_RECORDING_ID, stream.recordingId);
+  addAttribute(attributes, SESSION_RECORDING_SEQ, { intValue: String(chunk.seq) });
+  addAttribute(attributes, SESSION_RECORDING_EVENT_COUNT, { intValue: String(chunk.eventCount) });
+  addAttribute(attributes, SESSION_RECORDING_HAS_SNAPSHOT, chunk.hasSnapshot);
+  addAttribute(attributes, SESSION_RECORDING_END_TIME_UNIX_NANO, { intValue: toNanosTs(chunk.endTime) });
+
+  return {
+    timeUnixNano: toNanosTs(chunk.startTime),
+    severityNumber: LOG_SEVERITIES.INFO,
+    severityText: "INFO",
+    body: { stringValue: chunk.body },
+    attributes,
+    traceId: stream.traceId,
+    spanId: stream.spanId,
+  };
+}