Files
sam e8a84d3e41
Quality / check (push) Canceled after 1m17s
deploy / gate (push) Successful in 4m31s
deploy / archied-image (push) Successful in 2m49s
deploy / agent-image (push) Successful in 11s
deploy / dist-zip (push) Skipped
refactor(webui): extract the control-plane and logs modules (#1778)
2026-11-03 08:34:51 +11:00

156 lines
4.7 KiB
Go

package webui
import (
"context"
"maps"
"net/http"
"slices"
"strconv"
"strings"
"sync"
"time"
"github.com/samcharles93/archie-core/internal/domain/presence"
"github.com/samcharles93/archie-core/internal/logging"
)
// LogSource reads one service's bounded recent log over its contract.
type LogSource func(context.Context, logging.Query) (logging.Result, error)
// logsAPI owns GET /api/logs. With no sources it reads this process's own
// feed; with neither it reports logs disabled.
type logsAPI struct {
sources map[string]LogSource
feed *logging.Feed
}
func newLogsAPI(s *Server) *logsAPI { return &logsAPI{sources: s.LogSources, feed: s.LogFeed} }
func (a *logsAPI) register(mux *http.ServeMux) {
mux.HandleFunc("GET /api/logs", instanceOnly(a.handleLogs))
}
func (a *logsAPI) handleLogs(w http.ResponseWriter, r *http.Request) {
q := r.URL.Query()
limit := logging.DefaultTailLines
if raw := strings.TrimSpace(q.Get("limit")); raw != "" {
parsed, err := strconv.Atoi(raw)
if err != nil {
http.Error(w, "bad limit", http.StatusBadRequest)
return
}
if parsed > 0 {
limit = min(parsed, logging.MaxTailLines)
}
}
sources := a.sources
if len(sources) == 0 {
sources = map[string]LogSource{presence.UI: func(_ context.Context, q logging.Query) (logging.Result, error) { return a.feed.Read(q) }}
}
service := q.Get("service")
owner := service
if service == presence.Agent || service == presence.Broker {
owner = presence.Daemon
}
if owner != "" && sources[owner] == nil {
http.Error(w, "unknown service", http.StatusBadRequest)
return
}
query := logging.Query{Limit: limit, Levels: splitCSV(q.Get("level")), Component: q.Get("component"), Contains: q.Get("q")}
entries, errors, truncated := readServiceLogs(r.Context(), sources, owner, query)
services := logServices(sources, entries)
components := mergeComponents(nil, entries)
if service != "" {
entries = slices.DeleteFunc(entries, func(e logging.Entry) bool { return e.Fields["service"] != service })
}
slices.SortStableFunc(entries, func(a, b logging.Entry) int { return a.Time.Compare(b.Time) })
if len(entries) > limit {
entries = entries[len(entries)-limit:]
truncated = true
}
writeJSON(w, map[string]any{"entries": entries, "components": components, "services": services, "errors": errors, "truncated": truncated, "disabled": len(a.sources) == 0 && a.feed == nil})
}
func readServiceLogs(ctx context.Context, sources map[string]LogSource, selected string, q logging.Query) ([]logging.Entry, map[string]string, bool) {
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
entries := []logging.Entry{}
failures := map[string]string{}
truncated := false
var mu sync.Mutex
var wg sync.WaitGroup
for name, source := range sources {
if selected != "" && name != selected {
continue
}
wg.Go(func() {
result, err := source(ctx, q)
mu.Lock()
defer mu.Unlock()
if err != nil {
failures[name] = err.Error()
return
}
truncated = truncated || result.Truncated
for _, entry := range result.Entries {
entry.Fields = maps.Clone(entry.Fields)
if entry.Fields == nil {
entry.Fields = map[string]any{}
}
// Only the daemon receives worker and embedded-broker logs.
observed, _ := entry.Fields["service"].(string)
if name != presence.Daemon || (observed != presence.Agent && observed != presence.Broker) {
entry.Fields["service"] = name
}
entries = append(entries, entry)
}
})
}
wg.Wait()
return entries, failures, truncated
}
func mergeComponents(history []string, live []logging.Entry) []string {
seen := make(map[string]struct{}, len(history))
for _, component := range history {
seen[component] = struct{}{}
}
for _, entry := range live {
if component, ok := entry.Fields["component"].(string); ok && component != "" {
seen[component] = struct{}{}
}
}
// Non-nil so the JSON response carries [] rather than null.
components := slices.AppendSeq(make([]string, 0, len(seen)), maps.Keys(seen))
slices.Sort(components)
return components
}
func splitCSV(v string) []string {
if strings.TrimSpace(v) == "" {
return nil
}
parts := strings.Split(v, ",")
out := make([]string, 0, len(parts))
for _, p := range parts {
if p = strings.TrimSpace(p); p != "" {
out = append(out, p)
}
}
return out
}
func logServices(sources map[string]LogSource, entries []logging.Entry) []string {
services := make([]string, 0, len(sources))
for name := range sources {
services = append(services, name)
}
for _, entry := range entries {
if name, ok := entry.Fields["service"].(string); ok && !slices.Contains(services, name) {
services = append(services, name)
}
}
slices.Sort(services)
return services
}