feat(diagnostics): the debug recorder — start, the pill, steps, screenshots, stop (E16 S2)

- the start dialog is the consent: level (Részletes/Teljes), what is recorded, retention and the cap (now served as diagnostics.session_minutes) - the pill docks under the toasts: elapsed time, Step (an optional label, its own Escape layer), Screenshot (tab capture where the browser has it), Stop; compact on a phone - while recording, lib/log tags every event and every request path (req, beacon, uploadReq via one identityHeaders) names the session; applyDiagnostics raises the level for the session's run and never lowers a raised one, and lapses at whichever ends first - Stop sends what is waiting before the server closes the session; the cap says so and opens the composer - Settings → Diagnosztika and the command palette start/step/stop it - the evidence leaves the log upload's own request lines out - the step shortcut is deliberately palette-only: the keymap's D1 rule bars a new modifier chord, and a bare letter collides with the players'
2026-09-19 22:08:10 +02:00
parent 2d9595b0e5
commit 46fce4a767
26 changed files with 1347 additions and 89 deletions
@@ -0,0 +1,141 @@
+// @vitest-environment jsdom
+//
+// E16: a debug session applied to the tab. It raises the level for its own run (starting it was the
+// consent), never lowers a raised one, tags every event it keeps, and its last seconds reach the
+// server before Stop. Its own file: `lib/diagnostics` and `lib/log` keep module-level state, so every
+// test imports fresh copies of both, as diagnostics.dom.test does.
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const sent: { event: string; debug_session_id?: string }[][] = [];
+
+vi.mock("./api", async () => {
+  const core = await vi.importActual<typeof import("./api/core")>("./api/core");
+  return {
+    HttpError: core.HttpError,
+    DIAGNOSTICS_EVENTS_PATH: "/api/diagnostics/events",
+    api: {
+      sendLogEvents: (events: { event: string }[]) => {
+        sent.push(events);
+        return Promise.resolve({ ok: true, stored: events.length });
+      },
+      sendLogEventsOnUnload: () => {},
+    },
+  };
+});
+
+const BASE = { level: "INFO" as const, until: null, retention_days: 7, session_minutes: 60 };
+const raised = (level: "DEBUG" | "TRACE") => ({
+  ...BASE,
+  level,
+  until: new Date(Date.now() + 24 * 3_600_000).toISOString(),
+});
+const recording = (level: "DEBUG" | "TRACE", minutes = 60, over = {}) => ({
+  id: "0123456789abcdef",
+  level,
+  started_at: new Date().toISOString(),
+  until: new Date(Date.now() + minutes * 60_000).toISOString(),
+  ended_at: null,
+  ended_reason: null,
+  issue_url: null,
+  screenshots: 0,
+  ...over,
+});
+
+let current: typeof import("./diagnostics") | null = null;
+beforeEach(() => {
+  vi.useFakeTimers();
+  vi.resetModules();
+  sent.length = 0;
+});
+afterEach(() => {
+  current?.applyDiagnostics(BASE, null, () => {});
+  current = null;
+  vi.useRealTimers();
+});
+
+async function fresh() {
+  const diagnostics = await import("./diagnostics");
+  current = diagnostics;
+  return { ...diagnostics, ...(await import("./log")) };
+}
+
+const flat = () => sent.flat();
+
+describe("a debug session applied to the tab", () => {
+  it("raises the base level to its own, and tags and streams what it keeps", async () => {
+    const d = await fresh();
+    d.applyDiagnostics(BASE, recording("DEBUG"), () => {});
+    expect(d.enabled("DEBUG")).toBe(true);
+    expect(d.currentDebugSession()).toBe("0123456789abcdef");
+    d.log.debug("ui.click", "click");
+    expect(d.events().slice(-1)[0]?.debug_session_id).toBe("0123456789abcdef");
+    await vi.advanceTimersByTimeAsync(5_000);
+    const click = flat().find((e) => e.event === "ui.click");
+    expect(click?.debug_session_id).toBe("0123456789abcdef");
+  });
+
+  it("never lowers a level the user raised further", async () => {
+    const d = await fresh();
+    d.applyDiagnostics(raised("TRACE"), recording("DEBUG"), () => {});
+    expect(d.enabled("TRACE")).toBe(true);
+    expect(d.currentDebugSession()).toBe("0123456789abcdef");
+  });
+
+  it("an ended session records nothing and tags nothing", async () => {
+    const d = await fresh();
+    d.applyDiagnostics(
+      BASE,
+      recording("DEBUG", 60, { ended_at: new Date().toISOString() }),
+      () => {},
+    );
+    expect(d.currentDebugSession()).toBeNull();
+    expect(d.enabled("DEBUG")).toBe(false);
+  });
+
+  it("at its cap it lapses back to the user's own level, untagged", async () => {
+    const d = await fresh();
+    const lapsed = vi.fn();
+    d.applyDiagnostics(raised("DEBUG"), recording("TRACE", 1), lapsed);
+    expect(d.enabled("TRACE")).toBe(true);
+    await vi.advanceTimersByTimeAsync(60_000);
+    expect(d.currentDebugSession()).toBeNull();
+    // The user's own Részletes is still in force — the session's end is not the consent's.
+    expect(d.enabled("DEBUG")).toBe(true);
+    expect(d.enabled("TRACE")).toBe(false);
+    expect(lapsed).toHaveBeenCalled();
+  });
+
+  it("at its cap the tag goes even when the user's own level outlasts the session", async () => {
+    // Own Teljes for 24 h, a Részletes session for 1 min: the level never changes, so only the
+    // session's own end can take its tag off the events that follow.
+    const d = await fresh();
+    d.applyDiagnostics(raised("TRACE"), recording("DEBUG", 1), () => {});
+    expect(d.currentDebugSession()).toBe("0123456789abcdef");
+    await vi.advanceTimersByTimeAsync(60_000);
+    expect(d.currentDebugSession()).toBeNull();
+    expect(d.enabled("TRACE")).toBe(true);
+    d.log.debug("ui.after", "after");
+    expect(d.events().slice(-1)[0]?.debug_session_id).toBeUndefined();
+  });
+
+  it("starting a recording on a raised level drops nothing already waiting", async () => {
+    const d = await fresh();
+    d.applyDiagnostics(raised("DEBUG"), null, () => {});
+    d.log.debug("ui.before", "before");
+    d.applyDiagnostics(raised("DEBUG"), recording("TRACE"), () => {});
+    d.log.debug("ui.after", "after");
+    await vi.advanceTimersByTimeAsync(5_000);
+    const codes = flat().map((e) => e.event);
+    expect(codes).toEqual(expect.arrayContaining(["ui.before", "ui.after"]));
+  });
+
+  it("flushNow sends what is waiting at once — before Stop closes the session", async () => {
+    const d = await fresh();
+    d.applyDiagnostics(BASE, recording("DEBUG"), () => {});
+    d.log.info("debug.step", "the last step");
+    expect(flat().some((e) => e.event === "debug.step")).toBe(false);
+    await d.flushNow();
+    const step = flat().find((e) => e.event === "debug.step");
+    expect(step?.debug_session_id).toBe("0123456789abcdef");
+  });
+});