The full switch: Monitors and Disks read only the sensor API; /api/metrics retired

- stock Monitors modules fed by one sensor stream, the catalog and one batch of
  histories (GET /api/sensors/history?ids=…), through sampleAdapter.ts
- the stream closes while the page is hidden and refills its curves on return
- Disks tab live rates from the stream
- new sensors: hamlab.sample_interval, ups.last_event
- stream: asking for about the sampling rate means every sample
- NUT runtime rounded at the source

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

internal/api/server.go

@@ -110,12 +110,11 @@ func New(cfg *config.Config, sessions *auth.Sessions, mgr *term.Manager, col *me
 	m.HandleFunc("PATCH /api/terminals/{id}", s.auth(s.renameTerminal))
 	m.HandleFunc("DELETE /api/terminals/{id}", s.auth(s.deleteTerminal))
 	m.HandleFunc("GET /api/terminals/{id}/attach", s.auth(s.attach))
-	m.HandleFunc("GET /api/metrics", s.auth(s.metricsLatest))
-	m.HandleFunc("GET /api/metrics/history", s.auth(s.metricsHistory))
 	m.HandleFunc("GET /api/sensors", s.sensorAuth(s.sensorCatalog))
 	m.HandleFunc("GET /api/sensors/query", s.sensorAuth(s.sensorQuery))
 	m.HandleFunc("POST /api/sensors/query", s.sensorAuth(s.sensorQuery))
 	m.HandleFunc("GET /api/sensors/stream", s.sensorAuth(s.sensorStream))
+	m.HandleFunc("GET /api/sensors/history", s.sensorAuth(s.sensorHistories))
 	m.HandleFunc("GET /api/sensors/prometheus", s.sensorAuth(s.sensorProm))
 	m.HandleFunc("GET /metrics", s.sensorAuth(s.sensorProm))
 	m.HandleFunc("GET /api/sensors/{id}", s.sensorAuth(s.sensorOne))
@@ -652,21 +651,6 @@ func (s *Server) me(w http.ResponseWriter, _ *http.Request) {
 	})
 }
 
-// ---- metrics (Dashboard) ----
-
-func (s *Server) metricsLatest(w http.ResponseWriter, _ *http.Request) {
-	smp, ok := s.metrics.Latest()
-	if !ok {
-		jsonErr(w, 503, "no sample yet")
-		return
-	}
-	jsonOK(w, 200, smp)
-}
-
-func (s *Server) metricsHistory(w http.ResponseWriter, _ *http.Request) {
-	jsonOK(w, 200, s.metrics.History())
-}
-
 // ---- sensors: the standard read interface (SENSORS.md) ----
 
 // sensorCatalog lists every sensor with its current value; ?ids= narrows it with
@@ -713,6 +697,16 @@ func (s *Server) sensorHistory(w http.ResponseWriter, r *http.Request) {
 	jsonOK(w, 200, h)
 }
 
