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.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
Preserve measured zero guest memory and reliable guidance proofs
pulse-triage[bot]b9409a0c7451
diff --git a/docs/release-control/v6/internal/subsystems/monitoring.md b/docs/release-control/v6/internal/subsystems/monitoring.mdindex 286ce796b1..5bb69533b2 100644--- a/docs/release-control/v6/internal/subsystems/monitoring.md+++ b/docs/release-control/v6/internal/subsystems/monitoring.md@@ -17,6 +17,34 @@## Purpose+### Guest filesystem guidance honours its caller's logger++Missing-filesystem guidance uses the existing caller context logger, falling+back to the ordinary global logger when none is set. Message, severity, scope,+provider-text exclusions and backup precautions are unchanged. The connected+`TestGuestFilesystemFailureGuidanceUsesObservedEvidence` captures its own+context-tagged output without replacing a shared logger; the scheduler-health+fixture stops the monitor it owns. This repairs the observed shared-logger race+with an otherwise leaked alert-save worker, not a guest or backup recovery.++### Measured zero guest availability stays authoritative++Status/current meminfo distinguishes an explicit numeric `available: 0` from+an omitted or null field. The measured zero stays selected, including through+JSON copies, rather than being replaced by free/cache components or another+memory source. Positive programmatic samples and legacy payloads without+availability retain their existing behaviour; invalid numeric fields remain+errors. The internal presence bit never becomes a wire field.++`TestGuestStatusMemoryAvailabilityContract` covers selection and both ordinary+collectors through direct/cluster HTTP clients, canonical views, History and+actual threshold evaluation: measured exhaustion raises a breach, missing+availability cannot clear it or add History, and fresh healthy evidence permits+recovery. `TestVMStatusMemoryAvailabilityPresence` preserves the wire distinction.+The sampled capacity, original observation time, guest command/backup-lock+fences, QGA parser and configured thresholds are unchanged. This is synthetic+source evidence, not reporter #2762 cause, native recovery or availability.+### Guest memory readings keep their own capacityThe QEMU memory selector pairs guest availability with the total from thediff --git a/internal/monitoring/guest_filesystem_logger_test.go b/internal/monitoring/guest_filesystem_logger_test.gonew file mode 100644index 0000000000..7b27e4c00f--- /dev/null+++ b/internal/monitoring/guest_filesystem_logger_test.go@@ -0,0 +1,22 @@+package monitoring++import (+ "bytes"+ "context"+ "testing"++ "github.com/rs/zerolog"+ "github.com/rs/zerolog/log"+)++func TestGuestFilesystemLoggerKeepsOrdinaryFallback(t *testing.T) {+ if guestFilesystemLogger(context.Background()) != &log.Logger {+ t.Fatal("ordinary filesystem guidance lost its process logger")+ }+ var output bytes.Buffer+ logger := zerolog.New(&output)+ ctx := logger.WithContext(context.Background())+ if guestFilesystemLogger(ctx) != log.Ctx(ctx) || guestFilesystemLogger(ctx) == &log.Logger {+ t.Fatal("filesystem guidance lost its explicit caller logger")+ }+}diff --git a/internal/monitoring/guest_memory_sources.go b/internal/monitoring/guest_memory_sources.goindex 93dc7d4080..d4689ecee6 100644--- a/internal/monitoring/guest_memory_sources.go+++ b/internal/monitoring/guest_memory_sources.go@@ -60,7 +60,7 @@ func deriveGuestMemInfoAvailable(memInfo *proxmox.VMMemInfo, guestRaw *VMMemoryRmemInfo.Cached == 0switch {- case memInfo.Available > 0 && (memInfo.Total == 0 || memInfo.Available <= memInfo.Total):+ case memInfo.HasAvailable() && (memInfo.Total == 0 || memInfo.Available <= memInfo.Total):return memInfo.Available, "available-field"case memInfo.Free > 0 || memInfo.Buffers > 0 || memInfo.Cached > 0:if availableFromUsed > 0 && missingCacheMetrics {diff --git a/internal/monitoring/guest_memory_status_test.go b/internal/monitoring/guest_memory_status_test.gonew file mode 100644index 0000000000..8959736ce5--- /dev/null+++ b/internal/monitoring/guest_memory_status_test.go@@ -0,0 +1,201 @@+package monitoring++import (+ "context"+ "encoding/json"+ "fmt"+ "net/http"+ "net/http/httptest"+ "strings"+ "sync/atomic"+ "testing"+ "time"++ "github.com/rcourtman/pulse-go-rewrite/internal/alerts"+ "github.com/rcourtman/pulse-go-rewrite/internal/config"+ "github.com/rcourtman/pulse-go-rewrite/internal/models"+ "github.com/rcourtman/pulse-go-rewrite/internal/unifiedresources"+ "github.com/rcourtman/pulse-go-rewrite/pkg/proxmox"+)++func testGuestStatusMemoryAvailabilitySelection(t *testing.T) {+ for _, tc := range []struct {+ name, fields, source string+ available uint64+ }{+ {"zero-overrides-components", `"available":0,"free":1024,"buffers":1024,"cached":4096`, "available-field", 0},+ {"zero-overrides-total-minus-used", `"available":0,"used":4096,"free":1024`, "available-field", 0},+ {"zero-only", `"available":0`, "available-field", 0},+ {"missing-with-components", `"free":1024,"buffers":1024,"cached":4096`, "derived-free-buffers-cached", 6144},+ {"null-with-components", `"available":null,"free":1024,"buffers":1024,"cached":4096`, "derived-free-buffers-cached", 6144},+ {"absent-is-not-exhausted", `"used":0`, "", 0},+ {"positive-available", `"available":6144,"free":1024,"cached":4096`, "available-field", 6144},+ {"invalid-capacity-is-not-exhausted", `"available":8193`, "", 0},+ } {+ t.Run(tc.name, func(t *testing.T) {+ var sample proxmox.VMMemInfo+ if err := json.Unmarshal([]byte(`{"total":8192,`+tc.fields+`}`), &sample); err != nil {+ t.Fatal(err)+ }+ for i := 0; i < 2; i++ {+ available, source := deriveGuestMemInfoAvailable(&sample, nil)+ if available != tc.available || source != tc.source {+ t.Errorf("selected %d (%s), want %d (%s)", available, source, tc.available, tc.source)+ }+ copy, err := json.Marshal(sample)+ if err != nil {+ t.Fatal(err)+ }+ if err := json.Unmarshal(copy, &sample); err != nil {+ t.Fatal(err)+ }+ }+ })+ }+}++// Real HTTP status decoding feeds each ordinary collector and canonical views,+// History, and threshold evaluation. No guest, backup or QGA fault is induced.+func testGuestStatusMemoryAvailabilityPolling(t *testing.T) {+ const gib = uint64(1024 * 1024 * 1024)+ for _, kind := range []string{"direct", "cluster"} {+ for _, collector := range []string{"cluster-resources", "node-list"} {+ t.Run(kind+"/"+collector, func(t *testing.T) {+ var phase, commands atomic.Int32+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ w.Header().Set("Content-Type", "application/json")+ switch {+ case strings.HasSuffix(r.URL.Path, "/status/current"):+ // Plausible components deliberately disagree with measured+ // availability. They are not a replacement for that field.+ fields := fmt.Sprintf(`"available":%d,"free":%d,"buffers":%d,"cached":%d`, 3*gib, gib/2, gib/2, 2*gib)+ switch phase.Load() {+ case 1, 3:+ fields = fmt.Sprintf(`"available":0,"free":%d,"buffers":%d,"cached":%d`, gib/2, gib/2, 2*gib)+ case 2:+ fields = `"available":null`+ case 5:+ fields = fmt.Sprintf(`"free":%d,"buffers":%d,"cached":%d`, gib/2, gib/2, 2*gib)+ }+ fmt.Fprintf(w, `{"data":{"status":"running","cpu":0.1,"agent":0,"maxmem":%d,"mem":%d,"meminfo":{"total":%d,%s}}}`, 20*gib, 20*gib, 4*gib, fields)+ case strings.Contains(r.URL.Path, "/agent/"):+ commands.Add(1)+ t.Error("status availability unexpectedly queued QGA")+ http.Error(w, "unexpected QGA read", http.StatusNotFound)+ case strings.HasSuffix(r.URL.Path, "/version"):+ fmt.Fprint(w, `{"data":{"version":"9.2-fixture"}}`)+ case strings.HasSuffix(r.URL.Path, "/nodes"):+ fmt.Fprint(w, `{"data":[{"node":"node","status":"online"}]}`)+ default:+ http.NotFound(w, r)+ }+ }))+ defer server.Close()+ pcfg := proxmox.ClientConfig{Host: server.URL, TokenName: "fixture@pve!pulse", TokenValue: "fixture", Timeout: time.Second}+ var client PVEClientInterface+ if kind == "direct" {+ var err error+ client, err = proxmox.NewClient(pcfg)+ if err != nil {+ t.Fatal(err)+ }+ } else {+ client = proxmox.NewClusterClient("status-zero", pcfg, []string{server.URL}, nil)+ }+ am := alerts.NewManagerWithDataDir(t.TempDir(), alerts.WithoutPersistedAlertRestore())+ defer am.Stop()+ acfg := am.GetConfig()+ acfg.Enabled = true+ acfg.GuestDefaults.Memory = &alerts.HysteresisThreshold{Trigger: 80, Clear: 75}+ acfg.MetricTimeThresholds = map[string]map[string]int{"guest": {"memory": 0}}+ am.UpdateConfig(acfg)+ m := &Monitor{config: &config.Config{}, alertManager: am, rateTracker: NewRateTracker(), metricsHistory: NewMetricsHistory(32, time.Hour), guestMetadataLimiter: make(map[string]time.Time)}+ registry := unifiedresources.NewRegistry(nil)+ id := makeGuestID("status-zero", "node", 105)+ previous := map[string]models.VM{}+ build := func() models.VM {+ t.Helper()+ res := proxmox.ClusterResource{Type: "qemu", Node: "node", Name: "guest", VMID: 105, Status: "running", MaxMem: 20 * gib, Mem: 20 * gib, CPU: .1}+ var vms []models.VM+ if collector == "cluster-resources" {+ vms = m.collectClusterVMResources(context.Background(), "status-zero", []indexedClusterResource{{resource: res, guestID: id}}, client, previous, nil)+ } else {+ vms, _ = m.pollNodeVMsWithClusterResourceBuilder(context.Background(), "status-zero", "node", []proxmox.VM{{VMID: 105, Name: "guest", Status: "running", MaxMem: res.MaxMem, Mem: res.Mem, CPU: .1}}, client, previous, nil)+ }+ if len(vms) != 1 {+ t.Fatalf("collector lost VM: %v", vms)+ }+ vm := vms[0]+ m.recordGuestMetrics(vms, nil, time.Now().Add(-time.Second))+ registry.IngestSnapshot(models.StateSnapshot{VMs: vms})+ views := registry.VMs()+ if len(views) != 1 {+ t.Fatalf("canonical view lost VM: %v", views)+ }+ view := views[0]+ evidence := view.MemoryEvidence(time.Now())+ if vm.Memory.HasKnownUsage() {+ if view.MemoryTotal() != vm.Memory.Total || view.MemoryUsed() != vm.Memory.Used || view.MemoryPercent() != vm.Memory.Usage || (vm.Memory.Observation.State == "current" && !evidence.PressureKnown) {+ t.Errorf("selected measurement changed at canonical boundary: %+v", evidence)+ }+ } else if evidence.Available || evidence.PressureKnown {+ t.Errorf("missing measurement became pressure: %+v", evidence)+ }+ previous[id] = previousVMFromView(view)+ return vm+ }+ assertCurrent := func(vm models.VM, want float64, source string) {+ t.Helper()+ if !vm.Memory.HasKnownUsage() || vm.Memory.Total != 4*int64(gib) || vm.Memory.Usage != want || vm.Memory.Observation.State != "current" || vm.Memory.Observation.Source != source {+ t.Errorf("current sample lost zero/presence/capacity: %+v", vm.Memory)+ }+ }+ assertCurrent(build(), 25, "available-field")+ if len(am.GetActiveAlerts()) != 0 {+ t.Error("healthy observation alerted")+ }+ phase.Store(1)+ pressure := build()+ assertCurrent(pressure, 100, "available-field")+ if pressure.Memory.Used != pressure.Memory.Total || pressure.Memory.Free != 0 || pressure.Memory.Cache != 0 {+ t.Errorf("exhaustion retained speculative cache: %+v", pressure.Memory)+ }+ active := am.GetActiveAlerts()+ if len(active) != 1 || active[0].Type != "memory" || active[0].Value != 100 {+ t.Errorf("full pressure was not alerted: %+v", active)+ }+ phase.Store(2)+ unknown := build()+ if unknown.Memory.Observation.State == "current" ||+ (unknown.Memory.HasKnownUsage() && (unknown.Memory.Observation.State != "last-known" || unknown.Memory.Used != pressure.Memory.Used || unknown.Memory.Total != pressure.Memory.Total || !unknown.Memory.Observation.ObservedAt.Equal(pressure.Memory.Observation.ObservedAt))) {+ t.Errorf("null availability invented or renewed usage: %+v", unknown.Memory)+ }+ if len(am.GetActiveAlerts()) != 1 {+ t.Error("missing availability cleared real breach")+ }+ phase.Store(3)+ assertCurrent(build(), 100, "available-field")+ phase.Store(4)+ assertCurrent(build(), 25, "available-field")+ if len(am.GetActiveAlerts()) != 0 {+ t.Error("real healthy observation did not recover breach")+ }+ phase.Store(5)+ assertCurrent(build(), 25, "derived-free-buffers-cached")+ points := m.metricsHistory.GetGuestMetrics(id, "memory", time.Hour)+ want := []float64{25, 100, 100, 25, 25}+ if len(points) != len(want) {+ t.Fatalf("History lost measurement or gained missing sample: %+v", points)+ }+ for i, point := range points {+ if point.Value != want[i] {+ t.Errorf("History[%d] = %v, want %v", i, point.Value, want[i])+ }+ }+ if commands.Load() != 0 {+ t.Error("status-only collection gained guest commands")+ }+ })+ }+ }+}diff --git a/internal/monitoring/memory_trust_characterization_test.go b/internal/monitoring/memory_trust_characterization_test.goindex d7e87fb800..2f6faa63c3 100644--- a/internal/monitoring/memory_trust_characterization_test.go+++ b/internal/monitoring/memory_trust_characterization_test.go@@ -1198,3 +1198,8 @@ func TestBackupLockMemoryTrustKeepsNativeEvidenceWithoutAgentReads(t *testing.T)})}}++func TestGuestStatusMemoryAvailabilityContract(t *testing.T) {+ testGuestStatusMemoryAvailabilitySelection(t)+ testGuestStatusMemoryAvailabilityPolling(t)+}diff --git a/internal/monitoring/monitor_health_test.go b/internal/monitoring/monitor_health_test.goindex a421891046..ed2f66470b 100644--- a/internal/monitoring/monitor_health_test.go+++ b/internal/monitoring/monitor_health_test.go@@ -25,6 +25,7 @@ func TestSchedulerHealth_EnhancedResponse(t *testing.T) {if err != nil {t.Fatalf("unexpected error creating monitor: %v", err)}+ t.Cleanup(monitor.Stop)instanceKey := schedulerKey(InstanceTypePVE, "pve-a")monitor.pollStatusMap[instanceKey] = &pollStatus{diff --git a/internal/monitoring/monitor_pve_guest_builders.go b/internal/monitoring/monitor_pve_guest_builders.goindex f56dc2ff0c..37899bdbe8 100644--- a/internal/monitoring/monitor_pve_guest_builders.go+++ b/internal/monitoring/monitor_pve_guest_builders.go@@ -10,6 +10,7 @@ import ("github.com/rcourtman/pulse-go-rewrite/internal/models""github.com/rcourtman/pulse-go-rewrite/pkg/fsfilters""github.com/rcourtman/pulse-go-rewrite/pkg/proxmox"+ "github.com/rs/zerolog""github.com/rs/zerolog/log")@@ -640,20 +641,30 @@ func (m *Monitor) fetchVMFSInfo(ctx context.Context, instanceName string, res prreturn nil, reason, false}reason := classifyGuestAgentDiskStatusError(err)- logVMFilesystemUnavailable(instanceName, res, reason)+ logVMFilesystemUnavailable(ctx, instanceName, res, reason)return nil, classifyGuestAgentDiskStatusError(err), false}if len(fsInfo) == 0 {- logVMFilesystemUnavailable(instanceName, res, "no-filesystems")+ logVMFilesystemUnavailable(ctx, instanceName, res, "no-filesystems")return nil, "no-filesystems", false}return fsInfo, "", true}+// Keep ordinary process logging when no context logger is installed. Tests and+// callers with an explicit logger can own their output without global mutation.+func guestFilesystemLogger(ctx context.Context) *zerolog.Logger {+ logger := log.Ctx(ctx)+ if logger.GetLevel() == zerolog.Disabled {+ return &log.Logger+ }+ return logger+}+// Missing optional readings do not establish a need to activate/restart QGA,// change backup policy, or reconfigure a shared Proxmox role. Keep this guidance// independent of provider error text and the guest's operating system.-func logVMFilesystemUnavailable(instanceName string, res proxmox.ClusterResource, reason string) {+func logVMFilesystemUnavailable(ctx context.Context, instanceName string, res proxmox.ClusterResource, reason string) {message := "Guest filesystem query failed; check disk usage inside the guest. Keep existing guest-agent and backup settings."switch reason {case "agent-not-running":@@ -665,7 +676,7 @@ func logVMFilesystemUnavailable(instanceName string, res proxmox.ClusterResourcecase "no-filesystems":message = "Guest agent returned no filesystem readings; check disk usage inside the guest. Keep existing guest-agent and backup settings."}- log.Info().+ guestFilesystemLogger(ctx).Info().Str("instance", instanceName).Str("vm", res.Name).Int("vmid", res.VMID).diff --git a/internal/monitoring/monitor_pve_guest_lxc_test.go b/internal/monitoring/monitor_pve_guest_lxc_test.goindex bdca67a7d6..6f7492e721 100644--- a/internal/monitoring/monitor_pve_guest_lxc_test.go+++ b/internal/monitoring/monitor_pve_guest_lxc_test.go@@ -20,7 +20,6 @@ import (agentshost "github.com/rcourtman/pulse-go-rewrite/pkg/agents/host""github.com/rcourtman/pulse-go-rewrite/pkg/proxmox""github.com/rs/zerolog"- "github.com/rs/zerolog/log")func TestGuestMemoryCarryForwardExpiryContract(t *testing.T) {@@ -934,12 +933,11 @@ func TestGuestFilesystemFailureGuidanceUsesObservedEvidence(t *testing.T) {t.Fatal(err)}var output bytes.Buffer- previousLogger := log.Logger- log.Logger = zerolog.New(&output)- defer func() { log.Logger = previousLogger }()+ logger := zerolog.New(&output).With().Str("receipt_scope", "fixture").Logger()+ ctx := logger.WithContext(context.Background())m := &Monitor{guestAgentFSInfoTimeout: time.Second, guestAgentRetries: 2}res := proxmox.ClusterResource{Node: "node", VMID: 105, Name: "fixture-vm", Type: "qemu", Status: "running", MaxDisk: 1000}- total, used, free, usage, disks, fromAgent, reason := m.updateVMDisksFromGuestAgentFSInfo(context.Background(), "fixture-instance", res, client, 1000, 0, 0)+ total, used, free, usage, disks, fromAgent, reason := m.updateVMDisksFromGuestAgentFSInfo(ctx, "fixture-instance", res, client, 1000, 0, 0)if reason != tc.reason || fromAgent || usage != -1 || total != 1000 || used != 0 || free != 1000 || disks != nil {t.Errorf("unavailable reading = %d/%d/%d/%v/%v/%t/%q", total, used, free, usage, disks, fromAgent, reason)}@@ -980,7 +978,7 @@ func TestGuestFilesystemFailureGuidanceUsesObservedEvidence(t *testing.T) {}guidance++message, _ := event["message"].(string)- if !tc.logged || event["level"] != "info" || event["instance"] != "fixture-instance" || event["vm"] != "fixture-vm" || event["reason"] != tc.reason || !strings.HasPrefix(message, tc.message) {+ if !tc.logged || event["receipt_scope"] != "fixture" || event["level"] != "info" || event["instance"] != "fixture-instance" || event["vm"] != "fixture-vm" || event["reason"] != tc.reason || !strings.HasPrefix(message, tc.message) {t.Errorf("observed-evidence guidance lost: %v", event)}if !strings.Contains(message, "guest-agent and backup settings") {diff --git a/pkg/proxmox/client.go b/pkg/proxmox/client.goindex 4b0b6568fc..9d80472c11 100644--- a/pkg/proxmox/client.go+++ b/pkg/proxmox/client.go@@ -2649,6 +2649,47 @@ type VMMemInfo struct {Buffers uint64 `json:"buffers,omitempty"`Cached uint64 `json:"cached,omitempty"`Shared uint64 `json:"shared,omitempty"`++ availablePresent bool // Measured zero must not become missing availability.+}++// HasAvailable distinguishes a guest's measured zero availability from older+// status payloads without that field. Nonzero programmatically built samples+// retain their existing meaning.+func (m VMMemInfo) HasAvailable() bool {+ return m.availablePresent || m.Available > 0+}++func (m *VMMemInfo) UnmarshalJSON(data []byte) error {+ type plain VMMemInfo+ var decoded plain+ wire := struct {+ *plain+ Available *uint64 `json:"available"`+ }{plain: &decoded}+ if err := json.Unmarshal(data, &wire); err != nil {+ return err+ }+ if wire.Available != nil {+ decoded.Available = *wire.Available+ decoded.availablePresent = true+ }+ *m = VMMemInfo(decoded)+ return nil+}++// Keep explicit zero through status copies/JSON round trips without inventing+// an available field for legacy payloads. Internal presence is not a wire field.+func (m VMMemInfo) MarshalJSON() ([]byte, error) {+ type plain VMMemInfo+ var available *uint64+ if m.HasAvailable() {+ available = &m.Available+ }+ return json.Marshal(struct {+ plain+ Available *uint64 `json:"available,omitempty"`+ }{plain: plain(m), Available: available})}// VMBalloonInfo describes guest memory details returned by status/current whendiff --git a/pkg/proxmox/guest_memory_status_test.go b/pkg/proxmox/guest_memory_status_test.gonew file mode 100644index 0000000000..1cc39cd879--- /dev/null+++ b/pkg/proxmox/guest_memory_status_test.go@@ -0,0 +1,76 @@+package proxmox++import (+ "encoding/json"+ "testing"+)++// These tests also run unchanged against the parent: the wire distinction is+// the requirement, rather than the new implementation's private presence bit.+func testVMMemInfoAvailabilityRoundTrip(t *testing.T) {+ for _, tc := range []struct {+ name, wire string+ present bool+ available uint64+ }{+ {"measured-zero", `{"total":8192,"available":0,"free":1024,"cached":4096}`, true, 0},+ {"positive", `{"total":8192,"available":6144}`, true, 6144},+ {"missing", `{"total":8192,"free":1024,"cached":4096}`, false, 0},+ {"null-is-not-zero", `{"total":8192,"available":null,"free":1024,"cached":4096}`, false, 0},+ } {+ t.Run(tc.name, func(t *testing.T) {+ var sample VMMemInfo+ if err := json.Unmarshal([]byte(tc.wire), &sample); err != nil {+ t.Fatal(err)+ }+ for i := 0; i < 3; i++ {+ encoded, err := json.Marshal(sample)+ if err != nil {+ t.Fatal(err)+ }+ var fields map[string]json.RawMessage+ if err := json.Unmarshal(encoded, &fields); err != nil {+ t.Fatal(err)+ }+ _, present := fields["available"]+ if present != tc.present || sample.Available != tc.available || sample.Total != 8192 {+ t.Errorf("round trip %d: availability presence/value/capacity lost: %s", i, encoded)+ }+ if err := json.Unmarshal(encoded, &sample); err != nil {+ t.Fatal(err)+ }+ }+ })+ }+}++func testVMMemInfoAvailabilityRejectsInvalidNumbers(t *testing.T) {+ for _, value := range []string{`-1`, `0.5`, `"0"`, `true`, `{}`, `[]`, `18446744073709551616`} {+ t.Run(value, func(t *testing.T) {+ var sample VMMemInfo+ if err := json.Unmarshal([]byte(`{"total":8192,"available":`+value+`}`), &sample); err == nil {+ t.Fatal("invalid availability became a valid sample")+ }+ })+ }+}++func testVMMemInfoAvailabilityPresenceDoesNotLeakAcrossDecode(t *testing.T) {+ var sample VMMemInfo+ for _, wire := range []string{`{"total":8192,"available":0}`, `{"total":4096}`, `{"total":2048,"available":null}`} {+ if err := json.Unmarshal([]byte(wire), &sample); err != nil {+ t.Fatal(err)+ }+ encoded, err := json.Marshal(sample)+ if err != nil {+ t.Fatal(err)+ }+ var fields map[string]json.RawMessage+ json.Unmarshal(encoded, &fields)+ _, present := fields["available"]+ want := wire == `{"total":8192,"available":0}`+ if present != want {+ t.Errorf("presence survived unrelated sample: %s", encoded)+ }+ }+}diff --git a/pkg/proxmox/io_counters_test.go b/pkg/proxmox/io_counters_test.goindex d36e7fe244..c914db7a61 100644--- a/pkg/proxmox/io_counters_test.go+++ b/pkg/proxmox/io_counters_test.go@@ -246,3 +246,10 @@ func TestGuestAgentTransportDeferralPreservesLiveCounterReceipts(t *testing.T) {})}}++// The same ordinary status decoder also preserves memory availability presence.+func TestVMStatusMemoryAvailabilityPresence(t *testing.T) {+ t.Run("round-trip", testVMMemInfoAvailabilityRoundTrip)+ t.Run("invalid-numbers", testVMMemInfoAvailabilityRejectsInvalidNumbers)+ t.Run("reused-decode", testVMMemInfoAvailabilityPresenceDoesNotLeakAcrossDecode)+}