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
Chart history for disks named by their Unraid serial
rcourtman58347f0c4fcf
diff --git a/docs/release-control/v6/internal/subsystems/agent-lifecycle.md b/docs/release-control/v6/internal/subsystems/agent-lifecycle.mdindex 64a343aa03..faec9ec737 100644--- a/docs/release-control/v6/internal/subsystems/agent-lifecycle.md+++ b/docs/release-control/v6/internal/subsystems/agent-lifecycle.md@@ -8791,6 +8791,21 @@ Focused proof lives in `internal/monitoring/physical_disk_roundtrip_test.go`(`TestNestedProxmoxDefaultQEMUSerialsStayPerNode` and`TestTrueNASPlaceholderDiskSerialsStayPerApplianceAndShareOneHistoryKey`).+### Unraid serials key agent disk history++`internal/monitoring/monitor_agents.go` changed only so the SMART and disk I/O+history writers key a host agent's disk by the serial its resource carries: the+SMART row's own, else the one the host's Unraid inventory reports for that disk+(`HostSMARTDiskMetricID`, `HostUnraidDeviceMetricID`). While the Unraid row+names such a disk, its SMART and I/O history is written under that serial, which+its chart already reads, instead of its WWN or host/device key. Agent+registration, enrolment, install, update, removal, report identity and disk+source IDs are unchanged. Focused proof lives+in `internal/monitoring/monitor_host_agents_test.go`+(`TestHostDiskIOMetricResourceIDFallbacks`) and+`internal/monitoring/issue1595_collection_trust_test.go`+(`TestAgentDiskHistoryFollowsTheSerialItsUnraidRowReports`).+### Windows braced MachineGuid does not abort agent startupThe Windows unified agent resolves host information through gopsutil's combineddiff --git a/docs/release-control/v6/internal/subsystems/monitoring.md b/docs/release-control/v6/internal/subsystems/monitoring.mdindex ec49474ffd..f1d7dce1a5 100644--- a/docs/release-control/v6/internal/subsystems/monitoring.md+++ b/docs/release-control/v6/internal/subsystems/monitoring.md@@ -4790,6 +4790,20 @@ disk history model, and mock seeding plus live mock ticks in`internal/monitoring/mock_metrics_history.go` must append to that same disktimeline instead of creating a second drawer-only or mock-only disk historypath.+The SMART-resolved id is the serial the disk resource carries: when a SMART row+reports none, `HostSMARTDiskMetricID` takes the one the host's Unraid inventory+reports for that disk, as the unified-resources adapter does, unless several+SMART rows share the disk's device path, and `hostDiskIOMetricResourceID` keys+a device with no non-standby SMART row by its Unraid serial+(`HostUnraidDeviceMetricID`, which refuses a device several Unraid rows name)+before the linked Proxmox node's disks and the `<host>:<device>` fallback.+Controller members sharing a device path keep distinct keys, so the I/O+writer's aggregate-device guard, which compares every row on the path by its+own identity (standby rows and legacy `sdc [sat]` labels included), files+their counter under no member.+Proof:+`TestAgentDiskHistoryFollowsTheSerialItsUnraidRowReports` and+`TestHostDiskIOMetricResourceIDFallbacks`.That same monitoring-owned disk-health boundary also includes shared storagerisk assessment in `internal/storagehealth/`. When providers or host agentsemit structured storage topology such as Unraid per-disk state, the shareddiff --git a/docs/release-control/v6/internal/subsystems/unified-resources.md b/docs/release-control/v6/internal/subsystems/unified-resources.mdindex 9c28cda4e8..c91656d065 100644--- a/docs/release-control/v6/internal/subsystems/unified-resources.md+++ b/docs/release-control/v6/internal/subsystems/unified-resources.md@@ -5389,6 +5389,31 @@ disk on a single host. Proof:`TestHostSMARTDiskSourceIDScopesHardwareIdentityToItsHost`,`TestRehydratedAgentDisksKeepTheirLiveSourceIDs`,`TestSplitAgentDisksOnTwoMachinesNeverOverwriteEachOther`.+A SMART row that reports no serial, smartctl's standby row among them, takes+the serial the host's Unraid inventory reports for the same disk+(`hostSMARTDiskSerial` over `matchUnraidDisk`). The adapter shows that serial+and the disk's metrics target reads it, so `HostSMARTDiskMetricID` resolves the+same serial, and the disk I/O writer keys a device with no SMART reading by its+Unraid serial (`HostUnraidDeviceMetricID`) before its Proxmox and host/device+fallbacks. The writers used to key such a row on its WWN or host/device key,+which the chart did not read, so the disk's SMART temperature and I/O history+never appeared. The row's source ID stays its own (`HostSMARTDiskSourceID`+reads only the row), so its SMART and Unraid observations still ingest under+two keys onto one disk. Samples already written under the old key stay there:+the chart did not read that key while the Unraid row named the disk (only+Unraid OS reports an Unraid inventory, and it is never a Proxmox node whose+disk row could replace the serial), and a device-keyed series can hold another+disk's samples once device letters move. The key follows the inventory: while the host+reports no Unraid row for the disk, the row's own key is both written and read.+A row matches its Unraid row by device path alone, so a row on a path several+of the host's SMART rows share, controller members behind one block device,+takes no serial from it, and the I/O writer still files that device's counter+under no member. The I/O writer's inventory fallback also skips a device+several Unraid rows name, while a SMART row keeps the adapter's first match.+A row's own serial is kept even when it is a placeholder, as the+adapter keeps it, and the Unraid row then stays a disk of its own. Proof:+`TestHostSMARTDiskMetricIDTakesTheSerialItsUnraidRowReports`,+`TestAgentDiskHistoryFollowsTheSerialItsUnraidRowReports`.That same canonical physical-disk view must also expose source-independent hostcontext. When a disk is API-backed rather than node-backed, typed views shouldfall back to canonical host identity such as `identity.hostnames` instead ofdiff --git a/internal/monitoring/issue1595_collection_trust_test.go b/internal/monitoring/issue1595_collection_trust_test.goindex a484609166..b79ac63f09 100644--- a/internal/monitoring/issue1595_collection_trust_test.go+++ b/internal/monitoring/issue1595_collection_trust_test.go@@ -453,6 +453,94 @@ func TestSameSerialAgentDisksOnTwoHostsEachKeepTheirMetricsTarget(t *testing.T)}}+// An Unraid host reports each array disk twice: as a SMART row and as an+// Unraid inventory row. When the SMART row carries no serial, smartctl's+// standby row among them, the disk takes the serial its Unraid row reports,+// and its metrics target reads that serial. The SMART and disk I/O writers must+// file under it too, as must the I/O writer for a disk with no SMART row,+// or the disk's temperature and I/O history never chart.+func TestAgentDiskHistoryFollowsTheSerialItsUnraidRowReports(t *testing.T) {+ storeConfig := metrics.DefaultConfig(t.TempDir())+ storeConfig.FlushInterval = time.Hour+ store, err := metrics.NewStore(storeConfig)+ if err != nil {+ t.Fatal(err)+ }+ t.Cleanup(func() { _ = store.Close() })+ m := &Monitor{metricsStore: store, rateTracker: NewRateTracker()}++ now := time.Now().UTC().Truncate(time.Second)+ collected := func() *diskinventory.CollectionStatus {+ return &diskinventory.CollectionStatus{Temperature: diskinventory.Available("smartctl")}+ }+ host := models.Host{ID: "host-tower", Hostname: "tower", MachineID: "machine-tower", Status: "online", LastSeen: now}+ host.Sensors.SMART = []models.HostDiskSMART{+ {Device: "sdb", Temperature: 40, Collection: collected()},+ {Device: "/dev/sdc", WWN: "0x5000c500aaaa0001", Temperature: 41, Collection: collected()},+ {Device: "sdd", Standby: true, Collection: &diskinventory.CollectionStatus{+ Temperature: diskinventory.Unavailable("smartctl", "disk is in standby")}},+ }+ host.Unraid = &models.HostUnraidStorage{ArrayStarted: true, Disks: []models.HostUnraidDisk{+ {Device: "sdb", Serial: "UNRAID-SERIAL-B", Name: "disk1", Role: "data", Status: "online"},+ {Device: "sdc", Serial: "UNRAID-SERIAL-C", Name: "disk2", Role: "data", Status: "online"},+ {Device: "sdd", Serial: "UNRAID-SERIAL-D", Name: "disk3", Role: "data", Status: "online", SpunDown: true},+ {Device: "sde", Serial: "UNRAID-SERIAL-E", Name: "disk4", Role: "data", Status: "online"},+ {Device: "sdf", Name: "disk5", Role: "data", Status: "online"},+ }}+ want := map[string][]string{+ "sdb": {"smart_temp", "diskread", "diskwrite", "disk"},+ "/dev/sdc": {"smart_temp", "diskread", "diskwrite", "disk"},+ "sdd": {"diskread", "diskwrite", "disk"},+ "sde": {"diskread", "diskwrite", "disk"},+ "sdf": {"diskread", "diskwrite", "disk"},+ }+ for _, device := range []string{"sdb", "sdc", "sdd", "sde", "sdf"} {+ host.DiskIO = append(host.DiskIO, models.DiskIO{Device: device, ReadBytes: 1 << 20, WriteBytes: 1 << 20, IOTime: 100})+ }+ m.writeHostPhysicalDiskIOMetrics(host, now.Add(-30*time.Second))+ for i := range host.DiskIO {+ host.DiskIO[i].ReadBytes += 1 << 20+ host.DiskIO[i].WriteBytes += 1 << 20+ host.DiskIO[i].IOTime += 1000+ }+ m.writeHostPhysicalDiskIOMetrics(host, now)+ m.writeHostSMARTMetrics(host, now)+ store.Flush()++ live := unifiedresources.NewRegistry(nil)+ live.IngestSnapshot(models.StateSnapshot{Hosts: []models.Host{host}})+ rehydrated := unifiedresources.NewRegistry(nil)+ rehydrated.IngestResources(live.List())+ for _, tc := range []struct {+ name string+ registry *unifiedresources.ResourceRegistry+ }{{"live", live}, {"rehydrated", rehydrated}} {+ disks := tc.registry.ListByType(unifiedresources.ResourceTypePhysicalDisk)+ if len(disks) != len(want) {+ t.Fatalf("%s: disks = %d, want %d", tc.name, len(disks), len(want))+ }+ for _, disk := range disks {+ metricNames, ok := want[disk.PhysicalDisk.DevPath]+ if !ok {+ t.Fatalf("%s: unexpected disk %s at %q", tc.name, disk.ID, disk.PhysicalDisk.DevPath)+ }+ target := tc.registry.MetricsTarget(disk.ID)+ if target == nil {+ t.Fatalf("%s: disk %s has no metrics target", tc.name, disk.PhysicalDisk.DevPath)+ }+ for _, metric := range metricNames {+ points, err := store.Query(target.ResourceType, target.ResourceID, metric, now.Add(-time.Minute), now.Add(time.Minute), 0)+ if err != nil {+ t.Fatal(err)+ }+ if len(points) == 0 {+ t.Errorf("%s: disk %s metrics target %+v reads no %s history", tc.name, disk.PhysicalDisk.DevPath, *target, metric)+ }+ }+ }+ }+}+// A SMART row found only by device path may describe the slot's previous// occupant. It is refused when its identity contradicts the Proxmox disk's,// judged only on what both producers report like for like: WWNs for everydiff --git a/internal/monitoring/monitor_agents.go b/internal/monitoring/monitor_agents.goindex 589516c78f..85599d39e7 100644--- a/internal/monitoring/monitor_agents.go+++ b/internal/monitoring/monitor_agents.go@@ -4228,24 +4228,34 @@ func hostDiskIOMetricResourceID(host models.Host, io models.DiskIO, proxmoxDisksreturn ""}+ smartDevice := diskinventory.DeviceToken(io.Device)smartMetricID := ""+ smartRowID := ""for _, disk := range host.Sensors.SMART {- if disk.Standby {+ if !strings.EqualFold(diskinventory.DeviceToken(disk.Device), smartDevice) {continue}- if strings.EqualFold(normalizeHostDiskDevice(disk.Device), device) {- candidate := unifiedresources.HostSMARTDiskMetricID(host, disk)- if smartMetricID != "" && smartMetricID != candidate {- // Multiple controller members share this kernel block path.- // The counter belongs to the aggregate device, not any member.- return ""- }- smartMetricID = candidate+ // Multiple controller members share this kernel block path. The+ // counter belongs to the aggregate device, not any member. Judge that+ // on each row's own identity, standby rows included, since members+ // never take the path's Unraid serial.+ rowID := unifiedresources.HostSMARTDiskSourceID(host, disk)+ if smartRowID != "" && smartRowID != rowID {+ return ""+ }+ smartRowID = rowID+ if !disk.Standby {+ smartMetricID = unifiedresources.HostSMARTDiskMetricID(host, disk)}}if smartMetricID != "" {return smartMetricID}+ // A disk with no SMART reading to key it, spun down or unread, still+ // carries the serial its Unraid row reports.+ if unraidMetricID := unifiedresources.HostUnraidDeviceMetricID(host, device); unraidMetricID != "" {+ return unraidMetricID+ }for _, pd := range proxmoxDisks {if pd.device == "" || pd.metricID == "" {diff --git a/internal/monitoring/monitor_host_agents_test.go b/internal/monitoring/monitor_host_agents_test.goindex a55f0881a3..baef427792 100644--- a/internal/monitoring/monitor_host_agents_test.go+++ b/internal/monitoring/monitor_host_agents_test.go@@ -3550,6 +3550,49 @@ func TestHostDiskIOMetricResourceIDFallbacks(t *testing.T) {if got != "SATA-SERIAL-456" {t.Fatalf("proxmox fallback: expected SATA-SERIAL-456, got %q", got)}++ // The disk resource carries the serial the host's Unraid inventory reports+ // when no SMART reading names the disk, so its I/O is filed under it.+ // Controller members behind one block device keep their own identity, so+ // the device's counter belongs to no member, even while one is in standby.+ // Two inventory rows on one device name no single disk. A legacy SMART+ // device label still names its block device.+ host.Sensors.SMART = append(host.Sensors.SMART,+ models.HostDiskSMART{Device: "sdb"},+ models.HostDiskSMART{Device: "sdc", Serial: "STANDBY-SERIAL", Standby: true},+ models.HostDiskSMART{Device: "sde", Controller: "ctrl0", Target: "megaraid,0"},+ models.HostDiskSMART{Device: "sde", Controller: "ctrl0", Target: "megaraid,1"},+ models.HostDiskSMART{Device: "sdg", WWN: "5000c500a1b2c3e0", Controller: "ctrl1", Target: "megaraid,0"},+ models.HostDiskSMART{Device: "/dev/sdg", WWN: "5000c500a1b2c3e1", Controller: "ctrl1", Target: "megaraid,1", Standby: true},+ models.HostDiskSMART{Device: "sdh [sat]", Serial: "LEGACY-LABEL-SERIAL"},+ )+ host.Unraid = &models.HostUnraidStorage{Disks: []models.HostUnraidDisk{+ {Device: "sda", Serial: "UNRAID-SERIAL-A"},+ {Device: "sdb", Serial: "UNRAID-SERIAL-B"},+ {Device: "sdc", Serial: "UNRAID-SERIAL-C"},+ {Device: "sdd"},+ {Device: "sde", Serial: "UNRAID-SERIAL-E"},+ {Device: "sdf", Serial: "UNRAID-SERIAL-F1"},+ {Device: "sdf", Serial: "UNRAID-SERIAL-F2"},+ }}+ for _, tc := range []struct {+ device string+ want string+ }{+ {"sda", "UNRAID-SERIAL-A"},+ {"sdb", "UNRAID-SERIAL-B"},+ {"sdc", "UNRAID-SERIAL-C"},+ {"sdd", "myhost:sdd"},+ {"sde", ""},+ {"sdf", "myhost:sdf"},+ {"sdg", ""},+ {"sdh", "LEGACY-LABEL-SERIAL"},+ {"nvme0n1", "NVME-SERIAL-123"},+ } {+ if got := hostDiskIOMetricResourceID(host, models.DiskIO{Device: tc.device}, proxmoxDisks); got != tc.want {+ t.Fatalf("device %s: expected %q, got %q", tc.device, tc.want, got)+ }+ }}func TestApplyHostReportSkipsMetricsAndSMARTWritesInMockMode(t *testing.T) {diff --git a/internal/unifiedresources/adapters.go b/internal/unifiedresources/adapters.goindex e9386c81f0..167af4c6b1 100644--- a/internal/unifiedresources/adapters.go+++ b/internal/unifiedresources/adapters.go@@ -905,7 +905,7 @@ func resourceFromHostSMARTDisk(host models.Host, disk models.HostDiskSMART) (Res}unraidDisk := matchUnraidDisk(host.Unraid, disk)model := strings.TrimSpace(disk.Model)- serial := strings.TrimSpace(disk.Serial)+ serial := hostSMARTDiskSerial(host, disk, unraidDisk)diskType := strings.TrimSpace(disk.Type)temperature := disk.Temperaturecollection := diskinventory.CloneStatus(disk.Collection)@@ -914,9 +914,6 @@ func resourceFromHostSMARTDisk(host models.Host, disk models.HostDiskSMART) (Resif model == "" {model = strings.TrimSpace(unraidDisk.Model)}- if serial == "" {- serial = strings.TrimSpace(unraidDisk.Serial)- }if diskType == "" {diskType = unraidDiskDiskType(*unraidDisk)}diff --git a/internal/unifiedresources/canonical_ids_types_test.go b/internal/unifiedresources/canonical_ids_types_test.goindex 149627b6b8..4be51f17b9 100644--- a/internal/unifiedresources/canonical_ids_types_test.go+++ b/internal/unifiedresources/canonical_ids_types_test.go@@ -565,6 +565,121 @@ func TestHostSMARTDiskSourceIDScopesHardwareIdentityToItsHost(t *testing.T) {}}+// A SMART row without a serial takes the one the host's Unraid inventory+// reports for the disk, and its metrics key follows, because the disk resource+// carries that serial and its metrics target reads it. The source ID stays the+// row's own. A row's own serial, even a placeholder, is kept, as the adapter+// keeps it, and the Unraid row then stays a disk of its own. So does a row on a+// device path several rows share: controller members behind one block device+// keep their own identity. A disk with no SMART row is keyed by its Unraid+// serial alone, unless several Unraid rows name its device.+func TestHostSMARTDiskMetricIDTakesTheSerialItsUnraidRowReports(t *testing.T) {+ host := models.Host{ID: "host-tower", Hostname: "tower", MachineID: "machine-tower", Status: "online", LastSeen: time.Now().UTC()}+ host.Unraid = &models.HostUnraidStorage{ArrayStarted: true, Disks: []models.HostUnraidDisk{+ {Name: "disk1", Device: "sdb", Role: "data", Serial: "UNRAID-B"},+ {Name: "disk2", Device: "sdc", Role: "data", Serial: "UNRAID-C"},+ {Name: "disk3", Device: "sdd", Role: "data", Serial: "UNRAID-D"},+ {Name: "disk4", Device: "sde", Role: "data", Serial: "UNRAID-E"},+ {Name: "disk5", Device: "sdf", Role: "data", Serial: "UNRAID-F"},+ {Name: "disk6", Device: "sdg", Role: "data"},+ {Name: "disk7", Device: "sdh", Role: "data", Serial: "UNRAID-H"},+ {Name: "disk8", Device: "sdi", Role: "data", Serial: "UNRAID-I1"},+ {Name: "disk9", Device: "sdi", Role: "data", Serial: "UNRAID-I2"},+ }}+ tests := []struct {+ name string+ disk models.HostDiskSMART+ wantSource string+ wantMetric string+ }{+ {+ name: "no hardware identity",+ disk: models.HostDiskSMART{Device: "/dev/sdb"},+ wantSource: "host-tower:sdb",+ wantMetric: "UNRAID-B",+ },+ {+ name: "standby row",+ disk: models.HostDiskSMART{Device: "sdc", Standby: true},+ wantSource: "host-tower:sdc",+ wantMetric: "UNRAID-C",+ },+ {+ name: "wwn only",+ disk: models.HostDiskSMART{Device: "sdd", WWN: "5000c500a1b2c3d4"},+ wantSource: "host-tower/physical-disk:5000c500a1b2c3d4",+ wantMetric: "UNRAID-D",+ },+ {+ name: "own serial",+ disk: models.HostDiskSMART{Device: "sde", Serial: "SMART-E"},+ wantSource: "host-tower/physical-disk:SMART-E",+ wantMetric: "SMART-E",+ },+ {+ name: "own placeholder serial",+ disk: models.HostDiskSMART{Device: "sdf", Serial: "0000000000"},+ wantSource: "host-tower:sdf",+ wantMetric: "host-tower:sdf",+ },+ {+ name: "unraid row without serial",+ disk: models.HostDiskSMART{Device: "sdg"},+ wantSource: "host-tower:sdg",+ wantMetric: "host-tower:sdg",+ },+ {+ name: "controller member sharing a path",+ disk: models.HostDiskSMART{Device: "sdh", WWN: "5000c500a1b2c3e0", Controller: "ctrl0", Target: "megaraid,0"},+ wantSource: "host-tower/physical-disk:5000c500a1b2c3e0",+ wantMetric: "5000c500a1b2c3e0",+ },+ {+ name: "second controller member on that path",+ disk: models.HostDiskSMART{Device: "/dev/sdh", WWN: "5000c500a1b2c3e1", Controller: "ctrl0", Target: "megaraid,1"},+ wantSource: "host-tower/physical-disk:5000c500a1b2c3e1",+ wantMetric: "5000c500a1b2c3e1",+ },+ }+ host.Sensors.SMART = make([]models.HostDiskSMART, 0, len(tests))+ for _, tt := range tests {+ host.Sensors.SMART = append(host.Sensors.SMART, tt.disk)+ }+ rr := NewRegistry(nil)+ rr.IngestSnapshot(models.StateSnapshot{Hosts: []models.Host{host}})+ targetBySourceID := make(map[string]string)+ for _, disk := range rr.ListByType(ResourceTypePhysicalDisk) {+ target := rr.MetricsTarget(disk.ID)+ if target == nil {+ continue+ }+ for _, sourceTarget := range rr.SourceTargets(disk.ID) {+ if sourceTarget.Source == SourceAgent {+ targetBySourceID[sourceTarget.SourceID] = target.ResourceID+ }+ }+ }+ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ if got := HostSMARTDiskSourceID(host, tt.disk); got != tt.wantSource {+ t.Fatalf("HostSMARTDiskSourceID = %q, want %q", got, tt.wantSource)+ }+ if got := HostSMARTDiskMetricID(host, tt.disk); got != tt.wantMetric {+ t.Fatalf("HostSMARTDiskMetricID = %q, want %q", got, tt.wantMetric)+ }+ if got := targetBySourceID[tt.wantSource]; got != tt.wantMetric {+ t.Fatalf("disk metrics target = %q, want the writer's %q", got, tt.wantMetric)+ }+ })+ }++ for device, want := range map[string]string{"/dev/sde": "UNRAID-E", "sdg": "", "sdi": "", "sdz": ""} {+ if got := HostUnraidDeviceMetricID(host, device); got != want {+ t.Fatalf("HostUnraidDeviceMetricID(%q) = %q, want %q", device, got, want)+ }+ }+}+// A registry seeded from unified resources rebuilds each agent disk's source// mapping from the resource alone, after a JSON round trip drops per-source// parents. It must reproduce the key the agent's observation ingests under,diff --git a/internal/unifiedresources/physical_disk_ids.go b/internal/unifiedresources/physical_disk_ids.goindex d4e55d46e8..3e96433b1a 100644--- a/internal/unifiedresources/physical_disk_ids.go+++ b/internal/unifiedresources/physical_disk_ids.go@@ -26,31 +26,93 @@ func PreferredPhysicalDiskMetricID(serial, wwn, fallback string) string {// machine: a dual-ported SAS shelf, cloned VMs with an explicit serial and// fixed-serial USB bridges report one identifier on several hosts, and the// registry keeps one resource per source ID. The key therefore carries the-// reporting host. A disk without hardware identity keeps its historical-// host/device/topology key, which is also its metrics key.+// reporting host. A row without hardware identity keeps its historical+// host/device/topology key, which is also its metrics key unless the host's+// Unraid inventory reports a serial for the disk.func HostSMARTDiskSourceID(host models.Host, disk models.HostDiskSMART) string {if hardwareID := PreferredPhysicalDiskMetricID(disk.Serial, disk.WWN, ""); hardwareID != "" {return hostPhysicalDiskSourceID(host.ID, hardwareID)}- return HostSMARTDiskMetricID(host, disk)+ return hostSMARTDiskKey(host, disk, "", "")}// HostSMARTDiskMetricID returns the history key a host agent's SMART and disk// I/O metrics are written under. Like every physical-disk source, it prefers// the drive's serial or WWN, so a disk keeps one history across sources and-// hosts; see PreferredPhysicalDiskMetricID.+// hosts; see PreferredPhysicalDiskMetricID. The serial is the one the disk+// resource carries (hostSMARTDiskSerial), which its metrics target reads.func HostSMARTDiskMetricID(host models.Host, disk models.HostDiskSMART) string {- device := normalizePhysicalDiskDeviceToken(disk.Device)+ serial := hostSMARTDiskSerial(host, disk, matchUnraidDisk(host.Unraid, disk))+ return hostSMARTDiskKey(host, disk, serial, disk.WWN)+}++func hostSMARTDiskKey(host models.Host, disk models.HostDiskSMART, serial, wwn string) string {return diskinventory.PreferredID(- disk.Serial,- disk.WWN,+ serial,+ wwn,strings.TrimSpace(host.ID),- device,+ normalizePhysicalDiskDeviceToken(disk.Device),disk.Controller,disk.Target,)}+// hostSMARTDiskSerial returns the serial of the disk a SMART row describes: the+// row's own, or, when the row reports none, the one the host's Unraid+// inventory reports for the disk. smartctl reports no serial for a disk in+// standby, and the Unraid row still names it. A row without a serial matches+// its Unraid row by device path alone, so it takes no serial from a path+// several of the host's rows share: controller members behind one kernel block+// device, which the Unraid row describes as a whole.+func hostSMARTDiskSerial(host models.Host, disk models.HostDiskSMART, unraidDisk *models.HostUnraidDisk) string {+ serial := strings.TrimSpace(disk.Serial)+ if serial != "" || unraidDisk == nil || hostSMARTDevicePathShared(host, disk) {+ return serial+ }+ return strings.TrimSpace(unraidDisk.Serial)+}++// hostSMARTDevicePathShared reports whether more than one of the host's SMART+// rows, the row itself among them, names the row's device path.+func hostSMARTDevicePathShared(host models.Host, disk models.HostDiskSMART) bool {+ device := strings.ToLower(normalizePhysicalDiskDeviceToken(disk.Device))+ if device == "" {+ return false+ }+ rows := 0+ for _, other := range host.Sensors.SMART {+ if strings.ToLower(normalizePhysicalDiskDeviceToken(other.Device)) == device {+ rows+++ }+ }+ return rows > 1+}++// HostUnraidDeviceMetricID returns the history key of the disk a host's Unraid+// inventory reports at device: its usable serial, which the disk resource+// carries and its metrics target reads. It returns "" when the inventory has+// no row for the device, more than one, or a row without a usable serial.+func HostUnraidDeviceMetricID(host models.Host, device string) string {+ device = strings.ToLower(normalizePhysicalDiskDeviceToken(device))+ if host.Unraid == nil || device == "" {+ return ""+ }+ var matched *models.HostUnraidDisk+ for i := range host.Unraid.Disks {+ if strings.ToLower(normalizePhysicalDiskDeviceToken(host.Unraid.Disks[i].Device)) != device {+ continue+ }+ if matched != nil {+ return ""+ }+ matched = &host.Unraid.Disks[i]+ }+ if matched == nil {+ return ""+ }+ return PreferredPhysicalDiskMetricID(matched.Serial, "", "")+}+// HostUnraidDiskSourceID returns the registry source ID of a disk in a host's// Unraid inventory. It shares HostSMARTDiskSourceID's host-scoped serial key so// the SMART and Unraid observations of one disk keep one source mapping.