Skip to content

Modern Docker Management, Designed for Everyone

10.2 KB
Raw Blame
<script lang="ts">
	// Dozzle reference: the compact structured-log summary and expandable details pattern
	// here were informed by amir20/dozzle's ComplexLogItem.vue and LogDetails.vue.
	import * as Collapsible from '#lib/components/ui/collapsible/index.js';
	import { ArrowDownIcon, ArrowRightIcon, CheckIcon, CopyIcon } from '#lib/icons/index.js';
	import { m } from '#lib/paraglide/messages.js';
	import { handleApiResultWithCallbacks } from '#lib/utils/api.js';
	import { tryCatch } from '#lib/utils/try-catch.js';

	interface Props {
		data: Record<string, unknown>;
		rawJson?: string;
	}

	type SummaryField = {
		path: string;
		label: string;
		value: unknown;
	};

	let { data, rawJson }: Props = $props();

	let showDetails = $state(false);
	let copied = $state(false);

	const SUMMARY_LIMIT = 6;

	// Common field names used by various structured logging frameworks
	const LEVEL_KEYS = ['level', 'severity', 'log.level', 'loglevel', 'lvl', 'levelname', 'priority'];
	const MESSAGE_KEYS = ['message', 'msg', 'text', 'body', 'event', 'log', 'content'];
	const TIMESTAMP_KEYS = ['timestamp', 'time', 'ts', '@timestamp', 'datetime', 'date', 'created', 'time_local'];
	const TARGET_KEYS = ['target', 'logger', 'name', 'source', 'component', 'module', 'log.logger', 'logger_name', 'category'];
	const ERROR_KEYS = ['error', 'err', 'exception', 'stack', 'stacktrace', 'error.message'];
	const TRACE_KEYS = ['trace_id', 'traceId', 'correlation_id', 'correlationId', 'request_id', 'requestId', 'spanId', 'span_id'];
	const NESTED_MESSAGE_PATHS = [
		['fields', 'message'],
		['fields', 'msg'],
		['data', 'message']
	];
	const HIDDEN_SUMMARY_KEYS = new Set([...LEVEL_KEYS, ...MESSAGE_KEYS, ...TIMESTAMP_KEYS]);

	function findValue(obj: Record<string, unknown>, keys: string[]): unknown {
		for (const key of keys) {
			if (key in obj) return obj[key];
			if (key.includes('.')) {
				const parts = key.split('.');
				let current: unknown = obj;
				for (const part of parts) {
					if (current && typeof current === 'object' && part in (current as Record<string, unknown>)) {
						current = (current as Record<string, unknown>)[part];
					} else {
						current = undefined;
						break;
					}
				}
				if (current !== undefined) return current;
			}
		}
		return undefined;
	}

	function findNestedMessage(obj: Record<string, unknown>): string | undefined {
		for (const path of NESTED_MESSAGE_PATHS) {
			let current: unknown = obj;
			for (const key of path) {
				if (current && typeof current === 'object' && key in (current as Record<string, unknown>)) {
					current = (current as Record<string, unknown>)[key];
				} else {
					current = undefined;
					break;
				}
			}
			if (typeof current === 'string') return current;
		}
		return undefined;
	}

	function normalizeLevelValue(level: unknown): string | undefined {
		if (typeof level === 'string') return level;
		if (typeof level === 'number') {
			const syslogMap: Record<number, string> = {
				0: 'fatal',
				1: 'fatal',
				2: 'fatal',
				3: 'error',
				4: 'warn',
				5: 'info',
				6: 'info',
				7: 'debug'
			};
			return syslogMap[level] ?? 'info';
		}
		return undefined;
	}

	function extractFields(obj: Record<string, unknown>): {
		level: string | undefined;
		message: string | undefined;
		target: string | undefined;
		error: unknown;
		traceId: string | undefined;
		hasStructure: boolean;
	} {
		const rawLevel = findValue(obj, LEVEL_KEYS);
		let message = findValue(obj, MESSAGE_KEYS);
		if (!message) {
			message = findNestedMessage(obj);
		}
		if (!message && obj['event']) {
			message = String(obj['event']);
		}

		const target = findValue(obj, TARGET_KEYS);
		const error = findValue(obj, ERROR_KEYS);
		const traceId = findValue(obj, TRACE_KEYS);

		return {
			level: normalizeLevelValue(rawLevel),
			message: typeof message === 'string' ? message : undefined,
			target: typeof target === 'string' ? target : undefined,
			error,
			traceId: typeof traceId === 'string' ? traceId : undefined,
			hasStructure: !!(rawLevel || message || target)
		};
	}

	function getLevelDotClass(level: string | undefined): string {
		if (!level) return 'bg-muted-foreground';
		const normalizedLevel = level.toLowerCase();
		if (
			normalizedLevel === 'error' ||
			normalizedLevel === 'err' ||
			normalizedLevel === 'fatal' ||
			normalizedLevel === 'critical' ||
			normalizedLevel === 'panic' ||
			normalizedLevel === 'emergency'
		) {
			return 'bg-destructive';
		}
		if (normalizedLevel === 'warn' || normalizedLevel === 'warning' || normalizedLevel === 'alert') {
			return 'bg-orange';
		}
		if (normalizedLevel === 'info' || normalizedLevel === 'information' || normalizedLevel === 'notice') {
			return 'bg-success';
		}
		if (normalizedLevel === 'debug' || normalizedLevel === 'dbg') {
			return 'bg-sky';
		}
		if (normalizedLevel === 'trace' || normalizedLevel === 'verbose' || normalizedLevel === 'finest') {
			return 'bg-violet';
		}
		return 'bg-muted-foreground';
	}

	function safeStringify(value: unknown, indent = 0): string {
		if (typeof value === 'string') {
			return value;
		}
		if (value === null) {
			return 'null';
		}
		if (value === undefined) {
			return '';
		}
		try {
			return JSON.stringify(value, null, indent);
		} catch {
			return String(value);
		}
	}

	function formatInlineValue(value: unknown): string {
		if (value === null) {
			return '<null>';
		}
		if (typeof value === 'string') {
			return value;
		}
		if (typeof value === 'number' || typeof value === 'boolean') {
			return String(value);
		}

		const compact = safeStringify(value);
		if (compact.length <= 72) {
			return compact;
		}

		return `${compact.slice(0, 69)}...`;
	}

	function buildSummaryFields(obj: Record<string, unknown>): SummaryField[] {
		const fields: SummaryField[] = [];

		for (const [key, value] of Object.entries(obj)) {
			if (value === undefined || HIDDEN_SUMMARY_KEYS.has(key)) {
				continue;
			}

			if ((key === 'fields' || key === 'data') && value && typeof value === 'object' && !Array.isArray(value)) {
				for (const [nestedKey, nestedValue] of Object.entries(value as Record<string, unknown>)) {
					if (nestedValue === undefined || MESSAGE_KEYS.includes(nestedKey)) {
						continue;
					}

					fields.push({
						path: `${key}.${nestedKey}`,
						label: nestedKey,
						value: nestedValue
					});
				}
				continue;
			}

			fields.push({
				path: key,
				label: key,
				value
			});
		}

		return fields;
	}

	const extracted = $derived(extractFields(data));
	const summaryFields = $derived(buildSummaryFields(data));
	const visibleSummaryFields = $derived(summaryFields.slice(0, SUMMARY_LIMIT));
	const hiddenSummaryCount = $derived(Math.max(summaryFields.length - visibleSummaryFields.length, 0));
	const jsonString = $derived(rawJson ?? JSON.stringify(data, null, 2));
	const hasDetails = $derived(summaryFields.length > SUMMARY_LIMIT || summaryFields.length > 0 || !!rawJson);

	async function copyToClipboard() {
		await handleApiResultWithCallbacks({
			result: await tryCatch(navigator.clipboard.writeText(jsonString)),
			message: m.common_copy_failed(),
			onSuccess: () => {
				copied = true;
				setTimeout(() => {
					copied = false;
				}, 2000);
			}
		});
	}
