From b7c41490cc14d0dd934b3bc1fe8743261243bf4e Mon Sep 17 00:00:00 2001 From: Dotta Date: Tue, 10 Nov 2026 10:34:48 -0600 Subject: [PATCH] perf(ui): keep the live socket when a cached session is verified A session restored from the saved query cache has no session id. When the first session read answered with one for the same user, the live-updates socket key changed, the socket reconnected, and that second open refreshed every active query, session and health included: the duplicate wave of reads about 1.5-2.5 s after a returning hard load. The socket key now adopts the verified session id for the same user without reconnecting. A different user, or a different session id once one is known, still reconnects. The initial catch-up read for events between the first reads and the subscription is unchanged. Co-Authored-By: Claude Opus 5.5 --- tests/perf/collections/README.md | 12 ++ .../collections/returning-visit-fixture.ts | 129 ++++++++++++++++++ .../perf/collections/shell-read-waves.spec.ts | 52 +++++++ .../LiveUpdatesProvider.recovery.test.tsx | 34 +++++ ui/src/context/LiveUpdatesProvider.tsx | 25 +++- 5 files changed, 251 insertions(+), 1 deletion(-) create mode 100644 tests/perf/collections/returning-visit-fixture.ts create mode 100644 tests/perf/collections/shell-read-waves.spec.ts diff --git a/tests/perf/collections/README.md b/tests/perf/collections/README.md index 66c5c778290..408d5d03b2e 100644 --- a/tests/perf/collections/README.md +++ b/tests/perf/collections/README.md @@ -61,6 +61,18 @@ navigation start to the first Mine row (two frames after mount) over a native scenario without request interception and a separate diagnostic scenario that delays workspace reads by 3 seconds. The timings are attached evidence, not budgets. +`shell-read-waves.spec.ts` hard loads Mine with every API response delayed +300 ms and counts the shell and inbox reads that used to repeat about 1.5–2.5 s +after load (session, health, company list, agents, inbox dismissals, user +directory, approvals, execution workspaces). With the saved query cache +(`paperclip:query-cache:v1::`, primed by one earlier visit in +the same browser context) each read happens at most once and the live socket +opens once. Without it, the socket's catch-up read may repeat reads that +answered before the subscription, but never the session or health read. The +fixture (`returning-visit-fixture.ts`) is a company with 24 Mine tasks and +three pending board approvals, retained in +`test-results/collections/mine-returning-visit-fixture.json`. + `recent-task-open.spec.ts` covers opening a task from the sidebar's Recents. It gives eight fixture tasks twelve saved comments each and seeds them as the account's Recents. An idle Projects page must make exactly one diff --git a/tests/perf/collections/returning-visit-fixture.ts b/tests/perf/collections/returning-visit-fixture.ts new file mode 100644 index 00000000000..2a697dbd83b --- /dev/null +++ b/tests/perf/collections/returning-visit-fixture.ts @@ -0,0 +1,129 @@ +import fs from "node:fs/promises"; +import { expect, type APIRequestContext, type Browser, type BrowserContext, type Page } from "@playwright/test"; + +// A company with Mine tasks and pending board approvals, for hard loads of +// Mine with and without the saved query cache +// (`paperclip:query-cache:v1::`). Retained in +// test-results/collections with the same 404 rule as the other fixtures. +export type ReturningVisitFixture = { + company: { id: string; issuePrefix: string }; + tasks: Array<{ id: string; identifier: string }>; + approvalIds: string[]; +}; +const fixturePath = "test-results/collections/mine-returning-visit-fixture.json"; +const TASK_COUNT = 24; +const APPROVAL_COUNT = 3; + +export async function returningVisitFixture(request: APIRequestContext): Promise { + const saved = await fs.readFile(fixturePath, "utf8").then(text => JSON.parse(text) as ReturningVisitFixture).catch(error => { + if (error.code !== "ENOENT") throw error; + return null; + }); + if (saved) { + const existing = await request.get(`/api/companies/${saved.company.id}`); + if (existing.ok()) return saved; + expect(existing.status(), await existing.text()).toBe(404); + } + const created = await request.post("/api/companies", { data: { name: "Mine returning visit fixture" } }); + expect(created.ok(), await created.text()).toBeTruthy(); + const company = await created.json() as ReturningVisitFixture["company"]; + const tasks: ReturningVisitFixture["tasks"] = []; + for (let index = 0; index < TASK_COUNT; index++) { + const response = await request.post(`/api/companies/${company.id}/issues`, { data: { title: `Returning visit task ${index}`, status: "todo" } }); + expect(response.ok(), await response.text()).toBeTruthy(); + const task = await response.json(); + tasks.push({ id: task.id, identifier: task.identifier }); + } + const approvalIds: string[] = []; + for (let index = 0; index < APPROVAL_COUNT; index++) { + const response = await request.post(`/api/companies/${company.id}/approvals`, { data: { + type: "request_board_approval", payload: { title: `Returning visit approval ${index}`, summary: "Synthetic decision context." }, + } }); + expect(response.ok(), await response.text()).toBeTruthy(); + approvalIds.push((await response.json()).id); + } + const fixture = { company, tasks, approvalIds }; + await fs.mkdir("test-results/collections", { recursive: true }); + await fs.writeFile(fixturePath, JSON.stringify(fixture)); + return fixture; +} + +export const minePath = (fixture: ReturningVisitFixture) => `/${fixture.company.issuePrefix}/issues?view=mine`; +export const firstMineRow = (page: Page) => page.locator("[data-inbox-issue-link]").first(); +export type StorageState = Awaited>; +export const freshContext = (browser: Browser, baseURL: string | undefined, storageState?: StorageState) => + browser.newContext({ baseURL, serviceWorkers: "block", viewport: { width: 1440, height: 900 }, storageState }); + +/** Visits Mine once and returns the browser storage that visit saved, including the query cache. */ +export async function savedQueryCache(browser: Browser, baseURL: string | undefined, fixture: ReturningVisitFixture): Promise { + const context = await freshContext(browser, baseURL); + try { + const page = await context.newPage(); + await page.goto(minePath(fixture)); + await expect(firstMineRow(page)).toBeVisible({ timeout: 30_000 }); + await page.waitForFunction((companyId) => Object.keys(localStorage).some(key => key.startsWith("paperclip:query-cache:v1:") + && key.endsWith(`:${encodeURIComponent(companyId)}`) && (localStorage.getItem(key) ?? "").includes("mine-context")), + fixture.company.id, { timeout: 15_000 }); + // Let the debounced writer settle after the last background read. + await page.waitForTimeout(1_500); + await page.evaluate(() => window.dispatchEvent(new Event("pagehide"))); + return await context.storageState(); + } finally { await context.close(); } +} + +/** Shell and inbox reads that a hard load of Mine used to repeat about 1.5–2.5 s after load. */ +export const SHELL_READS: ReadonlyArray boolean]> = [ + ["auth/get-session", url => url.pathname === "/api/auth/get-session"], + ["health", url => url.pathname === "/api/health"], + ["companies?scope=accessible", url => url.pathname === "/api/companies" && url.searchParams.get("scope") === "accessible"], + ["agents", url => /^\/api\/companies\/[^/]+\/agents$/.test(url.pathname)], + ["inbox-dismissals", url => /^\/api\/companies\/[^/]+\/inbox-dismissals$/.test(url.pathname)], + ["user-directory", url => /^\/api\/companies\/[^/]+\/user-directory$/.test(url.pathname)], + ["approvals", url => /^\/api\/companies\/[^/]+\/approvals$/.test(url.pathname)], + ["execution-workspaces", url => /^\/api\/companies\/[^/]+\/execution-workspaces$/.test(url.pathname)], +]; + +export type ApiRead = { path: string; startedAt: number; finishedAt: number | null }; + +/** + * Delays every API response by `delayMs`, records each read, and marks the + * first Mine row (two frames after it mounts) in page time. + */ +export async function observeMineLoad(page: Page, delayMs: number) { + const reads: ApiRead[] = []; + await page.route(url => url.pathname.startsWith("/api/"), async route => { + const url = new URL(route.request().url()); + reads.push({ path: `${url.pathname}${url.search}`, startedAt: Date.now(), finishedAt: null }); + if (delayMs > 0) await new Promise(resolve => setTimeout(resolve, delayMs)); + // A closed page aborts outstanding routes; that read never finished. + await route.continue().catch(() => {}); + }); + page.on("requestfinished", request => { + const url = new URL(request.url()); + const read = reads.find(entry => entry.finishedAt === null && entry.path === `${url.pathname}${url.search}`); + if (read) read.finishedAt = Date.now(); + }); + await page.addInitScript(() => { + const state = window as unknown as { __mineRowsAt: number | null }; + state.__mineRowsAt = null; + const observer = new MutationObserver(() => { + if (!document.querySelector("[data-inbox-issue-link]")) return; + observer.disconnect(); + requestAnimationFrame(() => requestAnimationFrame(() => { state.__mineRowsAt = performance.timeOrigin + performance.now(); })); + }); + observer.observe(document, { subtree: true, childList: true }); + }); + const rowsAt = async () => { + await page.waitForFunction(() => (window as unknown as { __mineRowsAt: number | null }).__mineRowsAt !== null, null, { timeout: 30_000 }); + return await page.evaluate(() => (window as unknown as { __mineRowsAt: number }).__mineRowsAt); + }; + const shellReadCounts = () => Object.fromEntries(SHELL_READS.map(([name, matches]) => [name, + reads.filter(read => matches(new URL(read.path, "http://local"))).length])) as Record; + return { reads, rowsAt, shellReadCounts }; +} + +export const median = (values: number[]) => { + const sorted = [...values].sort((a, b) => a - b); + const middle = Math.floor(sorted.length / 2); + return sorted.length % 2 ? sorted[middle]! : (sorted[middle - 1]! + sorted[middle]!) / 2; +}; diff --git a/tests/perf/collections/shell-read-waves.spec.ts b/tests/perf/collections/shell-read-waves.spec.ts new file mode 100644 index 00000000000..fa253ba4768 --- /dev/null +++ b/tests/perf/collections/shell-read-waves.spec.ts @@ -0,0 +1,52 @@ +import { expect, test } from "@playwright/test"; +import { freshContext, minePath, observeMineLoad, returningVisitFixture, savedQueryCache, type ReturningVisitFixture } from "./returning-visit-fixture"; + +// A hard load of Mine used to repeat about eight shell and inbox reads 1.5–2.5 s +// after load. With the saved query cache, the restored session has no session +// id; when the server answered with one, the live-updates socket reconnected, +// and that reconnect refreshed every active query, session and health included. +// Every API response is delayed 300 ms so the socket opens while reads are in +// flight, as on a busy hosted instance. +let fixture: ReturningVisitFixture; +test.beforeAll(async ({ request }) => { + test.setTimeout(120_000); + fixture = await returningVisitFixture(request); +}); + +test("a returning visit makes each shell read at most once and keeps one live socket", async ({ browser, baseURL }) => { + const storageState = await savedQueryCache(browser, baseURL, fixture); + const context = await freshContext(browser, baseURL, storageState); + try { + const page = await context.newPage(); + const sockets: string[] = []; + page.on("websocket", socket => { if (socket.url().includes("/events/ws")) sockets.push(socket.url()); }); + const { rowsAt, shellReadCounts } = await observeMineLoad(page, 300); + await page.goto(minePath(fixture)); + await rowsAt(); + await page.waitForTimeout(5_000); + const counts = shellReadCounts(); + expect(Object.entries(counts).filter(([, count]) => count > 1), JSON.stringify(counts)).toEqual([]); + expect(sockets, "The verified session reconnected the live socket").toHaveLength(1); + } finally { await context.close(); } +}); + +// Without a saved cache the socket can open only after the company list has +// answered, so the catch-up read that covers events between a read and the +// subscription may repeat reads that answered first. It never repeats the +// session or health read, and the socket is opened once. +test("a first visit never repeats the session or health read", async ({ browser, baseURL }) => { + const context = await freshContext(browser, baseURL); + try { + const page = await context.newPage(); + const sockets: string[] = []; + page.on("websocket", socket => { if (socket.url().includes("/events/ws")) sockets.push(socket.url()); }); + const { rowsAt, shellReadCounts } = await observeMineLoad(page, 300); + await page.goto(minePath(fixture)); + await rowsAt(); + await page.waitForTimeout(5_000); + const counts = shellReadCounts(); + expect({ session: counts["auth/get-session"], health: counts.health }, JSON.stringify(counts)).toEqual({ session: 1, health: 1 }); + expect(Object.entries(counts).filter(([, count]) => count > 2), JSON.stringify(counts)).toEqual([]); + expect(sockets).toHaveLength(1); + } finally { await context.close(); } +}); diff --git a/ui/src/context/LiveUpdatesProvider.recovery.test.tsx b/ui/src/context/LiveUpdatesProvider.recovery.test.tsx index 2f7f9d8813d..58f8eb3ed14 100644 --- a/ui/src/context/LiveUpdatesProvider.recovery.test.tsx +++ b/ui/src/context/LiveUpdatesProvider.recovery.test.tsx @@ -278,6 +278,40 @@ describe("LiveUpdatesProvider connection recovery", () => { expect(pollRead).toHaveBeenCalledTimes(afterOpen); }); + // A session restored from the saved query cache has no session id. Its first + // verified read is the same sign-in, so the socket stays open and nothing is + // refetched. Before, the new id reconnected the socket, and that open + // refreshed every active query, session and health included. + it("keeps the socket when the restored session is verified for the same user", async () => { + vi.stubGlobal("WebSocket", Socket); + client.setQueryData(queryKeys.auth.session, { user: { id: "viewer" }, session: { userId: "viewer" } }); + await renderPolling(); + expect(Socket.instances).toHaveLength(1); + await act(async () => Socket.instances[0].onopen?.()); + expect(container.textContent).toBe("connected"); + const invalidate = vi.spyOn(client, "invalidateQueries"); + await act(async () => client.setQueryData(queryKeys.auth.session, { user: { id: "viewer" }, session: { id: "session", userId: "viewer" } })); + await act(async () => vi.advanceTimersByTimeAsync(1)); + expect(Socket.instances).toHaveLength(1); + expect(container.textContent).toBe("connected"); + expect(invalidate).not.toHaveBeenCalled(); + // A later replacement session still needs a new connection. + await act(async () => client.setQueryData(queryKeys.auth.session, { user: { id: "viewer" }, session: { id: "replacement", userId: "viewer" } })); + await act(async () => vi.advanceTimersByTimeAsync(1)); + expect(Socket.instances).toHaveLength(2); + }); + + it("reconnects when the verified session belongs to another user", async () => { + vi.stubGlobal("WebSocket", Socket); + client.setQueryData(queryKeys.auth.session, { user: { id: "viewer" }, session: { userId: "viewer" } }); + await renderPolling(); + await act(async () => Socket.instances[0].onopen?.()); + await act(async () => client.setQueryData(queryKeys.auth.session, { user: { id: "other" }, session: { id: "other-session", userId: "other" } })); + await act(async () => vi.advanceTimersByTimeAsync(1)); + expect(Socket.instances).toHaveLength(2); + expect(container.textContent).toBe("fallback"); + }); + it.each(["DEMO-1", "issue-1"])("discovers and finishes runs with cache key %s on an unfocused non-task route", async queryRef => { vi.stubGlobal("WebSocket", Socket); vi.spyOn(document, "hasFocus").mockReturnValue(false); diff --git a/ui/src/context/LiveUpdatesProvider.tsx b/ui/src/context/LiveUpdatesProvider.tsx index ed94ff641c6..0f2bc64e5e6 100644 --- a/ui/src/context/LiveUpdatesProvider.tsx +++ b/ui/src/context/LiveUpdatesProvider.tsx @@ -2214,6 +2214,7 @@ export const __liveUpdatesTestUtils = { readRunLiveStatusPatchFromPayload, resolveLiveCompanyId, canUseLiveSession, + nextSocketAuthScope, shouldDeferIssueRefetchForVisibleAgentActivity, shouldDeferVisibleIssueCommentActivity, shouldSuppressActivityToastForVisibleIssue, @@ -2221,6 +2222,26 @@ export const __liveUpdatesTestUtils = { shouldSuppressAgentStatusToastForVisibleIssue, }; +type SocketAuthScope = { userId: string | null; sessionId: string | null; key: string }; + +/** + * The socket's sign-in scope. A new key closes the socket, opens another and + * refreshes every active query, because events are not replayed. + * + * A session restored from the saved query cache carries the user but no + * session id. Its first verified read adds the id for the same user. That is + * the same sign-in, so the key stays and the open socket is kept. A + * different user, or a different session id once one is known, still + * reconnects. + */ +function nextSocketAuthScope(previous: SocketAuthScope | null, userId: string | null, sessionId: string | null): SocketAuthScope { + if (previous && userId !== null && previous.userId === userId) { + if (previous.sessionId === sessionId) return previous; + if (previous.sessionId === null) return { ...previous, sessionId }; + } + return { userId, sessionId, key: sessionId ?? userId ?? "signed_out" }; +} + function canUseLiveSession(sessionStatus: string, hasSession: boolean, deploymentMode?: string) { return sessionStatus === "success" && (hasSession || deploymentMode === "local_trusted"); } @@ -2248,7 +2269,9 @@ export function LiveUpdatesProvider({ children }: { children: ReactNode }) { const { data: health } = useQuery({ queryKey: queryKeys.health, queryFn: healthApi.get }); const currentUserId = session?.user?.id ?? session?.session?.userId ?? (health?.deploymentMode === "local_trusted" ? "local-board" : null); - const socketAuthKey = session?.session?.id ?? currentUserId ?? "signed_out"; + const socketAuth = useRef(null); + socketAuth.current = nextSocketAuthScope(socketAuth.current, currentUserId, session?.session?.id ?? null); + const socketAuthKey = socketAuth.current.key; const [connectedScopeKey, setConnectedScopeKey] = useState(null); const liveCompanyId = resolveLiveCompanyId(selectedCompanyId, selectedCompany?.id ?? null); const socketScopeKey = JSON.stringify([liveCompanyId, socketAuthKey]);