feat(logs): collapse large run log data and serve client manifest
CI / changes (pull_request) Successful in 6s
CI / version (pull_request) Skipped
CI / server (pull_request) Successful in 1m30s
CI / client (pull_request) Successful in 1m31s
CI / image (pull_request) Skipped

- collapse run log data blocks whose pretty-printed JSON exceeds a byte
  or line limit, with a per-block toggle and an expand/collapse-all
  button next to the Logs heading
- align data blocks and toggles with the context/message column
- add a "Copy logs" button that copies the filtered logs as plain text
  with every data block expanded
- add GET /manifest.json with the app name, version and run log data
  limits (RUN_LOG_DATA_COLLAPSE_BYTES / RUN_LOG_DATA_COLLAPSE_LINES)
- load the manifest in the client stale-while-revalidate: localStorage
  copy first, refetched per page load and on tab focus after a while
- show the server version in the sidebar footer, with a reload hint
  when it differs from the client build

Closes #3
This commit is contained in:
ars9 committed 2026-10-02 14:05:49 +03:00
1 parent 4e55d14599
commit 718a12c2f4
25 files changed
+623 -36

No files matched your search

+26 -1
View File
@@ -7,6 +7,8 @@
overflow: auto;
font-family: var(--font-mono, ui-monospace, 'Cascadia Code', 'Fira Code', monospace);
font-size: var(--font-size-xs);
/* Where the context/message column starts: timestamp + level + their gaps */
--log-body-offset: calc(7em + 4.5em + 2 * var(--space-2));
}
.empty {
@@ -36,7 +38,7 @@
}
.data {
margin: 0 0 var(--space-1) calc(7em + var(--space-2));
margin: 0 0 var(--space-1) var(--log-body-offset);
border: var(--border-width) solid var(--color-border);
border-radius: var(--radius-sm);
background: var(--color-bg);
@@ -120,3 +122,26 @@
.error .level {
color: var(--color-error-fg);
}
.dataToggle {
display: inline-flex;
align-items: center;
gap: var(--space-1);
align-self: flex-start;
margin-left: var(--log-body-offset);
padding: 0;
border: none;
background: none;
font: inherit;
color: var(--color-text);
cursor: pointer;
}
.dataToggle svg {
flex: 0 0 auto;
color: var(--color-primary-text);
}
.dataToggle:hover {
text-decoration: underline;
}
+76 -17
View File
@@ -1,4 +1,14 @@
import { useMemo, useState } from 'react';
import { ChevronDown, ChevronRight } from 'lucide-react';
import { CodeBlock } from '../CodeBlock/CodeBlock';
import {
DEFAULT_LOG_DATA_LIMITS,
exceedsLimits,
formatElapsed,
measureData,
prettyData,
type LogDataLimits,
} from './logText';
import styles from './LogOutput.module.css';
export type LogOutputLevel = 'debug' | 'log' | 'warn' | 'error';
@@ -22,25 +32,24 @@ export interface LogOutputProps {
maxHeight?: string | number;
emptyMessage?: string;
className?: string;
/** Data blocks whose pretty-printed JSON exceeds either limit start collapsed behind a toggle. */
dataLimits?: LogDataLimits;
/**
* Expands (true) or collapses (false) every large data block. Changing it
* discards the per-entry toggles made since the last change.
*/
dataExpanded?: boolean;
/** Label of a collapsed data block's toggle, e.g. "Show data (1.2 KB, 40 lines)". */
showDataLabel?: (size: { bytes: number; lines: number }) => string;
hideDataLabel?: string;
}
/**
* "+12s" (or "-" if before startTime, e.g. clock skew). Log timestamps are
* stored with second resolution, so fractions would be noise.
*/
function formatElapsed(deltaMs: number): string {
const sign = deltaMs < 0 ? '-' : '+';
return `${sign}${Math.round(Math.abs(deltaMs) / 1000)}s`;
function formatBytes(bytes: number): string {
return bytes < 1024 ? `${bytes} B` : `${(bytes / 1024).toFixed(1)} KB`;
}
/** Pretty-prints `data` if it's valid JSON, otherwise returns it as-is. */
function prettyData(data: string): string {
try {
return JSON.stringify(JSON.parse(data), null, 2);
} catch {
return data;
}
}
const defaultShowDataLabel = ({ bytes, lines }: { bytes: number; lines: number }) =>
`Show data (${formatBytes(bytes)}, ${lines} ${lines === 1 ? 'line' : 'lines'})`;
/** Terminal-style log viewer: one line per entry, color-coded by level. */
export function LogOutput({
@@ -49,7 +58,39 @@ export function LogOutput({
maxHeight,
emptyMessage = 'No logs.',
className,
dataLimits = DEFAULT_LOG_DATA_LIMITS,
dataExpanded = false,
showDataLabel = defaultShowDataLabel,
hideDataLabel = 'Hide data',
}: LogOutputProps) {
// Per-entry toggles, reset whenever dataExpanded changes
const [toggled, setToggled] = useState<Set<LogOutputEntry['id']>>(() => new Set());
const [prevDataExpanded, setPrevDataExpanded] = useState(dataExpanded);
if (prevDataExpanded !== dataExpanded) {
setPrevDataExpanded(dataExpanded);
setToggled(new Set());
}
const dataBlocks = useMemo(() => {
const blocks = new Map<
LogOutputEntry['id'],
{ pretty: string; bytes: number; lines: number }
>();
for (const entry of entries) {
if (!entry.data) continue;
const pretty = prettyData(entry.data);
blocks.set(entry.id, { pretty, ...measureData(pretty) });
}
return blocks;
}, [entries]);
const toggle = (id: LogOutputEntry['id']) =>
setToggled((prev) => {
const next = new Set(prev);
if (!next.delete(id)) next.add(id);
return next;
});
if (entries.length === 0) {
return <div className={styles.empty}>{emptyMessage}</div>;
}
@@ -65,6 +106,9 @@ export function LogOutput({
>
{entries.map((entry) => {
const entryMs = new Date(entry.createdAt).getTime();
const block = dataBlocks.get(entry.id);
const large = block != null && exceedsLimits(block, dataLimits);
const open = !large || dataExpanded !== toggled.has(entry.id);
return (
<div key={entry.id} className={[styles.line, styles[entry.level]].join(' ')}>
<div className={styles.lineHeader}>
@@ -75,9 +119,24 @@ export function LogOutput({
{entry.context && <span className={styles.context}>{entry.context}</span>}
<span className={styles.message}>{entry.message}</span>
</div>
{entry.data && (
{block && large && (
<button
type="button"
className={styles.dataToggle}
aria-expanded={open}
onClick={() => toggle(entry.id)}
>
{open ? (
<ChevronDown size={14} strokeWidth={3} aria-hidden="true" />
) : (
<ChevronRight size={14} strokeWidth={3} aria-hidden="true" />
)}
{open ? hideDataLabel : showDataLabel(block)}
</button>
)}
{block && open && (
<div className={styles.data}>
<CodeBlock code={prettyData(entry.data)} language="json" />
<CodeBlock code={block.pretty} language="json" />
</div>
)}
</div>
+73
View File
@@ -0,0 +1,73 @@
import type { LogOutputEntry } from './LogOutput';
/** Data blocks above either limit start collapsed. */
export interface LogDataLimits {
/** UTF-8 byte size of the pretty-printed data. */
bytes: number;
/** Line count of the pretty-printed data. */
lines: number;
}
export const DEFAULT_LOG_DATA_LIMITS: LogDataLimits = { bytes: 256, lines: 5 };
const encoder = new TextEncoder();
/**
* "+12s" (or "-" if before startTime, e.g. clock skew). Log timestamps are
* stored with second resolution, so fractions would be noise.
*/
export function formatElapsed(deltaMs: number): string {
const sign = deltaMs < 0 ? '-' : '+';
return `${sign}${Math.round(Math.abs(deltaMs) / 1000)}s`;
}
/** Pretty-prints `data` if it's valid JSON, otherwise returns it as-is. */
export function prettyData(data: string): string {
try {
return JSON.stringify(JSON.parse(data), null, 2);
} catch {
return data;
}
}
/** Byte size and line count of an already pretty-printed data block. */
export function measureData(pretty: string): { bytes: number; lines: number } {
return { bytes: encoder.encode(pretty).length, lines: pretty.split('\n').length };
}
export function exceedsLimits(size: { bytes: number; lines: number }, limits: LogDataLimits) {
return size.bytes > limits.bytes || size.lines > limits.lines;
}
/** True if any entry's data block exceeds the limits (i.e. renders collapsed by default). */
export function hasLargeData(
entries: Pick<LogOutputEntry, 'data'>[],
limits: LogDataLimits = DEFAULT_LOG_DATA_LIMITS,
): boolean {
return entries.some((e) => e.data && exceedsLimits(measureData(prettyData(e.data)), limits));
}
/**
* Plain-text rendering of the log, one entry per line with every data block
* pretty-printed and indented below its line (e.g. for copying to the clipboard).
*/
export function formatLogText(
entries: LogOutputEntry[],
startTime?: string | number | Date,
): string {
if (entries.length === 0) return '';
const startMs = new Date(startTime ?? entries[0].createdAt).getTime();
return entries
.map((entry) => {
const elapsed = formatElapsed(new Date(entry.createdAt).getTime() - startMs);
const context = entry.context ? ` [${entry.context}]` : '';
const header = `${elapsed.padStart(6)} ${entry.level.toUpperCase().padEnd(5)}${context} ${entry.message}`;
if (!entry.data) return header;
const data = prettyData(entry.data)
.split('\n')
.map((line) => ` ${line}`)
.join('\n');
return `${header}\n${data}`;
})
.join('\n');
}