updates

agent/probe.go

@@ -13,6 +13,25 @@ import (
 	"github.com/henrygd/beszel/internal/entities/probe"
 )
 
+// Probe functionality overview:
+// Probes run at user-defined intervals (e.g., every 10s).
+// To keep memory usage low and constant, data is stored in two layers:
+// 1. Raw samples: The most recent individual results (kept for probeRawRetention).
+// 2. Minute buckets: A fixed-size ring buffer of 61 buckets, each representing one
+//    wall-clock minute. Samples collected within the same minute are aggregated
+//    (sum, min, max, count) into a single bucket.
+//
+// Short-term requests (<= 2m) use raw samples for perfect accuracy.
+// Long-term requests (up to 1h) use the minute buckets to avoid storing thousands
+// of individual data points.
+
+const (
+	// probeRawRetention is the duration to keep individual samples for high-precision short-term requests
+	probeRawRetention = 80 * time.Second
+	// probeMinuteBucketLen is the number of 1-minute buckets to keep (1 hour + 1 for partials)
+	probeMinuteBucketLen int32 = 61
+)
+
 // ProbeManager manages network probe tasks.
 type ProbeManager struct {
 	mu         sync.RWMutex
@@ -20,16 +39,35 @@ type ProbeManager struct {
 	httpClient *http.Client
 }
 
+// probeTask owns retention buffers and cancellation for a single probe config.
 type probeTask struct {
 	config  probe.Config
 	cancel  chan struct{}
 	mu      sync.Mutex
 	samples []probeSample
+	buckets [probeMinuteBucketLen]probeBucket
 }
 
+// probeSample stores one probe attempt and its collection time.
 type probeSample struct {
-	latencyMs float64 // -1 means loss
-	timestamp time.Time
+	responseMs float64 // -1 means loss
+	timestamp  time.Time
+}
+
+// probeBucket stores one minute of aggregated probe data.
+type probeBucket struct {
+	minute int32
+	filled bool
+	stats  probeAggregate
+}
+
+// probeAggregate accumulates successful response stats and total sample counts.
+type probeAggregate struct {
+	sumMs        float64
+	minMs        float64
+	maxMs        float64
+	totalCount   int
+	successCount int
 }
 
 func newProbeManager() *ProbeManager {
@@ -39,6 +77,82 @@ func newProbeManager() *ProbeManager {
 	}
 }
 
+// newProbeAggregate initializes an aggregate with an unset minimum value.
+func newProbeAggregate() probeAggregate {
+	return probeAggregate{minMs: math.MaxFloat64}
+}
+
+// addResponse folds a single probe sample into the aggregate.
+func (agg *probeAggregate) addResponse(responseMs float64) {
+	agg.totalCount++
+	if responseMs < 0 {
+		return
+	}
+	agg.successCount++
+	agg.sumMs += responseMs
+	if responseMs < agg.minMs {
+		agg.minMs = responseMs
+	}
+	if responseMs > agg.maxMs {
+		agg.maxMs = responseMs
+	}
+}
+
+// addAggregate merges another aggregate into this one.
+func (agg *probeAggregate) addAggregate(other probeAggregate) {
+	if other.totalCount == 0 {
+		return
+	}
+	agg.totalCount += other.totalCount
+	agg.successCount += other.successCount
+	agg.sumMs += other.sumMs
+	if other.successCount == 0 {
+		return
+	}
+	if agg.minMs == math.MaxFloat64 || other.minMs < agg.minMs {
+		agg.minMs = other.minMs
+	}
+	if other.maxMs > agg.maxMs {
+		agg.maxMs = other.maxMs
+	}
+}
+
+// hasData reports whether the aggregate contains any samples.
+func (agg probeAggregate) hasData() bool {
+	return agg.totalCount > 0
+}
+
+// result converts the aggregate into the probe result slice format.
+func (agg probeAggregate) result() probe.Result {
+	avg := agg.avgResponse()
+	minMs := 0.0
+	if agg.successCount > 0 {
+		minMs = math.Round(agg.minMs*100) / 100
+	}
+	return probe.Result{
+		avg,
+		minMs,
+		math.Round(agg.maxMs*100) / 100,
+		agg.lossPercentage(),
+	}
+}
+
+// avgResponse returns the rounded average of successful samples.
+func (agg probeAggregate) avgResponse() float64 {
+	if agg.successCount == 0 {
+		return 0
+	}
+	return math.Round(agg.sumMs/float64(agg.successCount)*100) / 100
+}
+
+// lossPercentage returns the rounded failure rate for the aggregate.
+func (agg probeAggregate) lossPercentage() float64 {
+	if agg.totalCount == 0 {
+		return 0
+	}
+	return math.Round(float64(agg.totalCount-agg.successCount)/float64(agg.totalCount)*10000) / 100
+}
+
 // SyncProbes replaces all probe tasks with the given configs.
 func (pm *ProbeManager) SyncProbes(configs []probe.Config) {
 	pm.mu.Lock()
@@ -47,7 +161,10 @@ func (pm *ProbeManager) SyncProbes(configs []probe.Config) {
 	// Build set of new keys
 	newKeys := make(map[string]probe.Config, len(configs))
 	for _, cfg := range configs {
-		newKeys[cfg.Key()] = cfg
+		if cfg.ID == "" {
+			continue
+		}
+		newKeys[cfg.ID] = cfg
 	}
 
 	// Stop removed probes
@@ -79,52 +196,34 @@ func (pm *ProbeManager) GetResults(durationMs uint16) map[string]probe.Result {
 	defer pm.mu.RUnlock()
 
 	results := make(map[string]probe.Result, len(pm.probes))
-	cutoff := time.Now().Add(-time.Duration(durationMs) * time.Millisecond)
+	now := time.Now()
+	duration := time.Duration(durationMs) * time.Millisecond
 
-	for key, task := range pm.probes {
+	for _, task := range pm.probes {
 		task.mu.Lock()
-		var sum, minMs, maxMs float64
-		var count, lossCount int
-		minMs = math.MaxFloat64
-
-		for _, s := range task.samples {
-			if s.timestamp.Before(cutoff) {
-				continue
-			}
-			count++
-			if s.latencyMs < 0 {
-				lossCount++
-				continue
-			}
-			sum += s.latencyMs
-			if s.latencyMs < minMs {
-				minMs = s.latencyMs
-			}
-			if s.latencyMs > maxMs {
-				maxMs = s.latencyMs
-			}
-		}
+		agg := task.aggregateLocked(duration, now)
+		hourAgg := task.aggregateLocked(time.Hour, now)
 		task.mu.Unlock()
 
-		if count == 0 {
+		if !agg.hasData() {
 			continue
 		}
 
-		successCount := count - lossCount
-		var avg float64
-		if successCount > 0 {
-			avg = math.Round(sum/float64(successCount)*100) / 100
-		}
-		if minMs == math.MaxFloat64 {
-			minMs = 0
-		}
-
-		results[key] = probe.Result{
-			avg,                         // average latency in ms
-			math.Round(minMs*100) / 100, // min latency in ms
-			math.Round(maxMs*100) / 100, // max latency in ms
-			math.Round(float64(lossCount)/float64(count)*10000) / 100, // packet loss percentage
+		result := agg.result()
+		hourAvg := hourAgg.avgResponse()
+		hourLoss := hourAgg.lossPercentage()
+		if hourAgg.successCount > 0 {
+			result = probe.Result{
+				result[0],
+				hourAvg,
+				math.Round(hourAgg.minMs*100) / 100,
+				math.Round(hourAgg.maxMs*100) / 100,
+				hourLoss,
+			}
+		} else {
+			result = probe.Result{result[0], hourAvg, 0, 0, hourLoss}
 		}
+		results[task.config.ID] = result
 	}
 
 	return results
@@ -161,32 +260,48 @@ func (pm *ProbeManager) runProbe(task *probeTask) {
 	}
 }
 
-func (pm *ProbeManager) executeProbe(task *probeTask) {
-	var latencyMs float64
-
-	switch task.config.Protocol {
-	case "icmp":
-		latencyMs = probeICMP(task.config.Target)
-	case "tcp":
-		latencyMs = probeTCP(task.config.Target, task.config.Port)
-	case "http":
-		latencyMs = probeHTTP(pm.httpClient, task.config.Target)
-	default:
-		slog.Warn("unknown probe protocol", "protocol", task.config.Protocol)
-		return
+// aggregateLocked collects probe data for the requested time window.
+func (task *probeTask) aggregateLocked(duration time.Duration, now time.Time) probeAggregate {
+	cutoff := now.Add(-duration)
+	// Keep short windows exact; longer windows read from minute buckets to avoid raw-sample retention.
+	if duration <= probeRawRetention {
+		return aggregateSamplesSince(task.samples, cutoff)
 	}
+	return aggregateBucketsSince(task.buckets[:], cutoff, now)
+}
 
-	sample := probeSample{
-		latencyMs: latencyMs,
-		timestamp: time.Now(),
+// aggregateSamplesSince aggregates raw samples newer than the cutoff.
+func aggregateSamplesSince(samples []probeSample, cutoff time.Time) probeAggregate {
+	agg := newProbeAggregate()
+	for _, sample := range samples {
+		if sample.timestamp.Before(cutoff) {
+			continue
+		}
+		agg.addResponse(sample.responseMs)
 	}
+	return agg
+}
 
-	task.mu.Lock()
-	// Trim old samples beyond 120s to bound memory
-	cutoff := time.Now().Add(-120 * time.Second)
+// aggregateBucketsSince aggregates minute buckets overlapping the requested window.
+func aggregateBucketsSince(buckets []probeBucket, cutoff, now time.Time) probeAggregate {
+	agg := newProbeAggregate()
+	startMinute := int32(cutoff.Unix() / 60)
+	endMinute := int32(now.Unix() / 60)
+	for _, bucket := range buckets {
+		if !bucket.filled || bucket.minute < startMinute || bucket.minute > endMinute {
+			continue
+		}
+		agg.addAggregate(bucket.stats)
+	}
+	return agg
+}
+
+// addSampleLocked stores a fresh sample in both raw and per-minute retention buffers.
+func (task *probeTask) addSampleLocked(sample probeSample) {
+	cutoff := sample.timestamp.Add(-probeRawRetention)
 	start := 0
 	for i := range task.samples {
-		if task.samples[i].timestamp.After(cutoff) {
+		if !task.samples[i].timestamp.Before(cutoff) {
 			start = i
 			break
 		}
@@ -199,10 +314,45 @@ func (pm *ProbeManager) executeProbe(task *probeTask) {
 		task.samples = task.samples[:size]
 	}
 	task.samples = append(task.samples, sample)
+
+	minute := int32(sample.timestamp.Unix() / 60)
+	// Each slot stores one wall-clock minute, so the ring stays fixed-size at ~1h per probe.
+	bucket := &task.buckets[minute%probeMinuteBucketLen]
+	if !bucket.filled || bucket.minute != minute {
+		bucket.minute = minute
+		bucket.filled = true
+		bucket.stats = newProbeAggregate()
+	}
+	bucket.stats.addResponse(sample.responseMs)
+}
+
+// executeProbe runs the configured probe and records the sample.
+func (pm *ProbeManager) executeProbe(task *probeTask) {
+	var responseMs float64
+
+	switch task.config.Protocol {
+	case "icmp":
+		responseMs = probeICMP(task.config.Target)
+	case "tcp":
+		responseMs = probeTCP(task.config.Target, task.config.Port)
+	case "http":
+		responseMs = probeHTTP(pm.httpClient, task.config.Target)
+	default:
+		slog.Warn("unknown probe protocol", "protocol", task.config.Protocol)
+		return
+	}
+
+	sample := probeSample{
+		responseMs: responseMs,
+		timestamp:  time.Now(),
+	}
+
+	task.mu.Lock()
+	task.addSampleLocked(sample)
 	task.mu.Unlock()
 }
 
-// probeTCP measures pure TCP handshake latency (excluding DNS resolution).
+// probeTCP measures pure TCP handshake response (excluding DNS resolution).
 // Returns -1 on failure.
 func probeTCP(target string, port uint16) float64 {
 	// Resolve DNS first, outside the timing window
@@ -222,7 +372,7 @@ func probeTCP(target string, port uint16) float64 {
 	return float64(time.Since(start).Microseconds()) / 1000.0
 }
 
-// probeHTTP measures HTTP GET request latency. Returns -1 on failure.
+// probeHTTP measures HTTP GET request response. Returns -1 on failure.
 func probeHTTP(client *http.Client, url string) float64 {
 	start := time.Now()
 	resp, err := client.Get(url)

agent/probe_ping.go

@@ -71,11 +71,11 @@ var (
 	}
 )
 
-// probeICMP sends an ICMP echo request and measures round-trip latency.
+// probeICMP sends an ICMP echo request and measures round-trip response.
 // Supports both IPv4 and IPv6 targets. The ICMP method (raw socket,
 // unprivileged datagram, or exec fallback) is detected once per address
 // family and cached for subsequent probes.
-// Returns latency in milliseconds, or -1 on failure.
+// Returns response in milliseconds, or -1 on failure.
 func probeICMP(target string) float64 {
 	family, ip := resolveICMPTarget(target)
 	if family == nil {

agent/probe_test.go

@@ -0,0 +1,216 @@
+package agent
+
+import (
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/henrygd/beszel/internal/entities/probe"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestProbeTaskAggregateLockedUsesRawSamplesForShortWindows(t *testing.T) {
+	now := time.Date(2026, time.April, 21, 12, 0, 0, 0, time.UTC)
+	task := &probeTask{}
+
+	task.addSampleLocked(probeSample{responseMs: 10, timestamp: now.Add(-90 * time.Second)})
+	task.addSampleLocked(probeSample{responseMs: 20, timestamp: now.Add(-30 * time.Second)})
+	task.addSampleLocked(probeSample{responseMs: -1, timestamp: now.Add(-10 * time.Second)})
+
+	agg := task.aggregateLocked(time.Minute, now)
+	require.True(t, agg.hasData())
+	assert.Equal(t, 2, agg.totalCount)
+	assert.Equal(t, 1, agg.successCount)
+	assert.Equal(t, 20.0, agg.result()[0])
+	assert.Equal(t, 20.0, agg.result()[1])
+	assert.Equal(t, 20.0, agg.result()[2])
+	assert.Equal(t, 50.0, agg.result()[3])
+}
+
+func TestProbeTaskAggregateLockedUsesMinuteBucketsForLongWindows(t *testing.T) {
+	now := time.Date(2026, time.April, 21, 12, 0, 30, 0, time.UTC)
+	task := &probeTask{}
+
+	task.addSampleLocked(probeSample{responseMs: 10, timestamp: now.Add(-11 * time.Minute)})
+	task.addSampleLocked(probeSample{responseMs: 20, timestamp: now.Add(-9 * time.Minute)})
+	task.addSampleLocked(probeSample{responseMs: 40, timestamp: now.Add(-5 * time.Minute)})
+	task.addSampleLocked(probeSample{responseMs: -1, timestamp: now.Add(-90 * time.Second)})
+	task.addSampleLocked(probeSample{responseMs: 30, timestamp: now.Add(-30 * time.Second)})
+
+	agg := task.aggregateLocked(10*time.Minute, now)
+	require.True(t, agg.hasData())
+	assert.Equal(t, 4, agg.totalCount)
+	assert.Equal(t, 3, agg.successCount)
+	assert.Equal(t, 30.0, agg.result()[0])
+	assert.Equal(t, 20.0, agg.result()[1])
+	assert.Equal(t, 40.0, agg.result()[2])
+	assert.Equal(t, 25.0, agg.result()[3])
+}
+
+func TestProbeTaskAddSampleLockedTrimsRawSamplesButKeepsBucketHistory(t *testing.T) {
+	now := time.Date(2026, time.April, 21, 12, 0, 0, 0, time.UTC)
+	task := &probeTask{}
+
+	task.addSampleLocked(probeSample{responseMs: 10, timestamp: now.Add(-10 * time.Minute)})
+	task.addSampleLocked(probeSample{responseMs: 20, timestamp: now})
+
+	require.Len(t, task.samples, 1)
+	assert.Equal(t, 20.0, task.samples[0].responseMs)
+
+	agg := task.aggregateLocked(10*time.Minute, now)
+	require.True(t, agg.hasData())
+	assert.Equal(t, 2, agg.totalCount)
+	assert.Equal(t, 2, agg.successCount)
+	assert.Equal(t, 15.0, agg.result()[0])
+	assert.Equal(t, 10.0, agg.result()[1])
+	assert.Equal(t, 20.0, agg.result()[2])
+	assert.Equal(t, 0.0, agg.result()[3])
+}
+
+func TestProbeManagerGetResultsIncludesHourResponseRange(t *testing.T) {
+	now := time.Now().UTC()
+	task := &probeTask{config: probe.Config{ID: "probe-1"}}
+	task.addSampleLocked(probeSample{responseMs: 10, timestamp: now.Add(-30 * time.Minute)})
+	task.addSampleLocked(probeSample{responseMs: 20, timestamp: now.Add(-9 * time.Minute)})
+	task.addSampleLocked(probeSample{responseMs: 40, timestamp: now.Add(-5 * time.Minute)})
+	task.addSampleLocked(probeSample{responseMs: -1, timestamp: now.Add(-90 * time.Second)})
+	task.addSampleLocked(probeSample{responseMs: 30, timestamp: now.Add(-30 * time.Second)})
+
+	pm := &ProbeManager{probes: map[string]*probeTask{"icmp:example.com": task}}
+
+	results := pm.GetResults(uint16(time.Minute / time.Millisecond))
+	result, ok := results["probe-1"]
+	require.True(t, ok)
+	require.Len(t, result, 5)
+	assert.Equal(t, 30.0, result[0])
+	assert.Equal(t, 25.0, result[1])
+	assert.Equal(t, 10.0, result[2])
+	assert.Equal(t, 40.0, result[3])
+	assert.Equal(t, 20.0, result[4])
+}
+
+func TestProbeManagerGetResultsIncludesLossOnlyHourData(t *testing.T) {
+	now := time.Now().UTC()
+	task := &probeTask{config: probe.Config{ID: "probe-1"}}
+	task.addSampleLocked(probeSample{responseMs: -1, timestamp: now.Add(-30 * time.Second)})
+	task.addSampleLocked(probeSample{responseMs: -1, timestamp: now.Add(-10 * time.Second)})
+
+	pm := &ProbeManager{probes: map[string]*probeTask{"icmp:example.com": task}}
+
+	results := pm.GetResults(uint16(time.Minute / time.Millisecond))
+	result, ok := results["probe-1"]
+	require.True(t, ok)
+	require.Len(t, result, 5)
+	assert.Equal(t, 0.0, result[0])
+	assert.Equal(t, 0.0, result[1])
+	assert.Equal(t, 0.0, result[2])
+	assert.Equal(t, 0.0, result[3])
+	assert.Equal(t, 100.0, result[4])
+}
+
+func TestProbeConfigResultKeyUsesSyncedID(t *testing.T) {
+	cfg := probe.Config{ID: "probe-1", Target: "1.1.1.1", Protocol: "icmp", Interval: 10}
+	assert.Equal(t, "probe-1", cfg.ID)
+}
+
+func TestProbeManagerSyncProbesSkipsConfigsWithoutStableID(t *testing.T) {
+	validCfg := probe.Config{ID: "probe-1", Target: "https://example.com", Protocol: "http", Interval: 10}
+	invalidCfg := probe.Config{Target: "1.1.1.1", Protocol: "icmp", Interval: 10}
+
+	pm := newProbeManager()
+	pm.SyncProbes([]probe.Config{validCfg, invalidCfg})
+	defer pm.Stop()
+
+	_, validExists := pm.probes[validCfg.ID]
+	_, invalidExists := pm.probes[invalidCfg.ID]
+	assert.True(t, validExists)
+	assert.False(t, invalidExists)
+}
+
+func TestProbeManagerSyncProbesStopsRemovedTasksButKeepsExisting(t *testing.T) {
+	keepCfg := probe.Config{ID: "probe-1", Target: "https://example.com", Protocol: "http", Interval: 10}
+	removeCfg := probe.Config{ID: "probe-2", Target: "1.1.1.1", Protocol: "icmp", Interval: 10}
+
+	keptTask := &probeTask{config: keepCfg, cancel: make(chan struct{})}
+	removedTask := &probeTask{config: removeCfg, cancel: make(chan struct{})}
+	pm := &ProbeManager{
+		probes: map[string]*probeTask{
+			keepCfg.ID:   keptTask,
+			removeCfg.ID: removedTask,
+		},
+	}
+
+	pm.SyncProbes([]probe.Config{keepCfg})
+
+	assert.Same(t, keptTask, pm.probes[keepCfg.ID])
+	_, exists := pm.probes[removeCfg.ID]
+	assert.False(t, exists)
+
+	select {
+	case <-removedTask.cancel:
+	default:
+		t.Fatal("expected removed probe task to be cancelled")
+	}
+
+	select {
+	case <-keptTask.cancel:
+		t.Fatal("expected existing probe task to remain active")
+	default:
+	}
+}
+
+func TestProbeHTTP(t *testing.T) {
+	t.Run("success", func(t *testing.T) {
+		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.WriteHeader(http.StatusNoContent)
+		}))
+		defer server.Close()
+
+		responseMs := probeHTTP(server.Client(), server.URL)
+		assert.GreaterOrEqual(t, responseMs, 0.0)
+	})
+
+	t.Run("server error", func(t *testing.T) {
+		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			http.Error(w, "boom", http.StatusInternalServerError)
+		}))
+		defer server.Close()
+
+		assert.Equal(t, -1.0, probeHTTP(server.Client(), server.URL))
+	})
+}
+
+func TestProbeTCP(t *testing.T) {
+	t.Run("success", func(t *testing.T) {
+		listener, err := net.Listen("tcp", "127.0.0.1:0")
+		require.NoError(t, err)
+		defer listener.Close()
+
+		accepted := make(chan struct{})
+		go func() {
+			defer close(accepted)
+			conn, err := listener.Accept()
+			if err == nil {
+				_ = conn.Close()
+			}
+		}()
+
+		port := uint16(listener.Addr().(*net.TCPAddr).Port)
+		responseMs := probeTCP("127.0.0.1", port)
+		assert.GreaterOrEqual(t, responseMs, 0.0)
+		<-accepted
+	})
+
+	t.Run("connection failure", func(t *testing.T) {
+		listener, err := net.Listen("tcp", "127.0.0.1:0")
+		require.NoError(t, err)
+
+		port := uint16(listener.Addr().(*net.TCPAddr).Port)
+		require.NoError(t, listener.Close())
+
+		assert.Equal(t, -1.0, probeTCP("127.0.0.1", port))
+	})
+}

internal/entities/probe/probe.go

@@ -1,32 +1,24 @@
 package probe
 
-import "strconv"
-
 // Config defines a network probe task sent from hub to agent.
 type Config struct {
-	Target   string `cbor:"0,keyasint" json:"target"`
-	Protocol string `cbor:"1,keyasint" json:"protocol"` // "icmp", "tcp", or "http"
-	Port     uint16 `cbor:"2,keyasint,omitempty" json:"port,omitempty"`
-	Interval uint16 `cbor:"3,keyasint" json:"interval"` // seconds
+	// ID is the stable network_probes record ID generated by the hub.
+	ID       string `cbor:"0,keyasint"`
+	Target   string `cbor:"1,keyasint"`
+	Protocol string `cbor:"2,keyasint"` // "icmp", "tcp", or "http"
+	Port     uint16 `cbor:"3,keyasint,omitempty"`
+	Interval uint16 `cbor:"4,keyasint"` // seconds
 }
 
 // Result holds aggregated probe results for a single target.
 //
-// 0: avg latency in ms
+// 0: avg response in ms
 //
-// 1: min latency in ms
+// 1: average response over the last hour in ms
 //
-// 2: max latency in ms
+// 2: min response over the last hour in ms
 //
-// 3: packet loss percentage (0-100)
+// 3: max response over the last hour in ms
+//
+// 4: packet loss percentage over the last hour (0-100)
 type Result []float64
-
-// Key returns the map key used for this probe config (e.g. "icmp:1.1.1.1", "tcp:host:443", "http:https://example.com").
-func (c Config) Key() string {
-	switch c.Protocol {
-	case "tcp":
-		return c.Protocol + ":" + c.Target + ":" + strconv.FormatUint(uint64(c.Port), 10)
-	default:
-		return c.Protocol + ":" + c.Target
-	}
-}

internal/hub/probes.go

@@ -1,11 +1,20 @@
 package hub
 
 import (
+	"strconv"
+
 	"github.com/henrygd/beszel/internal/entities/probe"
 	"github.com/henrygd/beszel/internal/hub/systems"
 	"github.com/pocketbase/pocketbase/core"
 )
 
+// generateProbeID creates a stable hash ID for a probe based on its configuration and the system it belongs to.
+func generateProbeID(systemId string, config probe.Config) string {
+	intervalStr := strconv.FormatUint(uint64(config.Interval), 10)
+	portStr := strconv.FormatUint(uint64(config.Port), 10)
+	return systems.MakeStableHashId(systemId, config.Protocol, config.Target, portStr, intervalStr)
+}
+
 func bindNetworkProbesEvents(h *Hub) {
 	// on create, make sure the id is set to a stable hash
 	h.OnRecordCreate("network_probes").BindFunc(func(e *core.RecordEvent) error {
@@ -16,8 +25,7 @@ func bindNetworkProbesEvents(h *Hub) {
 			Port:     uint16(e.Record.GetInt("port")),
 			Interval: uint16(e.Record.GetInt("interval")),
 		}
-		key := config.Key()
-		id := systems.MakeStableHashId(systemID, key)
+		id := generateProbeID(systemID, *config)
 		e.Record.Set("id", id)
 		return e.Next()
 	})

internal/hub/probes_test.go

@@ -0,0 +1,79 @@
+package hub
+
+import (
+	"testing"
+
+	"github.com/henrygd/beszel/internal/entities/probe"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGenerateProbeID(t *testing.T) {
+	tests := []struct {
+		name     string
+		systemID string
+		config   probe.Config
+		expected string
+	}{
+		{
+			name:     "HTTP probe on example.com",
+			systemID: "sys123",
+			config: probe.Config{
+				Protocol: "http",
+				Target:   "example.com",
+				Port:     80,
+				Interval: 60,
+			},
+			expected: "d5f27931",
+		},
+		{
+			name:     "HTTP probe on example.com with different system ID",
+			systemID: "sys1234",
+			config: probe.Config{
+				Protocol: "http",
+				Target:   "example.com",
+				Port:     80,
+				Interval: 60,
+			},
+			expected: "6f8b17f1",
+		},
+		{
+			name:     "Same probe, different interval",
+			systemID: "sys1234",
+			config: probe.Config{
+				Protocol: "http",
+				Target:   "example.com",
+				Port:     80,
+				Interval: 120,
+			},
+			expected: "6d4baf8",
+		},
+		{
+			name:     "ICMP probe on 1.1.1.1",
+			systemID: "sys456",
+			config: probe.Config{
+				Protocol: "icmp",
+				Target:   "1.1.1.1",
+				Port:     0,
+				Interval: 10,
+			},
+			expected: "80b5836b",
+		}, {
+			name:     "ICMP probe on 1.1.1.1 with different system ID",
+			systemID: "sys4567",
+			config: probe.Config{
+				Protocol: "icmp",
+				Target:   "1.1.1.1",
+				Port:     0,
+				Interval: 10,
+			},
+			expected: "a6652680",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := generateProbeID(tt.systemID, tt.config)
+			assert.Equal(t, tt.expected, got, "generateProbeID() = %v, want %v", got, tt.expected)
+		})
+	}
+}

internal/hub/systems/system.go

@@ -335,7 +335,7 @@ func updateNetworkProbesRecords(app core.App, data map[string]probe.Result, syst
 	if !realtimeActive {
 		db = app.DB()
 		nowString = time.Now().UTC().Format(types.DefaultDateLayout)
-		sql := fmt.Sprintf("UPDATE %s SET latency={:latency}, loss={:loss}, updated={:updated} WHERE id={:id}", collectionName)
+		sql := fmt.Sprintf("UPDATE %s SET resAvg={:res}, resMin1h={:resMin1h}, resMax1h={:resMax1h}, resAvg1h={:resAvg1h}, loss1h={:loss1h}, updated={:updated} WHERE id={:id}", collectionName)
 		updateQuery = db.NewQuery(sql)
 	}
 
@@ -349,12 +349,12 @@ func updateNetworkProbesRecords(app core.App, data map[string]probe.Result, syst
 		record.Set("type", "1m")
 		err = app.SaveNoValidate(record)
 	default:
-		if dataJson, e := json.Marshal(data); e == nil {
+		if dataJSON, marshalErr := json.Marshal(data); marshalErr == nil {
 			sql := "INSERT INTO network_probe_stats (system, stats, type, created) VALUES ({:system}, {:stats}, {:type}, {:created})"
 			insertQuery := db.NewQuery(sql)
 			_, err = insertQuery.Bind(dbx.Params{
 				"system":  systemId,
-				"stats":   dataJson,
+				"stats":   dataJSON,
 				"type":    "1m",
 				"created": nowString,
 			}).Execute()
@@ -365,34 +365,45 @@ func updateNetworkProbesRecords(app core.App, data map[string]probe.Result, syst
 	}
 
 	// update network_probes records
-	for key := range data {
-		probe := data[key]
-		id := MakeStableHashId(systemId, key)
+	for id, values := range data {
 		switch realtimeActive {
 		case true:
 			var record *core.Record
 			record, err = app.FindRecordById(collectionName, id)
 			if err == nil {
-				record.Set("latency", probe[0])
-				record.Set("loss", probe[3])
+				record.Set("res", probeMetric(values, 0))
+				record.Set("resAvg1h", probeMetric(values, 1))
+				record.Set("resMin1h", probeMetric(values, 2))
+				record.Set("resMax1h", probeMetric(values, 3))
+				record.Set("loss1h", probeMetric(values, 4))
 				err = app.SaveNoValidate(record)
 			}
 		default:
 			_, err = updateQuery.Bind(dbx.Params{
-				"id":      id,
-				"latency": probe[0],
-				"loss":    probe[3],
-				"updated": nowString,
+				"id":       id,
+				"res":      probeMetric(values, 0),
+				"resAvg1h": probeMetric(values, 1),
+				"resMin1h": probeMetric(values, 2),
+				"resMax1h": probeMetric(values, 3),
+				"loss1h":   probeMetric(values, 4),
+				"updated":  nowString,
 			}).Execute()
 		}
 		if err != nil {
-			app.Logger().Warn("Failed to update probe", "system", systemId, "probe", key, "err", err)
+			app.Logger().Warn("Failed to update probe", "system", systemId, "probe", id, "err", err)
 		}
 	}
 
 	return nil
 }
 
+func probeMetric(values probe.Result, index int) float64 {
+	if index < len(values) {
+		return values[index]
+	}
+	return 0
+}
+
 // createContainerRecords creates container records
 func createContainerRecords(app core.App, data []*container.Stats, systemId string) error {
 	if len(data) == 0 {

internal/hub/systems/system_manager.go

@@ -325,7 +325,7 @@ func (sm *SystemManager) AddWebSocketSystem(systemId string, agentVersion semver
 		configs := sm.GetProbeConfigsForSystem(systemId)
 		if len(configs) > 0 {
 			if err := system.SyncNetworkProbes(configs); err != nil {
-				sm.hub.Logger().Warn("failed to sync probes on connect", "system", systemId, "err", err)
+				sm.hub.Logger().Warn("failed to sync probes to agent", "system", systemId, "err", err)
 			}
 		}
 	}()
@@ -344,26 +344,11 @@ func (sm *SystemManager) resetFailedSmartFetchState(systemID string) {
 
 // GetProbeConfigsForSystem returns all enabled probe configs for a system.
 func (sm *SystemManager) GetProbeConfigsForSystem(systemID string) []probe.Config {
-	records, err := sm.hub.FindRecordsByFilter(
-		"network_probes",
-		"system = {:system} && enabled = true",
-		"",
-		0, 0,
-		dbx.Params{"system": systemID},
-	)
-	if err != nil || len(records) == 0 {
-		return nil
-	}
-
-	configs := make([]probe.Config, 0, len(records))
-	for _, r := range records {
-		configs = append(configs, probe.Config{
-			Target:   r.GetString("target"),
-			Protocol: r.GetString("protocol"),
-			Port:     uint16(r.GetInt("port")),
-			Interval: uint16(r.GetInt("interval")),
-		})
-	}
+	var configs []probe.Config
+	_ = sm.hub.DB().
+		NewQuery("SELECT id, target, protocol, port, interval FROM network_probes WHERE system = {:system} AND enabled = true").
+		Bind(dbx.Params{"system": systemID}).
+		All(&configs)
 	return configs
 }
 

internal/migrations/1776632983_updated_network_probes.go

@@ -1,62 +0,0 @@
-package migrations
-
-import (
-	"github.com/pocketbase/pocketbase/core"
-	m "github.com/pocketbase/pocketbase/migrations"
-)
-
-func init() {
-	m.Register(func(app core.App) error {
-		collection, err := app.FindCollectionByNameOrId("np_probes_001")
-		if err != nil {
-			return err
-		}
-
-		// add field
-		if err := collection.Fields.AddMarshaledJSONAt(7, []byte(`{
-			"hidden": false,
-			"id": "number926446584",
-			"max": null,
-			"min": null,
-			"name": "latency",
-			"onlyInt": false,
-			"presentable": false,
-			"required": false,
-			"system": false,
-			"type": "number"
-		}`)); err != nil {
-			return err
-		}
-
-		// add field
-		if err := collection.Fields.AddMarshaledJSONAt(8, []byte(`{
-			"hidden": false,
-			"id": "number3726709001",
-			"max": null,
-			"min": null,
-			"name": "loss",
-			"onlyInt": false,
-			"presentable": false,
-			"required": false,
-			"system": false,
-			"type": "number"
-		}`)); err != nil {
-			return err
-		}
-
-		return app.Save(collection)
-	}, func(app core.App) error {
-		collection, err := app.FindCollectionByNameOrId("np_probes_001")
-		if err != nil {
-			return err
-		}
-
-		// remove field
-		collection.Fields.RemoveById("number926446584")
-
-		// remove field
-		collection.Fields.RemoveById("number3726709001")
-
-		return app.Save(collection)
-	})
-}

internal/migrations/1_add_network_probes.go

@@ -1,245 +0,0 @@
-package migrations
-
-import (
-	"github.com/pocketbase/pocketbase/core"
-	m "github.com/pocketbase/pocketbase/migrations"
-)
-
-func init() {
-	m.Register(func(app core.App) error {
-		jsonData := `[
-	{
-		"id": "np_probes_001",
-		"listRule": null,
-		"viewRule": null,
-		"createRule": null,
-		"updateRule": null,
-		"deleteRule": null,
-		"name": "network_probes",
-		"type": "base",
-		"fields": [
-			{
-				"autogeneratePattern": "[a-z0-9]{15}",
-				"hidden": false,
-				"id": "text3208210256",
-				"max": 15,
-				"min": 15,
-				"name": "id",
-				"pattern": "^[a-z0-9]+$",
-				"presentable": false,
-				"primaryKey": true,
-				"required": true,
-				"system": true,
-				"type": "text"
-			},
-			{
-				"cascadeDelete": true,
-				"collectionId": "2hz5ncl8tizk5nx",
-				"hidden": false,
-				"id": "np_system",
-				"maxSelect": 1,
-				"minSelect": 0,
-				"name": "system",
-				"presentable": false,
-				"required": true,
-				"system": false,
-				"type": "relation"
-			},
-			{
-				"hidden": false,
-				"id": "np_name",
-				"max": 200,
-				"min": 0,
-				"name": "name",
-				"pattern": "",
-				"presentable": false,
-				"primaryKey": false,
-				"required": false,
-				"system": false,
-				"type": "text"
-			},
-			{
-				"hidden": false,
-				"id": "np_target",
-				"max": 500,
-				"min": 1,
-				"name": "target",
-				"pattern": "",
-				"presentable": false,
-				"primaryKey": false,
-				"required": true,
-				"system": false,
-				"type": "text"
-			},
-			{
-				"hidden": false,
-				"id": "np_protocol",
-				"maxSelect": 1,
-				"name": "protocol",
-				"presentable": false,
-				"required": true,
-				"system": false,
-				"type": "select",
-				"values": ["icmp", "tcp", "http"]
-			},
-			{
-				"hidden": false,
-				"id": "np_port",
-				"max": 65535,
-				"min": 0,
-				"name": "port",
-				"onlyInt": true,
-				"presentable": false,
-				"required": false,
-				"system": false,
-				"type": "number"
-			},
-			{
-				"hidden": false,
-				"id": "np_interval",
-				"max": 3600,
-				"min": 1,
-				"name": "interval",
-				"onlyInt": true,
-				"presentable": false,
-				"required": true,
-				"system": false,
-				"type": "number"
-			},
-			{
-				"hidden": false,
-				"id": "np_enabled",
-				"name": "enabled",
-				"presentable": false,
-				"required": false,
-				"system": false,
-				"type": "bool"
-			},
-			{
-				"hidden": false,
-				"id": "autodate2990389176",
-				"name": "created",
-				"onCreate": true,
-				"onUpdate": false,
-				"presentable": false,
-				"system": false,
-				"type": "autodate"
-			},
-			{
-				"hidden": false,
-				"id": "autodate3332085495",
-				"name": "updated",
-				"onCreate": true,
-				"onUpdate": true,
-				"presentable": false,
-				"system": false,
-				"type": "autodate"
-			}
-		],
-		"indexes": [
-			"CREATE INDEX ` + "`" + `idx_np_system_enabled` + "`" + ` ON ` + "`" + `network_probes` + "`" + ` (\n  ` + "`" + `system` + "`" + `,\n  ` + "`" + `enabled` + "`" + `\n)"
-		],
-		"system": false
-	},
-	{
-		"id": "np_stats_001",
-		"listRule": null,
-		"viewRule": null,
-		"createRule": null,
-		"updateRule": null,
-		"deleteRule": null,
-		"name": "network_probe_stats",
-		"type": "base",
-		"fields": [
-			{
-				"autogeneratePattern": "[a-z0-9]{15}",
-				"hidden": false,
-				"id": "text3208210256",
-				"max": 15,
-				"min": 15,
-				"name": "id",
-				"pattern": "^[a-z0-9]+$",
-				"presentable": false,
-				"primaryKey": true,
-				"required": true,
-				"system": true,
-				"type": "text"
-			},
-			{
-				"cascadeDelete": true,
-				"collectionId": "2hz5ncl8tizk5nx",
-				"hidden": false,
-				"id": "nps_system",
-				"maxSelect": 1,
-				"minSelect": 0,
-				"name": "system",
-				"presentable": false,
-				"required": true,
-				"system": false,
-				"type": "relation"
-			},
-			{
-				"hidden": false,
-				"id": "nps_stats",
-				"maxSize": 2000000,
-				"name": "stats",
-				"presentable": false,
-				"required": true,
-				"system": false,
-				"type": "json"
-			},
-			{
-				"hidden": false,
-				"id": "nps_type",
-				"maxSelect": 1,
-				"name": "type",
-				"presentable": false,
-				"required": true,
-				"system": false,
-				"type": "select",
-				"values": ["1m", "10m", "20m", "120m", "480m"]
-			},
-			{
-				"hidden": false,
-				"id": "autodate2990389176",
-				"name": "created",
-				"onCreate": true,
-				"onUpdate": false,
-				"presentable": false,
-				"system": false,
-				"type": "autodate"
-			},
-			{
-				"hidden": false,
-				"id": "autodate3332085495",
-				"name": "updated",
-				"onCreate": true,
-				"onUpdate": true,
-				"presentable": false,
-				"system": false,
-				"type": "autodate"
-			}
-		],
-		"indexes": [
-			"CREATE INDEX ` + "`" + `idx_nps_system_type_created` + "`" + ` ON ` + "`" + `network_probe_stats` + "`" + ` (\n  ` + "`" + `system` + "`" + `,\n  ` + "`" + `type` + "`" + `,\n  ` + "`" + `created` + "`" + `\n)"
-		],
-		"system": false
-	}
-]`
-
-		return app.ImportCollectionsByMarshaledJSON([]byte(jsonData), false)
-	}, func(app core.App) error {
-		// down: remove the network probe collections
-		if c, err := app.FindCollectionByNameOrId("network_probes"); err == nil {
-			if err := app.Delete(c); err != nil {
-				return err
-			}
-		}
-		if c, err := app.FindCollectionByNameOrId("network_probe_stats"); err == nil {
-			if err := app.Delete(c); err != nil {
-				return err
-			}
-		}
-		return nil
-	})
-}

internal/records/probe_averaging_test.go

@@ -0,0 +1,58 @@
+//go:build testing
+
+package records_test
+
+import (
+	"testing"
+
+	"github.com/henrygd/beszel/internal/records"
+	"github.com/henrygd/beszel/internal/tests"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestAverageProbeStats(t *testing.T) {
+	hub, err := tests.NewTestHub(t.TempDir())
+	require.NoError(t, err)
+	defer hub.Cleanup()
+
+	rm := records.NewRecordManager(hub)
+	user, err := tests.CreateUser(hub, "probe-avg@example.com", "testtesttest")
+	require.NoError(t, err)
+	system, err := tests.CreateRecord(hub, "systems", map[string]any{
+		"name":   "probe-avg-system",
+		"host":   "localhost",
+		"port":   "45876",
+		"status": "up",
+		"users":  []string{user.Id},
+	})
+	require.NoError(t, err)
+
+	recordA, err := tests.CreateRecord(hub, "network_probe_stats", map[string]any{
+		"system": system.Id,
+		"type":   "1m",
+		"stats":  `{"icmp:1.1.1.1":[10,80,8,14,1]}`,
+	})
+	require.NoError(t, err)
+	recordB, err := tests.CreateRecord(hub, "network_probe_stats", map[string]any{
+		"system": system.Id,
+		"type":   "1m",
+		"stats":  `{"icmp:1.1.1.1":[40,100,9,50,5]}`,
+	})
+	require.NoError(t, err)
+
+	result := rm.AverageProbeStats(hub.DB(), records.RecordIds{
+		{Id: recordA.Id},
+		{Id: recordB.Id},
+	})
+
+	stats, ok := result["icmp:1.1.1.1"]
+	require.True(t, ok)
+	require.Len(t, stats, 5)
+	assert.Equal(t, 25.0, stats[0])
+	assert.Equal(t, 90.0, stats[1])
+	assert.Equal(t, 8.0, stats[2])
+	assert.Equal(t, 50.0, stats[3])
+	assert.Equal(t, 3.0, stats[4])
+}

internal/records/records.go

@@ -507,11 +507,11 @@ func AverageContainerStatsSlice(records [][]container.Stats) []container.Stats {
 }
 
 // AverageProbeStats averages probe stats across multiple records.
-// For each probe key: avg of avgs, min of mins, max of maxes, avg of losses.
+// For each probe key: avg of average fields, min of mins, and max of maxes.
 func (rm *RecordManager) AverageProbeStats(db dbx.Builder, records RecordIds) map[string]probe.Result {
 	type probeValues struct {
-		sums  probe.Result
-		count float64
+		sums   probe.Result
+		counts []int
 	}
 
 	query := db.NewQuery("SELECT stats FROM network_probe_stats WHERE id = {:id}")
@@ -529,35 +529,52 @@ func (rm *RecordManager) AverageProbeStats(db dbx.Builder, records RecordIds) ma
 		for key, vals := range rawStats {
 			s, ok := sums[key]
 			if !ok {
-				s = &probeValues{sums: make(probe.Result, len(vals))}
+				s = &probeValues{sums: make(probe.Result, len(vals)), counts: make([]int, len(vals))}
 				sums[key] = s
 			}
+			if len(vals) > len(s.sums) {
+				expandedSums := make(probe.Result, len(vals))
+				copy(expandedSums, s.sums)
+				s.sums = expandedSums
+
+				expandedCounts := make([]int, len(vals))
+				copy(expandedCounts, s.counts)
+				s.counts = expandedCounts
+			}
 			for i := range vals {
 				switch i {
-				case 1: // min fields
-					if s.count == 0 || vals[i] < s.sums[i] {
+				case 2: // min fields
+					if s.counts[i] == 0 || vals[i] < s.sums[i] {
 						s.sums[i] = vals[i]
 					}
-				case 2: // max fields
-					if vals[i] > s.sums[i] {
+				case 3: // max fields
+					if s.counts[i] == 0 || vals[i] > s.sums[i] {
 						s.sums[i] = vals[i]
 					}
 				default: // average fields
 					s.sums[i] += vals[i]
 				}
+				s.counts[i]++
 			}
-			s.count++
 		}
 	}
 
 	// compute final averages
 	result := make(map[string]probe.Result, len(sums))
 	for key, s := range sums {
-		if s.count == 0 {
+		if len(s.counts) == 0 {
 			continue
 		}
-		s.sums[0] = twoDecimals(s.sums[0] / s.count) // avg latency
-		s.sums[3] = twoDecimals(s.sums[3] / s.count) // packet loss
+		for i := range s.sums {
+			switch i {
+			case 2, 3: // min and max fields should not be averaged
+				continue
+			default:
+				if s.counts[i] > 0 {
+					s.sums[i] = twoDecimals(s.sums[i] / float64(s.counts[i]))
+				}
+			}
+		}
 		result[key] = s.sums
 	}
 	return result

internal/site/src/components/network-probes-table/network-probes-columns.tsx

@@ -1,10 +1,9 @@
-import type { Column, ColumnDef } from "@tanstack/react-table"
+import type { CellContext, Column, ColumnDef } from "@tanstack/react-table"
 import { Button } from "@/components/ui/button"
 import { cn, decimalString, hourWithSeconds } from "@/lib/utils"
 import {
 	GlobeIcon,
 	TimerIcon,
-	ActivityIcon,
 	WifiOffIcon,
 	Trash2Icon,
 	ArrowLeftRightIcon,
@@ -12,6 +11,7 @@ import {
 	ServerIcon,
 	ClockIcon,
 	NetworkIcon,
+	RefreshCwIcon,
 } from "lucide-react"
 import { t } from "@lingui/core/macro"
 import type { NetworkProbeRecord } from "@/types"
@@ -61,7 +61,7 @@ export function getProbeColumns(longestName = 0, longestTarget = 0): ColumnDef<N
 			header: ({ column }) => <HeaderButton column={column} name={t`System`} Icon={ServerIcon} />,
 			cell: ({ getValue }) => {
 				const allSystems = useStore($allSystemsById)
-				return <span className="ms-1.5 xl:w-34 block truncate">{allSystems[getValue() as string]?.name ?? ""}</span>
+				return <span className="ms-1.5 xl:w-20 block truncate">{allSystems[getValue() as string]?.name ?? ""}</span>
 			},
 		},
 		{
@@ -91,52 +91,55 @@ export function getProbeColumns(longestName = 0, longestTarget = 0): ColumnDef<N
 		{
 			id: "interval",
 			accessorFn: (record) => record.interval,
-			header: ({ column }) => <HeaderButton column={column} name={t`Interval`} Icon={TimerIcon} />,
+			header: ({ column }) => <HeaderButton column={column} name={t`Interval`} Icon={RefreshCwIcon} />,
 			cell: ({ getValue }) => <span className="ms-1.5 tabular-nums">{getValue() as number}s</span>,
 		},
 		{
-			id: "latency",
-			accessorFn: (record) => record.latency,
+			id: "res",
+			accessorFn: (record) => record.res,
 			invertSorting: true,
-			header: ({ column }) => <HeaderButton column={column} name={t`Latency`} Icon={ActivityIcon} />,
-			cell: ({ row }) => {
-				const val = row.original.latency
-				if (!val) {
-					return <span className="ms-1.5 text-muted-foreground">-</span>
-				}
-				let color = "bg-green-500"
-				if (val > 200) {
-					color = "bg-yellow-500"
-				}
-				if (val > 2000) {
-					color = "bg-red-500"
-				}
-				return (
-					<span className="ms-1.5 tabular-nums flex gap-2 items-center">
-						<span className={cn("shrink-0 size-2 rounded-full", color)} />
-						{decimalString(val, val < 100 ? 2 : 1).toLocaleString()} ms
-					</span>
-				)
-			},
+			header: ({ column }) => <HeaderButton column={column} name={t`Response`} Icon={TimerIcon} />,
+			cell: responseTimeCell,
+		},
+		{
+			id: "res1h",
+			accessorFn: (record) => record.resAvg1h,
+			invertSorting: true,
+			header: ({ column }) => <HeaderButton column={column} name={t`Avg 1h`} Icon={TimerIcon} />,
+			cell: responseTimeCell,
+		},
+		{
+			id: "max1h",
+			accessorFn: (record) => record.resMax1h,
+			invertSorting: true,
+			header: ({ column }) => <HeaderButton column={column} name={t`Max 1h`} Icon={TimerIcon} />,
+			cell: responseTimeCell,
+		},
+		{
+			id: "min1h",
+			accessorFn: (record) => record.resMin1h,
+			invertSorting: true,
+			header: ({ column }) => <HeaderButton column={column} name={t`Min 1h`} Icon={TimerIcon} />,
+			cell: responseTimeCell,
 		},
 		{
 			id: "loss",
-			accessorFn: (record) => record.loss,
+			accessorFn: (record) => record.loss1h,
 			invertSorting: true,
-			header: ({ column }) => <HeaderButton column={column} name={t`Loss`} Icon={WifiOffIcon} />,
+			header: ({ column }) => <HeaderButton column={column} name={t`Loss 1h`} Icon={WifiOffIcon} />,
 			cell: ({ row }) => {
-				const { loss, latency } = row.original
-				if (loss === undefined || (!latency && !loss)) {
+				const { loss1h, res } = row.original
+				if (loss1h === undefined || (!res && !loss1h)) {
 					return <span className="ms-1.5 text-muted-foreground">-</span>
 				}
 				let color = "bg-green-500"
-				if (loss) {
-					color = loss > 20 ? "bg-red-500" : "bg-yellow-500"
+				if (loss1h) {
+					color = loss1h > 20 ? "bg-red-500" : "bg-yellow-500"
 				}
 				return (
 					<span className="ms-1.5 tabular-nums flex gap-2 items-center">
 						<span className={cn("shrink-0 size-2 rounded-full", color)} />
-						{loss}%
+						{loss1h}%
 					</span>
 				)
 			},
@@ -188,6 +191,25 @@ export function getProbeColumns(longestName = 0, longestTarget = 0): ColumnDef<N
 		},
 	]
 }
+function responseTimeCell(cell: CellContext<NetworkProbeRecord, unknown>) {
+	const val = cell.getValue() as number | undefined
+	if (!val) {
+		return <span className="ms-1.5 text-muted-foreground">-</span>
+	}
+	let color = "bg-green-500"
+	if (val > 200) {
+		color = "bg-yellow-500"
+	}
+	if (val > 2000) {
+		color = "bg-red-500"
+	}
+	return (
+		<span className="ms-1.5 tabular-nums flex gap-2 items-center">
+			<span className={cn("shrink-0 size-2 rounded-full", color)} />
+			{decimalString(val, val < 100 ? 2 : 1).toLocaleString()}ms
+		</span>
+	)
+}
 
 function HeaderButton({
 	column,
@@ -210,7 +232,6 @@ function HeaderButton({
 		>
 			{Icon && <Icon className="size-4" />}
 			{name}
-			{/* <ArrowUpDownIcon className="size-4" /> */}
 		</Button>
 	)
 }

internal/site/src/components/network-probes-table/network-probes-table.tsx

@@ -102,7 +102,7 @@ export default function NetworkProbesTableNew({
 							<Trans>Network Probes</Trans>
 						</CardTitle>
 						<div className="text-sm text-muted-foreground flex items-center flex-wrap">
-							<Trans>ICMP/TCP/HTTP latency monitoring from agents</Trans>
+							<Trans>Response time monitoring from agents.</Trans>
 						</div>
 					</div>
 					<div className="md:ms-auto flex items-center gap-2">

internal/site/src/components/network-probes-table/probe-dialog.tsx

@@ -18,6 +18,17 @@ import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@
 import { PlusIcon } from "lucide-react"
 import { useToast } from "@/components/ui/use-toast"
 import { $systems } from "@/lib/stores"
+import * as v from "valibot"
+
+const Schema = v.object({
+	system: v.string(),
+	target: v.string(),
+	protocol: v.picklist(["icmp", "tcp", "http"]),
+	port: v.number(),
+	interval: v.pipe(v.string(), v.toNumber(), v.minValue(1), v.maxValue(3600)),
+	enabled: v.boolean(),
+	name: v.optional(v.string()),
+})
 
 export function AddProbeDialog({ systemId }: { systemId?: string }) {
 	const [open, setOpen] = useState(false)
@@ -45,16 +56,20 @@ export function AddProbeDialog({ systemId }: { systemId?: string }) {
 	const handleSubmit = async (e: React.FormEvent) => {
 		e.preventDefault()
 		setLoading(true)
+
 		try {
-			await pb.collection("network_probes").create({
+			const payload = v.parse(Schema, {
 				system: systemId ?? selectedSystemId,
-				name: name || targetName,
 				target,
 				protocol,
 				port: protocol === "tcp" ? Number(port) : 0,
-				interval: Number(probeInterval),
+				interval: probeInterval,
 				enabled: true,
 			})
+			if (name && name !== target) {
+				payload.name = name
+			}
+			await pb.collection("network_probes").create(payload)
 			resetForm()
 			setOpen(false)
 		} catch (err: unknown) {
@@ -78,7 +93,7 @@ export function AddProbeDialog({ systemId }: { systemId?: string }) {
 						<Trans>Add {{ foo: t`Network Probe` }}</Trans>
 					</DialogTitle>
 					<DialogDescription>
-						<Trans>Configure latency monitoring from this agent.</Trans>
+						<Trans>Configure response monitoring from this agent.</Trans>
 					</DialogDescription>
 				</DialogHeader>
 				<form onSubmit={handleSubmit} className="grid gap-4 tabular-nums">
@@ -116,6 +131,7 @@ export function AddProbeDialog({ systemId }: { systemId?: string }) {
 						<Label>
 							<Trans>Protocol</Trans>
 						</Label>
+
 						<Select value={protocol} onValueChange={setProtocol}>
 							<SelectTrigger>
 								<SelectValue />

internal/site/src/components/routes/system/charts/probes-charts.tsx

@@ -7,7 +7,6 @@ import type { ChartData, NetworkProbeRecord, NetworkProbeStatsRecord } from "@/t
 import { useMemo } from "react"
 import { atom } from "nanostores"
 import { useStore } from "@nanostores/react"
-import { probeKey } from "@/lib/use-network-probes"
 
 const $filter = atom("")
 
@@ -44,10 +43,10 @@ function ProbeChart({
 	const filter = useStore($filter)
 
 	const { dataPoints, visibleKeys } = useMemo(() => {
-		const sortedProbes = [...probes].sort((a, b) => b.latency - a.latency)
+		const sortedProbes = [...probes].sort((a, b) => b.resAvg1h - a.resAvg1h)
 		const count = sortedProbes.length
 		const points: DataPoint<NetworkProbeStatsRecord>[] = []
-		const visibleKeys: string[] = []
+		const visibleIDs: string[] = []
 		const filterTerms = filter
 			? filter
 					.toLowerCase()
@@ -56,25 +55,25 @@ function ProbeChart({
 			: []
 		for (let i = 0; i < count; i++) {
 			const p = sortedProbes[i]
-			const key = probeKey(p)
-			const filtered = filterTerms.length > 0 && !filterTerms.some((term) => key.toLowerCase().includes(term))
+			const label = p.name || p.target
+			const filtered = filterTerms.length > 0 && !filterTerms.some((term) => label.toLowerCase().includes(term))
 			if (filtered) {
 				continue
 			}
-			visibleKeys.push(key)
+			visibleIDs.push(p.id)
 			points.push({
 				order: i,
-				label: p.name || p.target,
-				dataKey: (record: NetworkProbeStatsRecord) => record.stats?.[key]?.[valueIndex] ?? "-",
+				label,
+				dataKey: (record: NetworkProbeStatsRecord) => record.stats?.[p.id]?.[valueIndex] ?? "-",
 				color: count <= 5 ? i + 1 : `hsl(${(i * 360) / count}, var(--chart-saturation), var(--chart-lightness))`,
 			})
 		}
-		return { dataPoints: points, visibleKeys }
+		return { dataPoints: points, visibleKeys: visibleIDs }
 	}, [probes, filter, valueIndex])
 
 	const filteredProbeStats = useMemo(() => {
 		if (!visibleKeys.length) return probeStats
-		return probeStats.filter((record) => visibleKeys.some((key) => record.stats?.[key] != null))
+		return probeStats.filter((record) => visibleKeys.some((id) => record.stats?.[id] != null))
 	}, [probeStats, visibleKeys])
 
 	const legend = dataPoints.length < 10
@@ -103,7 +102,7 @@ function ProbeChart({
 	)
 }
 
-export function LatencyChart({ probeStats, grid, probes, chartData, empty }: ProbeChartProps) {
+export function ResponseChart({ probeStats, grid, probes, chartData, empty }: ProbeChartProps) {
 	const { t } = useLingui()
 
 	return (
@@ -114,8 +113,8 @@ export function LatencyChart({ probeStats, grid, probes, chartData, empty }: Pro
 			chartData={chartData}
 			empty={empty}
 			valueIndex={0}
-			title={t`Latency`}
-			description={t`Average round-trip time (ms)`}
+			title={t`Response`}
+			description={t`Average response time (ms)`}
 			tickFormatter={(value) => `${toFixedFloat(value, value >= 10 ? 0 : 1)} ms`}
 			contentFormatter={({ value }) => {
 				if (typeof value !== "number") {
@@ -137,7 +136,7 @@ export function LossChart({ probeStats, grid, probes, chartData, empty }: ProbeC
 			probes={probes}
 			chartData={chartData}
 			empty={empty}
-			valueIndex={3}
+			valueIndex={4}
 			title={t`Loss`}
 			description={t`Packet loss (%)`}
 			domain={[0, 100]}

internal/site/src/components/routes/system/lazy-tables.tsx

@@ -1,7 +1,7 @@
 import { lazy } from "react"
 import { useIntersectionObserver } from "@/lib/use-intersection-observer"
 import { cn } from "@/lib/utils"
-import { LatencyChart, LossChart } from "./charts/probes-charts"
+import { ResponseChart, LossChart } from "./charts/probes-charts"
 import type { SystemData } from "./use-system-data"
 import { $chartTime } from "@/lib/stores"
 import { useStore } from "@nanostores/react"
@@ -63,7 +63,7 @@ function ProbesTable({ systemId, systemData }: { systemId: string; systemData: S
 			<NetworkProbesTable systemId={systemId} probes={probes} />
 			{!!chartData && !!probes.length && (
 				<div className="grid xl:grid-cols-2 gap-4">
-					<LatencyChart
+					<ResponseChart
 						probeStats={probeStats}
 						grid={grid}
 						probes={probes}

internal/site/src/lib/use-network-probes.ts

@@ -31,7 +31,8 @@ function appendCacheValue(
 	}
 }
 
-const NETWORK_PROBE_FIELDS = "id,name,system,target,protocol,port,interval,latency,loss,enabled,updated"
+const NETWORK_PROBE_FIELDS =
+	"id,name,system,target,protocol,port,interval,res,resMin1h,resMax1h,resAvg1h,loss1h,enabled,updated"
 
 interface UseNetworkProbesProps {
 	systemId?: string
@@ -244,16 +245,10 @@ export function useNetworkProbesData(props: UseNetworkProbesProps) {
 	}
 }
 
-export function probeKey(p: NetworkProbeRecord) {
-	if (p.protocol === "tcp") return `${p.protocol}:${p.target}:${p.port}`
-	return `${p.protocol}:${p.target}`
-}
-
 function probesToStats(probes: NetworkProbeRecord[]): NetworkProbeStatsRecord["stats"] {
 	const stats: NetworkProbeStatsRecord["stats"] = {}
 	for (const probe of probes) {
-		const key = probeKey(probe)
-		stats[key] = [probe.latency, 0, 0, probe.loss]
+		stats[probe.id] = [probe.res, probe.resAvg1h, probe.resMin1h, probe.resMax1h, probe.loss1h]
 	}
 	return stats
 }

internal/site/src/types.d.ts

@@ -552,21 +552,26 @@ export interface NetworkProbeRecord {
 	target: string
 	protocol: "icmp" | "tcp" | "http"
 	port: number
-	latency: number
-	loss: number
+	res: number
+	resMin1h: number
+	resMax1h: number
+	resAvg1h: number
+	loss1h: number
 	interval: number
 	enabled: boolean
 	updated: string
 }
 
 /**
- * 0: avg latency in ms
+ * 0: avg 1 minute response in ms
  *
- * 1: min latency in ms
+ * 1: avg response over 1 hour in ms
  *
- * 2: max latency in ms
+ * 2: min response over the last hour in ms
  *
- * 3: packet loss in %
+ * 3: max response over the last hour in ms
+ *
+ * 4: packet loss in %
  */
 type ProbeResult = number[]