132 lines
9.4 KiB
TypeScript
132 lines
9.4 KiB
TypeScript
"use client"
|
|
import { useCallback, useEffect, useRef, useState } from "react"
|
|
import { logStreamSchema, type LogEntry, type LogPage, type LogStream, type LogSummary } from "@mmapp/contracts"
|
|
import { getLogs, getLogSummary } from "@/shared/api/logs"
|
|
import { resolveApiUrl, withAuthHeaders } from "@/shared/api/http-client"
|
|
|
|
export function mergeLogEntries(previous: LogEntry[], incoming: LogEntry[], limit = 5000) {
|
|
return [...new Map([...previous, ...incoming].map(row => [row.id, row])).values()].sort((a, b) => b.effectiveAt.localeCompare(a.effectiveAt) || (BigInt(a.id) < BigInt(b.id) ? 1 : -1)).slice(0, limit)
|
|
}
|
|
const message = (error: unknown) => error instanceof Error ? error.message : String(error)
|
|
export function useRouterLogs(base: string, query: string, enabled: boolean, live: boolean, paused: boolean, windowMs = 0) {
|
|
const [entries, setEntries] = useState<LogEntry[]>([])
|
|
const [page, setPage] = useState<{ data: LogPage; query: string; signal: AbortSignal } | null>(null)
|
|
const [summary, setSummary] = useState<LogSummary | null>(null)
|
|
const [stream, setStream] = useState<{ batch: LogStream; receivedAt: number } | null>(null)
|
|
const [loading, setLoading] = useState(enabled), [fetchingMore, setFetchingMore] = useState(false)
|
|
const [error, setError] = useState<string | null>(null), [summaryError, setSummaryError] = useState<string | null>(null)
|
|
const [streamFailure, setStreamFailure] = useState<{ message: string | null; stopped: boolean } | null>(null)
|
|
const [revision, setRevision] = useState(0), [pendingCount, setPendingCount] = useState(0)
|
|
const pending = useRef<LogEntry[]>([]), pausedRef = useRef(paused), initialCursor = useRef<string | null>(null)
|
|
const moreBusy = useRef<AbortSignal | null>(null)
|
|
useEffect(() => { pausedRef.current = paused }, [paused])
|
|
const flush = useCallback(() => { const buffered = pending.current; setEntries(prev => mergeLogEntries(prev, buffered).filter(row => !windowMs || Date.parse(row.effectiveAt) >= Date.now() - windowMs)); pending.current = []; setPendingCount(0) }, [windowMs])
|
|
useEffect(() => {
|
|
if (!paused && pending.current.length) flush()
|
|
}, [paused, flush])
|
|
useEffect(() => {
|
|
if (!enabled) return
|
|
const ac = new AbortController()
|
|
queueMicrotask(() => { if (!ac.signal.aborted) { setLoading(true); setFetchingMore(false); setError(null) } })
|
|
const currentQuery = () => { const params = new URLSearchParams(query); if (windowMs) params.set("from", new Date(Date.now() - windowMs).toISOString()); return params }
|
|
const historyQuery = currentQuery()
|
|
void getLogs(base, historyQuery, ac.signal).then(data => {
|
|
if (ac.signal.aborted) return
|
|
setEntries(data.entries); setPage({ data, query: historyQuery.toString(), signal: ac.signal }); initialCursor.current = data.watermark
|
|
}).catch(e => { if (!ac.signal.aborted) setError(message(e)) }).finally(() => { if (!ac.signal.aborted) setLoading(false) })
|
|
const readSummary = () => { void getLogSummary(base, currentQuery(), ac.signal).then(data => { if (!ac.signal.aborted) { setSummary(data); setSummaryError(null) } }).catch(e => { if (!ac.signal.aborted) setSummaryError(message(e)) }) }
|
|
readSummary()
|
|
const timer = setInterval(readSummary, 10_000)
|
|
return () => { ac.abort(); clearInterval(timer); initialCursor.current = null }
|
|
}, [base, query, enabled, revision, windowMs])
|
|
|
|
const ready = page !== null && !loading && !error
|
|
useEffect(() => {
|
|
if (!enabled || !live || !ready || !initialCursor.current) return
|
|
const ac = new AbortController()
|
|
let cursor = initialCursor.current, retry = 1000
|
|
void (async () => {
|
|
while (!ac.signal.aborted) {
|
|
const connection = new AbortController(), abort = () => connection.abort()
|
|
ac.signal.addEventListener("abort", abort, { once: true })
|
|
let watchdog: ReturnType<typeof setTimeout> | undefined
|
|
const heartbeat = () => { clearTimeout(watchdog); watchdog = setTimeout(() => connection.abort(), 20_000) }
|
|
try {
|
|
heartbeat()
|
|
const params = new URLSearchParams(query); params.set("cursor", cursor); if (windowMs) params.set("from", new Date(Date.now() - windowMs).toISOString())
|
|
const res = await fetch(resolveApiUrl(base, "/api/logs/live?" + params), { headers: withAuthHeaders({ Accept: "text/event-stream" }), signal: connection.signal, credentials: "include" })
|
|
if (!res.ok || !res.body) {
|
|
const body = await res.json().catch(() => null)
|
|
throw Object.assign(new Error(body?.error ?? `Live недоступен (HTTP ${res.status})`), { status: res.status })
|
|
}
|
|
const reader = res.body.getReader(), decoder = new TextDecoder()
|
|
let buffer = ""
|
|
try {
|
|
while (!ac.signal.aborted) {
|
|
const { done, value } = await reader.read()
|
|
if (done) throw new Error("Поток завершён; переподключение…")
|
|
buffer += decoder.decode(value, { stream: true })
|
|
const blocks = buffer.split(/\r?\n\r?\n/); buffer = blocks.pop() ?? ""
|
|
if (buffer.length > 8 * 1024 * 1024) throw new Error("Слишком большой ответ live")
|
|
for (const block of blocks) {
|
|
const type = block.match(/^event:\s*(.+)$/m)?.[1]
|
|
const data = block.split(/\r?\n/).filter(line => line.startsWith("data:")).map(line => line.slice(5).trim()).join("\n")
|
|
if (type === "reset") {
|
|
const reason = "Поток остановлен для обслуживания БД. После завершения обновите журнал, чтобы заново загрузить историю."
|
|
if (!ac.signal.aborted) { setStream(null); setStreamFailure({ message: null, stopped: true }); setError(reason) }
|
|
return
|
|
}
|
|
if (type === "error") throw new Error(JSON.parse(data).error)
|
|
if (type !== "batch") continue
|
|
const batch = logStreamSchema.parse(JSON.parse(data))
|
|
const expectedServer = new URLSearchParams(query).get("serverId")
|
|
if (batch.entries.some(row => String(row.serverId) !== expectedServer) || batch.state && String(batch.state.serverId) !== expectedServer || BigInt(batch.cursor) < BigInt(cursor)) throw new Error("Live-поток относится к другому устройству или содержит некорректный курсор")
|
|
heartbeat(); retry = 1000; cursor = batch.cursor
|
|
if (ac.signal.aborted) return
|
|
setStream({ batch, receivedAt: Date.now() }); setStreamFailure(null)
|
|
if (batch.entries.length) {
|
|
if (pausedRef.current) {
|
|
pending.current = mergeLogEntries(pending.current, batch.entries)
|
|
setPendingCount(n => n + batch.entries.length)
|
|
} else setEntries(prev => mergeLogEntries(prev, batch.entries).filter(row => !windowMs || Date.parse(row.effectiveAt) >= Date.now() - windowMs))
|
|
} else if (!pausedRef.current && windowMs) {
|
|
setEntries(prev => { const firstExpired = prev.findIndex(row => Date.parse(row.effectiveAt) < Date.now() - windowMs); return firstExpired < 0 ? prev : prev.slice(0, firstExpired) })
|
|
}
|
|
}
|
|
}
|
|
} finally { await reader.cancel().catch(() => {}) }
|
|
} catch (e) {
|
|
if (ac.signal.aborted) return
|
|
const stopped = e instanceof Error && "status" in e && [401, 403, 404].includes(Number(e.status))
|
|
setStreamFailure({ message: message(e), stopped })
|
|
if (stopped) { setStream(null); return }
|
|
} finally { clearTimeout(watchdog); connection.abort(); ac.signal.removeEventListener("abort", abort) }
|
|
await new Promise<void>(resolve => {
|
|
const done = () => { clearTimeout(timer); ac.signal.removeEventListener("abort", done); resolve() }
|
|
const timer = setTimeout(done, retry); ac.signal.addEventListener("abort", done, { once: true }); if (ac.signal.aborted) done()
|
|
})
|
|
retry = Math.min(15_000, retry * 2)
|
|
}
|
|
})()
|
|
return () => ac.abort()
|
|
}, [base, query, enabled, live, ready, revision, windowMs])
|
|
|
|
const loadMore = useCallback(async () => {
|
|
if (!ready || !enabled || !page?.data.nextCursor || page.signal.aborted || moreBusy.current === page.signal) return
|
|
const { signal } = page
|
|
moreBusy.current = signal; setFetchingMore(true)
|
|
try {
|
|
const params = new URLSearchParams(page.query); params.set("cursor", page.data.nextCursor); params.set("watermark", page.data.watermark)
|
|
const data = await getLogs(base, params, signal)
|
|
if (signal.aborted) return
|
|
setEntries(prev => mergeLogEntries(prev, data.entries)); setPage({ ...page, data })
|
|
} catch (e) { if (!signal.aborted) setError(message(e)) }
|
|
finally {
|
|
if (moreBusy.current === signal) moreBusy.current = null
|
|
if (!signal.aborted) setFetchingMore(false)
|
|
}
|
|
}, [base, enabled, page, ready])
|
|
const reload = useCallback(() => { pending.current = []; setPendingCount(0); setStream(null); setStreamFailure(null); setRevision(n => n + 1) }, [])
|
|
return { entries, summary, stream: stream?.batch ?? null, streamReceivedAt: stream?.receivedAt ?? null, loading, fetchingMore, error, summaryError, streamError: streamFailure?.message ?? null, streamStopped: streamFailure?.stopped ?? false, pendingCount, hasMore: !!page?.data.nextCursor && entries.length < 5000, loadMore, reload, flush }
|
|
}
|