parameterize graph labels and generalize metrics (#24)

Author: kylerisse

.github/workflows/ci.yml

@@ -0,0 +1,24 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: cachix/install-nix-action@v31
+        with:
+          nix_path: nixpkgs=channel:nixos-unstable
+
+      - uses: cachix/cachix-action@v16
+        with:
+          name: devenv
+
+      - name: Run tests
+        run: nix develop --command make test-ci

Makefile

@@ -4,6 +4,10 @@ test:
 	staticcheck ./...
 	go test -count=1 --race -v ./...
 
+test-ci:
+	staticcheck ./...
+	go test -short -count=1 --race -v ./...
+
 build:
 	go build -o out/wasgehtd cmd/wasgehtd/main.go
 

README.md

@@ -1,11 +1,14 @@
 # Was Geht
 
+[![CI](https://github.com/kylerisse/wasgeht/actions/workflows/ci.yml/badge.svg)](https://github.com/kylerisse/wasgeht/actions/workflows/ci.yml)
+
 ## Overview
 
-**Was Geht** is a small Go application that pings a list of hosts at regular intervals, tracks their availability (UP or DOWN), and records the latency in a Round Robin Database (RRD). A lightweight web interface serves host status information and interactive graphs of the recorded latency.
+**Was Geht** is a small Go application that monitors a list of hosts at regular intervals, tracks their availability and metrics, and records the data in Round Robin Databases (RRD). A lightweight web interface serves host status information and interactive graphs of the recorded metrics.
 
 ## Features
 
+- **Extensible Check System**: Modular check types (ping, with more planned) via a Registry/Factory pattern.
 - **Ping Monitoring**: Sends ICMP Echo Requests to check host availability.
 - **Latency Logging**: Uses RRD to store latency data over time.
 - **Graphs Generation**: Generates historical latency graphs (15 minutes, 4 hours, 8 hours, etc.) for each host.
@@ -27,7 +30,7 @@ nix develop
 
 You will need experimental features `flakes` and `nix-command`.
 
-This loads the environment specified in `shell.nix`:
+This loads the environment specified in `flake.nix`:
 
 - Go (for building),
 - gnumake (for Makefile),
@@ -41,7 +44,7 @@ Once inside the shell, you can run the usual make commands
 
 Ensure the following are installed:
 
-- **Go** (1.23+ recommended)
+- **Go** (1.25+ recommended)
 - **air** (for live reload during development, optional)
 - **rrdtool** and **unixtools ping** must be installed and available on the system path.
 - Basic Unix tools for building and running (`make`, etc.).
@@ -126,6 +129,7 @@ Each check type gets its own RRD file (e.g., `ping.rrd`), making it straightforw
 
 ## Makefile Targets
 
+- **test**: Runs staticcheck and `go test` with race detection.
 - **build**: Compiles the Go code and produces `wasgehtd`.
 - **deps**: Verifies module dependencies and updates `go.mod` and `go.sum`.
 - **clean**: Removes the `wasgehtd` binary and any generated graphs.

pkg/check/check.go

@@ -59,6 +59,12 @@ type MetricDef struct {
 
 	// DSName is the RRD data source name (e.g. "latency").
 	DSName string
+
+	// Label is a human-readable label for graphs and display (e.g. "latency").
+	Label string
+
+	// Unit is the unit of measurement for graphs and display (e.g. "ms").
+	Unit string
 }
 
 // Descriptor declares static metadata about a check type, including

pkg/check/check_test.go

@@ -29,7 +29,7 @@ func failingFactory(config map[string]any) (Check, error) {
 }
 
 var stubDescriptor = Descriptor{
-	Metrics: []MetricDef{{ResultKey: "value", DSName: "value"}},
+	Metrics: []MetricDef{{ResultKey: "value", DSName: "value", Label: "value", Unit: "units"}},
 }
 
 func TestResult_ZeroValue(t *testing.T) {
@@ -223,7 +223,7 @@ func TestRegistry_Describe(t *testing.T) {
 
 	desc := Descriptor{
 		Metrics: []MetricDef{
-			{ResultKey: "latency_us", DSName: "latency"},
+			{ResultKey: "latency_us", DSName: "latency", Label: "latency", Unit: "ms"},
 		},
 	}
 	reg.Register("ping", stubFactory("ping", Result{}), desc)
@@ -241,6 +241,12 @@ func TestRegistry_Describe(t *testing.T) {
 	if got.Metrics[0].DSName != "latency" {
 		t.Errorf("expected DSName 'latency', got %q", got.Metrics[0].DSName)
 	}
+	if got.Metrics[0].Label != "latency" {
+		t.Errorf("expected Label 'latency', got %q", got.Metrics[0].Label)
+	}
+	if got.Metrics[0].Unit != "ms" {
+		t.Errorf("expected Unit 'ms', got %q", got.Metrics[0].Unit)
+	}
 }
 
 func TestRegistry_DescribeUnknownType(t *testing.T) {
@@ -257,8 +263,8 @@ func TestRegistry_DescribeMultipleMetrics(t *testing.T) {
 
 	desc := Descriptor{
 		Metrics: []MetricDef{
-			{ResultKey: "rx_bytes", DSName: "rx"},
-			{ResultKey: "tx_bytes", DSName: "tx"},
+			{ResultKey: "rx_bytes", DSName: "rx", Label: "received", Unit: "bytes"},
+			{ResultKey: "tx_bytes", DSName: "tx", Label: "transmitted", Unit: "bytes"},
 		},
 	}
 	reg.Register("bandwidth", stubFactory("bandwidth", Result{}), desc)
@@ -276,7 +282,7 @@ func TestRegistry_ConcurrentDescribe(t *testing.T) {
 	reg := NewRegistry()
 
 	desc := Descriptor{
-		Metrics: []MetricDef{{ResultKey: "val", DSName: "val"}},
+		Metrics: []MetricDef{{ResultKey: "val", DSName: "val", Label: "value", Unit: "units"}},
 	}
 	reg.Register("test", stubFactory("test", Result{}), desc)
 

pkg/check/ping/ping.go

@@ -30,7 +30,7 @@ const (
 // Desc describes the metrics produced by a ping check.
 var Desc = check.Descriptor{
 	Metrics: []check.MetricDef{
-		{ResultKey: "latency_us", DSName: "latency"},
+		{ResultKey: "latency_us", DSName: "latency", Label: "latency", Unit: "ms"},
 	},
 }
 

pkg/check/ping/ping_test.go

@@ -261,6 +261,12 @@ func TestDesc(t *testing.T) {
 	if m.DSName != "latency" {
 		t.Errorf("expected DSName 'latency', got %q", m.DSName)
 	}
+	if m.Label != "latency" {
+		t.Errorf("expected Label 'latency', got %q", m.Label)
+	}
+	if m.Unit != "ms" {
+		t.Errorf("expected Unit 'ms', got %q", m.Unit)
+	}
 }
 
 func TestRegistryIntegration(t *testing.T) {

pkg/check/status.go

@@ -2,20 +2,18 @@ package check
 
 import (
 	"sync"
-	"time"
 )
 
 // Status tracks the latest result of a check execution.
 // It is safe for concurrent reads via the exported accessor methods,
 // but writes should be done through SetResult.
 type Status struct {
 	mu         sync.RWMutex
-	alive      bool
-	latency    time.Duration
+	lastResult Result
 	lastUpdate int64
 }
 
-// NewStatus creates a Status with zero values (not alive, no latency).
+// NewStatus creates a Status with zero values (not alive, no metrics).
 func NewStatus() *Status {
 	return &Status{}
 }
@@ -24,14 +22,20 @@ func NewStatus() *Status {
 func (s *Status) Alive() bool {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
-	return s.alive
+	return s.lastResult.Success
 }
 
-// Latency returns the latency from the check's last execution.
-func (s *Status) Latency() time.Duration {
+// Metric returns the value of a named metric from the last result.
+// Returns the value and true if found, or 0 and false if not present
+// or the last check failed.
+func (s *Status) Metric(key string) (float64, bool) {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
-	return s.latency
+	if !s.lastResult.Success || s.lastResult.Metrics == nil {
+		return 0, false
+	}
+	v, ok := s.lastResult.Metrics[key]
+	return v, ok
 }
 
 // LastUpdate returns the unix timestamp of the last successful RRD update.
@@ -41,19 +45,11 @@ func (s *Status) LastUpdate() int64 {
 	return s.lastUpdate
 }
 
-// SetResult updates the status from a check Result.
-// For successful results, it extracts latency from the "latency_us" metric
-// if present. For failed results, alive is set to false.
+// SetResult stores the latest check result.
 func (s *Status) SetResult(result Result) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
-
-	s.alive = result.Success
-	if result.Success {
-		if latencyUs, ok := result.Metrics["latency_us"]; ok {
-			s.latency = time.Duration(latencyUs) * time.Microsecond
-		}
-	}
+	s.lastResult = result
 }
 
 // SetLastUpdate records the unix timestamp of the last successful RRD update.
@@ -68,16 +64,26 @@ func (s *Status) SetLastUpdate(ts int64) {
 func (s *Status) Snapshot() StatusSnapshot {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
+
+	// Deep copy the metrics map so the snapshot is independent
+	var metrics map[string]float64
+	if s.lastResult.Metrics != nil {
+		metrics = make(map[string]float64, len(s.lastResult.Metrics))
+		for k, v := range s.lastResult.Metrics {
+			metrics[k] = v
+		}
+	}
+
 	return StatusSnapshot{
-		Alive:      s.alive,
-		Latency:    s.latency,
+		Alive:      s.lastResult.Success,
+		Metrics:    metrics,
 		LastUpdate: s.lastUpdate,
 	}
 }
 
 // StatusSnapshot is a point-in-time copy of Status fields.
 type StatusSnapshot struct {
 	Alive      bool
-	Latency    time.Duration
+	Metrics    map[string]float64
 	LastUpdate int64
 }

pkg/check/status_test.go

@@ -3,16 +3,15 @@ package check
 import (
 	"sync"
 	"testing"
-	"time"
 )
 
 func TestNewStatus_ZeroValues(t *testing.T) {
 	s := NewStatus()
 	if s.Alive() {
 		t.Error("new status should not be alive")
 	}
-	if s.Latency() != 0 {
-		t.Errorf("new status should have zero latency, got %v", s.Latency())
+	if v, ok := s.Metric("latency_us"); ok {
+		t.Errorf("new status should have no metrics, got latency_us=%f", v)
 	}
 	if s.LastUpdate() != 0 {
 		t.Errorf("new status should have zero last update, got %d", s.LastUpdate())
@@ -29,9 +28,12 @@ func TestStatus_SetResult_Success(t *testing.T) {
 	if !s.Alive() {
 		t.Error("expected alive after successful result")
 	}
-	expected := time.Duration(1234) * time.Microsecond
-	if s.Latency() != expected {
-		t.Errorf("expected latency %v, got %v", expected, s.Latency())
+	v, ok := s.Metric("latency_us")
+	if !ok {
+		t.Fatal("expected latency_us metric to be present")
+	}
+	if v != 1234.0 {
+		t.Errorf("expected latency_us=1234.0, got %f", v)
 	}
 }
 
@@ -50,9 +52,12 @@ func TestStatus_SetResult_Failure(t *testing.T) {
 	if s.Alive() {
 		t.Error("expected not alive after failed result")
 	}
+	if _, ok := s.Metric("latency_us"); ok {
+		t.Error("expected no metrics after failed result")
+	}
 }
 
-func TestStatus_SetResult_SuccessWithoutLatency(t *testing.T) {
+func TestStatus_SetResult_SuccessWithoutMetrics(t *testing.T) {
 	s := NewStatus()
 	s.SetResult(Result{
 		Success: true,
@@ -62,8 +67,31 @@ func TestStatus_SetResult_SuccessWithoutLatency(t *testing.T) {
 	if !s.Alive() {
 		t.Error("expected alive after successful result")
 	}
-	if s.Latency() != 0 {
-		t.Errorf("expected zero latency when metric absent, got %v", s.Latency())
+	if _, ok := s.Metric("latency_us"); ok {
+		t.Error("expected no latency_us when metric absent")
+	}
+}
+
+func TestStatus_Metric_MultipleMetrics(t *testing.T) {
+	s := NewStatus()
+	s.SetResult(Result{
+		Success: true,
+		Metrics: map[string]float64{
+			"latency_us":    1234.0,
+			"response_code": 200.0,
+		},
+	})
+
+	v, ok := s.Metric("latency_us")
+	if !ok || v != 1234.0 {
+		t.Errorf("expected latency_us=1234.0, got %f (ok=%v)", v, ok)
+	}
+	v, ok = s.Metric("response_code")
+	if !ok || v != 200.0 {
+		t.Errorf("expected response_code=200.0, got %f (ok=%v)", v, ok)
+	}
+	if _, ok := s.Metric("nonexistent"); ok {
+		t.Error("expected nonexistent metric to not be found")
 	}
 }
 
@@ -89,9 +117,8 @@ func TestStatus_Snapshot(t *testing.T) {
 	if !snap.Alive {
 		t.Error("snapshot should be alive")
 	}
-	expected := time.Duration(5678) * time.Microsecond
-	if snap.Latency != expected {
-		t.Errorf("snapshot latency: expected %v, got %v", expected, snap.Latency)
+	if v, ok := snap.Metrics["latency_us"]; !ok || v != 5678.0 {
+		t.Errorf("snapshot metrics: expected latency_us=5678.0, got %v (ok=%v)", v, ok)
 	}
 	if snap.LastUpdate != 1700000000 {
 		t.Errorf("snapshot last update: expected 1700000000, got %d", snap.LastUpdate)
@@ -114,6 +141,28 @@ func TestStatus_Snapshot_Independent(t *testing.T) {
 	if !snap.Alive {
 		t.Error("snapshot should be independent of subsequent mutations")
 	}
+	if _, ok := snap.Metrics["latency_us"]; !ok {
+		t.Error("snapshot metrics should be independent of subsequent mutations")
+	}
+}
+
+func TestStatus_Snapshot_MetricsMapIndependent(t *testing.T) {
+	s := NewStatus()
+	s.SetResult(Result{
+		Success: true,
+		Metrics: map[string]float64{"latency_us": 1000.0},
+	})
+
+	snap := s.Snapshot()
+
+	// Mutate the snapshot's metrics map
+	snap.Metrics["latency_us"] = 9999.0
+
+	// Status should be unaffected
+	v, ok := s.Metric("latency_us")
+	if !ok || v != 1000.0 {
+		t.Errorf("mutating snapshot should not affect status, got %f", v)
+	}
 }
 
 func TestStatus_ConcurrentAccess(t *testing.T) {
@@ -139,7 +188,7 @@ func TestStatus_ConcurrentAccess(t *testing.T) {
 		go func() {
 			defer wg.Done()
 			_ = s.Alive()
-			_ = s.Latency()
+			_, _ = s.Metric("latency_us")
 			_ = s.LastUpdate()
 			_ = s.Snapshot()
 		}()