</script>

{#snippet entrySummary(showOverflowCount: boolean)}
	{#if extracted.level}
		<span class="mt-1.5 size-2.5 shrink-0 rounded-full {getLevelDotClass(extracted.level)}"></span>
	{/if}

	<div class="min-w-0 flex-1">
		<div class="flex flex-wrap items-center gap-x-4 gap-y-1">
			{#if extracted.target}
				<span class="truncate text-2xs font-medium text-info" title={extracted.target}>
					{extracted.target}
				</span>
			{/if}

			{#if extracted.message}
				<span class="min-w-0 text-foreground">{extracted.message}</span>
			{:else if !extracted.hasStructure}
				<span class="min-w-0 text-foreground/80">{safeStringify(data)}</span>
			{/if}

			{#each visibleSummaryFields as field (field.path)}
				<span class="inline-flex max-w-full min-w-0 items-baseline gap-0.5 text-foreground/80">
					<span class="shrink-0 text-muted-foreground">{field.label}=</span>
					<span class="truncate font-semibold text-foreground" title={safeStringify(field.value)}>
						{formatInlineValue(field.value)}
					</span>
				</span>
			{/each}

			{#if showOverflowCount && hiddenSummaryCount > 0}
				<span class="text-2xs font-medium text-muted-foreground">+{hiddenSummaryCount}</span>
			{/if}
		</div>
	</div>
{/snippet}

<Collapsible.Root bind:open={showDetails}>
	<div class="flex min-w-0 items-start gap-2">
		{#if hasDetails}
			<Collapsible.Trigger>
				{#snippet child({ props })}
					<button
						{...props}
						type="button"
						class="flex min-w-0 flex-1 items-start gap-3 rounded-md border border-transparent px-1 py-0.5 text-left outline-none hover:bg-white/3 focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50"
					>
						{@render entrySummary(true)}

						{#if showDetails}
							<ArrowDownIcon class="mt-0.5 size-4 shrink-0 text-muted-foreground" />
						{:else}
							<ArrowRightIcon class="mt-0.5 size-4 shrink-0 text-muted-foreground" />
						{/if}
					</button>
				{/snippet}
			</Collapsible.Trigger>
		{:else}
			<div class="flex min-w-0 flex-1 items-start gap-3 px-1 py-0.5">
				{@render entrySummary(false)}
			</div>
		{/if}

		<button
			type="button"
			onclick={copyToClipboard}
			class="shrink-0 rounded p-1 text-muted-foreground transition-colors hover:bg-white/5 hover:text-foreground"
			title={copied ? 'Copied' : 'Copy JSON'}
		>
			{#if copied}
				<CheckIcon class="size-3.5 text-success" />
			{:else}
				<CopyIcon class="size-3.5" />
			{/if}
		</button>
	</div>

	{#if hasDetails}
		<Collapsible.Content>
			<div class="mt-2 rounded-md border border-border bg-background/75 p-3">
				{#if summaryFields.length > 0}
					<div class="grid gap-x-4 gap-y-2 md:grid-cols-key-value">
						{#each summaryFields as field (field.path)}
							<div class="font-mono text-2xs text-muted-foreground">{field.path}</div>
							<pre class="overflow-x-auto text-xs break-all whitespace-pre-wrap text-foreground">{safeStringify(
									field.value,
									2
								)}</pre>
						{/each}
					</div>
				{/if}

				<div class="mt-3 border-t border-border pt-3">
					<pre class="overflow-x-auto text-xs break-all whitespace-pre-wrap text-foreground/80">{jsonString}</pre>
				</div>
			</div>
		</Collapsible.Content>
	{/if}
</Collapsible.Root>