feat: updates to debug UI

Author: owenrumney

.claude/settings.local.json

@@ -2,7 +2,9 @@
   "permissions": {
     "allow": [
       "Bash(golangci-lint run ./...)",
-      "Bash(go vet ./internal/debugui/...)"
+      "Bash(go vet ./internal/debugui/...)",
+      "Bash(go build ./...)",
+      "Bash(go vet ./...)"
     ]
   }
 }

.github/images/debugui.png

@@ -45,9 +45,9 @@ func (h *Hub) remove(conn *websocket.Conn) {
 	h.mu.Unlock()
 }
 
-// Broadcast sends an entry to all connected clients. Non-blocking: slow clients drop messages.
-func (h *Hub) Broadcast(e Entry) {
-	data, err := json.Marshal(e)
+// Broadcast sends a value to all connected clients. Non-blocking: slow clients drop messages.
+func (h *Hub) Broadcast(v any) {
+	data, err := json.Marshal(v)
 	if err != nil {
 		return
 	}
@@ -61,29 +61,44 @@ func (h *Hub) Broadcast(e Entry) {
 	}
 }
 
+// wsMessage wraps an entry or log for WebSocket broadcast with a kind discriminator.
+type wsMessage struct {
+	Kind string `json:"kind"`
+	Data any    `json:"data"`
+}
+
 // DebugUI is an HTTP server that serves the debug web interface and websocket.
 type DebugUI struct {
-	store *Store
-	hub   *Hub
-	stats *Stats
-	srv   *http.Server
+	store    *Store
+	logStore *LogStore
+	hub      *Hub
+	stats    *Stats
+	srv      *http.Server
 }
 
 // New creates a DebugUI bound to the given address.
-func New(addr string, store *Store) *DebugUI {
+func New(addr string, store *Store, logStore *LogStore) *DebugUI {
 	d := &DebugUI{
-		store: store,
-		hub:   newHub(),
-		stats: NewStats(store),
+		store:    store,
+		logStore: logStore,
+		hub:      newHub(),
+		stats:    NewStats(store),
 	}
 
-	store.Subscribe(d.hub.Broadcast)
+	store.Subscribe(func(e Entry) {
+		d.hub.Broadcast(wsMessage{Kind: "message", Data: e})
+	})
+	logStore.Subscribe(func(e LogEntry) {
+		d.hub.Broadcast(wsMessage{Kind: "log", Data: e})
+	})
 
 	mux := http.NewServeMux()
 	mux.Handle("GET /", http.FileServerFS(staticFiles()))
 	mux.HandleFunc("GET /ws", d.handleWS)
 	mux.HandleFunc("GET /api/messages", d.handleMessages)
 	mux.HandleFunc("GET /api/messages/search", d.handleSearch)
+	mux.HandleFunc("GET /api/logs", d.handleLogs)
+	mux.HandleFunc("GET /api/logs/search", d.handleLogSearch)
 	mux.HandleFunc("GET /api/stats", d.handleStats)
 
 	d.srv = &http.Server{
@@ -95,6 +110,11 @@ func New(addr string, store *Store) *DebugUI {
 	return d
 }
 
+// SlogHandler returns a slog.Handler that sends log records to the debug UI's log tab.
+func (d *DebugUI) SlogHandler() *SlogHandler {
+	return NewSlogHandler(d.logStore)
+}
+
 // ListenAndServe binds the port synchronously, then serves in the background.
 // Returns an error if the port cannot be bound. The server shuts down when ctx is cancelled.
 func (d *DebugUI) ListenAndServe(ctx context.Context) error {
@@ -189,6 +209,42 @@ func (d *DebugUI) handleSearch(w http.ResponseWriter, r *http.Request) {
 	_ = json.NewEncoder(w).Encode(entries)
 }
 
+func (d *DebugUI) handleLogs(w http.ResponseWriter, r *http.Request) {
+	offset, _ := strconv.Atoi(r.URL.Query().Get("offset"))
+	limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
+	if limit <= 0 {
+		limit = 100
+	}
+	if limit > 1000 {
+		limit = 1000
+	}
+
+	entries := d.logStore.Entries(offset, limit)
+	if entries == nil {
+		entries = []LogEntry{}
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(entries)
+}
+
+func (d *DebugUI) handleLogSearch(w http.ResponseWriter, r *http.Request) {
+	q := r.URL.Query().Get("q")
+	if q == "" {
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write([]byte("[]"))
+		return
+	}
+
+	entries := d.logStore.Search(q)
+	if entries == nil {
+		entries = []LogEntry{}
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(entries)
+}
+
 func (d *DebugUI) handleStats(w http.ResponseWriter, _ *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	_ = json.NewEncoder(w).Encode(d.stats.Snapshot())

internal/debugui/debugui.go

@@ -0,0 +1,168 @@
+package debugui
+
+import (
+	"context"
+	"log/slog"
+	"strings"
+	"sync"
+	"time"
+)
+
+const maxLogEntries = 5000
+
+// LogEntry is a captured log message.
+type LogEntry struct {
+	ID        int       `json:"id"`
+	Timestamp time.Time `json:"timestamp"`
+	Level     string    `json:"level"` // "error", "warning", "info", "debug"
+	Message   string    `json:"message"`
+}
+
+// LogSubscriber receives new log entries.
+type LogSubscriber func(LogEntry)
+
+// LogStore is a thread-safe ring buffer of log messages.
+type LogStore struct {
+	mu          sync.RWMutex
+	entries     []LogEntry
+	nextID      int
+	subscribers []LogSubscriber
+}
+
+// NewLogStore creates a new LogStore.
+func NewLogStore() *LogStore {
+	return &LogStore{
+		entries: make([]LogEntry, 0, 256),
+	}
+}
+
+// Subscribe registers a callback for new log entries.
+func (s *LogStore) Subscribe(fn LogSubscriber) {
+	s.mu.Lock()
+	s.subscribers = append(s.subscribers, fn)
+	s.mu.Unlock()
+}
+
+// Add stores a log entry and notifies subscribers.
+func (s *LogStore) Add(level, message string) {
+	e := LogEntry{
+		Timestamp: time.Now(),
+		Level:     level,
+		Message:   message,
+	}
+
+	s.mu.Lock()
+
+	e.ID = s.nextID
+	s.nextID++
+
+	if len(s.entries) < maxLogEntries {
+		s.entries = append(s.entries, e)
+	} else {
+		s.entries[e.ID%maxLogEntries] = e
+	}
+
+	subs := make([]LogSubscriber, len(s.subscribers))
+	copy(subs, s.subscribers)
+	s.mu.Unlock()
+
+	for _, fn := range subs {
+		fn(e)
+	}
+}
+
+// Entries returns a paginated slice of log entries.
+func (s *LogStore) Entries(offset, limit int) []LogEntry {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	n := len(s.entries)
+	if offset >= n {
+		return nil
+	}
+	end := min(offset+limit, n)
+	result := make([]LogEntry, end-offset)
+	copy(result, s.entries[offset:end])
+	return result
+}
+
+// Search returns log entries where the message contains the query substring.
+func (s *LogStore) Search(query string) []LogEntry {
+	query = strings.ToLower(query)
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	var result []LogEntry
+	for _, e := range s.entries {
+		if strings.Contains(strings.ToLower(e.Message), query) ||
+			strings.Contains(strings.ToLower(e.Level), query) {
+			result = append(result, e)
+		}
+	}
+	return result
+}
+
+// SlogHandler is a slog.Handler that sends log records to a LogStore.
+type SlogHandler struct {
+	store *LogStore
+	attrs []slog.Attr
+	group string
+}
+
+// NewSlogHandler creates a slog.Handler that writes to the given LogStore.
+func NewSlogHandler(store *LogStore) *SlogHandler {
+	return &SlogHandler{store: store}
+}
+
+func (h *SlogHandler) Enabled(_ context.Context, _ slog.Level) bool {
+	return true
+}
+
+func (h *SlogHandler) Handle(_ context.Context, r slog.Record) error {
+	level := strings.ToLower(r.Level.String())
+
+	msg := r.Message
+	// Append attrs if any.
+	var parts []string
+	for _, a := range h.attrs {
+		parts = append(parts, formatAttr(h.group, a))
+	}
+	r.Attrs(func(a slog.Attr) bool {
+		parts = append(parts, formatAttr(h.group, a))
+		return true
+	})
+	if len(parts) > 0 {
+		msg += " " + strings.Join(parts, " ")
+	}
+
+	h.store.Add(level, msg)
+	return nil
+}
+
+func (h *SlogHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
+	return &SlogHandler{
+		store: h.store,
+		attrs: append(append([]slog.Attr{}, h.attrs...), attrs...),
+		group: h.group,
+	}
+}
+
+func (h *SlogHandler) WithGroup(name string) slog.Handler {
+	prefix := name
+	if h.group != "" {
+		prefix = h.group + "." + name
+	}
+	return &SlogHandler{
+		store: h.store,
+		attrs: append([]slog.Attr{}, h.attrs...),
+		group: prefix,
+	}
+}
+
+func formatAttr(group string, a slog.Attr) string {
+	key := a.Key
+	if group != "" {
+		key = group + "." + key
+	}
+	return key + "=" + a.Value.String()
+}