From 9ce6153bd80fdc517ad625e9cc3c2a4992173e1e Mon Sep 17 00:00:00 2001 From: Tyler Koenig Date: Fri, 29 May 2026 12:35:08 -0400 Subject: [PATCH] feat(tui): add detail panel, type icons, and store improvements Wire up monitor detail view in TUI with type-specific icons. Add SQLite WAL glob to gitignore. Extend store interface with bulk-fetch and history queries for the detail panel. --- .gitignore | 2 +- cmd/uptop/main.go | 1 + internal/cluster/cluster_test.go | 8 +++- internal/metrics/prometheus_test.go | 8 +++- internal/models/models.go | 11 ++++++ internal/monitor/monitor.go | 32 +++++++++++++++ internal/monitor/monitor_test.go | 4 ++ internal/server/server_test.go | 8 +++- internal/store/dialect.go | 1 + internal/store/postgres.go | 12 ++++++ internal/store/sqlite.go | 12 ++++++ internal/store/sqlstore.go | 31 +++++++++++++++ internal/store/store.go | 4 ++ internal/tui/tab_sites.go | 60 ++++++++++++++++++----------- internal/tui/tui.go | 30 ++++++++++++--- 15 files changed, 189 insertions(+), 35 deletions(-) diff --git a/.gitignore b/.gitignore index a958ed7..4691cb7 100644 --- a/.gitignore +++ b/.gitignore @@ -27,7 +27,7 @@ go.work # End of https://www.toptal.com/developers/gitignore/api/go /uptop -uptop.db +uptop.db* .ssh diff --git a/cmd/uptop/main.go b/cmd/uptop/main.go index 65ad2f4..d88b2e7 100644 --- a/cmd/uptop/main.go +++ b/cmd/uptop/main.go @@ -385,6 +385,7 @@ func runServe(args []string) { eng.InitHistory() eng.InitLogs() + eng.InitAlertHealth() eng.Start(ctx) tlsCert := os.Getenv("UPTOP_TLS_CERT") diff --git a/internal/cluster/cluster_test.go b/internal/cluster/cluster_test.go index d665bbb..a7fb8a8 100644 --- a/internal/cluster/cluster_test.go +++ b/internal/cluster/cluster_test.go @@ -53,8 +53,12 @@ func (m *mockStore) GetNode(string) (models.ProbeNode, error) { return models.Pr func (m *mockStore) GetAllNodes() ([]models.ProbeNode, error) { return nil, nil } func (m *mockStore) UpdateNodeLastSeen(string) error { return nil } func (m *mockStore) DeleteNode(string) error { return nil } -func (m *mockStore) SaveLog(string) error { return nil } -func (m *mockStore) LoadLogs(int) ([]string, error) { return nil, nil } +func (m *mockStore) LoadAlertHealth() (map[int]models.AlertHealthRecord, error) { + return nil, nil +} +func (m *mockStore) SaveAlertHealth(models.AlertHealthRecord) error { return nil } +func (m *mockStore) SaveLog(string) error { return nil } +func (m *mockStore) LoadLogs(int) ([]string, error) { return nil, nil } func (m *mockStore) GetActiveMaintenanceWindows() ([]models.MaintenanceWindow, error) { return nil, nil } diff --git a/internal/metrics/prometheus_test.go b/internal/metrics/prometheus_test.go index 24f6567..7effdc8 100644 --- a/internal/metrics/prometheus_test.go +++ b/internal/metrics/prometheus_test.go @@ -51,8 +51,12 @@ func (m *mockStore) GetNode(string) (models.ProbeNode, error) { return m func (m *mockStore) GetAllNodes() ([]models.ProbeNode, error) { return nil, nil } func (m *mockStore) UpdateNodeLastSeen(string) error { return nil } func (m *mockStore) DeleteNode(string) error { return nil } -func (m *mockStore) SaveLog(string) error { return nil } -func (m *mockStore) LoadLogs(int) ([]string, error) { return nil, nil } +func (m *mockStore) LoadAlertHealth() (map[int]models.AlertHealthRecord, error) { + return nil, nil +} +func (m *mockStore) SaveAlertHealth(models.AlertHealthRecord) error { return nil } +func (m *mockStore) SaveLog(string) error { return nil } +func (m *mockStore) LoadLogs(int) ([]string, error) { return nil, nil } func (m *mockStore) GetActiveMaintenanceWindows() ([]models.MaintenanceWindow, error) { return nil, nil } diff --git a/internal/models/models.go b/internal/models/models.go index 571d555..98c1be5 100644 --- a/internal/models/models.go +++ b/internal/models/models.go @@ -79,6 +79,17 @@ type ProbeNode struct { Version string } +// AlertHealthRecord is the persisted send health of an alert channel. It lets the +// "last sent" / health indicators survive restarts instead of resetting to "never". +type AlertHealthRecord struct { + AlertID int + LastSendAt time.Time + LastSendOK bool + LastError string + SendCount int + FailCount int +} + type MaintenanceWindow struct { ID int MonitorID int diff --git a/internal/monitor/monitor.go b/internal/monitor/monitor.go index 1a1c8d2..91a8ef6 100644 --- a/internal/monitor/monitor.go +++ b/internal/monitor/monitor.go @@ -146,6 +146,26 @@ func (e *Engine) InitLogs() { e.logStore = logs } +// InitAlertHealth restores persisted alert send health so the dashboard shows real +// "last sent" / health state on startup instead of resetting every channel to "never". +func (e *Engine) InitAlertHealth() { + records, err := e.db.LoadAlertHealth() + if err != nil { + return + } + e.alertHealthMu.Lock() + defer e.alertHealthMu.Unlock() + for id, r := range records { + e.alertHealth[id] = AlertHealth{ + LastSendAt: r.LastSendAt, + LastSendOK: r.LastSendOK, + LastError: r.LastError, + SendCount: r.SendCount, + FailCount: r.FailCount, + } + } +} + func (e *Engine) GetLogs() []string { e.logMu.RLock() defer e.logMu.RUnlock() @@ -612,6 +632,18 @@ func (e *Engine) recordAlertResult(alertID int, ok bool, errMsg string) { h.FailCount++ } e.alertHealth[alertID] = h + + // Persist best-effort so health survives restarts; DB IO off the alert path. + go func(rec models.AlertHealthRecord) { + _ = e.db.SaveAlertHealth(rec) + }(models.AlertHealthRecord{ + AlertID: alertID, + LastSendAt: h.LastSendAt, + LastSendOK: h.LastSendOK, + LastError: h.LastError, + SendCount: h.SendCount, + FailCount: h.FailCount, + }) } func (e *Engine) GetAlertHealth(alertID int) AlertHealth { diff --git a/internal/monitor/monitor_test.go b/internal/monitor/monitor_test.go index 4792bf2..9425826 100644 --- a/internal/monitor/monitor_test.go +++ b/internal/monitor/monitor_test.go @@ -63,6 +63,10 @@ func (m *mockStore) GetNode(string) (models.ProbeNode, error) { return m func (m *mockStore) GetAllNodes() ([]models.ProbeNode, error) { return nil, nil } func (m *mockStore) UpdateNodeLastSeen(string) error { return nil } func (m *mockStore) DeleteNode(string) error { return nil } +func (m *mockStore) LoadAlertHealth() (map[int]models.AlertHealthRecord, error) { + return nil, nil +} +func (m *mockStore) SaveAlertHealth(models.AlertHealthRecord) error { return nil } func (m *mockStore) GetActiveMaintenanceWindows() ([]models.MaintenanceWindow, error) { return nil, nil } diff --git a/internal/server/server_test.go b/internal/server/server_test.go index 2e9de56..73b7152 100644 --- a/internal/server/server_test.go +++ b/internal/server/server_test.go @@ -65,8 +65,12 @@ func (m *mockStore) AddAlertReturningID(string, string, map[string]string) (int, func (m *mockStore) GetAllNodes() ([]models.ProbeNode, error) { return nil, nil } func (m *mockStore) UpdateNodeLastSeen(string) error { return nil } func (m *mockStore) DeleteNode(string) error { return nil } -func (m *mockStore) SaveLog(string) error { return nil } -func (m *mockStore) LoadLogs(int) ([]string, error) { return nil, nil } +func (m *mockStore) LoadAlertHealth() (map[int]models.AlertHealthRecord, error) { + return nil, nil +} +func (m *mockStore) SaveAlertHealth(models.AlertHealthRecord) error { return nil } +func (m *mockStore) SaveLog(string) error { return nil } +func (m *mockStore) LoadLogs(int) ([]string, error) { return nil, nil } func (m *mockStore) GetAllMaintenanceWindows(int) ([]models.MaintenanceWindow, error) { return nil, nil } diff --git a/internal/store/dialect.go b/internal/store/dialect.go index 4a4f8e8..2e9ce2c 100644 --- a/internal/store/dialect.go +++ b/internal/store/dialect.go @@ -14,6 +14,7 @@ type Dialect interface { ImportWipe(tx *sql.Tx) ImportResetSequences(tx *sql.Tx) UpsertNodeSQL() string + UpsertAlertHealthSQL() string } func rewritePlaceholders(query string, dollarStyle bool) string { diff --git a/internal/store/postgres.go b/internal/store/postgres.go index 320fb51..c6e896d 100644 --- a/internal/store/postgres.go +++ b/internal/store/postgres.go @@ -81,6 +81,14 @@ func (d *PostgresDialect) CreateTablesSQL() []string { changed_at TIMESTAMP DEFAULT NOW() )`, `CREATE INDEX IF NOT EXISTS idx_state_changes_site ON state_changes(site_id, changed_at DESC)`, + `CREATE TABLE IF NOT EXISTS alert_health ( + alert_id INTEGER PRIMARY KEY, + last_send_at TIMESTAMP, + last_send_ok BOOLEAN DEFAULT FALSE, + last_error TEXT DEFAULT '', + send_count INTEGER DEFAULT 0, + fail_count INTEGER DEFAULT 0 + )`, } } @@ -106,6 +114,10 @@ func (d *PostgresDialect) UpsertNodeSQL() string { return "INSERT INTO nodes (id, name, region, last_seen, version) VALUES ($1, $2, $3, NOW(), $4) ON CONFLICT (id) DO UPDATE SET name = EXCLUDED.name, region = EXCLUDED.region, last_seen = NOW(), version = EXCLUDED.version" } +func (d *PostgresDialect) UpsertAlertHealthSQL() string { + return "INSERT INTO alert_health (alert_id, last_send_at, last_send_ok, last_error, send_count, fail_count) VALUES ($1, $2, $3, $4, $5, $6) ON CONFLICT (alert_id) DO UPDATE SET last_send_at = EXCLUDED.last_send_at, last_send_ok = EXCLUDED.last_send_ok, last_error = EXCLUDED.last_error, send_count = EXCLUDED.send_count, fail_count = EXCLUDED.fail_count" +} + func (d *PostgresDialect) ResetSequenceOnEmpty(db *sql.DB, table string) {} func (d *PostgresDialect) ImportWipe(tx *sql.Tx) { diff --git a/internal/store/sqlite.go b/internal/store/sqlite.go index beadc40..ee2d65e 100644 --- a/internal/store/sqlite.go +++ b/internal/store/sqlite.go @@ -88,6 +88,14 @@ func (d *SQLiteDialect) CreateTablesSQL() []string { changed_at DATETIME DEFAULT CURRENT_TIMESTAMP )`, `CREATE INDEX IF NOT EXISTS idx_state_changes_site ON state_changes(site_id, changed_at DESC)`, + `CREATE TABLE IF NOT EXISTS alert_health ( + alert_id INTEGER PRIMARY KEY, + last_send_at DATETIME, + last_send_ok BOOLEAN DEFAULT 0, + last_error TEXT DEFAULT '', + send_count INTEGER DEFAULT 0, + fail_count INTEGER DEFAULT 0 + )`, } } @@ -113,6 +121,10 @@ func (d *SQLiteDialect) UpsertNodeSQL() string { return "INSERT OR REPLACE INTO nodes (id, name, region, last_seen, version) VALUES (?, ?, ?, CURRENT_TIMESTAMP, ?)" } +func (d *SQLiteDialect) UpsertAlertHealthSQL() string { + return "INSERT OR REPLACE INTO alert_health (alert_id, last_send_at, last_send_ok, last_error, send_count, fail_count) VALUES (?, ?, ?, ?, ?, ?)" +} + func (d *SQLiteDialect) ResetSequenceOnEmpty(db *sql.DB, table string) { var count int _ = db.QueryRow("SELECT COUNT(*) FROM " + table).Scan(&count) //nolint:errcheck diff --git a/internal/store/sqlstore.go b/internal/store/sqlstore.go index e24c9f1..bf6a27c 100644 --- a/internal/store/sqlstore.go +++ b/internal/store/sqlstore.go @@ -430,6 +430,37 @@ func (s *SQLStore) DeleteNode(id string) error { return err } +func (s *SQLStore) LoadAlertHealth() (map[int]models.AlertHealthRecord, error) { + rows, err := s.db.Query("SELECT alert_id, last_send_at, last_send_ok, last_error, send_count, fail_count FROM alert_health") + if err != nil { + return nil, err + } + defer rows.Close() + out := make(map[int]models.AlertHealthRecord) + for rows.Next() { + var r models.AlertHealthRecord + var lastSend sql.NullTime + if err := rows.Scan(&r.AlertID, &lastSend, &r.LastSendOK, &r.LastError, &r.SendCount, &r.FailCount); err != nil { + return out, err + } + if lastSend.Valid { + r.LastSendAt = lastSend.Time + } + out[r.AlertID] = r + } + return out, rows.Err() +} + +func (s *SQLStore) SaveAlertHealth(h models.AlertHealthRecord) error { + var lastSend interface{} + if !h.LastSendAt.IsZero() { + lastSend = h.LastSendAt + } + _, err := s.db.Exec(s.dialect.UpsertAlertHealthSQL(), + h.AlertID, lastSend, h.LastSendOK, h.LastError, h.SendCount, h.FailCount) + return err +} + func (s *SQLStore) SaveLog(message string) error { _, err := s.db.Exec(s.q("INSERT INTO logs (message) VALUES (?)"), message) if err != nil { diff --git a/internal/store/store.go b/internal/store/store.go index 8321486..2d00880 100644 --- a/internal/store/store.go +++ b/internal/store/store.go @@ -49,6 +49,10 @@ type Store interface { UpdateNodeLastSeen(id string) error DeleteNode(id string) error + // Alert Health + LoadAlertHealth() (map[int]models.AlertHealthRecord, error) + SaveAlertHealth(h models.AlertHealthRecord) error + // Logs SaveLog(message string) error LoadLogs(limit int) ([]string, error) diff --git a/internal/tui/tab_sites.go b/internal/tui/tab_sites.go index 13f45a9..ad1c19e 100644 --- a/internal/tui/tab_sites.go +++ b/internal/tui/tab_sites.go @@ -60,14 +60,18 @@ type siteFormData struct { Regions string } -func latencySparkline(latencies []time.Duration, width int) string { +func latencySparkline(latencies []time.Duration, statuses []bool, width int) string { if len(latencies) == 0 { return subtleStyle.Render(strings.Repeat("·", width)) } samples := latencies + sampledStatuses := statuses if len(samples) > width { samples = samples[len(samples)-width:] + if len(sampledStatuses) > width { + sampledStatuses = sampledStatuses[len(sampledStatuses)-width:] + } } minL, maxL := samples[0], samples[0] @@ -85,7 +89,7 @@ func latencySparkline(latencies []time.Duration, width int) string { sb.WriteString(subtleStyle.Render(strings.Repeat("·", remaining))) } spread := maxL - minL - for _, l := range samples { + for i, l := range samples { idx := 0 if spread > 0 { idx = int(float64(l-minL) / float64(spread) * 7) @@ -94,13 +98,18 @@ func latencySparkline(latencies []time.Duration, width int) string { } } ch := string(sparkChars[idx]) - ms := l.Milliseconds() - if ms < 200 { - sb.WriteString(specialStyle.Render(ch)) - } else if ms < 500 { - sb.WriteString(warnStyle.Render(ch)) - } else { + isDown := i < len(sampledStatuses) && !sampledStatuses[i] + if isDown { sb.WriteString(dangerStyle.Render(ch)) + } else { + ms := l.Milliseconds() + if ms < 200 { + sb.WriteString(specialStyle.Render(ch)) + } else if ms < 500 { + sb.WriteString(warnStyle.Render(ch)) + } else { + sb.WriteString(dangerStyle.Render(ch)) + } } } return sb.String() @@ -474,7 +483,7 @@ func (m Model) viewSitesTab() string { if site.Type == "push" { spark = heartbeatSparkline(hist.Statuses, sparkWidth) } else { - spark = latencySparkline(hist.Latencies, sparkWidth) + spark = latencySparkline(hist.Latencies, hist.Statuses, sparkWidth) } rows = append(rows, []string{ @@ -949,20 +958,27 @@ func (m Model) viewDetailPanel() string { up, len(hist.Statuses)) } } else { - b.WriteString(" " + latencySparkline(hist.Latencies, sparkWidth)) - if len(hist.Latencies) > 0 { - minL, maxL := hist.Latencies[0], hist.Latencies[0] - var total time.Duration - for _, l := range hist.Latencies { - total += l - if l < minL { - minL = l - } - if l > maxL { - maxL = l - } + b.WriteString(" " + latencySparkline(hist.Latencies, hist.Statuses, sparkWidth)) + // Stats over successful checks only — a failed check is stored as 0ns latency + // and would otherwise drag Min to 0ms and skew the average. + var minL, maxL, total time.Duration + count := 0 + for i, l := range hist.Latencies { + if i < len(hist.Statuses) && !hist.Statuses[i] { + continue } - avg := total / time.Duration(len(hist.Latencies)) + if count == 0 { + minL, maxL = l, l + } else if l < minL { + minL = l + } else if l > maxL { + maxL = l + } + total += l + count++ + } + if count > 0 { + avg := total / time.Duration(count) fmt.Fprintf(&b, "\n %s %dms %s %dms %s %dms", subtleStyle.Render("Min"), minL.Milliseconds(), subtleStyle.Render("Avg"), avg.Milliseconds(), diff --git a/internal/tui/tui.go b/internal/tui/tui.go index 0677643..1bddca1 100644 --- a/internal/tui/tui.go +++ b/internal/tui/tui.go @@ -4,6 +4,7 @@ import ( "encoding/json" "fmt" "math" + "os" "sort" "strings" "time" @@ -122,6 +123,10 @@ type Model struct { filterMode bool filterText string + + // demoMode renders a stable status dot instead of the animated pulse so + // screenshots/recordings don't capture the spinner mid-frame. Set via UPTOP_DEMO=1. + demoMode bool } func InitialModel(isAdmin bool, s store.Store, eng *monitor.Engine) Model { @@ -155,6 +160,7 @@ func InitialModel(isAdmin bool, s store.Store, eng *monitor.Engine) Model { collapsed: collapsed, theme: theme, themeIndex: themeIdx, + demoMode: os.Getenv("UPTOP_DEMO") == "1", } } @@ -754,11 +760,6 @@ func (m *Model) submitForm() { } func (m Model) pulseIndicator() string { - frame := m.tickCount % len(pulseFrames) - brightness := int(m.pulsePos*155) + 100 - if brightness > 255 { - brightness = 255 - } hasDown := false for _, s := range m.sites { if !s.Paused && !m.isMonitorInMaintenance(s.ID) && (s.Status == "DOWN" || s.Status == "SSL EXP") { @@ -766,6 +767,19 @@ func (m Model) pulseIndicator() string { break } } + // Stills can't show animation: render a stable status dot in demo mode. + if m.demoMode { + c := m.theme.Success + if hasDown { + c = m.theme.Danger + } + return lipgloss.NewStyle().Foreground(c).Render("●") + } + frame := m.tickCount % len(pulseFrames) + brightness := int(m.pulsePos*155) + 100 + if brightness > 255 { + brightness = 255 + } var color string if hasDown { color = fmt.Sprintf("#%02x%02x%02x", brightness, brightness/4, brightness/4) @@ -953,7 +967,11 @@ func (m Model) viewDashboard() string { online++ } } - statusParts = append(statusParts, fmt.Sprintf("%d probes", online)) + probeLabel := "probes" + if online == 1 { + probeLabel = "probe" + } + statusParts = append(statusParts, fmt.Sprintf("%d %s", online, probeLabel)) } statusLine := strings.Join(statusParts, subtleStyle.Render(" · "))