feat: capture and show server logs

Author: TimothyYe

cmd/godns/godns.go

@@ -10,6 +10,7 @@ import (
 	"github.com/TimothyYe/godns/internal/manager"
 	"github.com/TimothyYe/godns/internal/settings"
 	"github.com/TimothyYe/godns/internal/utils"
+	"github.com/TimothyYe/godns/pkg/lib"
 
 	log "github.com/sirupsen/logrus"
 
@@ -53,6 +54,12 @@ func main() {
 		log.Fatal(err)
 	}
 
+	// Initialize log buffer for web interface
+	lib.InitLogBuffer(1000) // Store last 1000 log entries
+	logBuffer := lib.GetLogBuffer()
+	logHook := lib.NewLogHook(logBuffer)
+	log.AddHook(logHook)
+
 	// set the log level
 	log.SetOutput(os.Stdout)
 

internal/server/controllers/logs.go

@@ -0,0 +1,59 @@
+package controllers
+
+import (
+	"strconv"
+
+	"github.com/TimothyYe/godns/pkg/lib"
+	"github.com/gofiber/fiber/v2"
+)
+
+// GetLogs returns log entries.
+func (c *Controller) GetLogs(ctx *fiber.Ctx) error {
+	// Get query parameters
+	limitStr := ctx.Query("limit", "100")
+	level := ctx.Query("level", "")
+
+	limit, err := strconv.Atoi(limitStr)
+	if err != nil || limit <= 0 {
+		limit = 100
+	}
+
+	// Get log buffer
+	logBuffer := lib.GetLogBuffer()
+	entries := logBuffer.GetRecent(limit)
+
+	// Filter by level if specified
+	if level != "" {
+		filteredEntries := make([]lib.LogEntry, 0)
+		for _, entry := range entries {
+			if entry.Level == level {
+				filteredEntries = append(filteredEntries, entry)
+			}
+		}
+		entries = filteredEntries
+	}
+
+	return ctx.JSON(fiber.Map{
+		"logs":  entries,
+		"total": len(entries),
+	})
+}
+
+// ClearLogs clears all log entries.
+func (c *Controller) ClearLogs(ctx *fiber.Ctx) error {
+	logBuffer := lib.GetLogBuffer()
+	logBuffer.Clear()
+
+	return ctx.JSON(fiber.Map{
+		"message": "Logs cleared successfully",
+	})
+}
+
+// GetLogLevels returns available log levels.
+func (c *Controller) GetLogLevels(ctx *fiber.Ctx) error {
+	levels := []string{"panic", "fatal", "error", "warn", "info", "debug", "trace"}
+
+	return ctx.JSON(fiber.Map{
+		"levels": levels,
+	})
+}

internal/server/server.go

@@ -127,6 +127,11 @@ func (s *Server) initRoutes() {
 	route.Get("/network", s.controller.GetNetworkSettings)
 	route.Put("/network", s.controller.UpdateNetworkSettings)
 
+	// Log related routes
+	route.Get("/logs", s.controller.GetLogs)
+	route.Delete("/logs", s.controller.ClearLogs)
+	route.Get("/logs/levels", s.controller.GetLogLevels)
+
 	// Serve embedded files
 	s.app.Use("/", filesystem.New(filesystem.Config{
 		Root:       http.FS(embeddedFiles),

pkg/lib/log_buffer.go

@@ -0,0 +1,145 @@
+package lib
+
+import (
+	"sync"
+	"time"
+
+	"github.com/sirupsen/logrus"
+)
+
+// LogEntry represents a single log entry.
+type LogEntry struct {
+	Timestamp time.Time     `json:"timestamp"`
+	Level     string        `json:"level"`
+	Message   string        `json:"message"`
+	Fields    logrus.Fields `json:"fields,omitempty"`
+}
+
+// LogBuffer is a thread-safe circular buffer for log entries.
+type LogBuffer struct {
+	entries []LogEntry
+	size    int
+	index   int
+	mutex   sync.RWMutex
+	full    bool
+}
+
+// NewLogBuffer creates a new log buffer with specified size.
+func NewLogBuffer(size int) *LogBuffer {
+	return &LogBuffer{
+		entries: make([]LogEntry, size),
+		size:    size,
+		index:   0,
+		full:    false,
+	}
+}
+
+// Add adds a new log entry to the buffer.
+func (lb *LogBuffer) Add(entry LogEntry) {
+	lb.mutex.Lock()
+	defer lb.mutex.Unlock()
+
+	lb.entries[lb.index] = entry
+	lb.index = (lb.index + 1) % lb.size
+
+	if lb.index == 0 {
+		lb.full = true
+	}
+}
+
+// GetAll returns all log entries in chronological order.
+func (lb *LogBuffer) GetAll() []LogEntry {
+	lb.mutex.RLock()
+	defer lb.mutex.RUnlock()
+
+	if !lb.full && lb.index == 0 {
+		return []LogEntry{}
+	}
+
+	var result []LogEntry
+
+	if lb.full {
+		// Buffer is full, start from current index (oldest entry)
+		result = make([]LogEntry, 0, lb.size)
+		for i := 0; i < lb.size; i++ {
+			idx := (lb.index + i) % lb.size
+			result = append(result, lb.entries[idx])
+		}
+	} else {
+		// Buffer is not full, return entries from 0 to index
+		result = make([]LogEntry, lb.index)
+		copy(result, lb.entries[:lb.index])
+	}
+
+	return result
+}
+
+// GetRecent returns the most recent n log entries.
+func (lb *LogBuffer) GetRecent(n int) []LogEntry {
+	all := lb.GetAll()
+	if len(all) <= n {
+		return all
+	}
+	return all[len(all)-n:]
+}
+
+// Clear clears all log entries.
+func (lb *LogBuffer) Clear() {
+	lb.mutex.Lock()
+	defer lb.mutex.Unlock()
+
+	lb.index = 0
+	lb.full = false
+	lb.entries = make([]LogEntry, lb.size)
+}
+
+// Global log buffer instance.
+var globalLogBuffer *LogBuffer
+
+// InitLogBuffer initializes the global log buffer.
+func InitLogBuffer(size int) {
+	globalLogBuffer = NewLogBuffer(size)
+}
+
+// GetLogBuffer returns the global log buffer instance.
+func GetLogBuffer() *LogBuffer {
+	if globalLogBuffer == nil {
+		InitLogBuffer(1000) // Default size
+	}
+	return globalLogBuffer
+}
+
+// LogHook is a logrus hook that captures logs in the buffer.
+type LogHook struct {
+	buffer *LogBuffer
+}
+
+// NewLogHook creates a new log hook.
+func NewLogHook(buffer *LogBuffer) *LogHook {
+	return &LogHook{
+		buffer: buffer,
+	}
+}
+
+// Fire is called when a log event is fired.
+func (hook *LogHook) Fire(entry *logrus.Entry) error {
+	logEntry := LogEntry{
+		Timestamp: entry.Time,
+		Level:     entry.Level.String(),
+		Message:   entry.Message,
+		Fields:    make(logrus.Fields),
+	}
+
+	// Copy fields
+	for k, v := range entry.Data {
+		logEntry.Fields[k] = v
+	}
+
+	hook.buffer.Add(logEntry)
+	return nil
+}
+
+// Levels returns the available logging levels.
+func (hook *LogHook) Levels() []logrus.Level {
+	return logrus.AllLevels
+}

web/api/logs.ts

@@ -0,0 +1,85 @@
+import { get_api_server } from '@/api/env';
+
+export interface LogEntry {
+	timestamp: string;
+	level: string;
+	message: string;
+	fields?: { [key: string]: any };
+}
+
+export interface LogsResponse {
+	logs: LogEntry[];
+	total: number;
+}
+
+export async function get_logs(credentials: string, limit?: number, level?: string): Promise<LogsResponse | null> {
+	if (!credentials) {
+		return null;
+	}
+
+	const params = new URLSearchParams();
+	if (limit) params.append('limit', limit.toString());
+	if (level) params.append('level', level);
+
+	try {
+		const resp = await fetch(get_api_server() + '/api/v1/logs?' + params.toString(), {
+			method: 'GET',
+			headers: {
+				'Authorization': `Basic ${credentials}`
+			}
+		});
+
+		if (resp.status === 200) {
+			return resp.json();
+		}
+	} catch (error) {
+		console.error('Error fetching logs:', error);
+	}
+
+	return null;
+}
+
+export async function clear_logs(credentials: string): Promise<boolean> {
+	if (!credentials) {
+		return false;
+	}
+
+	try {
+		const resp = await fetch(get_api_server() + '/api/v1/logs', {
+			method: 'DELETE',
+			headers: {
+				'Authorization': `Basic ${credentials}`
+			}
+		});
+
+		return resp.status === 200;
+	} catch (error) {
+		console.error('Error clearing logs:', error);
+	}
+
+	return false;
+}
+
+export async function get_log_levels(credentials: string): Promise<string[]> {
+	if (!credentials) {
+		return [];
+	}
+
+	try {
+		const resp = await fetch(get_api_server() + '/api/v1/logs/levels', {
+			method: 'GET',
+			headers: {
+				'Authorization': `Basic ${credentials}`
+			}
+		});
+
+		if (resp.status === 200) {
+			const data = await resp.json();
+			return data.levels || [];
+		}
+	} catch (error) {
+		console.error('Error fetching log levels:', error);
+	}
+
+	return [];
+}