Add Five Minute Buffer for Stats

Author: jlandersen

internal/api/handlers.go

@@ -160,8 +160,8 @@ func (h *Handler) handleStats(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	w.Header().Set("Access-Control-Allow-Origin", "*")
 
-	sysStats := h.stats.Get()
-	if err := json.NewEncoder(w).Encode(sysStats); err != nil {
+	history := h.stats.History()
+	if err := json.NewEncoder(w).Encode(history); err != nil {
 		log.Printf("Error encoding stats response: %v", err)
 	}
 }
@@ -233,7 +233,10 @@ func (h *Handler) sendAppsToClient(w http.ResponseWriter, flusher http.Flusher)
 }
 
 func (h *Handler) sendStatsToClient(w http.ResponseWriter, flusher http.Flusher) {
-	sysStats := h.stats.Get()
+	sysStats, ok := h.stats.Latest()
+	if !ok {
+		sysStats = h.stats.Get()
+	}
 	data, err := json.Marshal(sysStats)
 	if err != nil {
 		log.Printf("Error marshaling stats: %v", err)

internal/stats/stats.go

@@ -2,6 +2,7 @@ package stats
 
 import (
 	"runtime"
+	"sync"
 	"time"
 
 	"github.com/shirou/gopsutil/v3/cpu"
@@ -18,11 +19,22 @@ type SystemStats struct {
 	NetRX *float64 `json:"netRx"`
 }
 
+type Sample struct {
+	Timestamp time.Time
+	Stats     SystemStats
+}
+
 type Collector struct {
 	lastNetStats net.IOCountersStat
 	lastNetTime  time.Time
+	history      []Sample
+	mu           sync.Mutex
+	stopCh       chan struct{}
+	running      bool
 }
 
+const historyWindow = 5 * time.Minute
+
 func NewCollector() *Collector {
 	c := &Collector{
 		lastNetTime: time.Now(),
@@ -36,6 +48,7 @@ func NewCollector() *Collector {
 }
 
 func (c *Collector) Get() SystemStats {
+	now := time.Now()
 	stats := SystemStats{
 		CPU:   nil,
 		RAM:   nil,
@@ -62,9 +75,76 @@ func (c *Collector) Get() SystemStats {
 	stats.NetTX = netTx
 	stats.NetRX = netRx
 
+	c.recordSample(now, stats)
+
 	return stats
 }
 
+func (c *Collector) Start(interval time.Duration) {
+	if interval <= 0 {
+		interval = 2 * time.Second
+	}
+
+	c.mu.Lock()
+	if c.running {
+		c.mu.Unlock()
+		return
+	}
+	if c.stopCh == nil {
+		c.stopCh = make(chan struct{})
+	}
+	c.running = true
+	stopCh := c.stopCh
+	c.mu.Unlock()
+
+	go func() {
+		ticker := time.NewTicker(interval)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-ticker.C:
+				c.Get()
+			case <-stopCh:
+				return
+			}
+		}
+	}()
+}
+
+func (c *Collector) Stop() {
+	c.mu.Lock()
+	if !c.running {
+		c.mu.Unlock()
+		return
+	}
+	close(c.stopCh)
+	c.stopCh = nil
+	c.running = false
+	c.mu.Unlock()
+}
+
+func (c *Collector) History() []Sample {
+	now := time.Now()
+	cutoff := now.Add(-historyWindow)
+
+	c.mu.Lock()
+	c.pruneLocked(cutoff)
+	historyCopy := make([]Sample, len(c.history))
+	copy(historyCopy, c.history)
+	c.mu.Unlock()
+
+	return historyCopy
+}
+
+func (c *Collector) Latest() (SystemStats, bool) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if len(c.history) == 0 {
+		return SystemStats{}, false
+	}
+	return c.history[len(c.history)-1].Stats, true
+}
+
 func (c *Collector) getTemperature() *float64 {
 	// Temperature sensors are platform-specific
 	if runtime.GOOS == "darwin" {
@@ -105,10 +185,12 @@ func (c *Collector) getNetworkRates() (*float64, *float64) {
 	}
 
 	now := time.Now()
+	c.mu.Lock()
 	elapsed := now.Sub(c.lastNetTime).Seconds()
 
 	// Avoid division by zero
 	if elapsed < 0.1 {
+		c.mu.Unlock()
 		return nil, nil
 	}
 
@@ -121,6 +203,7 @@ func (c *Collector) getNetworkRates() (*float64, *float64) {
 	// Update last stats
 	c.lastNetStats = currentStats
 	c.lastNetTime = now
+	c.mu.Unlock()
 
 	// Convert to KB/s
 	txKbps := txRate / 1024
@@ -137,4 +220,23 @@ func (c *Collector) getNetworkRates() (*float64, *float64) {
 	return &txKbps, &rxKbps
 }
 
+func (c *Collector) recordSample(timestamp time.Time, stats SystemStats) {
+	cutoff := timestamp.Add(-historyWindow)
+
+	c.mu.Lock()
+	c.history = append(c.history, Sample{Timestamp: timestamp, Stats: stats})
+	c.pruneLocked(cutoff)
+	c.mu.Unlock()
+}
+
+func (c *Collector) pruneLocked(cutoff time.Time) {
+	idx := 0
+	for idx < len(c.history) && c.history[idx].Timestamp.Before(cutoff) {
+		idx++
+	}
+	if idx > 0 {
+		c.history = c.history[idx:]
+	}
+}
+
 // formatNetworkRate is no longer needed - removed

main.go

@@ -9,6 +9,7 @@ import (
 	"os"
 	"os/signal"
 	"syscall"
+	"time"
 
 	"homedash/internal/api"
 	"homedash/internal/config"
@@ -36,6 +37,7 @@ func main() {
 	checker := health.NewChecker(manifestMgr, cfg.CheckInterval, cfg.CheckTimeout)
 
 	statsCollector := stats.NewCollector()
+	statsCollector.Start(2 * time.Second)
 
 	uiConfig := api.UIConfig{
 		TimeFormat24h: cfg.TimeFormat24h,
@@ -82,6 +84,9 @@ func main() {
 		if checker != nil {
 			checker.Stop()
 		}
+		if statsCollector != nil {
+			statsCollector.Stop()
+		}
 		if manifestMgr != nil {
 			manifestMgr.Close()
 		}

web/app.js

@@ -76,6 +76,7 @@ document.addEventListener('DOMContentLoaded', () => {
     initSparklineCleanup();
 
     fetchApps();
+    fetchStatsHistory();
     connectSSE();
 });
 
@@ -536,6 +537,19 @@ async function fetchApps() {
     }
 }
 
+async function fetchStatsHistory() {
+    try {
+        const res = await fetch('/api/stats');
+        if (!res.ok) {
+            throw new Error('Failed to fetch stats history');
+        }
+        const historyPayload = await res.json();
+        hydrateHistory(historyPayload);
+    } catch (err) {
+        console.error('Failed to fetch stats history:', err);
+    }
+}
+
 function connectSSE() {
     const es = new EventSource('/api/events');
 
@@ -689,6 +703,43 @@ function renderStats(s) {
     updateHostTrendValues(s);
 }
 
+function hydrateHistory(samples) {
+    if (!Array.isArray(samples) || samples.length === 0) {
+        return;
+    }
+
+    history.host.cpu = [];
+    history.host.ram = [];
+    history.host.temp = [];
+    history.host.netTx = [];
+    history.host.netRx = [];
+
+    samples.forEach((sample) => {
+        const timestamp = Date.parse(sample.Timestamp);
+        if (!Number.isFinite(timestamp)) return;
+        const s = sample.Stats || {};
+        pushHistory(history.host.cpu, timestamp, s.cpu);
+        pushHistory(history.host.ram, timestamp, s.ram);
+        pushHistory(history.host.temp, timestamp, s.temp);
+        pushHistory(history.host.netTx, timestamp, s.netTx);
+        pushHistory(history.host.netRx, timestamp, s.netRx);
+    });
+
+    const latest = samples[samples.length - 1];
+    if (latest && latest.Stats) {
+        stats = latest.Stats;
+    }
+
+    const now = Date.now();
+    pruneHistory(history.host.cpu, now);
+    pruneHistory(history.host.ram, now);
+    pruneHistory(history.host.temp, now);
+    pruneHistory(history.host.netTx, now);
+    pruneHistory(history.host.netRx, now);
+    renderHostSparklines();
+    updateHostTrendValues(stats);
+}
+
 function applyStatsVisibility() {
     document.getElementById('stat-cpu').style.display = config.showCPU ? '' : 'none';
     document.getElementById('stat-ram').style.display = config.showRAM ? '' : 'none';