+// sensorHistories is many histories in one request: ?ids= takes IDs and globs.
+func (s *Server) sensorHistories(w http.ResponseWriter, r *http.Request) {
+	match, err := sensors.Matcher(r.URL.Query().Get("ids"))
+	if err != nil {
+		jsonErr(w, 400, err.Error())
+		return
+	}
+	jsonOK(w, 200, map[string]any{"series": s.sensors.Histories(match)})
+}
+
 // sensorProm is every numeric sensor in the Prometheus text format.
 func (s *Server) sensorProm(w http.ResponseWriter, _ *http.Request) {
 	w.Header().Set("Content-Type", "text/plain; version=0.0.4; charset=utf-8")
@@ -770,6 +764,11 @@ func (s *Server) sensorStream(w http.ResponseWriter, r *http.Request) {
 	if ms, err := strconv.Atoi(r.URL.Query().Get("every")); err == nil && ms > 0 {
 		every = time.Duration(ms) * time.Millisecond
 	}
+	// Asking for roughly the sampling rate means "every sample": don't let timer jitter
+	// drop alternate ticks.
+	if iv := s.metrics.Interval(); every <= iv+iv/2 {
+		every = 0
+	}
 	h := w.Header()
 	h.Set("Content-Type", "text/event-stream")
 	h.Set("Cache-Control", "no-store")

internal/metrics/metrics.go

@@ -136,16 +136,6 @@ type Sample struct {
 	fsT, upsT int64 // when the slow sections were really read; sensors report these, not T
 }
 
-// Series is the compact history the UI seeds its sparklines from.
-type Series struct {
-	T    []int64                         `json:"t"`
-	CPU  []float64                       `json:"cpu"`
-	Mem  []uint64                        `json:"mem"`
-	Net  map[string]map[string][]float64 `json:"net"`  // iface -> {rx,tx}
-	Disk map[string]map[string][]float64 `json:"disk"` // name -> {r,w,u}
-	Temp map[string][]float64            `json:"temp"` // "chip/label" -> °C
-}
-
 type Collector struct {
 	mu       sync.RWMutex
 	ring     []Sample
@@ -236,44 +226,6 @@ func (c *Collector) Latest() (Sample, bool) {
 	return c.ring[len(c.ring)-1], true
 }
 
-func (c *Collector) History() Series {
-	c.mu.RLock()
-	defer c.mu.RUnlock()
-	n := len(c.ring)
-	s := Series{T: make([]int64, n), CPU: make([]float64, n), Mem: make([]uint64, n),
-		Net: map[string]map[string][]float64{}, Disk: map[string]map[string][]float64{}, Temp: map[string][]float64{}}
-	series := func(m map[string]map[string][]float64, key string, keys ...string) map[string][]float64 {
-		v, ok := m[key]
-		if !ok {
-			v = map[string][]float64{}
-			for _, k := range keys {
-				v[k] = make([]float64, n)
-			}
-			m[key] = v
-		}
-		return v
-	}
-	for i, smp := range c.ring {
-		s.T[i], s.CPU[i], s.Mem[i] = smp.T, smp.CPU, smp.Mem.Used
-		for _, x := range smp.Net {
-			v := series(s.Net, x.Iface, "rx", "tx")
-			v["rx"][i], v["tx"][i] = x.RxBps, x.TxBps
-		}
-		for _, d := range smp.Disks {
-			v := series(s.Disk, d.Name, "r", "w", "u")
-			v["r"][i], v["w"][i], v["u"][i] = d.ReadBps, d.WriteBps, d.UtilPct
-		}
-		for _, t := range smp.Temps {
-			k := t.Chip + "/" + t.Label
-			if s.Temp[k] == nil {
-				s.Temp[k] = make([]float64, n)
-			}
-			s.Temp[k][i] = t.C
-		}
-	}
-	return s
-}
-
 // ---- sampling ----
 
 func (c *Collector) sample() {
@@ -853,7 +805,7 @@ func upsNUT() *UPS {
 	u.InV = leadingNum(kv["input.voltage"])
 	u.OutV = leadingNum(kv["output.voltage"])
 	u.BatteryPct = leadingNum(kv["battery.charge"])
-	u.RuntimeMin = leadingNum(kv["battery.runtime"]) / 60
+	u.RuntimeMin = round1(leadingNum(kv["battery.runtime"]) / 60)
 	u.LoadPct = leadingNum(kv["ups.load"])
 	u.LoadW = leadingNum(kv["ups.realpower"])
 	if u.LoadW == 0 {

internal/metrics/sensors.go

@@ -11,10 +11,10 @@ import (
 // IDs are built from names the hardware reports (chip, label, interface, device, mount),
 // never from enumeration order like hwmon3, which moves between boots.
 
-// flattener turns one Sample into sensors. With only set it builds just that one, so
-// walking the whole ring for a history costs string compares, not allocations.
+// flattener turns one Sample into sensors. With want set it builds only those, so walking
+// the whole ring for a history costs string compares, not allocations.
 type flattener struct {
-	only string
+	want func(id string) bool
 	seen map[string]int
 	out  []sensors.Sensor
 }
@@ -30,7 +30,7 @@ func (f *flattener) add(id, name, kind, unit string, v any, t int64, b bounds, l
 	if n := f.seen[id]; n > 1 { // two identical chips: the second is coretemp_2
 		id = fmt.Sprintf("%s_%d", id, n)
 	}
-	if f.only != "" && id != f.only {
+	if f.want != nil && !f.want(id) {
 		return
 	}
 	s := sensors.Sensor{ID: id, Name: name, Kind: kind, Unit: unit, Value: v, T: t, Min: b.min, Max: b.max, Warn: b.warn, Crit: b.crit}
@@ -50,8 +50,8 @@ func ratio(part, whole uint64) float64 {
 	return round1(float64(part) / float64(whole) * 100)
 }
 
-func flatten(s Sample, only string) []sensors.Sensor {
-	f := &flattener{only: only, seen: map[string]int{}}
+func flatten(s Sample, want func(id string) bool) []sensors.Sensor {
+	f := &flattener{want: want, seen: map[string]int{}}
 	t, none := s.T, bounds{}
 
 	f.add("cpu.usage", "CPU", "usage", "%", s.CPU, t, pct)
@@ -66,6 +66,7 @@ func flatten(s Sample, only string) []sensors.Sensor {
 		f.add("load."+w, "Load "+w+" min", "load", "", s.Load[i], t, none)
 	}
 	f.add("uptime", "Uptime", "duration", "s", s.Uptime, t, none)
+	f.add("hamlab.sample_interval", "Sampling interval", "duration", "ms", float64(s.Interval), t, none)
 
 	for _, m := range []struct {
 		id, name string
@@ -132,6 +133,7 @@ func flatten(s Sample, only string) []sensors.Sensor {
 		f.add("ups.on_battery", "UPS on battery", "state", "", u.OnBattery, ut, none, "model", u.Model)
 		f.add("ups.state", "UPS state", "state", "", u.State, ut, none, "model", u.Model)
 		f.add("ups.source", "UPS power source", "state", "", u.Source, ut, none, "model", u.Model)
+		f.add("ups.last_event", "UPS last event", "state", "", u.LastEvent, ut, none, "model", u.Model, "driver", u.Driver)
 	}
 	return f.out
 }
@@ -142,28 +144,35 @@ func (c *Collector) Sensors() []sensors.Sensor {
 	if !ok {
 		return nil
 	}
-	return flatten(s, "")
+	return flatten(s, nil)
 }
 
-// SensorHistory implements sensors.Historian: the ring, seen through one sensor. Samples
-// where the sensor didn't exist (a disk plugged in since) are left out, not zero-filled.
-func (c *Collector) SensorHistory(id string) (sensors.Series, bool) {
+// SensorHistories implements sensors.Historian: the ring, seen through the sensors that
+// match. A sensor that didn't exist in a sample (a disk plugged in since) simply has a
+// shorter series; nothing is zero-filled. States have no curve and are left out.
+func (c *Collector) SensorHistories(match func(id string) bool) []sensors.Series {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
-	out := sensors.Series{ID: id, T: []int64{}, V: []float64{}}
-	found := false
+	by := map[string]*sensors.Series{}
+	var order []string
 	for _, smp := range c.ring {
-		got := flatten(smp, id)
-		if len(got) == 0 {
-			continue
+		for _, x := range flatten(smp, match) {
+			v, ok := x.Value.(float64)
+			if !ok {
+				continue
+			}
+			s := by[x.ID]
+			if s == nil {
+				s = &sensors.Series{ID: x.ID, Unit: x.Unit, T: []int64{}, V: []float64{}}
+				by[x.ID] = s
+				order = append(order, x.ID)
+			}
+			s.T, s.V = append(s.T, smp.T), append(s.V, v)
 		}
-		found = true
-		v, ok := got[0].Value.(float64)
-		if !ok {
-			return sensors.Series{}, false // states have no curve
-		}
-		out.Unit = got[0].Unit
-		out.T, out.V = append(out.T, smp.T), append(out.V, v)
 	}
-	return out, found
+	out := make([]sensors.Series, 0, len(order))
+	for _, id := range order {
+		out = append(out, *by[id])
+	}
+	return out
 }

internal/metrics/sensors_test.go

@@ -8,7 +8,7 @@ func TestFlatten(t *testing.T) {
 		Fans:  []Fan{{Chip: "nct6775", Label: "fan2", RPM: 1100}},
 		FS:    []FS{{Mount: "/", Size: 100, Used: 25}}, fsT: 900}
 	got := map[string]any{}
-	for _, x := range flatten(s, "") {
+	for _, x := range flatten(s, nil) {
 		if _, dup := got[x.ID]; dup {
 			t.Errorf("duplicate id %s", x.ID)
 		}
@@ -20,31 +20,37 @@ func TestFlatten(t *testing.T) {
 			t.Errorf("%s = %v, want %v", id, got[id], want)
 		}
 	}
-	one := flatten(s, "temp.nvme.composite_2")
+	one := flatten(s, func(id string) bool { return id == "temp.nvme.composite_2" })
 	if len(one) != 1 || one[0].Value != 45.0 {
 		t.Errorf("only: got %+v", one)
 	}
-	for _, x := range flatten(s, "fs.root.used") {
+	for _, x := range flatten(s, func(id string) bool { return id == "fs.root.used" }) {
 		if x.T != 900 {
 			t.Errorf("fs sensor should carry the fs read time, got %d", x.T)
 		}
 	}
 }
 
-func TestSensorHistory(t *testing.T) {
+func TestSensorHistories(t *testing.T) {
 	c := NewCollector()
 	c.ring = []Sample{{T: 1, CPU: 10}, {T: 2, CPU: 20, Net: []Net{{Iface: "eth0", Up: true, RxBps: 5}}}}
-	h, ok := c.SensorHistory("cpu.usage")
-	if !ok || len(h.V) != 2 || h.V[1] != 20 || h.Unit != "%" {
-		t.Fatalf("cpu: %+v %v", h, ok)
+	got := map[string][]float64{}
+	for _, h := range c.SensorHistories(func(id string) bool { return id == "cpu.usage" || id == "net.eth0.rx" || id == "net.eth0.up" }) {
+		if len(h.T) != len(h.V) {
+			t.Errorf("%s: t and v differ in length", h.ID)
+		}
+		got[h.ID] = h.V
 	}
-	if h, ok := c.SensorHistory("net.eth0.rx"); !ok || len(h.V) != 1 || h.T[0] != 2 {
-		t.Fatalf("net: a sensor that appeared later has a shorter history, got %+v %v", h, ok)
+	if len(got["cpu.usage"]) != 2 || got["cpu.usage"][1] != 20 {
+		t.Errorf("cpu: %v", got["cpu.usage"])
 	}
-	if _, ok := c.SensorHistory("net.eth0.up"); ok {
+	if len(got["net.eth0.rx"]) != 1 {
+		t.Errorf("a sensor that appeared later has a shorter history, got %v", got["net.eth0.rx"])
+	}
+	if _, ok := got["net.eth0.up"]; ok {
 		t.Error("a state has no history")
 	}
-	if _, ok := c.SensorHistory("nope"); ok {
-		t.Error("unknown id")
+	if len(c.SensorHistories(func(string) bool { return false })) != 0 {
+		t.Error("nothing matched, nothing returned")
 	}
 }

internal/sensors/sensors.go

@@ -46,9 +46,10 @@ type Provider interface {
 	Sensors() []Sensor
 }
 
-// Historian is a Provider that also remembers. ok is false for an ID it doesn't hold.
+// Historian is a Provider that also remembers: the recent past of every numeric sensor
+// of its own that match accepts.
 type Historian interface {
-	SensorHistory(id string) (s Series, ok bool)
+	SensorHistories(match func(id string) bool) []Series
 }
 
 // Ticker is a Provider that can say when its values have changed.
@@ -125,16 +126,47 @@ func (r *Registry) All() []Sensor {
 	return out
 }
 
-// History finds the provider that remembers id.
+// History is one sensor's recent past. ok is false when nothing remembers it.
 func (r *Registry) History(id string) (Series, bool) {
+	got := r.Histories(func(x string) bool { return x == id })
+	if len(got) == 0 {
+		return Series{}, false
+	}
+	return got[0], true
+}
+
+// Histories is the recent past of every numeric sensor match accepts, sorted by ID.
+func (r *Registry) Histories(match func(id string) bool) []Series {
+	out := []Series{}
 	for _, p := range r.providers {
 		if h, ok := p.(Historian); ok {
-			if s, ok := h.SensorHistory(id); ok {
-				return s, true
-			}
+			out = append(out, h.SensorHistories(match)...)
 		}
 	}
-	return Series{}, false
+	sort.SliceStable(out, func(i, j int) bool { return out[i].ID < out[j].ID })
+	return out
+}
+
+// Matcher turns comma-separated selectors (IDs and globs) into a match function.
+func Matcher(selectors string) (func(id string) bool, error) {
+	var sels []string
+	for _, sel := range strings.Split(selectors, ",") {
+		if sel = strings.TrimSpace(sel); sel == "" {
+			continue
+		}
+		if _, err := path.Match(sel, ""); err != nil {
+			return nil, fmt.Errorf("bad pattern %q", sel)
+		}
+		sels = append(sels, sel)
+	}
+	return func(id string) bool {
+		for _, sel := range sels {
+			if ok, _ := path.Match(sel, id); ok {
+				return true
+			}
+		}
+		return false
+	}, nil
 }
 
 // IsGlob reports whether a selector names many sensors rather than one.