Skip to content

Modern Docker Management, Designed for Everyone

fix: container log performance issues (#222)

Kyle Mendelld337474870d4
diff --git a/src/lib/components/LogViewer.svelte b/src/lib/components/LogViewer.svelte
new file mode 100644
index 000000000..d9d76843b
--- /dev/null
+++ b/src/lib/components/LogViewer.svelte
@@ -0,0 +1,231 @@
+<script lang="ts">
+ import { onMount, onDestroy } from 'svelte';
+ import { browser } from '$app/environment';
+
+ interface LogEntry {
+ timestamp: string;
+ level: 'stdout' | 'stderr' | 'info' | 'error';
+ message: string;
+ service?: string; // Add service field for stack logs
+ containerId?: string;
+ }
+
+ interface Props {
+ containerId?: string | null;
+ stackId?: string | null; // Add stackId prop
+ type?: 'container' | 'stack';
+ maxLines?: number;
+ autoScroll?: boolean;
+ showTimestamps?: boolean;
+ height?: string;
+ onClear?: () => void;
+ onToggleAutoScroll?: () => void;
+ onStart?: () => void;
+ onStop?: () => void;
+ }
+
+ let { containerId = null, stackId = null, type = 'container', maxLines = 1000, autoScroll = $bindable(true), showTimestamps = true, height = '400px', onClear, onToggleAutoScroll, onStart, onStop }: Props = $props();
+
+ let logs: LogEntry[] = $state([]);
+ let logContainer: HTMLElement | undefined = $state();
+ let isStreaming = $state(false);
+ let error: string | null = $state(null);
+ let eventSource: EventSource | null = null;
+
+ // Expose functions for parent components
+ export function startLogStream() {
+ const targetId = type === 'stack' ? stackId : containerId;
+
+ if (!targetId || !browser) return;
+
+ try {
+ isStreaming = true;
+ error = null;
+ onStart?.();
+
+ // Use different API endpoint based on type
+ const endpoint = type === 'stack' ? `/api/stacks/${stackId}/logs?follow=true&tail=100&timestamps=true` : `/api/containers/${containerId}/logs/stream`;
+
+ console.log(`Starting ${type} log stream for ${targetId}:`, endpoint);
+
+ // Create SSE connection for log streaming
+ eventSource = new EventSource(endpoint);
+
+ eventSource.onmessage = (event) => {
+ try {
+ // Both stack and container logs now come as JSON
+ const logData = JSON.parse(event.data);
+ addLogEntry(logData);
+ } catch (parseError) {
+ console.error('Failed to parse log data:', parseError, 'Raw data:', event.data);
+ // Fallback: treat as plain text
+ addLogEntry({
+ level: 'info',
+ message: event.data,
+ timestamp: new Date().toISOString()
+ });
+ }
+ };
+
+ eventSource.onopen = () => {
+ console.log(`${type} log stream connected`);
+ error = null;
+ };
+
+ eventSource.onerror = (event) => {
+ console.error('Log stream error:', event);
+ error = `Connection to ${type} log stream lost`;
+ isStreaming = false;
+
+ // Try to get more specific error info
+ if (eventSource?.readyState === EventSource.CLOSED) {
+ error = `${type} log stream was closed by server`;
+ }
+ };
+ } catch (err) {
+ console.error('Failed to start log stream:', err);
+ error = `Failed to connect to ${type} log stream`;
+ isStreaming = false;
+ }
+ }
+
+ export function stopLogStream() {
+ if (eventSource) {
+ console.log(`Stopping ${type} log stream`);
+ eventSource.close();
+ eventSource = null;
+ }
+ isStreaming = false;
+ onStop?.();
+ }
+
+ export function clearLogs() {
+ logs = [];
+ onClear?.();
+ }
+
+ export function toggleAutoScroll() {
+ autoScroll = !autoScroll;
+ onToggleAutoScroll?.();
+ }
+
+ // Expose state getters
+ export function getIsStreaming() {
+ return isStreaming;
+ }
+
+ export function getLogCount() {
+ return logs.length;
+ }
+
+ function addLogEntry(logData: { level: string; message: string; timestamp?: string; service?: string; containerId?: string }) {
+ const entry: LogEntry = {
+ timestamp: logData.timestamp || new Date().toISOString(),
+ level: logData.level as LogEntry['level'],
+ message: logData.message,
+ service: logData.service,
+ containerId: logData.containerId
+ };
+
+ logs = [...logs.slice(-(maxLines - 1)), entry];
+
+ if (autoScroll && logContainer) {
+ setTimeout(() => {
+ if (logContainer) {
+ logContainer.scrollTop = logContainer.scrollHeight;
+ }
+ }, 10);
+ }
+ }
+
+ function formatTimestamp(timestamp: string): string {
+ return new Date(timestamp).toLocaleTimeString();
+ }
+
+ function getLevelClass(level: LogEntry['level']): string {
+ switch (level) {
+ case 'stderr':
+ case 'error':
+ return 'text-red-400';
+ case 'stdout':
+ case 'info':
+ return 'text-green-400';
+ default:
+ return 'text-gray-300';
+ }
+ }
+
+ onMount(() => {
+ const targetId = type === 'stack' ? stackId : containerId;
+ if (targetId) {
+ startLogStream();
+ }
+ });
+
+ onDestroy(() => {
+ stopLogStream();
+ });
+
+ $effect(() => {
+ const targetId = type === 'stack' ? stackId : containerId;
+ if (targetId && browser) {
+ stopLogStream();
+ logs = [];
+ startLogStream();
+ }
+ });
+</script>
+
+<div class="log-viewer bg-black text-white border rounded-md">
+ <!-- Error Display -->
+ {#if error}
+ <div class="p-3 bg-red-900/20 border-b border-red-700 text-red-200 text-sm">
+ {error}
+ </div>
+ {/if}
+
+ <!-- Log Content -->
+ <div bind:this={logContainer} class="log-viewer overflow-y-auto font-mono text-sm bg-black text-white border rounded-lg" style="height: {height}">
+ {#if logs.length === 0}
+ <div class="p-4 text-center text-gray-500">
+ {#if !containerId}
+ No {type} selected
+ {:else if !isStreaming}
+ No logs available. Start streaming to see logs.
+ {:else}
+ Waiting for logs...
+ {/if}
+ </div>
+ {:else}
+ {#each logs as log (log.timestamp + log.message + (log.service || ''))}
+ <div class="flex px-3 py-1 hover:bg-gray-900/50 border-l-2 border-transparent hover:border-blue-500 transition-colors">
+ {#if showTimestamps}
+ <span class="text-gray-500 text-xs mr-3 flex-shrink-0 w-20">
+ {formatTimestamp(log.timestamp)}
+ </span>
+ {/if}
+
+ <span class="text-xs mr-2 flex-shrink-0 w-12 {getLevelClass(log.level)}">
+ {log.level.toUpperCase()}
+ </span>
+
+ {#if type === 'stack' && log.service}
+ <span class="text-blue-400 text-xs mr-2 flex-shrink-0 w-16 truncate" title={log.service}>
+ {log.service}
+ </span>
+ {/if}
+
+ <span class="text-gray-300 whitespace-pre-wrap break-all">
+ {log.message}
+ </span>
+ </div>
+ {/each}
+ {/if}
+ </div>
+</div>
+
+<style>
+ .log-viewer {
+ font-family: 'SF Mono', Monaco, 'Cascadia Code', 'Roboto Mono', Consolas, 'Courier New', monospace;
+ }
+</style>
diff --git a/src/routes/api/containers/[containerId]/logs/stream/+server.ts b/src/routes/api/containers/[containerId]/logs/stream/+server.ts
index bb285f9d8..eac941520 100644
--- a/src/routes/api/containers/[containerId]/logs/stream/+server.ts
+++ b/src/routes/api/containers/[containerId]/logs/stream/+server.ts
@@ -1,98 +1,149 @@
+import { error } from '@sveltejs/kit';
import { getDockerClient } from '$lib/services/docker/core';
-import type { RequestHandler } from '@sveltejs/kit';
-import type { Readable } from 'stream';
+import { Writable } from 'stream';
+import type { RequestHandler } from './$types';
-// Define a custom interface for our stream source
-interface LogStreamSource extends UnderlyingDefaultSource<Uint8Array> {
- logStream?: Readable;
-}
+export const GET: RequestHandler = async ({ params, request }) => {
+ const { containerId } = params;
-export const GET: RequestHandler = async ({ params }) => {
- if (!params.containerId) {
- return new Response('Container ID is required', { status: 400 });
+ if (!containerId) {
+ throw error(400, 'Container ID is required');
}
- const docker = await getDockerClient();
- const container = docker.getContainer(params.containerId);
-
- // Create a ReadableStream with our custom source type
- const stream = new ReadableStream<Uint8Array>({
- async start(controller) {
- try {
- // Get logs stream from Docker
- const logStream = (await container.logs({
- follow: true,
- stdout: true,
- stderr: true,
- timestamps: true
- })) as Readable;
-
- // Track controller state
- let isControllerClosed = false;
-
- // Set up cleanup for client disconnection
- const cleanup = () => {
- isControllerClosed = true;
- if (logStream && logStream.destroy) {
- logStream.destroy();
+ try {
+ const docker = await getDockerClient();
+ const container = docker.getContainer(containerId);
+ await container.inspect();
+
+ const stream = new ReadableStream({
+ start(controller) {
+ const encoder = new TextEncoder();
+ let isClosed = false;
+ let logStream: NodeJS.ReadableStream | null = null;
+
+ const safeEnqueue = (data: string) => {
+ if (!isClosed) {
+ try {
+ controller.enqueue(encoder.encode(data));
+ } catch (err) {
+ isClosed = true;
+ }
}
};
- // Handle Docker stream events
- logStream.on('data', (chunk) => {
- try {
- // Only enqueue if controller is still open
- if (!isControllerClosed) {
- controller.enqueue(chunk);
- }
- } catch (error: any) {
- // Handle "controller closed" errors gracefully
- if (error.code === 'ERR_INVALID_STATE') {
- cleanup();
- } else {
- console.error('Error streaming logs:', error);
+ const stdoutStream = new Writable({
+ write(chunk, encoding, callback) {
+ if (isClosed) {
+ callback();
+ return;
}
+
+ const message = chunk.toString();
+ const data = JSON.stringify({
+ level: 'stdout',
+ message: message,
+ timestamp: new Date().toISOString()
+ });
+
+ safeEnqueue(`data: ${data}\n\n`);
+ callback();
}
});
- logStream.on('end', () => {
- if (!isControllerClosed) {
- controller.close();
- isControllerClosed = true;
+ const stderrStream = new Writable({
+ write(chunk, encoding, callback) {
+ if (isClosed) {
+ callback();
+ return;
+ }
+
+ const message = chunk.toString();
+ const data = JSON.stringify({
+ level: 'stderr',
+ message: message,
+ timestamp: new Date().toISOString()
+ });
+
+ safeEnqueue(`data: ${data}\n\n`);
+ callback();
}
});
- logStream.on('error', (err) => {
- console.error('Docker logs stream error:', err);
- if (!isControllerClosed) {
- controller.error(err);
- isControllerClosed = true;
+ const cleanup = () => {
+ isClosed = true;
+ if (logStream) {
+ try {
+ if (typeof (logStream as any).destroy === 'function') {
+ (logStream as any).destroy();
+ }
+ } catch (err) {
+ // Silent cleanup
+ }
}
+ };
+
+ container.logs(
+ {
+ follow: true,
+ stdout: true,
+ stderr: true,
+ timestamps: true,
+ tail: 50
+ },
+ (err, stream) => {
+ if (err) {
+ if (!isClosed) {
+ controller.error(err);
+ }
+ return;
+ }
+
+ logStream = stream || null;
+
+ if (stream && !isClosed) {
+ container.modem.demuxStream(stream, stdoutStream, stderrStream);
+
+ stream.on('end', () => {
+ cleanup();
+ if (!isClosed) {
+ controller.close();
+ }
+ });
+
+ stream.on('error', (streamErr) => {
+ cleanup();
+ if (!isClosed) {
+ controller.error(streamErr);
+ }
+ });
+
+ stream.on('close', () => {
+ cleanup();
+ });
+ } else {
+ cleanup();
+ }
+ }
+ );
+
+ request.signal.addEventListener('abort', () => {
+ cleanup();
});
- // Store for cleanup in cancel
- (this as LogStreamSource).logStream = logStream;
- } catch (error) {
- console.error('Error starting logs stream:', error);
- controller.error(error);
+ return cleanup;
}
- },
-
- cancel() {
- // Called when client disconnects
- console.log('Client disconnected from logs stream');
- const self = this as LogStreamSource;
- if (self.logStream && self.logStream.destroy) {
- self.logStream.destroy();
+ });
+
+ return new Response(stream, {
+ headers: {
+ 'Content-Type': 'text/event-stream',
+ 'Cache-Control': 'no-cache',
+ Connection: 'keep-alive',
+ 'Access-Control-Allow-Origin': '*',
+ 'Access-Control-Allow-Headers': 'Cache-Control'
}
- }
- } as LogStreamSource);
-
- return new Response(stream, {
- headers: {
- 'Content-Type': 'text/event-stream',
- 'Cache-Control': 'no-cache',
- Connection: 'keep-alive'
- }
- });
+ });
+ } catch (err) {
+ throw error(500, 'Failed to stream container logs');
+ }
};
diff --git a/src/routes/api/stacks/[stackId]/logs/+server.ts b/src/routes/api/stacks/[stackId]/logs/+server.ts
index 3e916e829..2623a5833 100644
--- a/src/routes/api/stacks/[stackId]/logs/+server.ts
+++ b/src/routes/api/stacks/[stackId]/logs/+server.ts
@@ -1,126 +1,307 @@
+import { error } from '@sveltejs/kit';
import { getDockerClient } from '$lib/services/docker/core';
-import type { RequestHandler } from '@sveltejs/kit';
-import type { Readable } from 'stream';
+import { Writable } from 'stream';
+import type { RequestHandler } from './$types';
-interface StackLogStreamSource extends UnderlyingDefaultSource<Uint8Array> {
- logStreams?: Map<string, Readable>;
-}
+export const GET: RequestHandler = async ({ params, request, url }) => {
+ const { stackId } = params;
-export const GET: RequestHandler = async ({ params }) => {
- if (!params.stackId) {
- return new Response('Stack ID is required', { status: 400 });
+ if (!stackId) {
+ throw error(400, 'Stack ID is required');
}
- const docker = await getDockerClient();
+ // Get query parameters for log configuration
+ const tail = parseInt(url.searchParams.get('tail') || '50');
+ const timestamps = url.searchParams.get('timestamps') !== 'false';
+ const follow = url.searchParams.get('follow') !== 'false';
- const stream = new ReadableStream<Uint8Array>({
- async start(controller) {
- try {
- const containers = await docker.listContainers({
- all: true,
- filters: { label: [`com.docker.compose.project=${params.stackId}`] }
+ console.log(`Starting stack logs for ${stackId}, follow=${follow}, tail=${tail}`);
+
+ try {
+ const docker = await getDockerClient();
+
+ // Get all containers for this stack
+ const containers = await docker.listContainers({
+ all: true,
+ filters: {
+ label: [`com.docker.compose.project=${stackId}`]
+ }
+ });
+
+ console.log(`Found ${containers.length} containers for stack ${stackId}`);
+
+ if (containers.length === 0) {
+ throw error(404, `No containers found for stack: ${stackId}`);
+ }
+
+ const stream = new ReadableStream({
+ start(controller) {
+ const encoder = new TextEncoder();
+ let isClosed = false;
+ const activeStreams = new Map<string, NodeJS.ReadableStream>();
+ const containerNames = new Map<string, string>();
+
+ // Build container name mapping
+ containers.forEach((containerInfo) => {
+ const serviceName = containerInfo.Labels['com.docker.compose.service'] || containerInfo.Names[0]?.replace(/^\//, '') || containerInfo.Id.substring(0, 12);
+ containerNames.set(containerInfo.Id, serviceName);
+ console.log(`Container ${containerInfo.Id.substring(0, 12)} -> Service: ${serviceName}`);
});
- const logStreams = new Map<string, Readable>();
- let isControllerClosed = false;
+ const safeEnqueue = (data: string) => {
+ if (!isClosed) {
+ try {
+ controller.enqueue(encoder.encode(data));
+ } catch (err) {
+ console.error('Error enqueuing data:', err);
+ isClosed = true;
+ cleanup();
+ }
+ }
+ };
+
+ const createLogProcessor = (containerId: string, serviceName: string) => {
+ const stdoutStream = new Writable({
+ write(chunk, encoding, callback) {
+ if (isClosed) {
+ callback();
+ return;
+ }
+
+ try {
+ const message = chunk.toString().trim();
+ if (message) {
+ const data = JSON.stringify({
+ level: 'stdout',
+ message: message,
+ timestamp: new Date().toISOString(),
+ service: serviceName,
+ containerId: containerId.substring(0, 12)
+ });
+
+ safeEnqueue(`data: ${data}\n\n`);
+ }
+ callback();
+ } catch (err) {
+ console.error(`Error processing stdout for ${serviceName}:`, err);
+ callback();
+ }
+ }
+ });
+
+ const stderrStream = new Writable({
+ write(chunk, encoding, callback) {
+ if (isClosed) {
+ callback();
+ return;
+ }
+
+ try {
+ const message = chunk.toString().trim();
+ if (message) {
+ const data = JSON.stringify({
+ level: 'stderr',
+ message: message,
+ timestamp: new Date().toISOString(),
+ service: serviceName,
+ containerId: containerId.substring(0, 12)
+ });
+
+ safeEnqueue(`data: ${data}\n\n`);
+ }
+ callback();
+ } catch (err) {
+ console.error(`Error processing stderr for ${serviceName}:`, err);
+ callback();
+ }
+ }
+ });
+
+ return { stdoutStream, stderrStream };
+ };
const cleanup = () => {
- isControllerClosed = true;
- logStreams.forEach((stream, containerId) => {
- if (stream && stream.destroy) {
- stream.destroy();
+ if (isClosed) return;
+ console.log(`Cleaning up stack logs for ${stackId}`);
+ isClosed = true;
+
+ activeStreams.forEach((stream, containerId) => {
+ try {
+ if (typeof (stream as any).destroy === 'function') {
+ (stream as any).destroy();
+ }
+ } catch (err) {
+ console.error(`Error cleaning up stream for container ${containerId}:`, err);
}
});
- logStreams.clear();
+
+ activeStreams.clear();
};
- for (const containerInfo of containers) {
+ // Send initial connection message
+ const initialData = JSON.stringify({
+ level: 'info',
+ message: `Starting logs for stack ${stackId} (${containers.length} containers)`,
+ timestamp: new Date().toISOString(),
+ service: 'system',
+ containerId: 'N/A'
+ });
+ safeEnqueue(`data: ${initialData}\n\n`);
+
+ // Start log streams for each container
+ const streamPromises = containers.map(async (containerInfo) => {
+ console.log('Container id: ', containerInfo.Id, 'Service name:', containerNames.get(containerInfo.Id));
const container = docker.getContainer(containerInfo.Id);
- const serviceName = containerInfo.Labels['com.docker.compose.service'] || containerInfo.Names[0]?.replace('/', '') || 'unknown';
+ const serviceName = containerNames.get(containerInfo.Id)!;
try {
- const logStream = (await container.logs({
- follow: true,
- stdout: true,
- stderr: true,
- timestamps: true
- })) as Readable;
+ // Check if container exists and is accessible
+ const containerInspect = await container.inspect();
+ console.log(`Container ${serviceName} state: ${containerInspect.State.Status}`);
- logStreams.set(containerInfo.Id, logStream);
+ return new Promise<void>((resolve) => {
+ container.logs(
+ {
+ follow: follow as true,
+ stdout: true,
+ stderr: true,
+ timestamps: timestamps,
+ tail: Math.min(tail, 100)
+ },
+ (err, logStream) => {
+ if (err) {
+ console.error(`Failed to get logs for ${serviceName}:`, err);
+ const errorData = JSON.stringify({
+ level: 'error',
+ message: `Failed to get logs: ${err.message}`,
+ timestamp: new Date().toISOString(),
+ service: serviceName,
+ containerId: containerInfo.Id.substring(0, 12)
+ });
+ safeEnqueue(`data: ${errorData}\n\n`);
+ resolve();
+ return;
+ }
- logStream.on('data', (chunk) => {
- try {
- if (!isControllerClosed) {
- const logData = chunk.toString();
- const lines = logData.split('\n');
-
- for (const line of lines) {
- if (line.length > 8) {
- // Remove Docker's 8-byte header
- const cleanLine = line.substring(8);
- if (cleanLine.trim()) {
- // Format each line with service prefix and ensure it ends with newline
- const formattedLine = `[${serviceName}] ${cleanLine}\n`;
- controller.enqueue(new TextEncoder().encode(`data: ${formattedLine}\n\n`));
- }
- }
+ if (!logStream || isClosed) {
+ resolve();
+ return;
+ }
+
+ activeStreams.set(containerInfo.Id, logStream);
+ const { stdoutStream, stderrStream } = createLogProcessor(containerInfo.Id, serviceName);
+
+ try {
+ // Demux the Docker stream
+ container.modem.demuxStream(logStream, stdoutStream, stderrStream);
+
+ logStream.on('end', () => {
+ console.log(`Log stream ended for ${serviceName}`);
+ activeStreams.delete(containerInfo.Id);
+ resolve();
+ });
+
+ logStream.on('error', (streamErr) => {
+ console.error(`Log stream error for ${serviceName}:`, streamErr);
+ activeStreams.delete(containerInfo.Id);
+ resolve();
+ });
+
+ logStream.on('close', () => {
+ console.log(`Log stream closed for ${serviceName}`);
+ activeStreams.delete(containerInfo.Id);
+ });
+
+ // Send connection confirmation
+ const connectionData = JSON.stringify({
+ level: 'info',
+ message: `Connected to ${serviceName} logs`,
+ timestamp: new Date().toISOString(),
+ service: serviceName,
+ containerId: containerInfo.Id.substring(0, 12)
+ });
+ safeEnqueue(`data: ${connectionData}\n\n`);
+ } catch (demuxError) {
+ console.error(`Error setting up demux for ${serviceName}:`, demuxError);
+ resolve();
}
}
- } catch (error: any) {
- if (error.code === 'ERR_INVALID_STATE') {
- cleanup();
- } else {
- console.error(`Error streaming logs for ${serviceName}:`, error);
- }
- }
+ );
+ });
+ } catch (inspectError) {
+ console.error(`Container ${serviceName} not accessible:`, inspectError);
+ const errorMessage = inspectError instanceof Error ? inspectError.message : String(inspectError);
+ const errorData = JSON.stringify({
+ level: 'error',
+ message: `Container ${serviceName} is not accessible: ${errorMessage}`,
+ timestamp: new Date().toISOString(),
+ service: serviceName,
+ containerId: containerInfo.Id.substring(0, 12)
});
+ safeEnqueue(`data: ${errorData}\n\n`);
+ return Promise.resolve();
+ }
+ });
- logStream.on('end', () => {
- logStreams.delete(containerInfo.Id);
- if (logStreams.size === 0 && !isControllerClosed) {
- controller.close();
- isControllerClosed = true;
+ // Wait for all stream setups to complete
+ Promise.allSettled(streamPromises)
+ .then((results) => {
+ console.log(`Stream setup complete for ${stackId}. Active streams: ${activeStreams.size}`);
+
+ results.forEach((result, index) => {
+ if (result.status === 'rejected') {
+ console.error(`Stream setup failed for container ${index}:`, result.reason);
}
});
- logStream.on('error', (err) => {
- console.error(`Docker logs stream error for ${serviceName}:`, err);
- logStreams.delete(containerInfo.Id);
- });
- } catch (error) {
- console.error(`Failed to start log stream for ${serviceName}:`, error);
- }
- }
+ if (!isClosed && activeStreams.size === 0) {
+ const finalData = JSON.stringify({
+ level: 'warning',
+ message: 'No active log streams available - containers may be stopped',
+ timestamp: new Date().toISOString(),
+ service: 'system',
+ containerId: 'N/A'
+ });
+ safeEnqueue(`data: ${finalData}\n\n`);
+ }
+ })
+ .catch((setupError) => {
+ console.error('Error setting up log streams:', setupError);
+ if (!isClosed) {
+ const errorData = JSON.stringify({
+ level: 'error',
+ message: `Failed to setup log streams: ${setupError.message}`,
+ timestamp: new Date().toISOString(),
+ service: 'system',
+ containerId: 'N/A'
+ });
+ safeEnqueue(`data: ${errorData}\n\n`);
+ }
+ });
- (this as StackLogStreamSource).logStreams = logStreams;
+ // Handle client disconnect
+ request.signal.addEventListener('abort', cleanup);
- if (containers.length === 0) {
- controller.enqueue(new TextEncoder().encode(`data: No containers found in this stack\n\n`));
- }
- } catch (error) {
- console.error('Error starting stack logs stream:', error);
- controller.error(error);
- }
- },
-
- cancel() {
- console.log('Client disconnected from stack logs stream');
- const self = this as StackLogStreamSource;
- if (self.logStreams) {
- self.logStreams.forEach((stream) => {
- if (stream && stream.destroy) {
- stream.destroy();
- }
- });
+ // Return cleanup function
+ return cleanup;
+ },
+
+ cancel() {
+ console.log(`Client disconnected from stack ${stackId} logs`);
}
- }
- } as StackLogStreamSource);
+ });
- return new Response(stream, {
- headers: {
- 'Content-Type': 'text/event-stream',
- 'Cache-Control': 'no-cache',
- Connection: 'keep-alive'
- }
- });
+ return new Response(stream, {
+ headers: {
+ 'Content-Type': 'text/event-stream',
+ 'Cache-Control': 'no-cache',
+ Connection: 'keep-alive',
+ 'Access-Control-Allow-Origin': '*',
+ 'Access-Control-Allow-Headers': 'Cache-Control'
+ }
+ });
+ } catch (err: any) {
+ console.error(`Error streaming logs for stack ${stackId}:`, err);
+ throw error(500, `Failed to stream stack logs: ${err.message}`);
+ }
};
diff --git a/src/routes/containers/[id]/+page.svelte b/src/routes/containers/[id]/+page.svelte
index 1b28967ba..f24ab8985 100644
--- a/src/routes/containers/[id]/+page.svelte
+++ b/src/routes/containers/[id]/+page.svelte
@@ -14,6 +14,7 @@
import StatusBadge from '$lib/components/badges/status-badge.svelte';
import * as Tabs from '$lib/components/ui/tabs/index.js';
import { onDestroy } from 'svelte';
+ import LogViewer from '$lib/components/LogViewer.svelte';
// Define the network config interface to match what Docker actually returns
interface NetworkConfig {
@@ -34,87 +35,19 @@
let { data }: { data: PageData } = $props();
let { container, logs: initialLogsFromServer, stats } = $derived(data);
- let displayedLogs = $derived(initialLogsFromServer || '');
-
let starting = $state(false);
let stopping = $state(false);
let restarting = $state(false);
let removing = $state(false);
let isRefreshing = $state(false);
- let formattedLogHtml = $derived(
- displayedLogs
- ? displayedLogs
- .split('\n')
- .map((line) => {
- const cleanedLine = line.replace(/[\x00-\x09\x0B-\x1F\x7F-\x9F]/g, '');
- return formatLogLine(cleanedLine);
- })
- .join('\n')
- : ''
- );
- let logsContainer = $state<HTMLDivElement | undefined>(undefined);
let activeTab = $state('overview');
let autoScrollLogs = $state(true);
+ let isStreaming = $state(false);
- let logEventSource: EventSource | null = $state(null);
- let statsEventSource: EventSource | null = $state(null);
-
- function scrollLogsToBottom() {
- if (logsContainer) {
- logsContainer.scrollTop = logsContainer.scrollHeight;
- }
- }
-
- $effect(() => {
- if (logsContainer && displayedLogs && activeTab === 'logs' && autoScrollLogs) {
- scrollLogsToBottom();
- }
- });
-
- $effect(() => {
- if (activeTab === 'logs') {
- startLogStream();
- setTimeout(scrollLogsToBottom, 100);
- } else if (logEventSource) {
- closeLogStream();
- }
- });
-
- function startLogStream() {
- if (logEventSource || !container?.Id) return;
-
- try {
- const url = `/api/containers/${container.Id}/logs/stream`;
- const eventSource = new EventSource(url);
- logEventSource = eventSource;
+ let logViewer = $state<LogViewer>();
- eventSource.onmessage = (event) => {
- if (event.data) {
- displayedLogs = (displayedLogs || '') + event.data;
-
- if (autoScrollLogs) {
- scrollLogsToBottom();
- }
- }
- };
-
- eventSource.onerror = (error) => {
- console.error('EventSource error:', error);
- eventSource.close();
- logEventSource = null;
- };
- } catch (error) {
- console.error('Failed to connect to log stream:', error);
- }
- }
-
- function closeLogStream() {
- if (logEventSource) {
- logEventSource.close();
- logEventSource = null;
- }
- }
+ let statsEventSource: EventSource | null = $state(null);
function startStatsStream() {
if (statsEventSource || !container?.Id || !container.State?.Running) return;
@@ -167,7 +100,6 @@
});
onDestroy(() => {
- closeLogStream();
closeStatsStream();
});
@@ -216,13 +148,6 @@
const primaryIpAddress = $derived(getPrimaryIpAddress(container?.NetworkSettings));
$effect(() => {
- if (logsContainer && displayedLogs && autoScrollLogs) {
- const atBottom = logsContainer.scrollHeight - logsContainer.scrollTop <= logsContainer.clientHeight + 50;
- if (atBottom) {
- scrollLogsToBottom();
- }
- }
-
starting = false;
stopping = false;
restarting = false;
@@ -236,6 +161,23 @@
isRefreshing = false;
}, 500);
}
+
+ // LogViewer callback functions
+ function handleLogStart() {
+ isStreaming = true;
+ }
+
+ function handleLogStop() {
+ isStreaming = false;
+ }
+
+ function handleLogClear() {
+ // Custom logic when logs are cleared if needed
+ }
+
+ function handleToggleAutoScroll() {
+ // Custom logic when auto-scroll is toggled if needed
+ }
</script>
<div class="space-y-6 pb-8">
@@ -664,45 +606,36 @@
<div class="flex flex-col sm:flex-row justify-between items-start sm:items-center w-full gap-4">
<div>
<Card.Title class="text-lg font-semibold">Container Logs</Card.Title>
- <Card.Description>Recent output from the container</Card.Description>
+ <Card.Description>Live output from the container</Card.Description>
</div>
<div class="flex items-center gap-2">
<div class="flex items-center">
- <input type="checkbox" id="auto-scroll" class="mr-2" checked={autoScrollLogs} onchange={(e) => (autoScrollLogs = e.currentTarget.checked)} />
+ <input type="checkbox" id="auto-scroll" class="mr-2" bind:checked={autoScrollLogs} />
<label for="auto-scroll" class="text-xs">Auto-scroll</label>
</div>
+
+ <Button variant="outline" size="sm" onclick={() => logViewer?.clearLogs()}>Clear</Button>
+
+ {#if isStreaming}
+ <div class="flex items-center space-x-1">
+ <div class="w-2 h-2 bg-green-500 rounded-full animate-pulse"></div>
+ <span class="text-xs text-green-400">Live</span>
+ </div>
+ <Button variant="outline" size="sm" onclick={() => logViewer?.stopLogStream()}>Stop</Button>
+ {:else}
+ <Button variant="outline" size="sm" onclick={() => logViewer?.startLogStream()} disabled={!container?.Id}>Start</Button>
+ {/if}
+
<Button variant="outline" size="sm" onclick={refreshData} disabled={isRefreshing}>
<RefreshCw class={`size-4 ${isRefreshing ? 'animate-spin' : ''}`} />
- Refresh Logs
+ Refresh
</Button>
</div>
</div>
</Card.Header>
<Card.Content>
- <div
- class="bg-muted/50 text-foreground p-4 rounded-md font-mono text-xs overflow-auto border h-[500px]"
- bind:this={logsContainer}
- id="logs-container"
- style="overflow-x: auto;"
- onscroll={() => {
- if (logsContainer) {
- const atBottom = logsContainer.scrollHeight - logsContainer.scrollTop <= logsContainer.clientHeight + 50;
- if (!atBottom && autoScrollLogs) {
- autoScrollLogs = false;
- }
- }
- }}
- >
- {#if formattedLogHtml}
- <pre class="m-0 whitespace-pre-wrap break-words">{@html formattedLogHtml}</pre>
- {:else}
- <div class="flex flex-col items-center justify-center h-full text-center">
- <Terminal class="text-muted-foreground mb-3 opacity-40 size-8" />
- <p class="text-muted-foreground italic">No logs available. The container may not have started yet or produces no output.</p>
- </div>
- {/if}
- </div>
+ <LogViewer bind:this={logViewer} bind:autoScroll={autoScrollLogs} type="container" containerId={container?.Id} maxLines={500} showTimestamps={true} height="500px" onStart={handleLogStart} onStop={handleLogStop} onClear={handleLogClear} onToggleAutoScroll={handleToggleAutoScroll} />
</Card.Content>
</Card.Root>
</Tabs.Content>
diff --git a/src/routes/stacks/[stackId]/+page.svelte b/src/routes/stacks/[stackId]/+page.svelte
index 55fc4be43..32d6653a5 100644
--- a/src/routes/stacks/[stackId]/+page.svelte
+++ b/src/routes/stacks/[stackId]/+page.svelte
@@ -20,6 +20,7 @@
import StackAPIService from '$lib/services/api/stack-api-service';
import { handleApiResultWithCallbacks } from '$lib/utils/api.util';
import ArcaneButton from '$lib/components/arcane-button.svelte';
+ import LogViewer from '$lib/components/LogViewer.svelte';
const stackApi = new StackAPIService();
@@ -50,10 +51,9 @@
const baseServerUrl = $derived(settings?.baseServerUrl || 'localhost');
let activeTab = $state('config');
- let stackLogsEventSource: EventSource | null = $state(null);
- let displayedStackLogs = $state('');
let autoScrollStackLogs = $state(true);
- let stackLogsContainer = $state<HTMLDivElement | undefined>(undefined);
+ let isStackLogsStreaming = $state(false);
+ let stackLogViewer = $state<LogViewer>();
$effect(() => {
isLoading.deploying = false;
@@ -138,78 +138,21 @@
return `${protocol}://${host}:80`;
}
- function scrollStackLogsToBottom() {
- if (stackLogsContainer) {
- stackLogsContainer.scrollTop = stackLogsContainer.scrollHeight;
- }
+ function handleStackLogStart() {
+ isStackLogsStreaming = true;
}
- $effect(() => {
- if (stackLogsContainer && displayedStackLogs && activeTab === 'logs' && autoScrollStackLogs) {
- scrollStackLogsToBottom();
- }
- });
-
- $effect(() => {
- if (activeTab === 'logs' && stack?.id) {
- startStackLogsStream();
- setTimeout(scrollStackLogsToBottom, 100);
- } else if (stackLogsEventSource) {
- closeStackLogsStream();
- }
- });
-
- function startStackLogsStream() {
- if (stackLogsEventSource || !stack?.id) return;
-
- // Reset logs when starting a new stream (like container logs do)
- displayedStackLogs = '';
-
- try {
- const url = `/api/stacks/${stack.id}/logs`;
- const eventSource = new EventSource(url);
- stackLogsEventSource = eventSource;
-
- eventSource.onmessage = (event) => {
- if (event.data) {
- // Ensure proper newline formatting
- const logLine = event.data;
- const formattedLine = logLine.endsWith('\n') ? logLine : logLine + '\n';
-
- displayedStackLogs = (displayedStackLogs || '') + formattedLine;
-
- if (autoScrollStackLogs) {
- scrollStackLogsToBottom();
- }
- }
- };
-
- eventSource.onerror = (error) => {
- console.error('Stack logs EventSource error:', error);
- eventSource.close();
- stackLogsEventSource = null;
- };
- } catch (error) {
- console.error('Failed to connect to stack logs stream:', error);
- }
+ function handleStackLogStop() {
+ isStackLogsStreaming = false;
}
- function closeStackLogsStream() {
- if (stackLogsEventSource) {
- stackLogsEventSource.close();
- stackLogsEventSource = null;
- }
+ function handleStackLogClear() {
+ // Custom logic when logs are cleared if needed
}
- function clearStackLogs() {
- displayedStackLogs = '';
+ function handleToggleStackAutoScroll() {
+ // Custom logic when auto-scroll is toggled if needed
}
-
- $effect(() => {
- return () => {
- closeStackLogsStream();
- };
- });
</script>
<div class="space-y-6 pb-8">
@@ -417,16 +360,28 @@
</div>
<div class="flex items-center gap-2">
<div class="flex items-center">
- <input type="checkbox" id="auto-scroll-stack" class="mr-2" checked={autoScrollStackLogs} onchange={(e) => (autoScrollStackLogs = e.currentTarget.checked)} />
+ <input type="checkbox" id="auto-scroll-stack" class="mr-2" bind:checked={autoScrollStackLogs} />
<label for="auto-scroll-stack" class="text-xs">Auto-scroll</label>
</div>
- <Button variant="outline" size="sm" onclick={clearStackLogs}>Clear Logs</Button>
+
+ <Button variant="outline" size="sm" onclick={() => stackLogViewer?.clearLogs()}>Clear Logs</Button>
+
+ {#if isStackLogsStreaming}
+ <div class="flex items-center space-x-1">
+ <div class="w-2 h-2 bg-green-500 rounded-full animate-pulse"></div>
+ <span class="text-xs text-green-400">Live</span>
+ </div>
+ <Button variant="outline" size="sm" onclick={() => stackLogViewer?.stopLogStream()}>Stop</Button>
+ {:else}
+ <Button variant="outline" size="sm" onclick={() => stackLogViewer?.startLogStream()} disabled={!stack?.id}>Start</Button>
+ {/if}
+
<Button
variant="outline"
size="sm"
onclick={() => {
- closeStackLogsStream();
- startStackLogsStream();
+ stackLogViewer?.stopLogStream();
+ stackLogViewer?.startLogStream();
}}
>
<RefreshCw class="size-4" />
@@ -435,29 +390,8 @@
</div>
</div>
- <!-- Logs Container -->
- <div
- class="bg-muted/50 text-foreground p-4 rounded-md font-mono text-xs overflow-auto border h-[600px]"
- bind:this={stackLogsContainer}
- style="overflow-x: auto;"
- onscroll={() => {
- if (stackLogsContainer) {
- const atBottom = stackLogsContainer.scrollHeight - stackLogsContainer.scrollTop <= stackLogsContainer.clientHeight + 50;
- if (!atBottom && autoScrollStackLogs) {
- autoScrollStackLogs = false;
- }
- }
- }}
- >
- {#if displayedStackLogs}
- <pre class="m-0 whitespace-pre-wrap break-words">{displayedStackLogs}</pre>
- {:else}
- <div class="flex flex-col items-center justify-center h-full text-center">
- <Terminal class="text-muted-foreground mb-3 opacity-40 size-8" />
- <p class="text-muted-foreground italic">No logs available. Containers may not have started yet or produce no output.</p>
- </div>
- {/if}
- </div>
+ <!-- LogViewer Component -->
+ <LogViewer bind:this={stackLogViewer} bind:autoScroll={autoScrollStackLogs} stackId={stack?.id} type="stack" maxLines={500} showTimestamps={true} height="600px" onStart={handleStackLogStart} onStop={handleStackLogStop} onClear={handleStackLogClear} onToggleAutoScroll={handleToggleStackAutoScroll} />
</div>
</Card.Content>
{:else}