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
Capture fresh broadcast resources and history targets together
pulse-triage[bot]54de7bdca738
diff --git a/docs/release-control/v6/internal/subsystems/monitoring.md b/docs/release-control/v6/internal/subsystems/monitoring.mdindex 354ad8d5e2..fd23f74cc1 100644--- a/docs/release-control/v6/internal/subsystems/monitoring.md+++ b/docs/release-control/v6/internal/subsystems/monitoring.md@@ -17,6 +17,30 @@## Purpose+### Fresh broadcast projection owns one resource/target capture++Canonical live, fallback and standalone-host continuity broadcast reads prefer+the adapter's detached bulk resource/metrics-target capture. After host+coalescing selects presentation identity, missing history targets are attached+from that same capture, including authoritative absence. Stores without this+optional capability retain the previous point-resolver fallback. Only the owned+outer coalesced slice is decorated in place; nested source payloads stay read-only.++Every read still observes complete current resource data and derives live alert+health, metadata URL edits/clears and connected/ignored infrastructure. No+timestamp-only cache, telemetry omission, policy change or new wire field is+introduced. All existing catalogs, discovery/history coordinates, original+observation times, LastSeen, identity and tenant/revocation boundaries remain.++`broadcast_metrics_snapshot_test.go` compares the complete served JSON with an+independent earlier projection across the metadata-heavy nine-provider demo,+typed-view and same-time dirty cases; it also covers captured target replacement+and continuity/metadata/live-alert boundaries. `monitor_host_agents_test.go`+retains its one-materialization and live-change regression. Benchmarks include+the exact parent's complete conversion and final JSON encoding, with cold,+list-only, typed-clean and dirty inputs; they do not establish installed CPU/RSS+relief, native identity refresh throughput or completion of #2199.+### Report identity lookups do not rebuild unrelated Kubernetes metadataThe producer's two temporary host/Docker-host admission registries use adiff --git a/docs/release-control/v6/internal/subsystems/unified-resources.md b/docs/release-control/v6/internal/subsystems/unified-resources.mdindex 829cedf05e..1bd25916bf 100644--- a/docs/release-control/v6/internal/subsystems/unified-resources.md+++ b/docs/release-control/v6/internal/subsystems/unified-resources.md@@ -23,6 +23,29 @@ and sort the complete canonical change table while startup and ingestion wait.## Purpose+### Broadcast bulk reads capture resources and history coordinates together++`ListWithMetricsTargets` and the monitor adapter's matching optional read return+detached resources and a detached target map from one locked registry generation.+The existing source-mapping inversion runs once for this read when typed views+are dirty; it does not build all typed views or add a retained generation cache.+Clean typed views may supply their already-current inverse mapping. Legacy List,+GetAll and individual target reads preserve their shapes and semantics.++The target map stays separate from resources until presentation host coalescing+selects the row identity. Missing coordinates remain missing in that capture;+they never fall through to a later live registry. Mapping changes with unchanged+LastSeen take effect on the next read. Returned resources, policy/identity blocks+and target values remain caller-owned across mutations and adapter replacement.+Projection cannot pair an earlier resource row with a later history identity.++`registry_test.go`, `registry_projection_test.go` and+`monitor_adapter_read_state_test.go` exercise full resource/point-target parity,+same-time edits, concurrent mapping writes, detachments, empty/nil reads and+tenant separation. Connected monitoring proof covers all nine demo providers,+continuity overlays and complete served JSON. Paired cold/clean/dirty benchmarks+measure whole materialization, not a new point-lookup envelope or native relief.+Canonical resource History honours selected memory observation provenance and Proxmox VM filesystem deferrals instead of treating numeric carriers as fresh measurements.### Canonical resource History cannot promote retained guest readingsdiff --git a/internal/monitoring/broadcast_metrics_snapshot_test.go b/internal/monitoring/broadcast_metrics_snapshot_test.gonew file mode 100644index 0000000000..4e61cc2f3d--- /dev/null+++ b/internal/monitoring/broadcast_metrics_snapshot_test.go@@ -0,0 +1,264 @@+package monitoring++import (+ "encoding/json"+ "fmt"+ "reflect"+ "testing"+ "time"++ "github.com/rcourtman/pulse-go-rewrite/internal/config"+ "github.com/rcourtman/pulse-go-rewrite/internal/mock"+ "github.com/rcourtman/pulse-go-rewrite/internal/models"+ "github.com/rcourtman/pulse-go-rewrite/internal/unifiedresources"+)++func projectionFixtureGraph(t testing.TB) mock.FixtureGraph {+ t.Helper()+ previousEnabled, previousConfig := mock.IsMockEnabled(), mock.GetConfig()+ t.Cleanup(func() {+ mustSetMockEnabled(t, false)+ mock.SetMockConfig(previousConfig)+ mustSetMockEnabled(t, previousEnabled)+ })+ mustSetMockEnabled(t, false)+ cfg := mock.DefaultConfig+ cfg.UpdateInterval = 5 * time.Minute+ mock.SetMockConfig(cfg)+ mustSetMockEnabled(t, true)+ graph := mock.CurrentFixtureGraph()+ mustSetMockEnabled(t, false)+ return graph+}++func projectionFixtureRegistry(graph mock.FixtureGraph) *unifiedresources.ResourceRegistry {+ rr := unifiedresources.NewRegistry(nil)+ rr.IngestSnapshot(graph.State)+ for _, source := range []unifiedresources.DataSource{unifiedresources.SourceTrueNAS, unifiedresources.SourceVMware, unifiedresources.SourceAvailability} {+ rr.IngestRecords(source, graph.SupplementalRecords(source))+ }+ return rr+}++// The original full projection, including target resolution after host+// coalescing. Compare all wire fields/catalogues, not selected metric values.+func legacyFrontendProjectionForTest(m *Monitor, snapshot models.StateSnapshot, resources []unifiedresources.Resource, resolver MetricsTargetResourceStore, now time.Time) models.StateFrontend {+ rows := unifiedresources.CoalescePresentationHostResources(resources)+ rows = m.applyPersistedMetadataToUnifiedResources(rows)+ rows = unifiedresources.AttachResourceHealth(rows, resourceHealthAlerts(snapshot.ActiveAlerts), now)+ projected, catalogs := convertResourcesForBroadcastReference(rows, resolver)+ out := snapshot.ToFrontend()+ out.Resources = projected+ out.CapabilityCatalog = catalogs.capabilities+ out.PolicyCatalog = catalogs.policies+ out.AISafeSummaryCatalog = catalogs.aiSafeSummaries+ out.ConnectedInfrastructure = buildConnectedInfrastructure(rows, snapshot)+ return out+}++func TestBroadcastMetricsSnapshotConnectedContent(t *testing.T) {+ graph := projectionFixtureGraph(t)+ rr := projectionFixtureRegistry(graph)+ adapter := unifiedresources.NewMonitorAdapter(rr)+ store := &broadcastProjectionCountingStore{MonitorAdapter: adapter}+ m := &Monitor{resourceStore: store}+ resources := adapter.GetAll()+ if len(resources) < 1000 {+ t.Fatalf("demo fixture too small: %d", len(resources))+ }+ sources := map[unifiedresources.DataSource]bool{}+ for _, r := range resources {+ for _, source := range r.Sources {+ sources[source] = true+ }+ }+ for _, source := range []unifiedresources.DataSource{unifiedresources.SourceProxmox, unifiedresources.SourceAgent, unifiedresources.SourceDocker, unifiedresources.SourcePBS, unifiedresources.SourcePMG, unifiedresources.SourceK8s, unifiedresources.SourceTrueNAS, unifiedresources.SourceVMware, unifiedresources.SourceAvailability} {+ if !sources[source] {+ t.Fatalf("demo omits provider %s", source)+ }+ }+ assertEqual := func(stage string) {+ t.Helper()+ before, err := json.Marshal(adapter.GetAll())+ if err != nil {+ t.Fatal(err)+ }+ want := legacyFrontendProjectionForTest(m, graph.State, adapter.GetAll(), adapter, time.Now().UTC())+ got := m.buildBroadcastFrontendStateFromSnapshot(graph.State)+ wantJSON, err := json.Marshal(want)+ if err != nil {+ t.Fatal(err)+ }+ gotJSON, err := json.Marshal(got)+ if err != nil {+ t.Fatal(err)+ }+ if string(wantJSON) != string(gotJSON) {+ t.Fatalf("%s: complete frontend/catalogue/infrastructure JSON differs", stage)+ }+ after, _ := json.Marshal(adapter.GetAll())+ if string(before) != string(after) {+ t.Fatalf("%s: projection changed source data", stage)+ }+ t.Logf("%s: %d complete resources, %d frontend rows, %d wire bytes equal legacy projection", stage, len(adapter.GetAll()), len(got.Resources), len(gotJSON))+ }+ assertEqual("cold-list-only")+ rr.Workloads()+ assertEqual("typed-views-clean")+ // Same timestamps, new payload, policy and URL. No time-only invalidation.+ resources = adapter.GetAll()+ resources[0].Name = "changed-resource"+ resources[0].Tags = []string{"customer-data"}+ resources[0].CustomURL = "https://example.invalid/changed"+ rr.IngestResources(resources)+ assertEqual("dirty-same-time")+}++func TestBroadcastMetricsSnapshotOwnsTargetsBeforeLiveReplacement(t *testing.T) {+ m, adapter, _ := newReadStateCloneTestMonitor(t, 4)+ view := m.currentUnifiedStateView()+ if view.metricsTargets == nil {+ t.Fatal("broadcast did not capture a bulk resolver")+ }+ old := view.resources[0]+ want := adapter.MetricsTargetForResource(old.ID)+ adapter.PopulateFromSnapshot(models.EmptyStateSnapshot())+ if got := view.metricsTargets.MetricsTargetForResource(old.ID); !reflect.DeepEqual(got, want) {+ t.Fatal("captured resources were paired with a later generation's target")+ }+ if got := view.metricsTargets.MetricsTargetForResource("unknown"); got != nil {+ t.Fatal("unknown target fell through to live data")+ }+ copyTarget := view.metricsTargets.MetricsTargetForResource(old.ID)+ copyTarget.ResourceID = "caller-edit"+ if got := view.metricsTargets.MetricsTargetForResource(old.ID); got.ResourceID == "caller-edit" {+ t.Fatal("caller mutated the captured resolver")+ }+}++func TestBroadcastMetricsSnapshotContinuityAndLiveOverlays(t *testing.T) {+ m, adapter, _ := newReadStateCloneTestMonitor(t, 2)+ now := time.Now().UTC()+ m.hostContinuityStore = config.NewHostContinuityStore(t.TempDir(), nil)+ entry := config.HostContinuityEntry{HostID: "absent-host", Hostname: "absent.example", MachineID: "absent-machine", LastSeen: now.Add(-time.Hour)}+ if err := m.hostContinuityStore.Upsert(entry); err != nil {+ t.Fatal(err)+ }+ view := m.unifiedStateViewWithStandaloneHostContinuity(monitorUnifiedStateView{readState: adapter})+ if len(view.resources) != 3 || view.metricsTargets == nil {+ t.Fatal("continuity projection omitted its resources or captured resolver")+ }+ var host unifiedresources.Resource+ for _, r := range view.resources {+ if r.Agent != nil && r.Agent.AgentID == entry.HostID {+ host = r+ }+ if got, want := view.metricsTargets.MetricsTargetForResource(r.ID), broadcastMetricsTargetResolver(view.readState).MetricsTargetForResource(r.ID); !reflect.DeepEqual(got, want) {+ t.Fatal("overlay target differs from overlay registry")+ }+ }+ if host.ID == "" || host.Status == unifiedresources.StatusOnline || !host.LastSeen.Equal(entry.LastSeen) {+ t.Fatal("continuity history was omitted or promoted to current")+ }+ m.hostMetadataStore = config.NewHostMetadataStore(t.TempDir(), nil)+ for _, url := range []string{"https://example.invalid/operator", ""} {+ if err := m.hostMetadataStore.Set(entry.HostID, &config.HostMetadata{CustomURL: url}); err != nil {+ t.Fatal(err)+ }+ decorated := m.applyPersistedMetadataToUnifiedResources(view.resources)+ for _, r := range decorated {+ if r.ID == host.ID && r.CustomURL != url {+ t.Fatal("operator URL change/clear was hidden by captured data")+ }+ }+ }+ critical := unifiedresources.EvaluateResourceHealth(host, []unifiedresources.ResourceHealthAlert{{ResourceID: host.ID, Level: "critical", Type: "cpu"}}, now)+ if critical.Verdict != unifiedresources.HealthCritical {+ t.Fatal("live alert was hidden by captured data")+ }+ if len(adapter.GetAll()) != 2 {+ t.Fatal("continuity overlay wrote back to the live registry")+ }+}++var completeProjectionSink models.StateFrontend+var completeProjectionJSONSink []byte++// Exact parent broadcast shape (one coalesce, copy-to-attach, then conversion),+// not the older two-coalesce content oracle above. The unchanged conversion,+// metadata/health decoration and snapshot projection are part of both costs.+func parentFrontendProjectionForTest(m *Monitor, snapshot models.StateSnapshot, resources []unifiedresources.Resource, resolver MetricsTargetResourceStore, now time.Time) models.StateFrontend {+ rows := unifiedresources.CoalescePresentationHostResources(resources)+ for i := range rows {+ m.applyPersistedMetadataToUnifiedResource(&rows[i])+ health := unifiedresources.EvaluateResourceHealth(rows[i], resourceHealthAlerts(snapshot.ActiveAlerts), now)+ rows[i].Health = &health+ }+ projected, catalogs := convertPresentationResourcesForBroadcast(attachBroadcastMetricsTargets(rows, resolver))+ out := snapshot.ToFrontend()+ out.Resources = projected+ out.CapabilityCatalog = catalogs.capabilities+ out.PolicyCatalog = catalogs.policies+ out.AISafeSummaryCatalog = catalogs.aiSafeSummaries+ out.ConnectedInfrastructure = buildConnectedInfrastructure(rows, snapshot)+ return out+}++func BenchmarkBroadcastMetricsSnapshot(b *testing.B) {+ graph := projectionFixtureGraph(b)+ for _, mode := range []string{"cold", "list-clean", "views-clean", "dirty"} {+ for _, encode := range []bool{false, true} {+ stage := "projection"+ if encode {+ stage = "json-frame"+ }+ for _, bulk := range []bool{false, true} {+ path := "point-targets"+ if bulk {+ path = "bulk-targets"+ }+ b.Run(fmt.Sprintf("%s/%s/%s", mode, stage, path), func(b *testing.B) {+ rr := projectionFixtureRegistry(graph)+ adapter := unifiedresources.NewMonitorAdapter(rr)+ store := &broadcastProjectionCountingStore{MonitorAdapter: adapter}+ m := &Monitor{resourceStore: store}+ if mode != "cold" {+ rr.List()+ }+ if mode == "views-clean" {+ rr.Workloads()+ }+ b.ReportAllocs()+ b.ResetTimer()+ for i := 0; i < b.N; i++ {+ if mode == "cold" || mode == "dirty" {+ b.StopTimer()+ if mode == "cold" {+ rr = projectionFixtureRegistry(graph)+ adapter = unifiedresources.NewMonitorAdapter(rr)+ store.MonitorAdapter = adapter+ } else {+ changed := rr.List()[0]+ changed.Tags = []string{fmt.Sprintf("edit-%d", i)}+ rr.IngestResources([]unifiedresources.Resource{changed})+ }+ b.StartTimer()+ }+ if bulk {+ completeProjectionSink = m.buildBroadcastFrontendStateFromSnapshot(graph.State)+ } else {+ completeProjectionSink = parentFrontendProjectionForTest(m, graph.State, adapter.GetAll(), adapter, time.Now().UTC())+ }+ if encode {+ var err error+ completeProjectionJSONSink, err = json.Marshal(completeProjectionSink)+ if err != nil {+ b.Fatal(err)+ }+ }+ }+ })+ }+ }+ }+}diff --git a/internal/monitoring/canonical_guardrails_test.go b/internal/monitoring/canonical_guardrails_test.goindex 165f94a540..9e11cb4f7e 100644--- a/internal/monitoring/canonical_guardrails_test.go+++ b/internal/monitoring/canonical_guardrails_test.go@@ -607,10 +607,11 @@ func TestBroadcastResourceProjectionCoalescesSplitHostIdentities(t *testing.T) {source := string(data)for _, snippet := range []string{- "metricsTargetResolver := broadcastMetricsTargetResolver(unifiedView.readState)",+ "metricsTargetResolver := unifiedView.metricsTargets",+ "metricsTargetResolver = broadcastMetricsTargetResolver(unifiedView.readState)","broadcastResources := unifiedresources.CoalescePresentationHostResources(unifiedView.resources)",- "broadcastFrontendResources, broadcastCatalogs := convertPresentationResourcesForBroadcast(",- "attachBroadcastMetricsTargets(broadcastResources, metricsTargetResolver)",+ "broadcastFrontendResources, broadcastCatalogs := convertPresentationResourcesForBroadcast(broadcastResources)",+ "attachBroadcastMetricsTargetsInPlace(broadcastResources, metricsTargetResolver)","frontendState.CapabilityCatalog = broadcastCatalogs.capabilities","frontendState.PolicyCatalog = broadcastCatalogs.policies","frontendState.AISafeSummaryCatalog = broadcastCatalogs.aiSafeSummaries",diff --git a/internal/monitoring/monitor.go b/internal/monitoring/monitor.goindex 6bab63084c..162d189642 100644--- a/internal/monitoring/monitor.go+++ b/internal/monitoring/monitor.go@@ -4341,7 +4341,10 @@ func (m *Monitor) buildBroadcastFrontendStateFromSnapshot(snapshot models.StateS}}unifiedView := m.currentUnifiedStateView()- metricsTargetResolver := broadcastMetricsTargetResolver(unifiedView.readState)+ metricsTargetResolver := unifiedView.metricsTargets+ if metricsTargetResolver == nil {+ metricsTargetResolver = broadcastMetricsTargetResolver(unifiedView.readState)+ }broadcastResources := unifiedresources.CoalescePresentationHostResources(unifiedView.resources)// Coalescing owns the outer slice. Decorate that one projection in place,// not three full-resource copies; nested store data is still read-only.@@ -4352,9 +4355,8 @@ func (m *Monitor) buildBroadcastFrontendStateFromSnapshot(snapshot models.StateShealth := unifiedresources.EvaluateResourceHealth(broadcastResources[i], healthAlerts, now)broadcastResources[i].Health = &health}- broadcastFrontendResources, broadcastCatalogs := convertPresentationResourcesForBroadcast(- attachBroadcastMetricsTargets(broadcastResources, metricsTargetResolver),- )+ attachBroadcastMetricsTargetsInPlace(broadcastResources, metricsTargetResolver)+ broadcastFrontendResources, broadcastCatalogs := convertPresentationResourcesForBroadcast(broadcastResources)frontendState.Resources = broadcastFrontendResourcesfrontendState.CapabilityCatalog = broadcastCatalogs.capabilitiesfrontendState.PolicyCatalog = broadcastCatalogs.policies@@ -4871,23 +4873,50 @@ func (m *Monitor) RecentResourceChanges(resourceID string, since time.Time, limi}type monitorUnifiedStateView struct {- resources []unifiedresources.Resource- readState unifiedresources.ReadState- freshness time.Time+ resources []unifiedresources.Resource+ readState unifiedresources.ReadState+ freshness time.Time+ metricsTargets MetricsTargetResourceStore}type unifiedResourceReadStateLister interface {GetAll() []unifiedresources.Resource}+type unifiedResourceProjectionLister interface {+ GetAllWithMetricsTargets() ([]unifiedresources.Resource, map[string]unifiedresources.MetricsTarget)+}++// This resolver never falls through to the live store, including for an+// unknown ID. A missing target belongs to this captured generation too.+type projectionMetricsTargets map[string]unifiedresources.MetricsTarget++func (targets projectionMetricsTargets) MetricsTargetForResource(id string) *unifiedresources.MetricsTarget {+ target, ok := targets[unifiedresources.CanonicalResourceID(id)]+ if !ok {+ return nil+ }+ return &target+}++func unifiedProjectionResources(lister unifiedResourceReadStateLister) ([]unifiedresources.Resource, MetricsTargetResourceStore) {+ if projection, ok := lister.(unifiedResourceProjectionLister); ok {+ resources, targets := projection.GetAllWithMetricsTargets()+ return resources, projectionMetricsTargets(targets)+ }+ return lister.GetAll(), nil+}+func monitorUnifiedStateViewFromSnapshot(snapshot models.StateSnapshot) monitorUnifiedStateView {registry := unifiedresources.NewRegistry(nil)registry.IngestSnapshot(snapshot)adapter := unifiedresources.NewMonitorAdapter(registry)+ resources, targets := unifiedProjectionResources(adapter)return monitorUnifiedStateView{- resources: registry.List(),- readState: adapter,- freshness: snapshot.LastUpdate,+ resources: resources,+ readState: adapter,+ freshness: snapshot.LastUpdate,+ metricsTargets: targets,}}@@ -4895,10 +4924,12 @@ func monitorUnifiedStateViewFromResources(resources []unifiedresources.Resource,registry := unifiedresources.NewRegistry(nil)registry.IngestResources(resources)adapter := unifiedresources.NewMonitorAdapter(registry)+ resources, targets := unifiedProjectionResources(adapter)return monitorUnifiedStateView{- resources: registry.List(),- readState: adapter,- freshness: freshness,+ resources: resources,+ readState: adapter,+ freshness: freshness,+ metricsTargets: targets,}}@@ -4915,8 +4946,9 @@ func (m *Monitor) unifiedStateViewWithStandaloneHostContinuity(view monitorUnifireturn view}- resources := lister.GetAll()+ resources, targets := unifiedProjectionResources(lister)view.resources = resources+ view.metricsTargets = targetsif view.freshness.IsZero() {view.freshness = latestUnifiedResourceLastSeen(resources)}@@ -6479,15 +6511,22 @@ func attachBroadcastMetricsTargets(}out := make([]unifiedresources.Resource, len(resources))- for i, resource := range resources {- if resource.MetricsTarget == nil {- resource.MetricsTarget = validBroadcastMetricsTarget(- resolver.MetricsTargetForResource(resource.ID),- )+ copy(out, resources)+ attachBroadcastMetricsTargetsInPlace(out, resolver)+ return out+}++// Only call with the owned outer slice of a coalesced broadcast projection.+// Nested resource data stays read-only, and the resolver returns owned targets.+func attachBroadcastMetricsTargetsInPlace(resources []unifiedresources.Resource, resolver MetricsTargetResourceStore) {+ if resolver == nil {+ return+ }+ for i := range resources {+ if resources[i].MetricsTarget == nil {+ resources[i].MetricsTarget = validBroadcastMetricsTarget(resolver.MetricsTargetForResource(resources[i].ID))}- out[i] = resource}- return out}func validBroadcastMetricsTarget(diff --git a/internal/monitoring/monitor_host_agents_test.go b/internal/monitoring/monitor_host_agents_test.goindex 12e934c142..695d475395 100644--- a/internal/monitoring/monitor_host_agents_test.go+++ b/internal/monitoring/monitor_host_agents_test.go@@ -6718,6 +6718,10 @@ func (s *broadcastProjectionCountingStore) GetAll() []unifiedresources.Resources.reads++return s.MonitorAdapter.GetAll()}+func (s *broadcastProjectionCountingStore) GetAllWithMetricsTargets() ([]unifiedresources.Resource, map[string]unifiedresources.MetricsTarget) {+ s.reads+++ return s.MonitorAdapter.GetAllWithMetricsTargets()+}func (*broadcastProjectionCountingStore) TryReplaceRegistryForRead(models.StateSnapshot, time.Duration, func() map[unifiedresources.DataSource][]unifiedresources.IngestRecord) bool {return false}diff --git a/internal/unifiedresources/monitor_adapter.go b/internal/unifiedresources/monitor_adapter.goindex 28eda9d110..8bac41ceaa 100644--- a/internal/unifiedresources/monitor_adapter.go+++ b/internal/unifiedresources/monitor_adapter.go@@ -496,6 +496,18 @@ func (a *MonitorAdapter) GetAll() []Resource {return registry.List()}+// GetAllWithMetricsTargets materializes one complete broadcast read, binding+// its detached target map to the same registry as its detached resource list.+// The adapter may publish a replacement immediately after this capture; neither+// half of the returned read then consults that newer generation.+func (a *MonitorAdapter) GetAllWithMetricsTargets() ([]Resource, map[string]MetricsTarget) {+ registry := a.currentRegistry()+ if registry == nil {+ return nil, nil+ }+ return registry.ListWithMetricsTargets()+}+func (a *MonitorAdapter) unifiedAIAdapter() *UnifiedAIAdapter {registry := a.currentRegistry()if registry == nil {diff --git a/internal/unifiedresources/monitor_adapter_read_state_test.go b/internal/unifiedresources/monitor_adapter_read_state_test.goindex 5eb791f3cf..7eefcb5b99 100644--- a/internal/unifiedresources/monitor_adapter_read_state_test.go+++ b/internal/unifiedresources/monitor_adapter_read_state_test.go@@ -971,3 +971,40 @@ func TestHostContinuityOverlayReusedWithinRegistryGeneration(t *testing.T) {t.Fatal("overlay was reused past its maximum age")}}++func TestMonitorAdapterProjectionSnapshotKeepsReplacedGeneration(t *testing.T) {+ var absent *MonitorAdapter+ rows, targets := absent.GetAllWithMetricsTargets()+ if rows != nil || targets != nil {+ t.Fatal("nil adapter invented a projection")+ }+ adapter := NewMonitorAdapter(NewRegistry(nil))+ snapshot := readRefreshSnapshot("before")+ adapter.PopulateFromSnapshot(snapshot)+ first, firstTargets := adapter.GetAllWithMetricsTargets()+ snapshot.VMs[0].Name = "after"+ snapshot.VMs[0].ID = "new-node:201"+ snapshot.VMs[0].VMID = 201+ // Observation time is deliberately unchanged.+ adapter.PopulateFromSnapshot(snapshot)+ second, secondTargets := adapter.GetAllWithMetricsTargets()+ if len(first) != 1 || len(second) != 1 || first[0].Name != "before" || second[0].Name != "after" {+ t.Fatal("replacement lost complete fresh resource content")+ }+ if firstTargets[first[0].ID].ResourceID == secondTargets[second[0].ID].ResourceID {+ t.Fatal("replacement retained old history coordinates")+ }+ for _, r := range second {+ if want := adapter.MetricsTargetForResource(r.ID); want == nil || *want != secondTargets[r.ID] {+ t.Fatal("target differs from the generation's point resolver")+ }+ }+ other := NewMonitorAdapter(NewRegistry(nil))+ snapshot.VMs[0].ID = "other-tenant:501"+ snapshot.VMs[0].Name = "other-tenant"+ other.PopulateFromSnapshot(snapshot)+ otherRows, otherTargets := other.GetAllWithMetricsTargets()+ if reflect.DeepEqual(otherRows, second) || reflect.DeepEqual(otherTargets, secondTargets) {+ t.Fatal("separate adapters shared a tenant projection")+ }+}diff --git a/internal/unifiedresources/registry.go b/internal/unifiedresources/registry.goindex 774f2d8930..34992538c1 100644--- a/internal/unifiedresources/registry.go+++ b/internal/unifiedresources/registry.go@@ -1321,6 +1321,21 @@ func seededVMwareSourceID(resource *Resource) string {// the read lock and copy it without repeating identity/scope/policy derivation.// The typed views remain lazy, so a List-only consumer pays for no extra copy.func (rr *ResourceRegistry) List() []Resource {+ resources, _ := rr.listMaterialized(false)+ return resources+}++// ListWithMetricsTargets captures detached resources and their history targets+// from the same registry generation. Resolve all source mappings in one pass,+// without forcing the unrelated typed views to be built. In particular a+// freshly ingested registry must not scan every mapping once per broadcast row.+// Targets are separate: host coalescing must select the presentation identity+// before a missing target is attached, just as with individual target lookups.+func (rr *ResourceRegistry) ListWithMetricsTargets() ([]Resource, map[string]MetricsTarget) {+ return rr.listMaterialized(true)+}++func (rr *ResourceRegistry) listMaterialized(withTargets bool) ([]Resource, map[string]MetricsTarget) {for {rr.mu.RLock()if rr.canonicalMetadataDirty {@@ -1332,13 +1347,27 @@ func (rr *ResourceRegistry) List() []Resource {// rather than copy a generation that is no longer materialized.continue}+ var sourceTargets map[string][]SourceTarget+ var targets map[string]MetricsTarget+ if withTargets {+ sourceTargets = rr.cachedSourceTargets+ if rr.viewsDirty || sourceTargets == nil {+ sourceTargets = rr.buildSourceTargetsIndexLocked()+ }+ targets = make(map[string]MetricsTarget, len(rr.resources))+ }out := make([]Resource, 0, len(rr.resources))for _, r := range rr.resources {out = append(out, cloneMaterializedResource(r))+ if withTargets {+ if target := rr.metricsTargetFromSourceTargets(r, sourceTargets[r.ID]); target != nil {+ targets[r.ID] = *target+ }+ }}rr.mu.RUnlock()sortResourcesByName(out)- return out+ return out, targets}}diff --git a/internal/unifiedresources/registry_projection_test.go b/internal/unifiedresources/registry_projection_test.gonew file mode 100644index 0000000000..ca9dda8383--- /dev/null+++ b/internal/unifiedresources/registry_projection_test.go@@ -0,0 +1,99 @@+package unifiedresources++import (+ "fmt"+ "sync"+ "testing"+)++// Exercise the capture while a writer changes the mapping and row together.+// Separate List/point reads can legitimately observe different generations;+// this paired bulk read cannot. The test never touches persistence or drivers.+func TestRegistryProjectionSnapshotConcurrentMappingEdits(t *testing.T) {+ rr := NewRegistry(nil)+ rr.IngestSnapshot(benchmarkVMState(1))+ id := rr.List()[0].ID+ set := func(version int) {+ rr.mu.Lock()+ defer rr.mu.Unlock()+ name := fmt.Sprintf("coordinate-%d", version)+ rr.resources[id].Name = name+ rr.bySource[SourceProxmox] = map[string]string{name: id}+ rr.invalidateViewsLocked()+ }+ set(0)+ var wg sync.WaitGroup+ wg.Add(1)+ go func() {+ defer wg.Done()+ for i := 0; i < 200; i++ {+ set(i % 2)+ }+ }()+ defer wg.Wait()+ for i := 0; i < 200; i++ {+ rows, targets := rr.ListWithMetricsTargets()+ if len(rows) != 1 || rows[0].Name != targets[id].ResourceID {+ t.Fatalf("mixed row/target generation: row=%q target=%q", rows[0].Name, targets[id].ResourceID)+ }+ }+}++var projectionResourceSink []Resource+var projectionTargetSink map[string]MetricsTarget++// Include the entire owned List and every history coordinate. These are not+// point-lookup timings, nor a replacement for the old clone-allocation envelope.+func BenchmarkRegistryProjectionSnapshot(b *testing.B) {+ for _, count := range []int{0, 1, 1000} {+ for _, mode := range []string{"cold", "list-clean", "views-clean", "dirty"} {+ for _, bulk := range []bool{false, true} {+ name := "point-targets"+ if bulk {+ name = "bulk-targets"+ }+ b.Run(fmt.Sprintf("%d/%s/%s", count, mode, name), func(b *testing.B) {+ state := benchmarkVMState(count)+ rr := NewRegistry(nil)+ rr.IngestSnapshot(state)+ if mode != "cold" {+ rr.List()+ }+ if mode == "views-clean" {+ rr.VMs()+ }+ b.ReportAllocs()+ b.ResetTimer()+ for i := 0; i < b.N; i++ {+ if mode == "cold" {+ b.StopTimer()+ rr = NewRegistry(nil)+ rr.IngestSnapshot(state)+ b.StartTimer()+ }+ if mode == "dirty" {+ rr.mu.Lock()+ for _, r := range rr.resources {+ r.Tags = []string{fmt.Sprintf("version-%d", i)}+ break+ }+ rr.invalidateViewsLocked()+ rr.mu.Unlock()+ }+ if bulk {+ projectionResourceSink, projectionTargetSink = rr.ListWithMetricsTargets()+ } else {+ projectionResourceSink = rr.List()+ projectionTargetSink = make(map[string]MetricsTarget, len(projectionResourceSink))+ for _, row := range projectionResourceSink {+ if target := rr.MetricsTarget(row.ID); target != nil {+ projectionTargetSink[row.ID] = *target+ }+ }+ }+ }+ })+ }+ }+ }+}diff --git a/internal/unifiedresources/registry_test.go b/internal/unifiedresources/registry_test.goindex e7490bef07..8eacc8f37b 100644--- a/internal/unifiedresources/registry_test.go+++ b/internal/unifiedresources/registry_test.go@@ -6968,3 +6968,68 @@ func TestEvaluateResourceHealthKeepsStaleTelemetryBehindAWinningAlert(t *testingt.Fatalf("expected only the alert reason for a fresh source, got %+v", health.Reasons)}}++// A List-only broadcast must capture history coordinates without constructing+// every typed view, and without trusting freshness timestamps as mutation keys.+func TestRegistryProjectionSnapshotDetachesAndTracksMappings(t *testing.T) {+ rr := NewRegistry(nil)+ rr.IngestSnapshot(benchmarkVMState(3))+ resources, targets := rr.ListWithMetricsTargets()+ if !reflect.DeepEqual(resources, rr.List()) {+ t.Fatal("bulk read changed resource content")+ }+ if !rr.viewsDirty || rr.cachedVMs != nil {+ t.Fatal("projection forced unrelated typed views to materialize")+ }+ if len(targets) != len(resources) {+ t.Fatalf("targets=%d resources=%d", len(targets), len(resources))+ }+ for _, r := range resources {+ if want := rr.MetricsTarget(r.ID); want == nil || *want != targets[r.ID] {+ t.Fatalf("target for %s differs from point resolver", r.ID)+ }+ }+ id := resources[0].ID+ observedAt := resources[0].LastSeen+ rr.mu.Lock()+ for key, mapped := range rr.bySource[SourceProxmox] {+ if mapped == id {+ delete(rr.bySource[SourceProxmox], key)+ }+ }+ rr.bySource[SourceProxmox]["new-history-coordinate"] = id+ rr.resources[id].Tags = []string{"customer-data"}+ rr.invalidateViewsLocked()+ rr.mu.Unlock()+ changed, updatedTargets := rr.ListWithMetricsTargets()+ if updatedTargets[id].ResourceID != "new-history-coordinate" {+ t.Fatal("same-time mapping change left an old target")+ }+ if targets[id].ResourceID == "new-history-coordinate" {+ t.Fatal("later mapping edit mutated a prior target snapshot")+ }+ for _, r := range changed {+ if r.ID == id {+ if !r.LastSeen.Equal(observedAt) || r.Policy.Sensitivity != ResourceSensitivityRestricted {+ t.Fatal("same-time metadata edit was stale")+ }+ r.Canonical.Aliases[0] = "caller-change"+ r.Tags[0] = "caller-change"+ r.Policy.Routing.Redact = append(r.Policy.Routing.Redact, ResourceRedactionPath)+ }+ }+ again, againTargets := rr.ListWithMetricsTargets()+ if !reflect.DeepEqual(againTargets, updatedTargets) {+ t.Fatal("detached map mutation escaped")+ }+ for _, r := range again {+ if r.ID == id && (r.Tags[0] != "customer-data" || r.Canonical.Aliases[0] == "caller-change") {+ t.Fatal("caller changed live registry")+ }+ }+ empty := NewRegistry(nil)+ rows, emptyTargets := empty.ListWithMetricsTargets()+ if len(rows) != 0 || len(emptyTargets) != 0 {+ t.Fatal("empty projection invented resources or targets")+ }+}