fix(dashboard): start each log follow run with its own buffer

Turning Follow off and on again reused the previous run's buffer, so
new lines were appended after a silent gap and, on a quick toggle,
duplicated. A follow run is now identified by a session value, so the
buffer starts empty each time.

A resume now uses the newest _time seen rather than the last line
received, so an out-of-order line cannot move since backwards, and
the backoff sleep no longer leaves an abort listener per retry.

Assisted-by: LLM
Signed-off-by: ZverGuy <maximbel2003@gmail.com>
This commit is contained in:
ZverGuy committed 2026-11-04 05:47:13 +07:00
1 parent 97dcf4c4f0
commit 4b44971d12
2 files changed
+41 -13

No files matched your search

@@ -27,7 +27,7 @@ describe("useLogTail", () => {
it("streams lines and resumes after a disconnect from the last _time without duplicates", async () => {
const { raw, wrapper } = setup(ndjson(line(T1, "a"), line(T2, "b")), ndjson(line(T2, "b"), line(T3, "c")))
const { result } = renderHook(() => useLogTail("/root/", "*", true, { cap: 100, retryDelayMs: 1 }), { wrapper })
const { result } = renderHook(() => useLogTail("/root/", "*", 1, { cap: 100, retryDelayMs: 1 }), { wrapper })
await waitFor(() => expect(result.current.entries.map((e) => e._msg)).toEqual(["a", "b", "c"]))
expect(new URL(raw.mock.calls[0][0], "http://x").searchParams.has("since")).toBe(false)
@@ -37,24 +37,47 @@ describe("useLogTail", () => {
it("stops and reports an error the proxy will repeat on every retry", async () => {
const { raw, wrapper } = setup(new Response("", { status: 403 }))
const { result } = renderHook(() => useLogTail("/root/", "*", true, { cap: 100, retryDelayMs: 1 }), { wrapper })
const { result } = renderHook(() => useLogTail("/root/", "*", 1, { cap: 100, retryDelayMs: 1 }), { wrapper })
await waitFor(() => expect(result.current.state).toBe("stopped"))
expect(result.current.error).toMatchObject({ kind: "forbidden" })
expect(raw).toHaveBeenCalledTimes(1)
})
it("starts a new follow session with an empty buffer", async () => {
const { wrapper } = setup(ndjson(line(T1, "first")), ndjson(line(T3, "second")))
const { result, rerender } = renderHook(
({ session }: { session: number | null }) => useLogTail("/root/", "*", session, { retryDelayMs: 60_000 }),
{ wrapper, initialProps: { session: 1 as number | null } },
)
await waitFor(() => expect(result.current.entries.map((e) => e._msg)).toEqual(["first"]))
rerender({ session: null })
rerender({ session: 2 })
await waitFor(() => expect(result.current.entries.map((e) => e._msg)).toEqual(["second"]))
})
it("resumes from the newest line seen, not the last one received", async () => {
const { raw, wrapper } = setup(ndjson(line(T3, "c"), line(T1, "a")), ndjson())
renderHook(() => useLogTail("/root/", "*", 1, { retryDelayMs: 1 }), { wrapper })
await waitFor(() => expect(raw.mock.calls.length).toBeGreaterThan(1))
expect(new URL(raw.mock.calls[1][0], "http://x").searchParams.get("since")).toBe(T3)
})
it("does not connect while disabled", () => {
const { raw, wrapper } = setup()
renderHook(() => useLogTail("/root/", "*", false), { wrapper })
renderHook(() => useLogTail("/root/", "*", null), { wrapper })
expect(raw).not.toHaveBeenCalled()
})
it("aborts the stream on unmount", async () => {
const { raw, wrapper } = setup()
const { unmount } = renderHook(() => useLogTail("/root/", "*", true), { wrapper })
const { unmount } = renderHook(() => useLogTail("/root/", "*", 1), { wrapper })
await waitFor(() => expect(raw).toHaveBeenCalled())
unmount()
@@ -1,6 +1,6 @@
import { useEffect, useState } from "react"
import { useK8sClient } from "@cozystack/k8s-client"
import { mergeTail } from "./logs.ts"
import { compareTime, mergeTail } from "./logs.ts"
import { ProxyError, tailLogs, type LogEntry } from "./proxy.ts"
export type TailState = "connecting" | "live" | "reconnecting" | "stopped"
@@ -18,25 +18,30 @@ const FATAL: ReadonlySet<string> = new Set(["bad-request", "unauthorized", "forb
const sleep = (ms: number, signal: AbortSignal) =>
new Promise<void>((resolve) => {
const t = setTimeout(resolve, ms)
signal.addEventListener("abort", () => {
const onAbort = () => {
clearTimeout(t)
resolve()
})
}
const t = setTimeout(() => {
signal.removeEventListener("abort", onAbort)
resolve()
}, ms)
signal.addEventListener("abort", onAbort, { once: true })
})
// Each non-null session is one follow run with its own buffer; null stops following.
export function useLogTail(
root: string,
query: string,
enabled: boolean,
session: number | null,
{ cap = 1000, retryDelayMs = 2000 }: { cap?: number; retryDelayMs?: number } = {},
): Omit<TailSnapshot, "key"> {
const client = useK8sClient()
const key = `${root}\n${query}\n${enabled}`
const key = `${root}\n${query}\n${session}`
const [snap, setSnap] = useState<TailSnapshot>({ key, entries: [], state: "connecting", error: null })
useEffect(() => {
if (!enabled) return
if (session === null) return
const controller = new AbortController()
const { signal } = controller
let pending: LogEntry[] = []
@@ -64,7 +69,7 @@ export function useLogTail(
try {
await tailLogs(client, root, { query, since: lastTime }, (entry) => {
attempt = 0
lastTime = entry._time
if (!lastTime || compareTime(entry._time, lastTime) > 0) lastTime = entry._time
pending.push(entry)
timer ??= setTimeout(flush, FLUSH_MS)
}, signal)
@@ -88,7 +93,7 @@ export function useLogTail(
controller.abort()
clearTimeout(timer)
}
}, [client, root, query, enabled, key, cap, retryDelayMs])
}, [client, root, query, session, key, cap, retryDelayMs])
const current = snap.key === key ? snap : { key, entries: [], state: "connecting" as const, error: null }
return { entries: current.entries, state: current.state, error: current.error }