Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

Preserve numeric counter precision in dashboard deltas

pulse-triage[bot]666912d73229
diff --git a/internal/websocket/state_delta.go b/internal/websocket/state_delta.go
index f9c073fb15..592f7cb529 100644
--- a/internal/websocket/state_delta.go
+++ b/internal/websocket/state_delta.go
@@ -4,6 +4,7 @@ import (
"bytes"
"encoding/json"
"fmt"
+ "io"
"reflect"
"sort"
@@ -300,12 +301,12 @@ func buildClientStateDelta(previous, current *clientStateSnapshot) (map[string]i
}
func createJSONMergePatch(previous, current json.RawMessage) (json.RawMessage, error) {
- var previousValue interface{}
- if err := json.Unmarshal(previous, &previousValue); err != nil {
+ previousValue, err := decodeJSONMergeValue(previous)
+ if err != nil {
return nil, err
}
- var currentValue interface{}
- if err := json.Unmarshal(current, &currentValue); err != nil {
+ currentValue, err := decodeJSONMergeValue(current)
+ if err != nil {
return nil, err
}
@@ -327,6 +328,29 @@ func createJSONMergePatch(previous, current json.RawMessage) (json.RawMessage, e
return patch, nil
}
+// A delta must preserve the authoritative encoded counters, not round them
+// through float64. Otherwise adjacent int64/uint64 readings above 2^53 can
+// compare equal, and a changed nested value/array can be sent with altered
+// numbers. Keep number tokens exact while retaining the existing merge rules.
+func decodeJSONMergeValue(encoded json.RawMessage) (interface{}, error) {
+ decoder := json.NewDecoder(bytes.NewReader(encoded))
+ decoder.UseNumber()
+ var value interface{}
+ if err := decoder.Decode(&value); err != nil {
+ return nil, err
+ }
+ // Decode accepts a stream by default. Preserve Unmarshal's one-value
+ // contract, including rejection of a valid prefix followed by more JSON.
+ var trailing interface{}
+ if err := decoder.Decode(&trailing); err != io.EOF {
+ if err == nil {
+ err = fmt.Errorf("multiple JSON merge values")
+ }
+ return nil, err
+ }
+ return value, nil
+}
+
func diffJSONMergeValue(previous, current interface{}) (interface{}, bool) {
if reflect.DeepEqual(previous, current) {
return nil, false
diff --git a/internal/websocket/state_delta_numbers_bench_test.go b/internal/websocket/state_delta_numbers_bench_test.go
new file mode 100644
index 0000000000..9d008da074
--- /dev/null
+++ b/internal/websocket/state_delta_numbers_bench_test.go
@@ -0,0 +1,104 @@
+package websocket
+
+import (
+ "encoding/json"
+ "fmt"
+ "reflect"
+ "testing"
+)
+
+// Exact pre-repair helper from assigned 0a99cb5a, kept independent for paired
+// same-executable cost comparisons. These are synthetic patch costs, not
+// installed CPU, transport/compression or native-fleet acceptance.
+func parentNumberMergePatch(previous, current json.RawMessage) (json.RawMessage, error) {
+ var previousValue interface{}
+ if err := json.Unmarshal(previous, &previousValue); err != nil {
+ return nil, err
+ }
+ var currentValue interface{}
+ if err := json.Unmarshal(current, &currentValue); err != nil {
+ return nil, err
+ }
+
+ patchValue, changed := parentNumberMergeValue(previousValue, currentValue)
+ if !changed {
+ return json.RawMessage(`{}`), nil
+ }
+ if patchObject, ok := patchValue.(map[string]interface{}); ok {
+ if currentObject, ok := currentValue.(map[string]interface{}); ok {
+ if id, ok := currentObject["id"]; ok {
+ patchObject["id"] = id
+ }
+ }
+ }
+ patch, err := json.Marshal(patchValue)
+ if err != nil {
+ return nil, err
+ }
+ return patch, nil
+}
+
+func parentNumberMergeValue(previous, current interface{}) (interface{}, bool) {
+ if reflect.DeepEqual(previous, current) {
+ return nil, false
+ }
+
+ previousObject, previousIsObject := previous.(map[string]interface{})
+ currentObject, currentIsObject := current.(map[string]interface{})
+ if !previousIsObject || !currentIsObject {
+ return current, true
+ }
+
+ patch := make(map[string]interface{})
+ for key := range previousObject {
+ if _, exists := currentObject[key]; !exists {
+ patch[key] = nil
+ }
+ }
+ for key, currentValue := range currentObject {
+ previousValue, exists := previousObject[key]
+ if !exists {
+ patch[key] = currentValue
+ continue
+ }
+ if nestedPatch, changed := parentNumberMergeValue(previousValue, currentValue); changed {
+ patch[key] = nestedPatch
+ }
+ }
+ return patch, len(patch) > 0
+}
+
+func BenchmarkJSONMergeNumberFidelity(b *testing.B) {
+ for _, metadataKeys := range []int{0, 32} {
+ previous := map[string]interface{}{"id": "r", "cpu": map[string]interface{}{"current": 10}, "lastSeen": int64(100), "counter": uint64(9007199254740993)}
+ metadata := make(map[string]interface{}, metadataKeys)
+ for i := 0; i < metadataKeys; i++ {
+ metadata[fmt.Sprintf("key-%d", i)] = map[string]interface{}{"name": "unchanged", "enabled": true, "values": []string{"one", "two", "three"}}
+ }
+ previous["platformData"] = metadata
+ before, err := json.Marshal(previous)
+ if err != nil {
+ b.Fatal(err)
+ }
+ previous["lastSeen"] = int64(200)
+ previous["cpu"] = map[string]interface{}{"current": 20}
+ after, err := json.Marshal(previous)
+ if err != nil {
+ b.Fatal(err)
+ }
+ for _, implementation := range []struct {
+ name string
+ patch func(json.RawMessage, json.RawMessage) (json.RawMessage, error)
+ }{{"parent", parentNumberMergePatch}, {"exact", createJSONMergePatch}} {
+ b.Run(fmt.Sprintf("metadata-%d/%s", metadataKeys, implementation.name), func(b *testing.B) {
+ b.ReportAllocs()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ if _, err := implementation.patch(before, after); err != nil {
+ b.Fatal(err)
+ }
+ }
+ })
+ }
+ }
+}