Repair live server operations console

platform/api/resource_handlers_test.go

@@ -170,7 +170,7 @@ func TestMetricsAndConfigReadAPIAreSafeAndRoleScoped(t *testing.T) {
 	assertErrorResponse(t, requestWithAuth(t, router, http.MethodGet, "/api/v1/metrics/platform", "", ownerSession), http.StatusForbidden, errorCodeForbidden)
 
 	ownerMetrics := getJSONWithAuth[dto.ServerMetricsListResponse](t, router, "/api/v1/metrics/server-instances", ownerSession)
-	if ownerMetrics.Count != 1 || ownerMetrics.Items[0].ServerInstanceID != instance.ID || !ownerMetrics.Items[0].Online {
+	if ownerMetrics.Count != 1 || ownerMetrics.Items[0].ServerInstanceID != instance.ID || !ownerMetrics.Items[0].Online || ownerMetrics.Items[0].CPUPercent != nil || ownerMetrics.Items[0].Source != "run-metrics-pending" {
 		t.Fatalf("unexpected owner metrics: %+v", ownerMetrics)
 	}
 	otherMetrics := getJSONWithAuth[dto.ServerMetricsListResponse](t, router, "/api/v1/metrics/server-instances", otherSession)

platform/service/resources.go

@@ -1805,7 +1805,7 @@ func (svc *CoreService) ListServerMetricsForSession(sessionID string) ([]domain.
 	}
 	items := make([]domain.ServerMetrics, 0, len(instances))
 	for _, instance := range instances {
-		items = append(items, svc.metricsForServer(instance))
+		items = append(items, svc.latestMetricsForServer(instance))
 	}
 	if err := validator.ValidateServerMetricsList(items); err != nil {
 		return nil, err
@@ -2026,32 +2026,43 @@ func (svc *CoreService) runtimeProfileScope(serverInstanceID string) string {
 	return binding.ProfileKey
 }
 
-func (svc *CoreService) metricsForServer(instance domain.ServerInstance) domain.ServerMetrics {
-	metrics := domain.ServerMetrics{
+func (svc *CoreService) latestMetricsForServer(instance domain.ServerInstance) domain.ServerMetrics {
+	samples, err := svc.store.MetricSamples().List(domain.MetricSampleFilter{ServerInstanceID: instance.ID})
+	if err == nil {
+		var latest domain.MetricSample
+		found := false
+		for i := range samples {
+			sample := samples[i]
+			if sample.RunEndpointID != "" && sample.RunEndpointID != instance.RunEndpointID {
+				continue
+			}
+			if !found || sample.CollectedAt.After(latest.CollectedAt) {
+				latest = sample
+				found = true
+			}
+		}
+		if found {
+			return domain.ServerMetrics{
+				ServerInstanceID: latest.ServerInstanceID,
+				Online:           latest.Online,
+				PlayerCount:      latest.PlayerCount,
+				MaxPlayers:       latest.MaxPlayers,
+				TPS:              latest.TPS,
+				LatencyMS:        latest.LatencyMS,
+				CPUPercent:       latest.CPUPercent,
+				MemoryPercent:    latest.MemoryPercent,
+				DiskPercent:      latest.DiskPercent,
+				Source:           latest.Source,
+				CollectedAt:      latest.CollectedAt,
+			}
+		}
+	}
+	return domain.ServerMetrics{
 		ServerInstanceID: instance.ID,
 		Online:           instance.State == domain.ServerInstanceStateRunning,
-		Source:           "platform-derived",
+		Source:           "run-metrics-pending",
 		CollectedAt:      svc.now(),
 	}
-	if !metrics.Online {
-		return metrics
-	}
-	seed := len(instance.ID) + len(instance.Name) + instance.ConfigVersion
-	playerCount := seed % 20
-	maxPlayers := 20
-	tps := 18.5 + float64(seed%15)/10
-	latency := 35.0 + float64(seed%40)
-	cpu := clampPercent(25 + float64(seed%45))
-	memory := clampPercent(30 + float64(seed%50))
-	disk := clampPercent(20 + float64(seed%60))
-	metrics.PlayerCount = &playerCount
-	metrics.MaxPlayers = &maxPlayers
-	metrics.TPS = &tps
-	metrics.LatencyMS = &latency
-	metrics.CPUPercent = &cpu
-	metrics.MemoryPercent = &memory
-	metrics.DiskPercent = &disk
-	return metrics
 }
 
 func buildLogicalServerConfig(instance domain.ServerInstance) string {

platform/service/resources_test.go

@@ -557,8 +557,36 @@ func TestCoreServiceMetricsAndConfigReadAreRoleScoped(t *testing.T) {
 	if err != nil {
 		t.Fatalf("list owner metrics: %v", err)
 	}
-	if len(ownerMetrics) != 1 || ownerMetrics[0].ServerInstanceID != instance.ID || !ownerMetrics[0].Online || ownerMetrics[0].CPUPercent == nil {
-		t.Fatalf("unexpected owner metrics: %+v", ownerMetrics)
+	if len(ownerMetrics) != 1 || ownerMetrics[0].ServerInstanceID != instance.ID || !ownerMetrics[0].Online || ownerMetrics[0].CPUPercent != nil || ownerMetrics[0].Source != "run-metrics-pending" {
+		t.Fatalf("expected pending metrics without fabricated resource values, got %+v", ownerMetrics)
+	}
+
+	runHello := validRunControlHello()
+	runHello.RunEndpointID = endpoint.ID
+	registered, err := svc.RegisterRunHello(runHello)
+	if err != nil {
+		t.Fatalf("register run: %v", err)
+	}
+	oldCPU := 28.0
+	latestCPU := 64.0
+	latestMemory := 52.0
+	latestDisk := 31.0
+	players := 11
+	maxPlayers := 40
+	tps := 19.7
+	latency := 48.0
+	if _, err := svc.IngestMetricBatch(domain.MetricBatchIngest{RunEndpointID: endpoint.ID, SessionToken: registered.SessionToken, Samples: []domain.MetricSample{
+		{ServerInstanceID: instance.ID, Online: true, CPUPercent: &oldCPU, Source: "run", CollectedAt: fixedTime.Add(-time.Minute)},
+		{ServerInstanceID: instance.ID, Online: true, PlayerCount: &players, MaxPlayers: &maxPlayers, TPS: &tps, LatencyMS: &latency, CPUPercent: &latestCPU, MemoryPercent: &latestMemory, DiskPercent: &latestDisk, Source: "run", CollectedAt: fixedTime.Add(time.Minute)},
+	}}); err != nil {
+		t.Fatalf("ingest metrics: %v", err)
+	}
+	ownerMetrics, err = svc.ListServerMetricsForSession(ownerSession)
+	if err != nil {
+		t.Fatalf("list owner metrics after ingest: %v", err)
+	}
+	if len(ownerMetrics) != 1 || ownerMetrics[0].CPUPercent == nil || *ownerMetrics[0].CPUPercent != latestCPU || ownerMetrics[0].PlayerCount == nil || *ownerMetrics[0].PlayerCount != players || ownerMetrics[0].CollectedAt != fixedTime.Add(time.Minute) {
+		t.Fatalf("expected latest persisted sample metrics, got %+v", ownerMetrics)
 	}
 	otherMetrics, err := svc.ListServerMetricsForSession(otherSession)
 	if err != nil {