feat: implement query point budget and downsampling for server data points

Co-authored-by: Copilot <copilot@github.com>

Author: byPixelTV

data/query.go

@@ -405,3 +405,28 @@ func BuildInfluxQueryFromParams(params QueryParams) (string, int, string, error)
 
 	return query, dataPoints, step, nil
 }
+
+// QueryPointBudget returns the query point budget for a given time range.
+// Longer ranges use a smaller budget so the graph stays readable instead of
+// over-representing the most recent, dense portion of the series.
+func QueryPointBudget(start string) (maxDataPoints, minDataPoints int) {
+	rangeInMinutes, err := timeToMinutes(start)
+	if err != nil {
+		return 500, 10
+	}
+
+	rangeInMinutes = math.Abs(rangeInMinutes)
+
+	switch {
+	case rangeInMinutes >= 525600:
+		return 120, 10
+	case rangeInMinutes >= 43200:
+		return 240, 10
+	case rangeInMinutes >= 10080:
+		return 180, 10
+	case rangeInMinutes >= 1440:
+		return 240, 10
+	default:
+		return 500, 10
+	}
+}

data/servers.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"math"
 	"os"
 	"sort"
 )
@@ -60,12 +61,17 @@ func LoadServers(path string) ([]PingableServer, error) {
 
 func QueryDataPoints(ip string, duration string) ([]ServerDataPoint, string, error) {
 	queryApi := database.InfluxClient.QueryAPI(os.Getenv("INFLUXDB_ORG"))
+	renderMaxDataPoints, minDataPoints := QueryPointBudget(duration)
+	queryMaxDataPoints := renderMaxDataPoints
+	if durationLongerThanADay(duration) {
+		queryMaxDataPoints = renderMaxDataPoints * 4
+	}
 
 	query, _, step, err := BuildInfluxQueryFromParams(QueryParams{
 		Start:         duration,
 		ServerFilter:  ip,
-		MaxDataPoints: 500,
-		MinDataPoints: 10,
+		MaxDataPoints: queryMaxDataPoints,
+		MinDataPoints: minDataPoints,
 		UseAdaptive:   false,
 	})
 
@@ -115,7 +121,19 @@ func QueryDataPoints(ip string, duration string) ([]ServerDataPoint, string, err
 		return nil, "0m", err
 	}
 
-	return mergeServerDataPoints(dataPoints, extremes), step, nil
+	points := mergeServerDataPoints(dataPoints, extremes)
+	points = downsampleServerDataPoints(points, renderMaxDataPoints)
+
+	return points, step, nil
+}
+
+func durationLongerThanADay(duration string) bool {
+	rangeInMinutes, err := timeToMinutes(duration)
+	if err != nil {
+		return false
+	}
+
+	return math.Abs(rangeInMinutes) >= 1440
 }
 
 func queryExtremeDataPoints(ip string, duration string) ([]ServerDataPoint, error) {
@@ -240,6 +258,99 @@ func mergeServerDataPoints(base []ServerDataPoint, extras []ServerDataPoint) []S
 	return merged
 }
 
+func downsampleServerDataPoints(points []ServerDataPoint, maxPoints int) []ServerDataPoint {
+	if maxPoints <= 0 || len(points) <= maxPoints {
+		return points
+	}
+
+	sort.Slice(points, func(i, j int) bool {
+		if points[i].Timestamp != points[j].Timestamp {
+			return points[i].Timestamp < points[j].Timestamp
+		}
+		if points[i].PlayerCount != points[j].PlayerCount {
+			return points[i].PlayerCount < points[j].PlayerCount
+		}
+		if points[i].Ip != points[j].Ip {
+			return points[i].Ip < points[j].Ip
+		}
+		return points[i].Name < points[j].Name
+	})
+
+	bucketCount := maxPoints / 4
+	if bucketCount < 1 {
+		bucketCount = 1
+	}
+
+	target := make([]ServerDataPoint, 0, maxPoints)
+	seen := make(map[string]struct{}, maxPoints)
+	bucketSize := float64(len(points)) / float64(bucketCount)
+
+	appendPoint := func(point ServerDataPoint) {
+		key := fmt.Sprintf("%d|%d|%s|%s", point.Timestamp, point.PlayerCount, point.Ip, point.Name)
+		if _, ok := seen[key]; ok {
+			return
+		}
+		seen[key] = struct{}{}
+		target = append(target, point)
+	}
+
+	for bucket := 0; bucket < bucketCount; bucket++ {
+		start := int(math.Floor(float64(bucket) * bucketSize))
+		end := int(math.Floor(float64(bucket+1) * bucketSize))
+		if bucket == bucketCount-1 {
+			end = len(points)
+		}
+		if start < 0 {
+			start = 0
+		}
+		if end > len(points) {
+			end = len(points)
+		}
+		if start >= end {
+			continue
+		}
+
+		bucketPoints := points[start:end]
+		first := bucketPoints[0]
+		last := bucketPoints[len(bucketPoints)-1]
+		minPoint := first
+		maxPoint := first
+
+		for _, point := range bucketPoints[1:] {
+			if point.PlayerCount < minPoint.PlayerCount || (point.PlayerCount == minPoint.PlayerCount && point.Timestamp < minPoint.Timestamp) {
+				minPoint = point
+			}
+			if point.PlayerCount > maxPoint.PlayerCount || (point.PlayerCount == maxPoint.PlayerCount && point.Timestamp < maxPoint.Timestamp) {
+				maxPoint = point
+			}
+		}
+
+		bucketSelection := []ServerDataPoint{first, minPoint, maxPoint, last}
+		for _, point := range bucketSelection {
+			appendPoint(point)
+		}
+	}
+
+	sort.Slice(target, func(i, j int) bool {
+		if target[i].Timestamp != target[j].Timestamp {
+			return target[i].Timestamp < target[j].Timestamp
+		}
+		if target[i].PlayerCount != target[j].PlayerCount {
+			return target[i].PlayerCount < target[j].PlayerCount
+		}
+		if target[i].Ip != target[j].Ip {
+			return target[i].Ip < target[j].Ip
+		}
+		return target[i].Name < target[j].Name
+	})
+
+	if len(target) > maxPoints {
+		return target[:maxPoints]
+	}
+
+	return target
+}
+
 func recordValueToInt(value interface{}) (int, bool) {
 	switch v := value.(type) {
 	case int:

data/servers_test.go

@@ -36,3 +36,64 @@ func TestMergeServerDataPointsKeepsExtremesAndOrder(t *testing.T) {
 		}
 	}
 }
+
+func TestQueryPointBudgetScalesWithRange(t *testing.T) {
+	tests := []struct {
+		name    string
+		start   string
+		wantMax int
+		wantMin int
+	}{
+		{name: "year", start: "-1y", wantMax: 120, wantMin: 10},
+		{name: "month", start: "-1M", wantMax: 240, wantMin: 10},
+		{name: "week", start: "-7d", wantMax: 180, wantMin: 10},
+		{name: "short", start: "-6h", wantMax: 500, wantMin: 10},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotMax, gotMin := QueryPointBudget(tt.start)
+			if gotMax != tt.wantMax || gotMin != tt.wantMin {
+				t.Fatalf("QueryPointBudget(%q) = (%d, %d), want (%d, %d)", tt.start, gotMax, gotMin, tt.wantMax, tt.wantMin)
+			}
+		})
+	}
+}
+
+func TestDownsampleServerDataPointsPreservesExtremesAndBudget(t *testing.T) {
+	points := []ServerDataPoint{
+		{Timestamp: 1, PlayerCount: 10, Ip: "1.2.3.4", Name: "srv"},
+		{Timestamp: 2, PlayerCount: 4, Ip: "1.2.3.4", Name: "srv"},
+		{Timestamp: 3, PlayerCount: 9, Ip: "1.2.3.4", Name: "srv"},
+		{Timestamp: 4, PlayerCount: 18, Ip: "1.2.3.4", Name: "srv"},
+		{Timestamp: 5, PlayerCount: 7, Ip: "1.2.3.4", Name: "srv"},
+		{Timestamp: 6, PlayerCount: 15, Ip: "1.2.3.4", Name: "srv"},
+		{Timestamp: 7, PlayerCount: 2, Ip: "1.2.3.4", Name: "srv"},
+		{Timestamp: 8, PlayerCount: 11, Ip: "1.2.3.4", Name: "srv"},
+	}
+
+	downsampled := downsampleServerDataPoints(points, 4)
+	if len(downsampled) > 4 {
+		t.Fatalf("expected at most 4 points, got %d", len(downsampled))
+	}
+
+	wants := map[int64]int{
+		1: 10,
+		4: 18,
+		7: 2,
+		8: 11,
+	}
+
+	for _, point := range downsampled {
+		if expected, ok := wants[point.Timestamp]; ok {
+			if point.PlayerCount != expected {
+				t.Fatalf("timestamp %d has player_count %d, want %d", point.Timestamp, point.PlayerCount, expected)
+			}
+			delete(wants, point.Timestamp)
+		}
+	}
+
+	if len(wants) != 0 {
+		t.Fatalf("missing expected anchor points: %#v", wants)
+	}
+}