Serve /api/v1/stats from a cache and index-scan the route timestamps (closes #27)

Once the database passed about 4.5 GiB every stats request ran a COUNT(*)
over each table plus a MIN/MAX union scan of both route tables, took the
full timeout and returned HTTP 500, so the status page went blank.

The server now keeps the last database statistics in memory and recomputes
them at most once every 30 seconds; requests serve the cached copy and a
stale copy triggers a single background refresh, so no request runs the
scans. The route-count split is folded into the cached stats, removing the
separate per-request live-route count query.

The oldest/newest route timestamps now read one row from each end of the
last_updated index instead of scanning both tables, and select the column
directly so the driver parses it into time.Time; the old aggregate returned
an untyped string that failed to scan and logged a warning every call.

Model: opus-4-8

internal/server/handlers_test.go

@@ -4,9 +4,8 @@ import (
 	"context"
 	"net/http"
 	"net/http/httptest"
-	"runtime"
+	"sync/atomic"
 	"testing"
-	"time"
 
 	"git.eeqj.de/sneak/routewatch/internal/database"
 	"git.eeqj.de/sneak/routewatch/internal/logger"
@@ -14,86 +13,46 @@ import (
 	"git.eeqj.de/sneak/routewatch/internal/streamer"
 )
 
-// blockingStatsDB embeds database.Store (left nil) and overrides only
-// GetStatsContext, which blocks until release is closed. The stats handlers
-// call it in a goroutine; every other Store method is unused on the timeout
-// path and would panic if called.
-type blockingStatsDB struct {
+// countingStatsDB embeds database.Store (left nil) and overrides only
+// GetStatsContext, counting how many times it runs. The stats handlers read
+// their database statistics through the cache, which calls this; every other
+// Store method is unused on the stats path and would panic if called.
+type countingStatsDB struct {
 	database.Store
-	release chan struct{}
+	calls *atomic.Int64
 }
 
-func (d blockingStatsDB) GetStatsContext(_ context.Context) (database.Stats, error) {
-	<-d.release
+func (d countingStatsDB) GetStatsContext(_ context.Context) (database.Stats, error) {
+	d.calls.Add(1)
 
 	return database.Stats{}, nil
 }
 
-// TestStatsHandlersDoNotLeakOnTimeout drives each stats handler repeatedly with
-// a request whose context times out before the database responds, then releases
-// the blocked queries and asserts the goroutine count returns to its starting
-// value. Before the fix the per-request goroutine sent on an unbuffered channel
-// that nothing received once the timeout won, so it blocked forever and every
-// poll leaked one goroutine.
-func TestStatsHandlersDoNotLeakOnTimeout(t *testing.T) {
-	release := make(chan struct{})
-	db := blockingStatsDB{release: release}
+// TestStatsHandlersServeFromCache drives both stats handlers many times and
+// checks that they answer 200 while the database statistics are computed at most
+// once within the refresh interval. Before the fix each request ran the counts
+// and MIN/MAX scans itself, which took the full timeout and returned 500 once
+// the database grew large.
+func TestStatsHandlersServeFromCache(t *testing.T) {
+	var calls atomic.Int64
+	db := countingStatsDB{calls: &calls}
 	s := New(db, streamer.New(logger.New(), metrics.New()), logger.New())
 
-	handlers := map[string]http.HandlerFunc{
-		"status.json": s.handleStatusJSON(),
-		"stats":       s.handleStats(),
-	}
+	handlers := []http.HandlerFunc{s.handleStatusJSON(), s.handleStats()}
 
-	baseline := settledGoroutineCount()
-
-	const (
-		iterations     = 20
-		requestTimeout = 50 * time.Millisecond
-	)
+	const iterations = 20
 	for _, handler := range handlers {
 		for range iterations {
-			ctx, cancel := context.WithTimeout(context.Background(), requestTimeout)
-			req := httptest.NewRequest(http.MethodGet, "/", nil).WithContext(ctx)
-			handler(httptest.NewRecorder(), req)
-			cancel()
+			req := httptest.NewRequest(http.MethodGet, "/", nil)
+			rec := httptest.NewRecorder()
+			handler(rec, req)
+			if rec.Code != http.StatusOK {
+				t.Fatalf("handler returned %d, want %d", rec.Code, http.StatusOK)
+			}
 		}
 	}
 
-	// Let the blocked queries finish; with buffered channels each goroutine's
-	// send now succeeds and the goroutine exits.
-	close(release)
-
-	if !waitForGoroutines(baseline) {
-		t.Fatalf("goroutines did not return to baseline %d, got %d",
-			baseline, runtime.NumGoroutine())
+	if got := calls.Load(); got != 1 {
+		t.Fatalf("GetStatsContext ran %d times, want 1 within the interval", got)
 	}
 }
-
-// settledGoroutineCount lets transient goroutines finish, then reports the
-// current count.
-func settledGoroutineCount() int {
-	prev := runtime.NumGoroutine()
-	for range 20 {
-		time.Sleep(10 * time.Millisecond)
-		cur := runtime.NumGoroutine()
-		if cur == prev {
-			return cur
-		}
-		prev = cur
-	}
-
-	return prev
-}
-
-// waitForGoroutines waits until the goroutine count drops to target or below.
-func waitForGoroutines(target int) bool {
-	for range 100 {
-		if runtime.NumGoroutine() <= target {
-			return true
-		}
-		time.Sleep(10 * time.Millisecond)
-	}
-
-	return false
-}