119 lines
3.3 KiB
Go
119 lines
3.3 KiB
Go
package webui
|
|
|
|
import (
|
|
"net/http"
|
|
"slices"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/samcharles93/archie-core/internal/logging"
|
|
)
|
|
|
|
// handleLogs serves a page of log history.
|
|
//
|
|
// This handler is transport only: parsing the log format belongs to the
|
|
// logging package, which owns it. Live output reaches the dashboard over the
|
|
// existing /api/stream stream; this endpoint exists so the view has history from
|
|
// before the browser connected, which is the whole reason file logging landed
|
|
// first.
|
|
func (s *Server) handleLogs(w http.ResponseWriter, r *http.Request) {
|
|
path := s.logFile()
|
|
if path == "" {
|
|
// Not an error: file logging is optional. Say so plainly so the UI can
|
|
// explain how to turn it on rather than showing an empty table.
|
|
writeJSON(w, map[string]any{
|
|
"entries": s.LogFeed.Snapshot(),
|
|
"file": "",
|
|
"disabled": true,
|
|
"components": mergeComponents(nil, s.LogFeed.Snapshot()),
|
|
})
|
|
return
|
|
}
|
|
|
|
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
|
|
}
|
|
switch {
|
|
case parsed <= 0:
|
|
limit = logging.DefaultTailLines
|
|
case parsed > logging.MaxTailLines:
|
|
limit = logging.MaxTailLines
|
|
default:
|
|
limit = parsed
|
|
}
|
|
}
|
|
result, err := logging.Tail(path, logging.Query{
|
|
Levels: splitCSV(q.Get("level")),
|
|
Component: strings.TrimSpace(q.Get("component")),
|
|
Contains: strings.TrimSpace(q.Get("q")),
|
|
Limit: limit,
|
|
})
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
components, err := logging.Components(path)
|
|
if err != nil {
|
|
// The filter list is a convenience; failing to build it must not cost
|
|
// the caller their log entries.
|
|
s.Log.Warn("log components unavailable", "err", err)
|
|
components = []string{}
|
|
}
|
|
liveEntries := s.LogFeed.Snapshot()
|
|
components = mergeComponents(components, liveEntries)
|
|
|
|
writeJSON(w, map[string]any{
|
|
"entries": append(result.Entries, liveEntries...),
|
|
"truncated": result.Truncated,
|
|
"file": result.File,
|
|
"components": components,
|
|
})
|
|
}
|
|
|
|
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{}{}
|
|
}
|
|
}
|
|
components := make([]string, 0, len(seen))
|
|
for component := range seen {
|
|
components = append(components, component)
|
|
}
|
|
slices.Sort(components)
|
|
return components
|
|
}
|
|
|
|
// logFile reports the log path this process can read, or "" when it has
|
|
// none. It is deliberately this process's own setting rather than the
|
|
// daemon's [log].file: the history lives on the daemon's disk, so a
|
|
// dashboard running elsewhere cannot read it by learning its path. Serving
|
|
// remote log history needs a contract, which /api/logs does not yet have.
|
|
func (s *Server) logFile() string {
|
|
return strings.TrimSpace(s.LogFile)
|
|
}
|
|
|
|
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
|
|
}
|