process: Use registry collector for V1 data (#1814)

Signed-off-by: Jan-Otto Kröpke <mail@jkroepke.de>

internal/collector/hyperv/hyperv_datastore.go

@@ -18,14 +18,15 @@ package hyperv
 import (
 	"fmt"
 
-	"github.com/prometheus-community/windows_exporter/internal/perfdata"
+	"github.com/prometheus-community/windows_exporter/internal/pdh"
 	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 )
 
 // collectorDataStore Hyper-V DataStore metrics
 type collectorDataStore struct {
-	perfDataCollectorDataStore *perfdata.Collector
+	perfDataCollectorDataStore *pdh.Collector
+	perfDataObjectDataStore    []perfDataCounterValuesDataStore
 
 	dataStoreFragmentationRatio          *prometheus.Desc // \Hyper-V DataStore(*)\Fragmentation ratio
 	dataStoreSectorSize                  *prometheus.Desc // \Hyper-V DataStore(*)\Sector size
@@ -75,107 +76,61 @@ type collectorDataStore struct {
 	dataStoreSetOperationCount           *prometheus.Desc // \Hyper-V DataStore(*)\Set operation count
 }
 
-const (
+type perfDataCounterValuesDataStore struct {
+	Name string
 	// Hyper-V DataStore metrics
-	dataStoreFragmentationRatio          = "Fragmentation ratio"
-	dataStoreSectorSize                  = "Sector size"
-	dataStoreDataAlignment               = "Data alignment"
-	dataStoreCurrentReplayLogSize        = "Current replay logSize"
-	dataStoreAvailableEntries            = "Number of available entries inside object tables"
-	dataStoreEmptyEntries                = "Number of empty entries inside object tables"
-	dataStoreFreeBytes                   = "Number of free bytes inside key tables"
-	dataStoreDataEnd                     = "Data end"
-	dataStoreFileObjects                 = "Number of file objects"
-	dataStoreObjectTables                = "Number of object tables"
-	dataStoreKeyTables                   = "Number of key tables"
-	dataStoreFileDataSize                = "File data size in bytes"
-	dataStoreTableDataSize               = "Table data size in bytes"
-	dataStoreNamesSize                   = "Names size in bytes"
-	dataStoreNumberOfKeys                = "Number of keys"
-	dataStoreReconnectLatencyMicro       = "Reconnect latency microseconds"
-	dataStoreDisconnectCount             = "Disconnect count"
-	dataStoreWriteToFileByteLatency      = "Write to file byte latency microseconds"
-	dataStoreWriteToFileByteCount        = "Write to file byte count"
-	dataStoreWriteToFileCount            = "Write to file count"
-	dataStoreReadFromFileByteLatency     = "Read from file byte latency microseconds"
-	dataStoreReadFromFileByteCount       = "Read from file byte count"
-	dataStoreReadFromFileCount           = "Read from file count"
-	dataStoreWriteToStorageByteLatency   = "Write to storage byte latency microseconds"
-	dataStoreWriteToStorageByteCount     = "Write to storage byte count"
-	dataStoreWriteToStorageCount         = "Write to storage count"
-	dataStoreReadFromStorageByteLatency  = "Read from storage byte latency microseconds"
-	dataStoreReadFromStorageByteCount    = "Read from storage byte count"
-	dataStoreReadFromStorageCount        = "Read from storage count"
-	dataStoreCommitByteLatency           = "Commit byte latency microseconds"
-	dataStoreCommitByteCount             = "Commit byte count"
-	dataStoreCommitCount                 = "Commit count"
-	dataStoreCacheUpdateOperationLatency = "Cache update operation latency microseconds"
-	dataStoreCacheUpdateOperationCount   = "Cache update operation count"
-	dataStoreCommitOperationLatency      = "Commit operation latency microseconds"
-	dataStoreCommitOperationCount        = "Commit operation count"
-	dataStoreCompactOperationLatency     = "Compact operation latency microseconds"
-	dataStoreCompactOperationCount       = "Compact operation count"
-	dataStoreLoadFileOperationLatency    = "Load file operation latency microseconds"
-	dataStoreLoadFileOperationCount      = "Load file operation count"
-	dataStoreRemoveOperationLatency      = "Remove operation latency microseconds"
-	dataStoreRemoveOperationCount        = "Remove operation count"
-	dataStoreQuerySizeOperationLatency   = "Query size operation latency microseconds"
-	dataStoreQuerySizeOperationCount     = "Query size operation count"
-	dataStoreSetOperationLatencyMicro    = "Set operation latency microseconds"
-	dataStoreSetOperationCount           = "Set operation count"
-)
+	DataStoreFragmentationRatio          float64 `perfdata:"Fragmentation ratio"`
+	DataStoreSectorSize                  float64 `perfdata:"Sector size"`
+	DataStoreDataAlignment               float64 `perfdata:"Data alignment"`
+	DataStoreCurrentReplayLogSize        float64 `perfdata:"Current replay logSize"`
+	DataStoreAvailableEntries            float64 `perfdata:"Number of available entries inside object tables"`
+	DataStoreEmptyEntries                float64 `perfdata:"Number of empty entries inside object tables"`
+	DataStoreFreeBytes                   float64 `perfdata:"Number of free bytes inside key tables"`
+	DataStoreDataEnd                     float64 `perfdata:"Data end"`
+	DataStoreFileObjects                 float64 `perfdata:"Number of file objects"`
+	DataStoreObjectTables                float64 `perfdata:"Number of object tables"`
+	DataStoreKeyTables                   float64 `perfdata:"Number of key tables"`
+	DataStoreFileDataSize                float64 `perfdata:"File data size in bytes"`
+	DataStoreTableDataSize               float64 `perfdata:"Table data size in bytes"`
+	DataStoreNamesSize                   float64 `perfdata:"Names size in bytes"`
+	DataStoreNumberOfKeys                float64 `perfdata:"Number of keys"`
+	DataStoreReconnectLatencyMicro       float64 `perfdata:"Reconnect latency microseconds"`
+	DataStoreDisconnectCount             float64 `perfdata:"Disconnect count"`
+	DataStoreWriteToFileByteLatency      float64 `perfdata:"Write to file byte latency microseconds"`
+	DataStoreWriteToFileByteCount        float64 `perfdata:"Write to file byte count"`
+	DataStoreWriteToFileCount            float64 `perfdata:"Write to file count"`
+	DataStoreReadFromFileByteLatency     float64 `perfdata:"Read from file byte latency microseconds"`
+	DataStoreReadFromFileByteCount       float64 `perfdata:"Read from file byte count"`
+	DataStoreReadFromFileCount           float64 `perfdata:"Read from file count"`
+	DataStoreWriteToStorageByteLatency   float64 `perfdata:"Write to storage byte latency microseconds"`
+	DataStoreWriteToStorageByteCount     float64 `perfdata:"Write to storage byte count"`
+	DataStoreWriteToStorageCount         float64 `perfdata:"Write to storage count"`
+	DataStoreReadFromStorageByteLatency  float64 `perfdata:"Read from storage byte latency microseconds"`
+	DataStoreReadFromStorageByteCount    float64 `perfdata:"Read from storage byte count"`
+	DataStoreReadFromStorageCount        float64 `perfdata:"Read from storage count"`
+	DataStoreCommitByteLatency           float64 `perfdata:"Commit byte latency microseconds"`
+	DataStoreCommitByteCount             float64 `perfdata:"Commit byte count"`
+	DataStoreCommitCount                 float64 `perfdata:"Commit count"`
+	DataStoreCacheUpdateOperationLatency float64 `perfdata:"Cache update operation latency microseconds"`
+	DataStoreCacheUpdateOperationCount   float64 `perfdata:"Cache update operation count"`
+	DataStoreCommitOperationLatency      float64 `perfdata:"Commit operation latency microseconds"`
+	DataStoreCommitOperationCount        float64 `perfdata:"Commit operation count"`
+	DataStoreCompactOperationLatency     float64 `perfdata:"Compact operation latency microseconds"`
+	DataStoreCompactOperationCount       float64 `perfdata:"Compact operation count"`
+	DataStoreLoadFileOperationLatency    float64 `perfdata:"Load file operation latency microseconds"`
+	DataStoreLoadFileOperationCount      float64 `perfdata:"Load file operation count"`
+	DataStoreRemoveOperationLatency      float64 `perfdata:"Remove operation latency microseconds"`
+	DataStoreRemoveOperationCount        float64 `perfdata:"Remove operation count"`
+	DataStoreQuerySizeOperationLatency   float64 `perfdata:"Query size operation latency microseconds"`
+	DataStoreQuerySizeOperationCount     float64 `perfdata:"Query size operation count"`
+	DataStoreSetOperationLatencyMicro    float64 `perfdata:"Set operation latency microseconds"`
+	DataStoreSetOperationCount           float64 `perfdata:"Set operation count"`
+}
 
 func (c *Collector) buildDataStore() error {
 	var err error
 
-	c.perfDataCollectorDataStore, err = perfdata.NewCollector("Hyper-V DataStore", perfdata.InstancesAll, []string{
-		dataStoreFragmentationRatio,
-		dataStoreSectorSize,
-		dataStoreDataAlignment,
-		dataStoreCurrentReplayLogSize,
-		dataStoreAvailableEntries,
-		dataStoreEmptyEntries,
-		dataStoreFreeBytes,
-		dataStoreDataEnd,
-		dataStoreFileObjects,
-		dataStoreObjectTables,
-		dataStoreKeyTables,
-		dataStoreFileDataSize,
-		dataStoreTableDataSize,
-		dataStoreNamesSize,
-		dataStoreNumberOfKeys,
-		dataStoreReconnectLatencyMicro,
-		dataStoreDisconnectCount,
-		dataStoreWriteToFileByteLatency,
-		dataStoreWriteToFileByteCount,
-		dataStoreWriteToFileCount,
-		dataStoreReadFromFileByteLatency,
-		dataStoreReadFromFileByteCount,
-		dataStoreReadFromFileCount,
-		dataStoreWriteToStorageByteLatency,
-		dataStoreWriteToStorageByteCount,
-		dataStoreWriteToStorageCount,
-		dataStoreReadFromStorageByteLatency,
-		dataStoreReadFromStorageByteCount,
-		dataStoreReadFromStorageCount,
-		dataStoreCommitByteLatency,
-		dataStoreCommitByteCount,
-		dataStoreCommitCount,
-		dataStoreCacheUpdateOperationLatency,
-		dataStoreCacheUpdateOperationCount,
-		dataStoreCommitOperationLatency,
-		dataStoreCommitOperationCount,
-		dataStoreCompactOperationLatency,
-		dataStoreCompactOperationCount,
-		dataStoreLoadFileOperationLatency,
-		dataStoreLoadFileOperationCount,
-		dataStoreRemoveOperationLatency,
-		dataStoreRemoveOperationCount,
-		dataStoreQuerySizeOperationLatency,
-		dataStoreQuerySizeOperationCount,
-		dataStoreSetOperationLatencyMicro,
-		dataStoreSetOperationCount,
-	})
+	c.perfDataCollectorDataStore, err = pdh.NewCollector[perfDataCounterValuesDataStore]("Hyper-V DataStore", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create Hyper-V DataStore collector: %w", err)
 	}
@@ -461,332 +416,332 @@ func (c *Collector) buildDataStore() error {
 }
 
 func (c *Collector) collectDataStore(ch chan<- prometheus.Metric) error {
-	data, err := c.perfDataCollectorDataStore.Collect()
+	err := c.perfDataCollectorDataStore.Collect(&c.perfDataObjectDataStore)
 	if err != nil {
 		return fmt.Errorf("failed to collect Hyper-V DataStore metrics: %w", err)
 	}
 
-	for name, page := range data {
+	for _, data := range c.perfDataObjectDataStore {
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreFragmentationRatio,
 			prometheus.GaugeValue,
-			page[dataStoreFragmentationRatio].FirstValue,
-			name,
+			data.DataStoreFragmentationRatio,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreSectorSize,
 			prometheus.GaugeValue,
-			page[dataStoreSectorSize].FirstValue,
-			name,
+			data.DataStoreSectorSize,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreDataAlignment,
 			prometheus.GaugeValue,
-			page[dataStoreDataAlignment].FirstValue,
-			name,
+			data.DataStoreDataAlignment,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreCurrentReplayLogSize,
 			prometheus.GaugeValue,
-			page[dataStoreCurrentReplayLogSize].FirstValue,
-			name,
+			data.DataStoreCurrentReplayLogSize,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreAvailableEntries,
 			prometheus.GaugeValue,
-			page[dataStoreAvailableEntries].FirstValue,
-			name,
+			data.DataStoreAvailableEntries,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreEmptyEntries,
 			prometheus.GaugeValue,
-			page[dataStoreEmptyEntries].FirstValue,
-			name,
+			data.DataStoreEmptyEntries,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreFreeBytes,
 			prometheus.GaugeValue,
-			page[dataStoreFreeBytes].FirstValue,
-			name,
+			data.DataStoreFreeBytes,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreDataEnd,
 			prometheus.GaugeValue,
-			page[dataStoreDataEnd].FirstValue,
-			name,
+			data.DataStoreDataEnd,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreFileObjects,
 			prometheus.GaugeValue,
-			page[dataStoreFileObjects].FirstValue,
-			name,
+			data.DataStoreFileObjects,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreObjectTables,
 			prometheus.GaugeValue,
-			page[dataStoreObjectTables].FirstValue,
-			name,
+			data.DataStoreObjectTables,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreKeyTables,
 			prometheus.GaugeValue,
-			page[dataStoreKeyTables].FirstValue,
-			name,
+			data.DataStoreKeyTables,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreFileDataSize,
 			prometheus.GaugeValue,
-			page[dataStoreFileDataSize].FirstValue,
-			name,
+			data.DataStoreFileDataSize,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreTableDataSize,
 			prometheus.GaugeValue,
-			page[dataStoreTableDataSize].FirstValue,
-			name,
+			data.DataStoreTableDataSize,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreNamesSize,
 			prometheus.GaugeValue,
-			page[dataStoreNamesSize].FirstValue,
-			name,
+			data.DataStoreNamesSize,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreNumberOfKeys,
 			prometheus.GaugeValue,
-			page[dataStoreNumberOfKeys].FirstValue,
-			name,
+			data.DataStoreNumberOfKeys,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreReconnectLatencyMicro,
 			prometheus.GaugeValue,
-			page[dataStoreReconnectLatencyMicro].FirstValue,
-			name,
+			data.DataStoreReconnectLatencyMicro,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreDisconnectCount,
 			prometheus.CounterValue,
-			page[dataStoreDisconnectCount].FirstValue,
-			name,
+			data.DataStoreDisconnectCount,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreWriteToFileByteLatency,
 			prometheus.GaugeValue,
-			page[dataStoreWriteToFileByteLatency].FirstValue,
-			name,
+			data.DataStoreWriteToFileByteLatency,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreWriteToFileByteCount,
 			prometheus.CounterValue,
-			page[dataStoreWriteToFileByteCount].FirstValue,
-			name,
+			data.DataStoreWriteToFileByteCount,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreWriteToFileCount,
 			prometheus.CounterValue,
-			page[dataStoreWriteToFileCount].FirstValue,
-			name,
+			data.DataStoreWriteToFileCount,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreReadFromFileByteLatency,
 			prometheus.GaugeValue,
-			page[dataStoreReadFromFileByteLatency].FirstValue,
-			name,
+			data.DataStoreReadFromFileByteLatency,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreReadFromFileByteCount,
 			prometheus.CounterValue,
-			page[dataStoreReadFromFileByteCount].FirstValue,
-			name,
+			data.DataStoreReadFromFileByteCount,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreReadFromFileCount,
 			prometheus.CounterValue,
-			page[dataStoreReadFromFileCount].FirstValue,
-			name,
+			data.DataStoreReadFromFileCount,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreWriteToStorageByteLatency,
 			prometheus.GaugeValue,
-			page[dataStoreWriteToStorageByteLatency].FirstValue,
-			name,
+			data.DataStoreWriteToStorageByteLatency,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreWriteToStorageByteCount,
 			prometheus.CounterValue,
-			page[dataStoreWriteToStorageByteCount].FirstValue,
-			name,
+			data.DataStoreWriteToStorageByteCount,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreWriteToStorageCount,
 			prometheus.CounterValue,
-			page[dataStoreWriteToStorageCount].FirstValue,
-			name,
+			data.DataStoreWriteToStorageCount,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreReadFromStorageByteLatency,
 			prometheus.GaugeValue,
-			page[dataStoreReadFromStorageByteLatency].FirstValue,
-			name,
+			data.DataStoreReadFromStorageByteLatency,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreReadFromStorageByteCount,
 			prometheus.CounterValue,
-			page[dataStoreReadFromStorageByteCount].FirstValue,
-			name,
+			data.DataStoreReadFromStorageByteCount,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreReadFromStorageCount,
 			prometheus.CounterValue,
-			page[dataStoreReadFromStorageCount].FirstValue,
-			name,
+			data.DataStoreReadFromStorageCount,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreCommitByteLatency,
 			prometheus.GaugeValue,
-			page[dataStoreCommitByteLatency].FirstValue,
-			name,
+			data.DataStoreCommitByteLatency,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreCommitByteCount,
 			prometheus.CounterValue,
-			page[dataStoreCommitByteCount].FirstValue,
-			name,
+			data.DataStoreCommitByteCount,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreCommitCount,
 			prometheus.CounterValue,
-			page[dataStoreCommitCount].FirstValue,
-			name,
+			data.DataStoreCommitCount,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreCacheUpdateOperationLatency,
 			prometheus.GaugeValue,
-			page[dataStoreCacheUpdateOperationLatency].FirstValue,
-			name,
+			data.DataStoreCacheUpdateOperationLatency,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreCacheUpdateOperationCount,
 			prometheus.CounterValue,
-			page[dataStoreCacheUpdateOperationCount].FirstValue,
-			name,
+			data.DataStoreCacheUpdateOperationCount,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreCommitOperationLatency,
 			prometheus.GaugeValue,
-			page[dataStoreCommitOperationLatency].FirstValue,
-			name,
+			data.DataStoreCommitOperationLatency,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreCommitOperationCount,
 			prometheus.CounterValue,
-			page[dataStoreCommitOperationCount].FirstValue,
-			name,
+			data.DataStoreCommitOperationCount,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreCompactOperationLatency,
 			prometheus.GaugeValue,
-			page[dataStoreCompactOperationLatency].FirstValue,
-			name,
+			data.DataStoreCompactOperationLatency,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreCompactOperationCount,
 			prometheus.CounterValue,
-			page[dataStoreCompactOperationCount].FirstValue,
-			name,
+			data.DataStoreCompactOperationCount,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreLoadFileOperationLatency,
 			prometheus.GaugeValue,
-			page[dataStoreLoadFileOperationLatency].FirstValue,
-			name,
+			data.DataStoreLoadFileOperationLatency,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreLoadFileOperationCount,
 			prometheus.CounterValue,
-			page[dataStoreLoadFileOperationCount].FirstValue,
-			name,
+			data.DataStoreLoadFileOperationCount,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreRemoveOperationLatency,
 			prometheus.GaugeValue,
-			page[dataStoreRemoveOperationLatency].FirstValue,
-			name,
+			data.DataStoreRemoveOperationLatency,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreRemoveOperationCount,
 			prometheus.CounterValue,
-			page[dataStoreRemoveOperationCount].FirstValue,
-			name,
+			data.DataStoreRemoveOperationCount,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreQuerySizeOperationLatency,
 			prometheus.GaugeValue,
-			page[dataStoreQuerySizeOperationLatency].FirstValue,
-			name,
+			data.DataStoreQuerySizeOperationLatency,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreQuerySizeOperationCount,
 			prometheus.CounterValue,
-			page[dataStoreQuerySizeOperationCount].FirstValue,
-			name,
+			data.DataStoreQuerySizeOperationCount,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreSetOperationLatencyMicro,
 			prometheus.GaugeValue,
-			page[dataStoreSetOperationLatencyMicro].FirstValue,
-			name,
+			data.DataStoreSetOperationLatencyMicro,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.dataStoreSetOperationCount,
 			prometheus.CounterValue,
-			page[dataStoreSetOperationCount].FirstValue,
-			name,
+			data.DataStoreSetOperationCount,
+			data.Name,
 		)
 	}
 

internal/collector/hyperv/hyperv_dynamic_memory_balancer.go

@@ -18,7 +18,7 @@ package hyperv
 import (
 	"fmt"
 
-	"github.com/prometheus-community/windows_exporter/internal/perfdata"
+	"github.com/prometheus-community/windows_exporter/internal/pdh"
 	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus-community/windows_exporter/internal/utils"
 	"github.com/prometheus/client_golang/prometheus"
@@ -26,31 +26,30 @@ import (
 
 // collectorDynamicMemoryBalancer Hyper-V Dynamic Memory Balancer metrics
 type collectorDynamicMemoryBalancer struct {
-	perfDataCollectorDynamicMemoryBalancer             *perfdata.Collector
+	perfDataCollectorDynamicMemoryBalancer *pdh.Collector
+	perfDataObjectDynamicMemoryBalancer    []perfDataCounterValuesDynamicMemoryBalancer
+
 	vmDynamicMemoryBalancerAvailableMemoryForBalancing *prometheus.Desc // \Hyper-V Dynamic Memory Balancer(*)\Available Memory For Balancing
 	vmDynamicMemoryBalancerSystemCurrentPressure       *prometheus.Desc // \Hyper-V Dynamic Memory Balancer(*)\System Current Pressure
 	vmDynamicMemoryBalancerAvailableMemory             *prometheus.Desc // \Hyper-V Dynamic Memory Balancer(*)\Available Memory
 	vmDynamicMemoryBalancerAveragePressure             *prometheus.Desc // \Hyper-V Dynamic Memory Balancer(*)\Average Pressure
 }
 
-const (
+type perfDataCounterValuesDynamicMemoryBalancer struct {
+	Name string
+
 	// Hyper-V Dynamic Memory Balancer metrics
-	vmDynamicMemoryBalancerAvailableMemory             = "Available Memory"
-	vmDynamicMemoryBalancerAvailableMemoryForBalancing = "Available Memory For Balancing"
-	vmDynamicMemoryBalancerAveragePressure             = "Average Pressure"
-	vmDynamicMemoryBalancerSystemCurrentPressure       = "System Current Pressure"
-)
+	VmDynamicMemoryBalancerAvailableMemory             float64 `perfdata:"Available Memory"`
+	VmDynamicMemoryBalancerAvailableMemoryForBalancing float64 `perfdata:"Available Memory For Balancing"`
+	VmDynamicMemoryBalancerAveragePressure             float64 `perfdata:"Average Pressure"`
+	VmDynamicMemoryBalancerSystemCurrentPressure       float64 `perfdata:"System Current Pressure"`
+}
 
 func (c *Collector) buildDynamicMemoryBalancer() error {
 	var err error
 
 	// https://learn.microsoft.com/en-us/archive/blogs/chrisavis/monitoring-dynamic-memory-in-windows-server-hyper-v-2012
-	c.perfDataCollectorDynamicMemoryBalancer, err = perfdata.NewCollector("Hyper-V Dynamic Memory Balancer", perfdata.InstancesAll, []string{
-		vmDynamicMemoryBalancerAvailableMemory,
-		vmDynamicMemoryBalancerAvailableMemoryForBalancing,
-		vmDynamicMemoryBalancerAveragePressure,
-		vmDynamicMemoryBalancerSystemCurrentPressure,
-	})
+	c.perfDataCollectorDynamicMemoryBalancer, err = pdh.NewCollector[perfDataCounterValuesDynamicMemoryBalancer]("Hyper-V Dynamic Memory Balancer", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create Hyper-V Virtual Machine Health Summary collector: %w", err)
 	}
@@ -84,38 +83,38 @@ func (c *Collector) buildDynamicMemoryBalancer() error {
 }
 
 func (c *Collector) collectDynamicMemoryBalancer(ch chan<- prometheus.Metric) error {
-	data, err := c.perfDataCollectorDynamicMemoryBalancer.Collect()
+	err := c.perfDataCollectorDynamicMemoryBalancer.Collect(&c.perfDataObjectDynamicMemoryBalancer)
 	if err != nil {
 		return fmt.Errorf("failed to collect Hyper-V Dynamic Memory Balancer metrics: %w", err)
 	}
 
-	for name, page := range data {
+	for _, data := range c.perfDataObjectDynamicMemoryBalancer {
 		ch <- prometheus.MustNewConstMetric(
 			c.vmDynamicMemoryBalancerAvailableMemory,
 			prometheus.GaugeValue,
-			utils.MBToBytes(page[vmDynamicMemoryBalancerAvailableMemory].FirstValue),
-			name,
+			utils.MBToBytes(data.VmDynamicMemoryBalancerAvailableMemory),
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.vmDynamicMemoryBalancerAvailableMemoryForBalancing,
 			prometheus.GaugeValue,
-			utils.MBToBytes(page[vmDynamicMemoryBalancerAvailableMemoryForBalancing].FirstValue),
-			name,
+			utils.MBToBytes(data.VmDynamicMemoryBalancerAvailableMemoryForBalancing),
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.vmDynamicMemoryBalancerAveragePressure,
 			prometheus.GaugeValue,
-			utils.PercentageToRatio(page[vmDynamicMemoryBalancerAveragePressure].FirstValue),
-			name,
+			utils.PercentageToRatio(data.VmDynamicMemoryBalancerAveragePressure),
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.vmDynamicMemoryBalancerSystemCurrentPressure,
 			prometheus.GaugeValue,
-			utils.PercentageToRatio(page[vmDynamicMemoryBalancerSystemCurrentPressure].FirstValue),
-			name,
+			utils.PercentageToRatio(data.VmDynamicMemoryBalancerSystemCurrentPressure),
+			data.Name,
 		)
 	}
 

internal/collector/hyperv/hyperv_dynamic_memory_vm.go

@@ -18,7 +18,7 @@ package hyperv
 import (
 	"fmt"
 
-	"github.com/prometheus-community/windows_exporter/internal/perfdata"
+	"github.com/prometheus-community/windows_exporter/internal/pdh"
 	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus-community/windows_exporter/internal/utils"
 	"github.com/prometheus/client_golang/prometheus"
@@ -26,7 +26,9 @@ import (
 
 // collectorDynamicMemoryVM Hyper-V Dynamic Memory VM metrics
 type collectorDynamicMemoryVM struct {
-	perfDataCollectorDynamicMemoryVM   *perfdata.Collector
+	perfDataCollectorDynamicMemoryVM *pdh.Collector
+	perfDataObjectDynamicMemoryVM    []perfDataCounterValuesDynamicMemoryVM
+
 	vmMemoryAddedMemory                *prometheus.Desc // \Hyper-V Dynamic Memory VM(*)\Added Memory
 	vmMemoryCurrentPressure            *prometheus.Desc // \Hyper-V Dynamic Memory VM(*)\Current Pressure
 	vmMemoryGuestVisiblePhysicalMemory *prometheus.Desc // \Hyper-V Dynamic Memory VM(*)\Guest Visible Physical Memory
@@ -39,35 +41,26 @@ type collectorDynamicMemoryVM struct {
 	vmMemoryGuestAvailableMemory       *prometheus.Desc // \Hyper-V Dynamic Memory VM(*)\Guest Available Memory
 }
 
-const (
+type perfDataCounterValuesDynamicMemoryVM struct {
+	Name string
+
 	// Hyper-V Dynamic Memory VM metrics
-	vmMemoryAddedMemory                = "Added Memory"
-	vmMemoryCurrentPressure            = "Current Pressure"
-	vmMemoryGuestAvailableMemory       = "Guest Available Memory"
-	vmMemoryGuestVisiblePhysicalMemory = "Guest Visible Physical Memory"
-	vmMemoryMaximumPressure            = "Maximum Pressure"
-	vmMemoryMemoryAddOperations        = "Memory Add Operations"
-	vmMemoryMemoryRemoveOperations     = "Memory Remove Operations"
-	vmMemoryMinimumPressure            = "Minimum Pressure"
-	vmMemoryPhysicalMemory             = "Physical Memory"
-	vmMemoryRemovedMemory              = "Removed Memory"
-)
+	VmMemoryAddedMemory                float64 `perfdata:"Added Memory"`
+	VmMemoryCurrentPressure            float64 `perfdata:"Current Pressure"`
+	VmMemoryGuestAvailableMemory       float64 `perfdata:"Guest Available Memory"`
+	VmMemoryGuestVisiblePhysicalMemory float64 `perfdata:"Guest Visible Physical Memory"`
+	VmMemoryMaximumPressure            float64 `perfdata:"Maximum Pressure"`
+	VmMemoryMemoryAddOperations        float64 `perfdata:"Memory Add Operations"`
+	VmMemoryMemoryRemoveOperations     float64 `perfdata:"Memory Remove Operations"`
+	VmMemoryMinimumPressure            float64 `perfdata:"Minimum Pressure"`
+	VmMemoryPhysicalMemory             float64 `perfdata:"Physical Memory"`
+	VmMemoryRemovedMemory              float64 `perfdata:"Removed Memory"`
+}
 
 func (c *Collector) buildDynamicMemoryVM() error {
 	var err error
 
-	c.perfDataCollectorDynamicMemoryVM, err = perfdata.NewCollector("Hyper-V Dynamic Memory VM", perfdata.InstancesAll, []string{
-		vmMemoryAddedMemory,
-		vmMemoryCurrentPressure,
-		vmMemoryGuestVisiblePhysicalMemory,
-		vmMemoryMaximumPressure,
-		vmMemoryMemoryAddOperations,
-		vmMemoryMemoryRemoveOperations,
-		vmMemoryMinimumPressure,
-		vmMemoryPhysicalMemory,
-		vmMemoryRemovedMemory,
-		vmMemoryGuestAvailableMemory,
-	})
+	c.perfDataCollectorDynamicMemoryVM, err = pdh.NewCollector[perfDataCounterValuesDynamicMemoryVM]("Hyper-V Dynamic Memory VM", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create Hyper-V Dynamic Memory VM collector: %w", err)
 	}
@@ -137,80 +130,80 @@ func (c *Collector) buildDynamicMemoryVM() error {
 }
 
 func (c *Collector) collectDynamicMemoryVM(ch chan<- prometheus.Metric) error {
-	data, err := c.perfDataCollectorDynamicMemoryVM.Collect()
+	err := c.perfDataCollectorDynamicMemoryVM.Collect(&c.perfDataObjectDynamicMemoryVM)
 	if err != nil {
 		return fmt.Errorf("failed to collect Hyper-V Dynamic Memory VM metrics: %w", err)
 	}
 
-	for vmName, vmData := range data {
+	for _, data := range c.perfDataObjectDynamicMemoryVM {
 		ch <- prometheus.MustNewConstMetric(
 			c.vmMemoryAddedMemory,
 			prometheus.CounterValue,
-			utils.MBToBytes(vmData[vmMemoryAddedMemory].FirstValue),
-			vmName,
+			utils.MBToBytes(data.VmMemoryAddedMemory),
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.vmMemoryCurrentPressure,
 			prometheus.GaugeValue,
-			utils.PercentageToRatio(vmData[vmMemoryCurrentPressure].FirstValue),
-			vmName,
+			utils.PercentageToRatio(data.VmMemoryCurrentPressure),
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.vmMemoryGuestAvailableMemory,
 			prometheus.GaugeValue,
-			utils.MBToBytes(vmData[vmMemoryGuestAvailableMemory].FirstValue),
-			vmName,
+			utils.MBToBytes(data.VmMemoryGuestAvailableMemory),
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.vmMemoryGuestVisiblePhysicalMemory,
 			prometheus.GaugeValue,
-			utils.MBToBytes(vmData[vmMemoryGuestVisiblePhysicalMemory].FirstValue),
-			vmName,
+			utils.MBToBytes(data.VmMemoryGuestVisiblePhysicalMemory),
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.vmMemoryMaximumPressure,
 			prometheus.GaugeValue,
-			utils.PercentageToRatio(vmData[vmMemoryMaximumPressure].FirstValue),
-			vmName,
+			utils.PercentageToRatio(data.VmMemoryMaximumPressure),
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.vmMemoryMemoryAddOperations,
 			prometheus.CounterValue,
-			vmData[vmMemoryMemoryAddOperations].FirstValue,
-			vmName,
+			data.VmMemoryMemoryAddOperations,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.vmMemoryMemoryRemoveOperations,
 			prometheus.CounterValue,
-			vmData[vmMemoryMemoryRemoveOperations].FirstValue,
-			vmName,
+			data.VmMemoryMemoryRemoveOperations,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.vmMemoryMinimumPressure,
 			prometheus.GaugeValue,
-			utils.PercentageToRatio(vmData[vmMemoryMinimumPressure].FirstValue),
-			vmName,
+			utils.PercentageToRatio(data.VmMemoryMinimumPressure),
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.vmMemoryPhysicalMemory,
 			prometheus.GaugeValue,
-			utils.MBToBytes(vmData[vmMemoryPhysicalMemory].FirstValue),
-			vmName,
+			utils.MBToBytes(data.VmMemoryPhysicalMemory),
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.vmMemoryRemovedMemory,
 			prometheus.CounterValue,
-			utils.MBToBytes(vmData[vmMemoryRemovedMemory].FirstValue),
-			vmName,
+			utils.MBToBytes(data.VmMemoryRemovedMemory),
+			data.Name,
 		)
 	}
 

internal/collector/hyperv/hyperv_hypervisor_logical_processor.go

@@ -19,14 +19,15 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/prometheus-community/windows_exporter/internal/perfdata"
+	"github.com/prometheus-community/windows_exporter/internal/pdh"
 	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 )
 
 // collectorHypervisorLogicalProcessor Hyper-V Hypervisor Logical Processor metrics
 type collectorHypervisorLogicalProcessor struct {
-	perfDataCollectorHypervisorLogicalProcessor *perfdata.Collector
+	perfDataCollectorHypervisorLogicalProcessor *pdh.Collector
+	perfDataObjectHypervisorLogicalProcessor    []perfDataCounterValuesHypervisorLogicalProcessor
 
 	// \Hyper-V Hypervisor Logical Processor(*)\% Guest Run Time
 	// \Hyper-V Hypervisor Logical Processor(*)\% Hypervisor Run Time
@@ -36,24 +37,20 @@ type collectorHypervisorLogicalProcessor struct {
 	hypervisorLogicalProcessorContextSwitches   *prometheus.Desc // \Hyper-V Hypervisor Logical Processor(*)\Context Switches/sec
 }
 
-const (
-	hypervisorLogicalProcessorGuestRunTimePercent      = "% Guest Run Time"
-	hypervisorLogicalProcessorHypervisorRunTimePercent = "% Hypervisor Run Time"
-	hypervisorLogicalProcessorTotalRunTimePercent      = "% Total Run Time"
-	hypervisorLogicalProcessorIdleRunTimePercent       = "% Idle Time"
-	hypervisorLogicalProcessorContextSwitches          = "Context Switches/sec"
-)
+type perfDataCounterValuesHypervisorLogicalProcessor struct {
+	Name string
+
+	HypervisorLogicalProcessorGuestRunTimePercent      float64 `perfdata:"% Guest Run Time"`
+	HypervisorLogicalProcessorHypervisorRunTimePercent float64 `perfdata:"% Hypervisor Run Time"`
+	HypervisorLogicalProcessorTotalRunTimePercent      float64 `perfdata:"% Total Run Time"`
+	HypervisorLogicalProcessorIdleRunTimePercent       float64 `perfdata:"% Idle Time"`
+	HypervisorLogicalProcessorContextSwitches          float64 `perfdata:"Context Switches/sec"`
+}
 
 func (c *Collector) buildHypervisorLogicalProcessor() error {
 	var err error
 
-	c.perfDataCollectorHypervisorLogicalProcessor, err = perfdata.NewCollector("Hyper-V Hypervisor Logical Processor", perfdata.InstancesAll, []string{
-		hypervisorLogicalProcessorGuestRunTimePercent,
-		hypervisorLogicalProcessorHypervisorRunTimePercent,
-		hypervisorLogicalProcessorTotalRunTimePercent,
-		hypervisorLogicalProcessorIdleRunTimePercent,
-		hypervisorLogicalProcessorContextSwitches,
-	})
+	c.perfDataCollectorHypervisorLogicalProcessor, err = pdh.NewCollector[perfDataCounterValuesHypervisorLogicalProcessor]("Hyper-V Hypervisor Logical Processor", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create Hyper-V Hypervisor Logical Processor collector: %w", err)
 	}
@@ -82,53 +79,53 @@ func (c *Collector) buildHypervisorLogicalProcessor() error {
 }
 
 func (c *Collector) collectHypervisorLogicalProcessor(ch chan<- prometheus.Metric) error {
-	data, err := c.perfDataCollectorHypervisorLogicalProcessor.Collect()
+	err := c.perfDataCollectorHypervisorLogicalProcessor.Collect(&c.perfDataObjectHypervisorLogicalProcessor)
 	if err != nil {
 		return fmt.Errorf("failed to collect Hyper-V Hypervisor Logical Processor metrics: %w", err)
 	}
 
-	for coreName, coreData := range data {
+	for _, data := range c.perfDataObjectHypervisorLogicalProcessor {
 		// The name format is Hv LP <core id>
-		parts := strings.Split(coreName, " ")
+		parts := strings.Split(data.Name, " ")
 		if len(parts) != 3 {
-			return fmt.Errorf("unexpected Hyper-V Hypervisor Logical Processor name format: %s", coreName)
+			return fmt.Errorf("unexpected Hyper-V Hypervisor Logical Processor name format: %s", data.Name)
 		}
 
-		coreId := parts[2]
+		coreID := parts[2]
 
 		ch <- prometheus.MustNewConstMetric(
 			c.hypervisorLogicalProcessorTimeTotal,
 			prometheus.CounterValue,
-			coreData[hypervisorLogicalProcessorGuestRunTimePercent].FirstValue,
-			coreId, "guest",
+			data.HypervisorLogicalProcessorGuestRunTimePercent,
+			coreID, "guest",
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.hypervisorLogicalProcessorTimeTotal,
 			prometheus.CounterValue,
-			coreData[hypervisorLogicalProcessorHypervisorRunTimePercent].FirstValue,
-			coreId, "hypervisor",
+			data.HypervisorLogicalProcessorHypervisorRunTimePercent,
+			coreID, "hypervisor",
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.hypervisorLogicalProcessorTimeTotal,
 			prometheus.CounterValue,
-			coreData[hypervisorLogicalProcessorIdleRunTimePercent].FirstValue,
-			coreId, "idle",
+			data.HypervisorLogicalProcessorIdleRunTimePercent,
+			coreID, "idle",
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.hypervisorLogicalProcessorTotalRunTimeTotal,
 			prometheus.CounterValue,
-			coreData[hypervisorLogicalProcessorTotalRunTimePercent].FirstValue,
-			coreId,
+			data.HypervisorLogicalProcessorTotalRunTimePercent,
+			coreID,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.hypervisorLogicalProcessorContextSwitches,
 			prometheus.CounterValue,
-			coreData[hypervisorLogicalProcessorContextSwitches].FirstValue,
-			coreId,
+			data.HypervisorLogicalProcessorContextSwitches,
+			coreID,
 		)
 	}
 

internal/collector/hyperv/hyperv_hypervisor_root_partition.go

@@ -16,17 +16,18 @@
 package hyperv
 
 import (
-	"errors"
 	"fmt"
 
-	"github.com/prometheus-community/windows_exporter/internal/perfdata"
+	"github.com/prometheus-community/windows_exporter/internal/pdh"
 	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 )
 
 // collectorHypervisorRootPartition Hyper-V Hypervisor Root Partition metrics
 type collectorHypervisorRootPartition struct {
-	perfDataCollectorHypervisorRootPartition             *perfdata.Collector
+	perfDataCollectorHypervisorRootPartition *pdh.Collector
+	perfDataObjectHypervisorRootPartition    []perfDataCounterValuesHypervisorRootPartition
+
 	hypervisorRootPartitionAddressSpaces                 *prometheus.Desc // \Hyper-V Hypervisor Root Partition(*)\Address Spaces
 	hypervisorRootPartitionAttachedDevices               *prometheus.Desc // \Hyper-V Hypervisor Root Partition(*)\Attached Devices
 	hypervisorRootPartitionDepositedPages                *prometheus.Desc // \Hyper-V Hypervisor Root Partition(*)\Deposited Pages
@@ -50,56 +51,34 @@ type collectorHypervisorRootPartition struct {
 	hypervisorRootPartitionVirtualTLBPages               *prometheus.Desc // \Hyper-V Hypervisor Root Partition(*)\Virtual TLB Pages
 }
 
-const (
-	hypervisorRootPartitionAddressSpaces                 = "Address Spaces"
-	hypervisorRootPartitionAttachedDevices               = "Attached Devices"
-	hypervisorRootPartitionDepositedPages                = "Deposited Pages"
-	hypervisorRootPartitionDeviceDMAErrors               = "Device DMA Errors"
-	hypervisorRootPartitionDeviceInterruptErrors         = "Device Interrupt Errors"
-	hypervisorRootPartitionDeviceInterruptMappings       = "Device Interrupt Mappings"
-	hypervisorRootPartitionDeviceInterruptThrottleEvents = "Device Interrupt Throttle Events"
-	hypervisorRootPartitionGPAPages                      = "GPA Pages"
-	hypervisorRootPartitionGPASpaceModifications         = "GPA Space Modifications/sec"
-	hypervisorRootPartitionIOTLBFlushCost                = "I/O TLB Flush Cost"
-	hypervisorRootPartitionIOTLBFlushes                  = "I/O TLB Flushes/sec"
-	hypervisorRootPartitionRecommendedVirtualTLBSize     = "Recommended Virtual TLB Size"
-	hypervisorRootPartitionSkippedTimerTicks             = "Skipped Timer Ticks"
-	hypervisorRootPartition1GDevicePages                 = "1G device pages"
-	hypervisorRootPartition1GGPAPages                    = "1G GPA pages"
-	hypervisorRootPartition2MDevicePages                 = "2M device pages"
-	hypervisorRootPartition2MGPAPages                    = "2M GPA pages"
-	hypervisorRootPartition4KDevicePages                 = "4K device pages"
-	hypervisorRootPartition4KGPAPages                    = "4K GPA pages"
-	hypervisorRootPartitionVirtualTLBFlushEntries        = "Virtual TLB Flush Entires/sec"
-	hypervisorRootPartitionVirtualTLBPages               = "Virtual TLB Pages"
-)
+type perfDataCounterValuesHypervisorRootPartition struct {
+	HypervisorRootPartitionAddressSpaces                 float64 `perfdata:"Address Spaces"`
+	HypervisorRootPartitionAttachedDevices               float64 `perfdata:"Attached Devices"`
+	HypervisorRootPartitionDepositedPages                float64 `perfdata:"Deposited Pages"`
+	HypervisorRootPartitionDeviceDMAErrors               float64 `perfdata:"Device DMA Errors"`
+	HypervisorRootPartitionDeviceInterruptErrors         float64 `perfdata:"Device Interrupt Errors"`
+	HypervisorRootPartitionDeviceInterruptMappings       float64 `perfdata:"Device Interrupt Mappings"`
+	HypervisorRootPartitionDeviceInterruptThrottleEvents float64 `perfdata:"Device Interrupt Throttle Events"`
+	HypervisorRootPartitionGPAPages                      float64 `perfdata:"GPA Pages"`
+	HypervisorRootPartitionGPASpaceModifications         float64 `perfdata:"GPA Space Modifications/sec"`
+	HypervisorRootPartitionIOTLBFlushCost                float64 `perfdata:"I/O TLB Flush Cost"`
+	HypervisorRootPartitionIOTLBFlushes                  float64 `perfdata:"I/O TLB Flushes/sec"`
+	HypervisorRootPartitionRecommendedVirtualTLBSize     float64 `perfdata:"Recommended Virtual TLB Size"`
+	HypervisorRootPartitionSkippedTimerTicks             float64 `perfdata:"Skipped Timer Ticks"`
+	HypervisorRootPartition1GDevicePages                 float64 `perfdata:"1G device pages"`
+	HypervisorRootPartition1GGPAPages                    float64 `perfdata:"1G GPA pages"`
+	HypervisorRootPartition2MDevicePages                 float64 `perfdata:"2M device pages"`
+	HypervisorRootPartition2MGPAPages                    float64 `perfdata:"2M GPA pages"`
+	HypervisorRootPartition4KDevicePages                 float64 `perfdata:"4K device pages"`
+	HypervisorRootPartition4KGPAPages                    float64 `perfdata:"4K GPA pages"`
+	HypervisorRootPartitionVirtualTLBFlushEntries        float64 `perfdata:"Virtual TLB Flush Entires/sec"`
+	HypervisorRootPartitionVirtualTLBPages               float64 `perfdata:"Virtual TLB Pages"`
+}
 
 func (c *Collector) buildHypervisorRootPartition() error {
 	var err error
 
-	c.perfDataCollectorHypervisorRootPartition, err = perfdata.NewCollector("Hyper-V Hypervisor Root Partition", []string{"Root"}, []string{
-		hypervisorRootPartitionAddressSpaces,
-		hypervisorRootPartitionAttachedDevices,
-		hypervisorRootPartitionDepositedPages,
-		hypervisorRootPartitionDeviceDMAErrors,
-		hypervisorRootPartitionDeviceInterruptErrors,
-		hypervisorRootPartitionDeviceInterruptMappings,
-		hypervisorRootPartitionDeviceInterruptThrottleEvents,
-		hypervisorRootPartitionGPAPages,
-		hypervisorRootPartitionGPASpaceModifications,
-		hypervisorRootPartitionIOTLBFlushCost,
-		hypervisorRootPartitionIOTLBFlushes,
-		hypervisorRootPartitionRecommendedVirtualTLBSize,
-		hypervisorRootPartitionSkippedTimerTicks,
-		hypervisorRootPartition1GDevicePages,
-		hypervisorRootPartition1GGPAPages,
-		hypervisorRootPartition2MDevicePages,
-		hypervisorRootPartition2MGPAPages,
-		hypervisorRootPartition4KDevicePages,
-		hypervisorRootPartition4KGPAPages,
-		hypervisorRootPartitionVirtualTLBFlushEntries,
-		hypervisorRootPartitionVirtualTLBPages,
-	})
+	c.perfDataCollectorHypervisorRootPartition, err = pdh.NewCollector[perfDataCounterValuesHypervisorRootPartition]("Hyper-V Hypervisor Root Partition", []string{"Root"})
 	if err != nil {
 		return fmt.Errorf("failed to create Hyper-V Hypervisor Root Partition collector: %w", err)
 	}
@@ -235,129 +214,124 @@ func (c *Collector) buildHypervisorRootPartition() error {
 }
 
 func (c *Collector) collectHypervisorRootPartition(ch chan<- prometheus.Metric) error {
-	data, err := c.perfDataCollectorHypervisorRootPartition.Collect()
+	err := c.perfDataCollectorHypervisorRootPartition.Collect(&c.perfDataObjectHypervisorRootPartition)
 	if err != nil {
 		return fmt.Errorf("failed to collect Hyper-V Hypervisor Root Partition metrics: %w", err)
 	}
 
-	rootData, ok := data["Root"]
-	if !ok {
-		return errors.New("no data returned from Hyper-V Hypervisor Root Partition")
-	}
-
 	ch <- prometheus.MustNewConstMetric(
 		c.hypervisorRootPartitionAddressSpaces,
 		prometheus.GaugeValue,
-		rootData[hypervisorRootPartitionAddressSpaces].FirstValue,
+		c.perfDataObjectHypervisorRootPartition[0].HypervisorRootPartitionAddressSpaces,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.hypervisorRootPartitionAttachedDevices,
 		prometheus.GaugeValue,
-		rootData[hypervisorRootPartitionAttachedDevices].FirstValue,
+		c.perfDataObjectHypervisorRootPartition[0].HypervisorRootPartitionAttachedDevices,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.hypervisorRootPartitionDepositedPages,
 		prometheus.GaugeValue,
-		rootData[hypervisorRootPartitionDepositedPages].FirstValue,
+		c.perfDataObjectHypervisorRootPartition[0].HypervisorRootPartitionDepositedPages,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.hypervisorRootPartitionDeviceDMAErrors,
 		prometheus.GaugeValue,
-		rootData[hypervisorRootPartitionDeviceDMAErrors].FirstValue,
+		c.perfDataObjectHypervisorRootPartition[0].HypervisorRootPartitionDeviceDMAErrors,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.hypervisorRootPartitionDeviceInterruptErrors,
 		prometheus.GaugeValue,
-		rootData[hypervisorRootPartitionDeviceInterruptErrors].FirstValue,
+		c.perfDataObjectHypervisorRootPartition[0].HypervisorRootPartitionDeviceInterruptErrors,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.hypervisorRootPartitionDeviceInterruptThrottleEvents,
 		prometheus.GaugeValue,
-		rootData[hypervisorRootPartitionDeviceInterruptThrottleEvents].FirstValue,
+		c.perfDataObjectHypervisorRootPartition[0].HypervisorRootPartitionDeviceInterruptThrottleEvents,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.hypervisorRootPartitionGPAPages,
 		prometheus.GaugeValue,
-		rootData[hypervisorRootPartitionGPAPages].FirstValue,
+		c.perfDataObjectHypervisorRootPartition[0].HypervisorRootPartitionGPAPages,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.hypervisorRootPartitionGPASpaceModifications,
 		prometheus.CounterValue,
-		rootData[hypervisorRootPartitionGPASpaceModifications].FirstValue,
+		c.perfDataObjectHypervisorRootPartition[0].HypervisorRootPartitionGPASpaceModifications,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.hypervisorRootPartitionIOTLBFlushCost,
 		prometheus.GaugeValue,
-		rootData[hypervisorRootPartitionIOTLBFlushCost].FirstValue,
+		c.perfDataObjectHypervisorRootPartition[0].HypervisorRootPartitionIOTLBFlushCost,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.hypervisorRootPartitionIOTLBFlushes,
 		prometheus.CounterValue,
-		rootData[hypervisorRootPartitionIOTLBFlushes].FirstValue,
+		c.perfDataObjectHypervisorRootPartition[0].HypervisorRootPartitionIOTLBFlushes,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.hypervisorRootPartitionRecommendedVirtualTLBSize,
 		prometheus.GaugeValue,
-		rootData[hypervisorRootPartitionRecommendedVirtualTLBSize].FirstValue,
+		c.perfDataObjectHypervisorRootPartition[0].HypervisorRootPartitionRecommendedVirtualTLBSize,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.hypervisorRootPartitionSkippedTimerTicks,
 		prometheus.GaugeValue,
-		rootData[hypervisorRootPartitionSkippedTimerTicks].FirstValue,
+		c.perfDataObjectHypervisorRootPartition[0].HypervisorRootPartitionSkippedTimerTicks,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.hypervisorRootPartition1GDevicePages,
 		prometheus.GaugeValue,
-		rootData[hypervisorRootPartition1GDevicePages].FirstValue,
+		c.perfDataObjectHypervisorRootPartition[0].HypervisorRootPartition1GDevicePages,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.hypervisorRootPartition1GGPAPages,
 		prometheus.GaugeValue,
-		rootData[hypervisorRootPartition1GGPAPages].FirstValue,
+		c.perfDataObjectHypervisorRootPartition[0].HypervisorRootPartition1GGPAPages,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.hypervisorRootPartition2MDevicePages,
 		prometheus.GaugeValue,
-		rootData[hypervisorRootPartition2MDevicePages].FirstValue,
+		c.perfDataObjectHypervisorRootPartition[0].HypervisorRootPartition2MDevicePages,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.hypervisorRootPartition2MGPAPages,
 		prometheus.GaugeValue,
-		rootData[hypervisorRootPartition2MGPAPages].FirstValue,
+		c.perfDataObjectHypervisorRootPartition[0].HypervisorRootPartition2MGPAPages,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.hypervisorRootPartition4KDevicePages,
 		prometheus.GaugeValue,
-		rootData[hypervisorRootPartition4KDevicePages].FirstValue,
+		c.perfDataObjectHypervisorRootPartition[0].HypervisorRootPartition4KDevicePages,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.hypervisorRootPartition4KGPAPages,
 		prometheus.GaugeValue,
-		rootData[hypervisorRootPartition4KGPAPages].FirstValue,
+		c.perfDataObjectHypervisorRootPartition[0].HypervisorRootPartition4KGPAPages,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.hypervisorRootPartitionVirtualTLBFlushEntries,
 		prometheus.CounterValue,
-		rootData[hypervisorRootPartitionVirtualTLBFlushEntries].FirstValue,
+		c.perfDataObjectHypervisorRootPartition[0].HypervisorRootPartitionVirtualTLBFlushEntries,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.hypervisorRootPartitionVirtualTLBPages,
 		prometheus.GaugeValue,
-		rootData[hypervisorRootPartitionVirtualTLBPages].FirstValue,
+		c.perfDataObjectHypervisorRootPartition[0].HypervisorRootPartitionVirtualTLBPages,
 	)
 
 	return nil

internal/collector/hyperv/hyperv_hypervisor_root_virtual_processor.go

@@ -19,14 +19,15 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/prometheus-community/windows_exporter/internal/perfdata"
+	"github.com/prometheus-community/windows_exporter/internal/pdh"
 	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 )
 
 // collectorHypervisorRootVirtualProcessor Hyper-V Hypervisor Root Virtual Processor metrics
 type collectorHypervisorRootVirtualProcessor struct {
-	perfDataCollectorHypervisorRootVirtualProcessor *perfdata.Collector
+	perfDataCollectorHypervisorRootVirtualProcessor *pdh.Collector
+	perfDataObjectHypervisorRootVirtualProcessor    []perfDataCounterValuesHypervisorRootVirtualProcessor
 
 	// \Hyper-V Hypervisor Root Virtual Processor(*)\% Guest Run Time
 	// \Hyper-V Hypervisor Root Virtual Processor(*)\% Hypervisor Run Time
@@ -37,24 +38,20 @@ type collectorHypervisorRootVirtualProcessor struct {
 	hypervisorRootVirtualProcessorCPUWaitTimePerDispatch *prometheus.Desc // \Hyper-V Hypervisor Root Virtual Processor(*)\CPU Wait Time Per Dispatch
 }
 
-const (
-	hypervisorRootVirtualProcessorGuestRunTimePercent      = "% Guest Run Time"
-	hypervisorRootVirtualProcessorHypervisorRunTimePercent = "% Hypervisor Run Time"
-	hypervisorRootVirtualProcessorTotalRunTimePercent      = "% Total Run Time"
-	hypervisorRootVirtualProcessorRemoteRunTimePercent     = "% Remote Run Time"
-	hypervisorRootVirtualProcessorCPUWaitTimePerDispatch   = "CPU Wait Time Per Dispatch"
-)
+type perfDataCounterValuesHypervisorRootVirtualProcessor struct {
+	Name string
+
+	HypervisorRootVirtualProcessorGuestRunTimePercent      float64 `perfdata:"% Guest Run Time"`
+	HypervisorRootVirtualProcessorHypervisorRunTimePercent float64 `perfdata:"% Hypervisor Run Time"`
+	HypervisorRootVirtualProcessorTotalRunTimePercent      float64 `perfdata:"% Total Run Time"`
+	HypervisorRootVirtualProcessorRemoteRunTimePercent     float64 `perfdata:"% Remote Run Time"`
+	HypervisorRootVirtualProcessorCPUWaitTimePerDispatch   float64 `perfdata:"CPU Wait Time Per Dispatch"`
+}
 
 func (c *Collector) buildHypervisorRootVirtualProcessor() error {
 	var err error
 
-	c.perfDataCollectorHypervisorRootVirtualProcessor, err = perfdata.NewCollector("Hyper-V Hypervisor Root Virtual Processor", perfdata.InstancesAll, []string{
-		hypervisorRootVirtualProcessorGuestRunTimePercent,
-		hypervisorRootVirtualProcessorHypervisorRunTimePercent,
-		hypervisorRootVirtualProcessorTotalRunTimePercent,
-		hypervisorRootVirtualProcessorRemoteRunTimePercent,
-		hypervisorRootVirtualProcessorCPUWaitTimePerDispatch,
-	})
+	c.perfDataCollectorHypervisorRootVirtualProcessor, err = pdh.NewCollector[perfDataCounterValuesHypervisorRootVirtualProcessor]("Hyper-V Hypervisor Root Virtual Processor", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create Hyper-V Hypervisor Root Virtual Processor collector: %w", err)
 	}
@@ -84,53 +81,53 @@ func (c *Collector) buildHypervisorRootVirtualProcessor() error {
 }
 
 func (c *Collector) collectHypervisorRootVirtualProcessor(ch chan<- prometheus.Metric) error {
-	data, err := c.perfDataCollectorHypervisorRootVirtualProcessor.Collect()
+	err := c.perfDataCollectorHypervisorRootVirtualProcessor.Collect(&c.perfDataObjectHypervisorRootVirtualProcessor)
 	if err != nil {
 		return fmt.Errorf("failed to collect Hyper-V Hypervisor Root Virtual Processor metrics: %w", err)
 	}
 
-	for coreName, coreData := range data {
+	for _, data := range c.perfDataObjectHypervisorRootVirtualProcessor {
 		// The name format is Hv LP <core id>
-		parts := strings.Split(coreName, " ")
+		parts := strings.Split(data.Name, " ")
 		if len(parts) != 3 {
-			return fmt.Errorf("unexpected Hyper-V Hypervisor Root Virtual Processor name format: %s", coreName)
+			return fmt.Errorf("unexpected Hyper-V Hypervisor Root Virtual Processor name format: %s", data.Name)
 		}
 
-		coreId := parts[2]
+		coreID := parts[2]
 
 		ch <- prometheus.MustNewConstMetric(
 			c.hypervisorRootVirtualProcessorTimeTotal,
 			prometheus.CounterValue,
-			coreData[hypervisorRootVirtualProcessorGuestRunTimePercent].FirstValue,
-			coreId, "guest_run",
+			data.HypervisorRootVirtualProcessorGuestRunTimePercent,
+			coreID, "guest_run",
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.hypervisorRootVirtualProcessorTimeTotal,
 			prometheus.CounterValue,
-			coreData[hypervisorRootVirtualProcessorHypervisorRunTimePercent].FirstValue,
-			coreId, "hypervisor",
+			data.HypervisorRootVirtualProcessorHypervisorRunTimePercent,
+			coreID, "hypervisor",
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.hypervisorRootVirtualProcessorTimeTotal,
 			prometheus.CounterValue,
-			coreData[hypervisorRootVirtualProcessorRemoteRunTimePercent].FirstValue,
-			coreId, "remote",
+			data.HypervisorRootVirtualProcessorRemoteRunTimePercent,
+			coreID, "remote",
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.hypervisorRootVirtualProcessorTotalRunTimeTotal,
 			prometheus.CounterValue,
-			coreData[hypervisorRootVirtualProcessorTotalRunTimePercent].FirstValue,
-			coreId,
+			data.HypervisorRootVirtualProcessorTotalRunTimePercent,
+			coreID,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.hypervisorRootVirtualProcessorCPUWaitTimePerDispatch,
 			prometheus.CounterValue,
-			coreData[hypervisorRootVirtualProcessorCPUWaitTimePerDispatch].FirstValue,
-			coreId,
+			data.HypervisorRootVirtualProcessorCPUWaitTimePerDispatch,
+			coreID,
 		)
 	}
 

internal/collector/hyperv/hyperv_hypervisor_virtual_processor.go

@@ -19,14 +19,15 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/prometheus-community/windows_exporter/internal/perfdata"
+	"github.com/prometheus-community/windows_exporter/internal/pdh"
 	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 )
 
 // collectorHypervisorVirtualProcessor Hyper-V Hypervisor Virtual Processor metrics
 type collectorHypervisorVirtualProcessor struct {
-	perfDataCollectorHypervisorVirtualProcessor *perfdata.Collector
+	perfDataCollectorHypervisorVirtualProcessor *pdh.Collector
+	perfDataObjectHypervisorVirtualProcessor    []perfDataCounterValuesHypervisorVirtualProcessor
 
 	// \Hyper-V Hypervisor Virtual Processor(*)\% Guest Run Time
 	// \Hyper-V Hypervisor Virtual Processor(*)\% Hypervisor Run Time
@@ -36,24 +37,20 @@ type collectorHypervisorVirtualProcessor struct {
 	hypervisorVirtualProcessorContextSwitches   *prometheus.Desc // \Hyper-V Hypervisor Virtual Processor(*)\CPU Wait Time Per Dispatch
 }
 
-const (
-	hypervisorVirtualProcessorGuestIdleTimePercent     = "% Guest Idle Time"
-	hypervisorVirtualProcessorHypervisorRunTimePercent = "% Hypervisor Run Time"
-	hypervisorVirtualProcessorTotalRunTimePercent      = "% Total Run Time"
-	hypervisorVirtualProcessorRemoteRunTimePercent     = "% Remote Run Time"
-	hypervisorVirtualProcessorCPUWaitTimePerDispatch   = "CPU Wait Time Per Dispatch"
-)
+type perfDataCounterValuesHypervisorVirtualProcessor struct {
+	Name string
+
+	HypervisorVirtualProcessorGuestIdleTimePercent     float64 `perfdata:"% Guest Idle Time"`
+	HypervisorVirtualProcessorHypervisorRunTimePercent float64 `perfdata:"% Hypervisor Run Time"`
+	HypervisorVirtualProcessorTotalRunTimePercent      float64 `perfdata:"% Total Run Time"`
+	HypervisorVirtualProcessorRemoteRunTimePercent     float64 `perfdata:"% Remote Run Time"`
+	HypervisorVirtualProcessorCPUWaitTimePerDispatch   float64 `perfdata:"CPU Wait Time Per Dispatch"`
+}
 
 func (c *Collector) buildHypervisorVirtualProcessor() error {
 	var err error
 
-	c.perfDataCollectorHypervisorVirtualProcessor, err = perfdata.NewCollector("Hyper-V Hypervisor Virtual Processor", perfdata.InstancesAll, []string{
-		hypervisorVirtualProcessorGuestIdleTimePercent,
-		hypervisorVirtualProcessorHypervisorRunTimePercent,
-		hypervisorVirtualProcessorTotalRunTimePercent,
-		hypervisorVirtualProcessorRemoteRunTimePercent,
-		hypervisorVirtualProcessorCPUWaitTimePerDispatch,
-	})
+	c.perfDataCollectorHypervisorVirtualProcessor, err = pdh.NewCollector[perfDataCounterValuesHypervisorVirtualProcessor]("Hyper-V Hypervisor Virtual Processor", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create Hyper-V Hypervisor Virtual Processor collector: %w", err)
 	}
@@ -81,16 +78,16 @@ func (c *Collector) buildHypervisorVirtualProcessor() error {
 }
 
 func (c *Collector) collectHypervisorVirtualProcessor(ch chan<- prometheus.Metric) error {
-	data, err := c.perfDataCollectorHypervisorVirtualProcessor.Collect()
+	err := c.perfDataCollectorHypervisorVirtualProcessor.Collect(&c.perfDataObjectHypervisorVirtualProcessor)
 	if err != nil {
 		return fmt.Errorf("failed to collect Hyper-V Hypervisor Virtual Processor metrics: %w", err)
 	}
 
-	for coreName, coreData := range data {
+	for _, data := range c.perfDataObjectHypervisorVirtualProcessor {
 		// The name format is <VM Name>:Hv VP <vcore id>
-		parts := strings.Split(coreName, ":")
+		parts := strings.Split(data.Name, ":")
 		if len(parts) != 2 {
-			return fmt.Errorf("unexpected format of Name in Hyper-V Hypervisor Virtual Processor: %q, expected %q", coreName, "<VM Name>:Hv VP <vcore id>")
+			return fmt.Errorf("unexpected format of Name in Hyper-V Hypervisor Virtual Processor: %q, expected %q", data.Name, "<VM Name>:Hv VP <vcore id>")
 		}
 
 		coreParts := strings.Split(parts[1], " ")
@@ -99,41 +96,41 @@ func (c *Collector) collectHypervisorVirtualProcessor(ch chan<- prometheus.Metri
 		}
 
 		vmName := parts[0]
-		coreId := coreParts[2]
+		coreID := coreParts[2]
 
 		ch <- prometheus.MustNewConstMetric(
 			c.hypervisorVirtualProcessorTimeTotal,
 			prometheus.CounterValue,
-			coreData[hypervisorVirtualProcessorHypervisorRunTimePercent].FirstValue,
-			vmName, coreId, "hypervisor",
+			data.HypervisorVirtualProcessorHypervisorRunTimePercent,
+			vmName, coreID, "hypervisor",
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.hypervisorVirtualProcessorTimeTotal,
 			prometheus.CounterValue,
-			coreData[hypervisorVirtualProcessorGuestIdleTimePercent].FirstValue,
-			vmName, coreId, "guest_idle",
+			data.HypervisorVirtualProcessorGuestIdleTimePercent,
+			vmName, coreID, "guest_idle",
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.hypervisorVirtualProcessorTimeTotal,
 			prometheus.CounterValue,
-			coreData[hypervisorVirtualProcessorGuestIdleTimePercent].FirstValue,
-			vmName, coreId, "guest_idle",
+			data.HypervisorVirtualProcessorGuestIdleTimePercent,
+			vmName, coreID, "guest_idle",
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.hypervisorVirtualProcessorTotalRunTimeTotal,
 			prometheus.CounterValue,
-			coreData[hypervisorVirtualProcessorTotalRunTimePercent].FirstValue,
-			vmName, coreId,
+			data.HypervisorVirtualProcessorTotalRunTimePercent,
+			vmName, coreID,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.hypervisorVirtualProcessorContextSwitches,
 			prometheus.CounterValue,
-			coreData[hypervisorVirtualProcessorCPUWaitTimePerDispatch].FirstValue,
-			vmName, coreId,
+			data.HypervisorVirtualProcessorCPUWaitTimePerDispatch,
+			vmName, coreID,
 		)
 	}
 

internal/collector/hyperv/hyperv_legacy_network_adapter.go

@@ -18,14 +18,15 @@ package hyperv
 import (
 	"fmt"
 
-	"github.com/prometheus-community/windows_exporter/internal/perfdata"
+	"github.com/prometheus-community/windows_exporter/internal/pdh"
 	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 )
 
 // collectorLegacyNetworkAdapter Hyper-V Legacy Network Adapter metrics
 type collectorLegacyNetworkAdapter struct {
-	perfDataCollectorLegacyNetworkAdapter *perfdata.Collector
+	perfDataCollectorLegacyNetworkAdapter *pdh.Collector
+	perfDataObjectLegacyNetworkAdapter    []perfDataCounterValuesLegacyNetworkAdapter
 
 	legacyNetworkAdapterBytesDropped   *prometheus.Desc // \Hyper-V Legacy Network Adapter(*)\Bytes Dropped
 	legacyNetworkAdapterBytesReceived  *prometheus.Desc // \Hyper-V Legacy Network Adapter(*)\Bytes Received/sec
@@ -35,26 +36,21 @@ type collectorLegacyNetworkAdapter struct {
 	legacyNetworkAdapterFramesSent     *prometheus.Desc // \Hyper-V Legacy Network Adapter(*)\Frames Sent/sec
 }
 
-const (
-	legacyNetworkAdapterBytesDropped   = "Bytes Dropped"
-	legacyNetworkAdapterBytesReceived  = "Bytes Received/sec"
-	legacyNetworkAdapterBytesSent      = "Bytes Sent/sec"
-	legacyNetworkAdapterFramesDropped  = "Frames Dropped"
-	legacyNetworkAdapterFramesReceived = "Frames Received/sec"
-	legacyNetworkAdapterFramesSent     = "Frames Sent/sec"
-)
+type perfDataCounterValuesLegacyNetworkAdapter struct {
+	Name string
+
+	LegacyNetworkAdapterBytesDropped   float64 `perfdata:"Bytes Dropped"`
+	LegacyNetworkAdapterBytesReceived  float64 `perfdata:"Bytes Received/sec"`
+	LegacyNetworkAdapterBytesSent      float64 `perfdata:"Bytes Sent/sec"`
+	LegacyNetworkAdapterFramesDropped  float64 `perfdata:"Frames Dropped"`
+	LegacyNetworkAdapterFramesReceived float64 `perfdata:"Frames Received/sec"`
+	LegacyNetworkAdapterFramesSent     float64 `perfdata:"Frames Sent/sec"`
+}
 
 func (c *Collector) buildLegacyNetworkAdapter() error {
 	var err error
 
-	c.perfDataCollectorLegacyNetworkAdapter, err = perfdata.NewCollector("Hyper-V Legacy Network Adapter", perfdata.InstancesAll, []string{
-		legacyNetworkAdapterBytesDropped,
-		legacyNetworkAdapterBytesReceived,
-		legacyNetworkAdapterBytesSent,
-		legacyNetworkAdapterFramesDropped,
-		legacyNetworkAdapterFramesReceived,
-		legacyNetworkAdapterFramesSent,
-	})
+	c.perfDataCollectorLegacyNetworkAdapter, err = pdh.NewCollector[perfDataCounterValuesLegacyNetworkAdapter]("Hyper-V Legacy Network Adapter", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create Hyper-V Legacy Network Adapter collector: %w", err)
 	}
@@ -100,52 +96,52 @@ func (c *Collector) buildLegacyNetworkAdapter() error {
 }
 
 func (c *Collector) collectLegacyNetworkAdapter(ch chan<- prometheus.Metric) error {
-	data, err := c.perfDataCollectorLegacyNetworkAdapter.Collect()
+	err := c.perfDataCollectorLegacyNetworkAdapter.Collect(&c.perfDataObjectLegacyNetworkAdapter)
 	if err != nil {
 		return fmt.Errorf("failed to collect Hyper-V Legacy Network Adapter metrics: %w", err)
 	}
 
-	for name, adapter := range data {
+	for _, data := range c.perfDataObjectLegacyNetworkAdapter {
 		ch <- prometheus.MustNewConstMetric(
 			c.legacyNetworkAdapterBytesDropped,
 			prometheus.GaugeValue,
-			adapter[legacyNetworkAdapterBytesDropped].FirstValue,
-			name,
+			data.LegacyNetworkAdapterBytesDropped,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.legacyNetworkAdapterBytesReceived,
 			prometheus.CounterValue,
-			adapter[legacyNetworkAdapterBytesReceived].FirstValue,
-			name,
+			data.LegacyNetworkAdapterBytesReceived,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.legacyNetworkAdapterBytesSent,
 			prometheus.CounterValue,
-			adapter[legacyNetworkAdapterBytesSent].FirstValue,
-			name,
+			data.LegacyNetworkAdapterBytesSent,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.legacyNetworkAdapterFramesReceived,
 			prometheus.CounterValue,
-			adapter[legacyNetworkAdapterFramesReceived].FirstValue,
-			name,
+			data.LegacyNetworkAdapterFramesReceived,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.legacyNetworkAdapterFramesDropped,
 			prometheus.CounterValue,
-			adapter[legacyNetworkAdapterFramesDropped].FirstValue,
-			name,
+			data.LegacyNetworkAdapterFramesDropped,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.legacyNetworkAdapterFramesSent,
 			prometheus.CounterValue,
-			adapter[legacyNetworkAdapterFramesSent].FirstValue,
-			name,
+			data.LegacyNetworkAdapterFramesSent,
+			data.Name,
 		)
 	}
 

internal/collector/hyperv/hyperv_virtual_machine_health_summary.go

@@ -16,36 +16,33 @@
 package hyperv
 
 import (
-	"errors"
 	"fmt"
 
-	"github.com/prometheus-community/windows_exporter/internal/perfdata"
+	"github.com/prometheus-community/windows_exporter/internal/pdh"
 	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 )
 
 // collectorVirtualMachineHealthSummary Hyper-V Virtual Machine Health Summary metrics
 type collectorVirtualMachineHealthSummary struct {
-	perfDataCollectorVirtualMachineHealthSummary *perfdata.Collector
+	perfDataCollectorVirtualMachineHealthSummary *pdh.Collector
+	perfDataObjectVirtualMachineHealthSummary    []perfDataCounterValuesVirtualMachineHealthSummary
 
 	// \Hyper-V Virtual Machine Health Summary\Health Critical
 	// \Hyper-V Virtual Machine Health Summary\Health Ok
 	health *prometheus.Desc
 }
 
-const (
+type perfDataCounterValuesVirtualMachineHealthSummary struct {
 	// Hyper-V Virtual Machine Health Summary
-	healthCritical = "Health Critical"
-	healthOk       = "Health Ok"
-)
+	HealthCritical float64 `perfdata:"Health Critical"`
+	HealthOk       float64 `perfdata:"Health Ok"`
+}
 
 func (c *Collector) buildVirtualMachineHealthSummary() error {
 	var err error
 
-	c.perfDataCollectorVirtualMachineHealthSummary, err = perfdata.NewCollector("Hyper-V Virtual Machine Health Summary", nil, []string{
-		healthCritical,
-		healthOk,
-	})
+	c.perfDataCollectorVirtualMachineHealthSummary, err = pdh.NewCollector[perfDataCounterValuesVirtualMachineHealthSummary]("Hyper-V Virtual Machine Health Summary", nil)
 	if err != nil {
 		return fmt.Errorf("failed to create Hyper-V Virtual Machine Health Summary collector: %w", err)
 	}
@@ -61,27 +58,22 @@ func (c *Collector) buildVirtualMachineHealthSummary() error {
 }
 
 func (c *Collector) collectVirtualMachineHealthSummary(ch chan<- prometheus.Metric) error {
-	data, err := c.perfDataCollectorVirtualMachineHealthSummary.Collect()
+	err := c.perfDataCollectorVirtualMachineHealthSummary.Collect(&c.perfDataObjectVirtualMachineHealthSummary)
 	if err != nil {
 		return fmt.Errorf("failed to collect Hyper-V Virtual Machine Health Summary metrics: %w", err)
 	}
 
-	healthData, ok := data[perfdata.InstanceEmpty]
-	if !ok {
-		return errors.New("no data returned for Hyper-V Virtual Machine Health Summary")
-	}
-
 	ch <- prometheus.MustNewConstMetric(
 		c.health,
 		prometheus.GaugeValue,
-		healthData[healthCritical].FirstValue,
+		c.perfDataObjectVirtualMachineHealthSummary[0].HealthCritical,
 		"critical",
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.health,
 		prometheus.GaugeValue,
-		healthData[healthOk].FirstValue,
+		c.perfDataObjectVirtualMachineHealthSummary[0].HealthOk,
 		"ok",
 	)
 

internal/collector/hyperv/hyperv_virtual_machine_vid_partition.go

@@ -18,33 +18,33 @@ package hyperv
 import (
 	"fmt"
 
-	"github.com/prometheus-community/windows_exporter/internal/perfdata"
+	"github.com/prometheus-community/windows_exporter/internal/pdh"
 	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 )
 
 // collectorVirtualMachineVidPartition Hyper-V VM Vid Partition metrics
 type collectorVirtualMachineVidPartition struct {
-	perfDataCollectorVirtualMachineVidPartition *perfdata.Collector
-	physicalPagesAllocated                      *prometheus.Desc // \Hyper-V VM Vid Partition(*)\Physical Pages Allocated
-	preferredNUMANodeIndex                      *prometheus.Desc // \Hyper-V VM Vid Partition(*)\Preferred NUMA Node Index
-	remotePhysicalPages                         *prometheus.Desc // \Hyper-V VM Vid Partition(*)\Remote Physical Pages
+	perfDataCollectorVirtualMachineVidPartition *pdh.Collector
+	perfDataObjectVirtualMachineVidPartition    []perfDataCounterValuesVirtualMachineVidPartition
+
+	physicalPagesAllocated *prometheus.Desc // \Hyper-V VM Vid Partition(*)\Physical Pages Allocated
+	preferredNUMANodeIndex *prometheus.Desc // \Hyper-V VM Vid Partition(*)\Preferred NUMA Node Index
+	remotePhysicalPages    *prometheus.Desc // \Hyper-V VM Vid Partition(*)\Remote Physical Pages
 }
 
-const (
-	physicalPagesAllocated = "Physical Pages Allocated"
-	preferredNUMANodeIndex = "Preferred NUMA Node Index"
-	remotePhysicalPages    = "Remote Physical Pages"
-)
+type perfDataCounterValuesVirtualMachineVidPartition struct {
+	Name string
+
+	PhysicalPagesAllocated float64 `perfdata:"Physical Pages Allocated"`
+	PreferredNUMANodeIndex float64 `perfdata:"Preferred NUMA Node Index"`
+	RemotePhysicalPages    float64 `perfdata:"Remote Physical Pages"`
+}
 
 func (c *Collector) buildVirtualMachineVidPartition() error {
 	var err error
 
-	c.perfDataCollectorVirtualMachineVidPartition, err = perfdata.NewCollector("Hyper-V VM Vid Partition", perfdata.InstancesAll, []string{
-		physicalPagesAllocated,
-		preferredNUMANodeIndex,
-		remotePhysicalPages,
-	})
+	c.perfDataCollectorVirtualMachineVidPartition, err = pdh.NewCollector[perfDataCounterValuesVirtualMachineVidPartition]("Hyper-V VM Vid Partition", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create Hyper-V VM Vid Partition collector: %w", err)
 	}
@@ -72,31 +72,31 @@ func (c *Collector) buildVirtualMachineVidPartition() error {
 }
 
 func (c *Collector) collectVirtualMachineVidPartition(ch chan<- prometheus.Metric) error {
-	data, err := c.perfDataCollectorVirtualMachineVidPartition.Collect()
+	err := c.perfDataCollectorVirtualMachineVidPartition.Collect(&c.perfDataObjectVirtualMachineVidPartition)
 	if err != nil {
 		return fmt.Errorf("failed to collect Hyper-V VM Vid Partition metrics: %w", err)
 	}
 
-	for name, page := range data {
+	for _, data := range c.perfDataObjectVirtualMachineVidPartition {
 		ch <- prometheus.MustNewConstMetric(
 			c.physicalPagesAllocated,
 			prometheus.GaugeValue,
-			page[physicalPagesAllocated].FirstValue,
-			name,
+			data.PhysicalPagesAllocated,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.preferredNUMANodeIndex,
 			prometheus.GaugeValue,
-			page[preferredNUMANodeIndex].FirstValue,
-			name,
+			data.PreferredNUMANodeIndex,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.remotePhysicalPages,
 			prometheus.GaugeValue,
-			page[remotePhysicalPages].FirstValue,
-			name,
+			data.RemotePhysicalPages,
+			data.Name,
 		)
 	}
 

internal/collector/hyperv/hyperv_virtual_network_adapter.go

@@ -18,14 +18,15 @@ package hyperv
 import (
 	"fmt"
 
-	"github.com/prometheus-community/windows_exporter/internal/perfdata"
+	"github.com/prometheus-community/windows_exporter/internal/pdh"
 	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 )
 
 // collectorVirtualNetworkAdapter Hyper-V Virtual Network Adapter metrics
 type collectorVirtualNetworkAdapter struct {
-	perfDataCollectorVirtualNetworkAdapter *perfdata.Collector
+	perfDataCollectorVirtualNetworkAdapter *pdh.Collector
+	perfDataObjectVirtualNetworkAdapter    []perfDataCounterValuesVirtualNetworkAdapter
 
 	virtualNetworkAdapterBytesReceived          *prometheus.Desc // \Hyper-V Virtual Network Adapter(*)\Bytes Received/sec
 	virtualNetworkAdapterBytesSent              *prometheus.Desc // \Hyper-V Virtual Network Adapter(*)\Bytes Sent/sec
@@ -35,26 +36,21 @@ type collectorVirtualNetworkAdapter struct {
 	virtualNetworkAdapterPacketsSent            *prometheus.Desc // \Hyper-V Virtual Network Adapter(*)\Packets Sent/sec
 }
 
-const (
-	virtualNetworkAdapterBytesReceived          = "Bytes Received/sec"
-	virtualNetworkAdapterBytesSent              = "Bytes Sent/sec"
-	virtualNetworkAdapterDroppedPacketsIncoming = "Dropped Packets Incoming/sec"
-	virtualNetworkAdapterDroppedPacketsOutgoing = "Dropped Packets Outgoing/sec"
-	virtualNetworkAdapterPacketsReceived        = "Packets Received/sec"
-	virtualNetworkAdapterPacketsSent            = "Packets Sent/sec"
-)
+type perfDataCounterValuesVirtualNetworkAdapter struct {
+	Name string
+
+	VirtualNetworkAdapterBytesReceived          float64 `perfdata:"Bytes Received/sec"`
+	VirtualNetworkAdapterBytesSent              float64 `perfdata:"Bytes Sent/sec"`
+	VirtualNetworkAdapterDroppedPacketsIncoming float64 `perfdata:"Dropped Packets Incoming/sec"`
+	VirtualNetworkAdapterDroppedPacketsOutgoing float64 `perfdata:"Dropped Packets Outgoing/sec"`
+	VirtualNetworkAdapterPacketsReceived        float64 `perfdata:"Packets Received/sec"`
+	VirtualNetworkAdapterPacketsSent            float64 `perfdata:"Packets Sent/sec"`
+}
 
 func (c *Collector) buildVirtualNetworkAdapter() error {
 	var err error
 
-	c.perfDataCollectorVirtualNetworkAdapter, err = perfdata.NewCollector("Hyper-V Virtual Network Adapter", perfdata.InstancesAll, []string{
-		virtualNetworkAdapterBytesReceived,
-		virtualNetworkAdapterBytesSent,
-		virtualNetworkAdapterDroppedPacketsIncoming,
-		virtualNetworkAdapterDroppedPacketsOutgoing,
-		virtualNetworkAdapterPacketsReceived,
-		virtualNetworkAdapterPacketsSent,
-	})
+	c.perfDataCollectorVirtualNetworkAdapter, err = pdh.NewCollector[perfDataCounterValuesVirtualNetworkAdapter]("Hyper-V Virtual Network Adapter", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create Hyper-V Virtual Network Adapter collector: %w", err)
 	}
@@ -100,52 +96,52 @@ func (c *Collector) buildVirtualNetworkAdapter() error {
 }
 
 func (c *Collector) collectVirtualNetworkAdapter(ch chan<- prometheus.Metric) error {
-	data, err := c.perfDataCollectorVirtualNetworkAdapter.Collect()
+	err := c.perfDataCollectorVirtualNetworkAdapter.Collect(&c.perfDataObjectVirtualNetworkAdapter)
 	if err != nil {
 		return fmt.Errorf("failed to collect Hyper-V Virtual Network Adapter metrics: %w", err)
 	}
 
-	for name, adapterData := range data {
+	for _, data := range c.perfDataObjectVirtualNetworkAdapter {
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterBytesReceived,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterBytesReceived].FirstValue,
-			name,
+			data.VirtualNetworkAdapterBytesReceived,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterBytesSent,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterBytesSent].FirstValue,
-			name,
+			data.VirtualNetworkAdapterBytesSent,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDroppedPacketsIncoming,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDroppedPacketsIncoming].FirstValue,
-			name,
+			data.VirtualNetworkAdapterDroppedPacketsIncoming,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDroppedPacketsOutgoing,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDroppedPacketsOutgoing].FirstValue,
-			name,
+			data.VirtualNetworkAdapterDroppedPacketsOutgoing,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterPacketsReceived,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterPacketsReceived].FirstValue,
-			name,
+			data.VirtualNetworkAdapterPacketsReceived,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterPacketsSent,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterPacketsSent].FirstValue,
-			name,
+			data.VirtualNetworkAdapterPacketsSent,
+			data.Name,
 		)
 	}
 

internal/collector/hyperv/hyperv_virtual_network_adapter_drop_reasons.go

@@ -18,14 +18,15 @@ package hyperv
 import (
 	"fmt"
 
-	"github.com/prometheus-community/windows_exporter/internal/perfdata"
+	"github.com/prometheus-community/windows_exporter/internal/pdh"
 	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 )
 
 // collectorVirtualNetworkAdapterDropReasons Hyper-V Virtual Network Adapter Drop Reasons metrics
 type collectorVirtualNetworkAdapterDropReasons struct {
-	perfDataCollectorVirtualNetworkAdapterDropReasons *perfdata.Collector
+	perfDataCollectorVirtualNetworkAdapterDropReasons *pdh.Collector
+	perfDataObjectVirtualNetworkAdapterDropReasons    []perfDataCounterValuesVirtualNetworkAdapterDropReasons
 
 	// \Hyper-V Virtual Network Adapter Drop Reasons(*)\Outgoing LowPowerPacketFilter
 	// \Hyper-V Virtual Network Adapter Drop Reasons(*)\Incoming LowPowerPacketFilter
@@ -106,114 +107,65 @@ type collectorVirtualNetworkAdapterDropReasons struct {
 	virtualNetworkAdapterDropReasons *prometheus.Desc
 }
 
-const (
-	virtualNetworkAdapterDropReasonsOutgoingNativeFwdingReq          = "Outgoing NativeFwdingReq"
-	virtualNetworkAdapterDropReasonsIncomingNativeFwdingReq          = "Incoming NativeFwdingReq"
-	virtualNetworkAdapterDropReasonsOutgoingMTUMismatch              = "Outgoing MTUMismatch"
-	virtualNetworkAdapterDropReasonsIncomingMTUMismatch              = "Incoming MTUMismatch"
-	virtualNetworkAdapterDropReasonsOutgoingInvalidConfig            = "Outgoing InvalidConfig"
-	virtualNetworkAdapterDropReasonsIncomingInvalidConfig            = "Incoming InvalidConfig"
-	virtualNetworkAdapterDropReasonsOutgoingRequiredExtensionMissing = "Outgoing RequiredExtensionMissing"
-	virtualNetworkAdapterDropReasonsIncomingRequiredExtensionMissing = "Incoming RequiredExtensionMissing"
-	virtualNetworkAdapterDropReasonsOutgoingVirtualSubnetId          = "Outgoing VirtualSubnetId"
-	virtualNetworkAdapterDropReasonsIncomingVirtualSubnetId          = "Incoming VirtualSubnetId"
-	virtualNetworkAdapterDropReasonsOutgoingBridgeReserved           = "Outgoing BridgeReserved"
-	virtualNetworkAdapterDropReasonsIncomingBridgeReserved           = "Incoming BridgeReserved"
-	virtualNetworkAdapterDropReasonsOutgoingRouterGuard              = "Outgoing RouterGuard"
-	virtualNetworkAdapterDropReasonsIncomingRouterGuard              = "Incoming RouterGuard"
-	virtualNetworkAdapterDropReasonsOutgoingDhcpGuard                = "Outgoing DhcpGuard"
-	virtualNetworkAdapterDropReasonsIncomingDhcpGuard                = "Incoming DhcpGuard"
-	virtualNetworkAdapterDropReasonsOutgoingMacSpoofing              = "Outgoing MacSpoofing"
-	virtualNetworkAdapterDropReasonsIncomingMacSpoofing              = "Incoming MacSpoofing"
-	virtualNetworkAdapterDropReasonsOutgoingIpsec                    = "Outgoing Ipsec"
-	virtualNetworkAdapterDropReasonsIncomingIpsec                    = "Incoming Ipsec"
-	virtualNetworkAdapterDropReasonsOutgoingQos                      = "Outgoing Qos"
-	virtualNetworkAdapterDropReasonsIncomingQos                      = "Incoming Qos"
-	virtualNetworkAdapterDropReasonsOutgoingFailedPvlanSetting       = "Outgoing FailedPvlanSetting"
-	virtualNetworkAdapterDropReasonsIncomingFailedPvlanSetting       = "Incoming FailedPvlanSetting"
-	virtualNetworkAdapterDropReasonsOutgoingFailedSecurityPolicy     = "Outgoing FailedSecurityPolicy"
-	virtualNetworkAdapterDropReasonsIncomingFailedSecurityPolicy     = "Incoming FailedSecurityPolicy"
-	virtualNetworkAdapterDropReasonsOutgoingUnauthorizedMAC          = "Outgoing UnauthorizedMAC"
-	virtualNetworkAdapterDropReasonsIncomingUnauthorizedMAC          = "Incoming UnauthorizedMAC"
-	virtualNetworkAdapterDropReasonsOutgoingUnauthorizedVLAN         = "Outgoing UnauthorizedVLAN"
-	virtualNetworkAdapterDropReasonsIncomingUnauthorizedVLAN         = "Incoming UnauthorizedVLAN"
-	virtualNetworkAdapterDropReasonsOutgoingFilteredVLAN             = "Outgoing FilteredVLAN"
-	virtualNetworkAdapterDropReasonsIncomingFilteredVLAN             = "Incoming FilteredVLAN"
-	virtualNetworkAdapterDropReasonsOutgoingFiltered                 = "Outgoing Filtered"
-	virtualNetworkAdapterDropReasonsIncomingFiltered                 = "Incoming Filtered"
-	virtualNetworkAdapterDropReasonsOutgoingBusy                     = "Outgoing Busy"
-	virtualNetworkAdapterDropReasonsIncomingBusy                     = "Incoming Busy"
-	virtualNetworkAdapterDropReasonsOutgoingNotAccepted              = "Outgoing NotAccepted"
-	virtualNetworkAdapterDropReasonsIncomingNotAccepted              = "Incoming NotAccepted"
-	virtualNetworkAdapterDropReasonsOutgoingDisconnected             = "Outgoing Disconnected"
-	virtualNetworkAdapterDropReasonsIncomingDisconnected             = "Incoming Disconnected"
-	virtualNetworkAdapterDropReasonsOutgoingNotReady                 = "Outgoing NotReady"
-	virtualNetworkAdapterDropReasonsIncomingNotReady                 = "Incoming NotReady"
-	virtualNetworkAdapterDropReasonsOutgoingResources                = "Outgoing Resources"
-	virtualNetworkAdapterDropReasonsIncomingResources                = "Incoming Resources"
-	virtualNetworkAdapterDropReasonsOutgoingInvalidPacket            = "Outgoing InvalidPacket"
-	virtualNetworkAdapterDropReasonsIncomingInvalidPacket            = "Incoming InvalidPacket"
-	virtualNetworkAdapterDropReasonsOutgoingInvalidData              = "Outgoing InvalidData"
-	virtualNetworkAdapterDropReasonsIncomingInvalidData              = "Incoming InvalidData"
-	virtualNetworkAdapterDropReasonsOutgoingUnknown                  = "Outgoing Unknown"
-	virtualNetworkAdapterDropReasonsIncomingUnknown                  = "Incoming Unknown"
-)
+type perfDataCounterValuesVirtualNetworkAdapterDropReasons struct {
+	Name string
+
+	VirtualNetworkAdapterDropReasonsOutgoingNativeFwdingReq          float64 `perfdata:"Outgoing NativeFwdingReq"`
+	VirtualNetworkAdapterDropReasonsIncomingNativeFwdingReq          float64 `perfdata:"Incoming NativeFwdingReq"`
+	VirtualNetworkAdapterDropReasonsOutgoingMTUMismatch              float64 `perfdata:"Outgoing MTUMismatch"`
+	VirtualNetworkAdapterDropReasonsIncomingMTUMismatch              float64 `perfdata:"Incoming MTUMismatch"`
+	VirtualNetworkAdapterDropReasonsOutgoingInvalidConfig            float64 `perfdata:"Outgoing InvalidConfig"`
+	VirtualNetworkAdapterDropReasonsIncomingInvalidConfig            float64 `perfdata:"Incoming InvalidConfig"`
+	VirtualNetworkAdapterDropReasonsOutgoingRequiredExtensionMissing float64 `perfdata:"Outgoing RequiredExtensionMissing"`
+	VirtualNetworkAdapterDropReasonsIncomingRequiredExtensionMissing float64 `perfdata:"Incoming RequiredExtensionMissing"`
+	VirtualNetworkAdapterDropReasonsOutgoingVirtualSubnetId          float64 `perfdata:"Outgoing VirtualSubnetId"`
+	VirtualNetworkAdapterDropReasonsIncomingVirtualSubnetId          float64 `perfdata:"Incoming VirtualSubnetId"`
+	VirtualNetworkAdapterDropReasonsOutgoingBridgeReserved           float64 `perfdata:"Outgoing BridgeReserved"`
+	VirtualNetworkAdapterDropReasonsIncomingBridgeReserved           float64 `perfdata:"Incoming BridgeReserved"`
+	VirtualNetworkAdapterDropReasonsOutgoingRouterGuard              float64 `perfdata:"Outgoing RouterGuard"`
+	VirtualNetworkAdapterDropReasonsIncomingRouterGuard              float64 `perfdata:"Incoming RouterGuard"`
+	VirtualNetworkAdapterDropReasonsOutgoingDhcpGuard                float64 `perfdata:"Outgoing DhcpGuard"`
+	VirtualNetworkAdapterDropReasonsIncomingDhcpGuard                float64 `perfdata:"Incoming DhcpGuard"`
+	VirtualNetworkAdapterDropReasonsOutgoingMacSpoofing              float64 `perfdata:"Outgoing MacSpoofing"`
+	VirtualNetworkAdapterDropReasonsIncomingMacSpoofing              float64 `perfdata:"Incoming MacSpoofing"`
+	VirtualNetworkAdapterDropReasonsOutgoingIpsec                    float64 `perfdata:"Outgoing Ipsec"`
+	VirtualNetworkAdapterDropReasonsIncomingIpsec                    float64 `perfdata:"Incoming Ipsec"`
+	VirtualNetworkAdapterDropReasonsOutgoingQos                      float64 `perfdata:"Outgoing Qos"`
+	VirtualNetworkAdapterDropReasonsIncomingQos                      float64 `perfdata:"Incoming Qos"`
+	VirtualNetworkAdapterDropReasonsOutgoingFailedPvlanSetting       float64 `perfdata:"Outgoing FailedPvlanSetting"`
+	VirtualNetworkAdapterDropReasonsIncomingFailedPvlanSetting       float64 `perfdata:"Incoming FailedPvlanSetting"`
+	VirtualNetworkAdapterDropReasonsOutgoingFailedSecurityPolicy     float64 `perfdata:"Outgoing FailedSecurityPolicy"`
+	VirtualNetworkAdapterDropReasonsIncomingFailedSecurityPolicy     float64 `perfdata:"Incoming FailedSecurityPolicy"`
+	VirtualNetworkAdapterDropReasonsOutgoingUnauthorizedMAC          float64 `perfdata:"Outgoing UnauthorizedMAC"`
+	VirtualNetworkAdapterDropReasonsIncomingUnauthorizedMAC          float64 `perfdata:"Incoming UnauthorizedMAC"`
+	VirtualNetworkAdapterDropReasonsOutgoingUnauthorizedVLAN         float64 `perfdata:"Outgoing UnauthorizedVLAN"`
+	VirtualNetworkAdapterDropReasonsIncomingUnauthorizedVLAN         float64 `perfdata:"Incoming UnauthorizedVLAN"`
+	VirtualNetworkAdapterDropReasonsOutgoingFilteredVLAN             float64 `perfdata:"Outgoing FilteredVLAN"`
+	VirtualNetworkAdapterDropReasonsIncomingFilteredVLAN             float64 `perfdata:"Incoming FilteredVLAN"`
+	VirtualNetworkAdapterDropReasonsOutgoingFiltered                 float64 `perfdata:"Outgoing Filtered"`
+	VirtualNetworkAdapterDropReasonsIncomingFiltered                 float64 `perfdata:"Incoming Filtered"`
+	VirtualNetworkAdapterDropReasonsOutgoingBusy                     float64 `perfdata:"Outgoing Busy"`
+	VirtualNetworkAdapterDropReasonsIncomingBusy                     float64 `perfdata:"Incoming Busy"`
+	VirtualNetworkAdapterDropReasonsOutgoingNotAccepted              float64 `perfdata:"Outgoing NotAccepted"`
+	VirtualNetworkAdapterDropReasonsIncomingNotAccepted              float64 `perfdata:"Incoming NotAccepted"`
+	VirtualNetworkAdapterDropReasonsOutgoingDisconnected             float64 `perfdata:"Outgoing Disconnected"`
+	VirtualNetworkAdapterDropReasonsIncomingDisconnected             float64 `perfdata:"Incoming Disconnected"`
+	VirtualNetworkAdapterDropReasonsOutgoingNotReady                 float64 `perfdata:"Outgoing NotReady"`
+	VirtualNetworkAdapterDropReasonsIncomingNotReady                 float64 `perfdata:"Incoming NotReady"`
+	VirtualNetworkAdapterDropReasonsOutgoingResources                float64 `perfdata:"Outgoing Resources"`
+	VirtualNetworkAdapterDropReasonsIncomingResources                float64 `perfdata:"Incoming Resources"`
+	VirtualNetworkAdapterDropReasonsOutgoingInvalidPacket            float64 `perfdata:"Outgoing InvalidPacket"`
+	VirtualNetworkAdapterDropReasonsIncomingInvalidPacket            float64 `perfdata:"Incoming InvalidPacket"`
+	VirtualNetworkAdapterDropReasonsOutgoingInvalidData              float64 `perfdata:"Outgoing InvalidData"`
+	VirtualNetworkAdapterDropReasonsIncomingInvalidData              float64 `perfdata:"Incoming InvalidData"`
+	VirtualNetworkAdapterDropReasonsOutgoingUnknown                  float64 `perfdata:"Outgoing Unknown"`
+	VirtualNetworkAdapterDropReasonsIncomingUnknown                  float64 `perfdata:"Incoming Unknown"`
+}
 
 func (c *Collector) buildVirtualNetworkAdapterDropReasons() error {
 	var err error
 
-	c.perfDataCollectorVirtualNetworkAdapterDropReasons, err = perfdata.NewCollector("Hyper-V Virtual Network Adapter Drop Reasons", perfdata.InstancesAll, []string{
-		virtualNetworkAdapterDropReasonsOutgoingNativeFwdingReq,
-		virtualNetworkAdapterDropReasonsIncomingNativeFwdingReq,
-		virtualNetworkAdapterDropReasonsOutgoingMTUMismatch,
-		virtualNetworkAdapterDropReasonsIncomingMTUMismatch,
-		virtualNetworkAdapterDropReasonsOutgoingInvalidConfig,
-		virtualNetworkAdapterDropReasonsIncomingInvalidConfig,
-		virtualNetworkAdapterDropReasonsOutgoingRequiredExtensionMissing,
-		virtualNetworkAdapterDropReasonsIncomingRequiredExtensionMissing,
-		virtualNetworkAdapterDropReasonsOutgoingVirtualSubnetId,
-		virtualNetworkAdapterDropReasonsIncomingVirtualSubnetId,
-		virtualNetworkAdapterDropReasonsOutgoingBridgeReserved,
-		virtualNetworkAdapterDropReasonsIncomingBridgeReserved,
-		virtualNetworkAdapterDropReasonsOutgoingRouterGuard,
-		virtualNetworkAdapterDropReasonsIncomingRouterGuard,
-		virtualNetworkAdapterDropReasonsOutgoingDhcpGuard,
-		virtualNetworkAdapterDropReasonsIncomingDhcpGuard,
-		virtualNetworkAdapterDropReasonsOutgoingMacSpoofing,
-		virtualNetworkAdapterDropReasonsIncomingMacSpoofing,
-		virtualNetworkAdapterDropReasonsOutgoingIpsec,
-		virtualNetworkAdapterDropReasonsIncomingIpsec,
-		virtualNetworkAdapterDropReasonsOutgoingQos,
-		virtualNetworkAdapterDropReasonsIncomingQos,
-		virtualNetworkAdapterDropReasonsOutgoingFailedPvlanSetting,
-		virtualNetworkAdapterDropReasonsIncomingFailedPvlanSetting,
-		virtualNetworkAdapterDropReasonsOutgoingFailedSecurityPolicy,
-		virtualNetworkAdapterDropReasonsIncomingFailedSecurityPolicy,
-		virtualNetworkAdapterDropReasonsOutgoingUnauthorizedMAC,
-		virtualNetworkAdapterDropReasonsIncomingUnauthorizedMAC,
-		virtualNetworkAdapterDropReasonsOutgoingUnauthorizedVLAN,
-		virtualNetworkAdapterDropReasonsIncomingUnauthorizedVLAN,
-		virtualNetworkAdapterDropReasonsOutgoingFilteredVLAN,
-		virtualNetworkAdapterDropReasonsIncomingFilteredVLAN,
-		virtualNetworkAdapterDropReasonsOutgoingFiltered,
-		virtualNetworkAdapterDropReasonsIncomingFiltered,
-		virtualNetworkAdapterDropReasonsOutgoingBusy,
-		virtualNetworkAdapterDropReasonsIncomingBusy,
-		virtualNetworkAdapterDropReasonsOutgoingNotAccepted,
-		virtualNetworkAdapterDropReasonsIncomingNotAccepted,
-		virtualNetworkAdapterDropReasonsOutgoingDisconnected,
-		virtualNetworkAdapterDropReasonsIncomingDisconnected,
-		virtualNetworkAdapterDropReasonsOutgoingNotReady,
-		virtualNetworkAdapterDropReasonsIncomingNotReady,
-		virtualNetworkAdapterDropReasonsOutgoingResources,
-		virtualNetworkAdapterDropReasonsIncomingResources,
-		virtualNetworkAdapterDropReasonsOutgoingInvalidPacket,
-		virtualNetworkAdapterDropReasonsIncomingInvalidPacket,
-		virtualNetworkAdapterDropReasonsOutgoingInvalidData,
-		virtualNetworkAdapterDropReasonsIncomingInvalidData,
-		virtualNetworkAdapterDropReasonsOutgoingUnknown,
-		virtualNetworkAdapterDropReasonsIncomingUnknown,
-	})
+	c.perfDataCollectorVirtualNetworkAdapterDropReasons, err = pdh.NewCollector[perfDataCounterValuesVirtualNetworkAdapterDropReasons]("Hyper-V Virtual Network Adapter Drop Reasons", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create Hyper-V Virtual Network Adapter Drop Reasons collector: %w", err)
 	}
@@ -229,311 +181,311 @@ func (c *Collector) buildVirtualNetworkAdapterDropReasons() error {
 }
 
 func (c *Collector) collectVirtualNetworkAdapterDropReasons(ch chan<- prometheus.Metric) error {
-	data, err := c.perfDataCollectorVirtualNetworkAdapterDropReasons.Collect()
+	err := c.perfDataCollectorVirtualNetworkAdapterDropReasons.Collect(&c.perfDataObjectVirtualNetworkAdapterDropReasons)
 	if err != nil {
 		return fmt.Errorf("failed to collect Hyper-V Virtual Network Adapter Drop Reasons metrics: %w", err)
 	}
 
-	for name, adapterData := range data {
+	for _, data := range c.perfDataObjectVirtualNetworkAdapterDropReasons {
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsOutgoingNativeFwdingReq].FirstValue,
-			name, "NativeFwdingReq", "outgoing",
+			data.VirtualNetworkAdapterDropReasonsOutgoingNativeFwdingReq,
+			data.Name, "NativeFwdingReq", "outgoing",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsIncomingNativeFwdingReq].FirstValue,
-			name, "NativeFwdingReq", "incoming",
+			data.VirtualNetworkAdapterDropReasonsIncomingNativeFwdingReq,
+			data.Name, "NativeFwdingReq", "incoming",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsOutgoingMTUMismatch].FirstValue,
-			name, "MTUMismatch", "outgoing",
+			data.VirtualNetworkAdapterDropReasonsOutgoingMTUMismatch,
+			data.Name, "MTUMismatch", "outgoing",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsIncomingMTUMismatch].FirstValue,
-			name, "MTUMismatch", "incoming",
+			data.VirtualNetworkAdapterDropReasonsIncomingMTUMismatch,
+			data.Name, "MTUMismatch", "incoming",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsOutgoingInvalidConfig].FirstValue,
-			name, "InvalidConfig", "outgoing",
+			data.VirtualNetworkAdapterDropReasonsOutgoingInvalidConfig,
+			data.Name, "InvalidConfig", "outgoing",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsIncomingInvalidConfig].FirstValue,
-			name, "InvalidConfig", "incoming",
+			data.VirtualNetworkAdapterDropReasonsIncomingInvalidConfig,
+			data.Name, "InvalidConfig", "incoming",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsOutgoingRequiredExtensionMissing].FirstValue,
-			name, "RequiredExtensionMissing", "outgoing",
+			data.VirtualNetworkAdapterDropReasonsOutgoingRequiredExtensionMissing,
+			data.Name, "RequiredExtensionMissing", "outgoing",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsIncomingRequiredExtensionMissing].FirstValue,
-			name, "RequiredExtensionMissing", "incoming",
+			data.VirtualNetworkAdapterDropReasonsIncomingRequiredExtensionMissing,
+			data.Name, "RequiredExtensionMissing", "incoming",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsOutgoingVirtualSubnetId].FirstValue,
-			name, "VirtualSubnetId", "outgoing",
+			data.VirtualNetworkAdapterDropReasonsOutgoingVirtualSubnetId,
+			data.Name, "VirtualSubnetId", "outgoing",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsIncomingVirtualSubnetId].FirstValue,
-			name, "VirtualSubnetId", "incoming",
+			data.VirtualNetworkAdapterDropReasonsIncomingVirtualSubnetId,
+			data.Name, "VirtualSubnetId", "incoming",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsOutgoingBridgeReserved].FirstValue,
-			name, "BridgeReserved", "outgoing",
+			data.VirtualNetworkAdapterDropReasonsOutgoingBridgeReserved,
+			data.Name, "BridgeReserved", "outgoing",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsIncomingBridgeReserved].FirstValue,
-			name, "BridgeReserved", "incoming",
+			data.VirtualNetworkAdapterDropReasonsIncomingBridgeReserved,
+			data.Name, "BridgeReserved", "incoming",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsOutgoingRouterGuard].FirstValue,
-			name, "RouterGuard", "outgoing",
+			data.VirtualNetworkAdapterDropReasonsOutgoingRouterGuard,
+			data.Name, "RouterGuard", "outgoing",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsIncomingRouterGuard].FirstValue,
-			name, "RouterGuard", "incoming",
+			data.VirtualNetworkAdapterDropReasonsIncomingRouterGuard,
+			data.Name, "RouterGuard", "incoming",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsOutgoingDhcpGuard].FirstValue,
-			name, "DhcpGuard", "outgoing",
+			data.VirtualNetworkAdapterDropReasonsOutgoingDhcpGuard,
+			data.Name, "DhcpGuard", "outgoing",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsIncomingDhcpGuard].FirstValue,
-			name, "DhcpGuard", "incoming",
+			data.VirtualNetworkAdapterDropReasonsIncomingDhcpGuard,
+			data.Name, "DhcpGuard", "incoming",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsOutgoingMacSpoofing].FirstValue,
-			name, "MacSpoofing", "outgoing",
+			data.VirtualNetworkAdapterDropReasonsOutgoingMacSpoofing,
+			data.Name, "MacSpoofing", "outgoing",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsIncomingMacSpoofing].FirstValue,
-			name, "MacSpoofing", "incoming",
+			data.VirtualNetworkAdapterDropReasonsIncomingMacSpoofing,
+			data.Name, "MacSpoofing", "incoming",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsOutgoingIpsec].FirstValue,
-			name, "Ipsec", "outgoing",
+			data.VirtualNetworkAdapterDropReasonsOutgoingIpsec,
+			data.Name, "Ipsec", "outgoing",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsIncomingIpsec].FirstValue,
-			name, "Ipsec", "incoming",
+			data.VirtualNetworkAdapterDropReasonsIncomingIpsec,
+			data.Name, "Ipsec", "incoming",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsOutgoingQos].FirstValue,
-			name, "Qos", "outgoing",
+			data.VirtualNetworkAdapterDropReasonsOutgoingQos,
+			data.Name, "Qos", "outgoing",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsIncomingQos].FirstValue,
-			name, "Qos", "incoming",
+			data.VirtualNetworkAdapterDropReasonsIncomingQos,
+			data.Name, "Qos", "incoming",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsOutgoingFailedPvlanSetting].FirstValue,
-			name, "FailedPvlanSetting", "outgoing",
+			data.VirtualNetworkAdapterDropReasonsOutgoingFailedPvlanSetting,
+			data.Name, "FailedPvlanSetting", "outgoing",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsIncomingFailedPvlanSetting].FirstValue,
-			name, "FailedPvlanSetting", "incoming",
+			data.VirtualNetworkAdapterDropReasonsIncomingFailedPvlanSetting,
+			data.Name, "FailedPvlanSetting", "incoming",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsOutgoingFailedSecurityPolicy].FirstValue,
-			name, "FailedSecurityPolicy", "outgoing",
+			data.VirtualNetworkAdapterDropReasonsOutgoingFailedSecurityPolicy,
+			data.Name, "FailedSecurityPolicy", "outgoing",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsIncomingFailedSecurityPolicy].FirstValue,
-			name, "FailedSecurityPolicy", "incoming",
+			data.VirtualNetworkAdapterDropReasonsIncomingFailedSecurityPolicy,
+			data.Name, "FailedSecurityPolicy", "incoming",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsOutgoingUnauthorizedMAC].FirstValue,
-			name, "UnauthorizedMAC", "outgoing",
+			data.VirtualNetworkAdapterDropReasonsOutgoingUnauthorizedMAC,
+			data.Name, "UnauthorizedMAC", "outgoing",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsIncomingUnauthorizedMAC].FirstValue,
-			name, "UnauthorizedMAC", "incoming",
+			data.VirtualNetworkAdapterDropReasonsIncomingUnauthorizedMAC,
+			data.Name, "UnauthorizedMAC", "incoming",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsOutgoingUnauthorizedVLAN].FirstValue,
-			name, "UnauthorizedVLAN", "outgoing",
+			data.VirtualNetworkAdapterDropReasonsOutgoingUnauthorizedVLAN,
+			data.Name, "UnauthorizedVLAN", "outgoing",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsIncomingUnauthorizedVLAN].FirstValue,
-			name, "UnauthorizedVLAN", "incoming",
+			data.VirtualNetworkAdapterDropReasonsIncomingUnauthorizedVLAN,
+			data.Name, "UnauthorizedVLAN", "incoming",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsOutgoingFilteredVLAN].FirstValue,
-			name, "FilteredVLAN", "outgoing",
+			data.VirtualNetworkAdapterDropReasonsOutgoingFilteredVLAN,
+			data.Name, "FilteredVLAN", "outgoing",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsIncomingFilteredVLAN].FirstValue,
-			name, "FilteredVLAN", "incoming",
+			data.VirtualNetworkAdapterDropReasonsIncomingFilteredVLAN,
+			data.Name, "FilteredVLAN", "incoming",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsOutgoingFiltered].FirstValue,
-			name, "Filtered", "outgoing",
+			data.VirtualNetworkAdapterDropReasonsOutgoingFiltered,
+			data.Name, "Filtered", "outgoing",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsIncomingFiltered].FirstValue,
-			name, "Filtered", "incoming",
+			data.VirtualNetworkAdapterDropReasonsIncomingFiltered,
+			data.Name, "Filtered", "incoming",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsOutgoingBusy].FirstValue,
-			name, "Busy", "outgoing",
+			data.VirtualNetworkAdapterDropReasonsOutgoingBusy,
+			data.Name, "Busy", "outgoing",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsIncomingBusy].FirstValue,
-			name, "Busy", "incoming",
+			data.VirtualNetworkAdapterDropReasonsIncomingBusy,
+			data.Name, "Busy", "incoming",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsOutgoingNotAccepted].FirstValue,
-			name, "NotAccepted", "outgoing",
+			data.VirtualNetworkAdapterDropReasonsOutgoingNotAccepted,
+			data.Name, "NotAccepted", "outgoing",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsIncomingNotAccepted].FirstValue,
-			name, "NotAccepted", "incoming",
+			data.VirtualNetworkAdapterDropReasonsIncomingNotAccepted,
+			data.Name, "NotAccepted", "incoming",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsOutgoingDisconnected].FirstValue,
-			name, "Disconnected", "outgoing",
+			data.VirtualNetworkAdapterDropReasonsOutgoingDisconnected,
+			data.Name, "Disconnected", "outgoing",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsIncomingDisconnected].FirstValue,
-			name, "Disconnected", "incoming",
+			data.VirtualNetworkAdapterDropReasonsIncomingDisconnected,
+			data.Name, "Disconnected", "incoming",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsOutgoingNotReady].FirstValue,
-			name, "NotReady", "outgoing",
+			data.VirtualNetworkAdapterDropReasonsOutgoingNotReady,
+			data.Name, "NotReady", "outgoing",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsIncomingNotReady].FirstValue,
-			name, "NotReady", "incoming",
+			data.VirtualNetworkAdapterDropReasonsIncomingNotReady,
+			data.Name, "NotReady", "incoming",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsOutgoingResources].FirstValue,
-			name, "Resources", "outgoing",
+			data.VirtualNetworkAdapterDropReasonsOutgoingResources,
+			data.Name, "Resources", "outgoing",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsIncomingResources].FirstValue,
-			name, "Resources", "incoming",
+			data.VirtualNetworkAdapterDropReasonsIncomingResources,
+			data.Name, "Resources", "incoming",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsOutgoingInvalidPacket].FirstValue,
-			name, "InvalidPacket", "outgoing",
+			data.VirtualNetworkAdapterDropReasonsOutgoingInvalidPacket,
+			data.Name, "InvalidPacket", "outgoing",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsIncomingInvalidPacket].FirstValue,
-			name, "InvalidPacket", "incoming",
+			data.VirtualNetworkAdapterDropReasonsIncomingInvalidPacket,
+			data.Name, "InvalidPacket", "incoming",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsOutgoingInvalidData].FirstValue,
-			name, "InvalidData", "outgoing",
+			data.VirtualNetworkAdapterDropReasonsOutgoingInvalidData,
+			data.Name, "InvalidData", "outgoing",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsIncomingInvalidData].FirstValue,
-			name, "InvalidData", "incoming",
+			data.VirtualNetworkAdapterDropReasonsIncomingInvalidData,
+			data.Name, "InvalidData", "incoming",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsOutgoingUnknown].FirstValue,
-			name, "Unknown", "outgoing",
+			data.VirtualNetworkAdapterDropReasonsOutgoingUnknown,
+			data.Name, "Unknown", "outgoing",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualNetworkAdapterDropReasons,
 			prometheus.CounterValue,
-			adapterData[virtualNetworkAdapterDropReasonsIncomingUnknown].FirstValue,
-			name, "Unknown", "incoming",
+			data.VirtualNetworkAdapterDropReasonsIncomingUnknown,
+			data.Name, "Unknown", "incoming",
 		)
 	}
 

internal/collector/hyperv/hyperv_virtual_smb.go

@@ -18,14 +18,15 @@ package hyperv
 import (
 	"fmt"
 
-	"github.com/prometheus-community/windows_exporter/internal/perfdata"
+	"github.com/prometheus-community/windows_exporter/internal/pdh"
 	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 )
 
 // collectorVirtualSMB Hyper-V Virtual SMB metrics
 type collectorVirtualSMB struct {
-	perfDataCollectorVirtualSMB *perfdata.Collector
+	perfDataCollectorVirtualSMB *pdh.Collector
+	perfDataObjectVirtualSMB    []perfDataCounterValuesVirtualSMB
 
 	virtualSMBDirectMappedSections   *prometheus.Desc // \Hyper-V Virtual SMB(*)\Direct-Mapped Sections
 	virtualSMBDirectMappedPages      *prometheus.Desc // \Hyper-V Virtual SMB(*)\Direct-Mapped Pages
@@ -46,48 +47,32 @@ type collectorVirtualSMB struct {
 	virtualSMBReceivedBytes          *prometheus.Desc // \Hyper-V Virtual SMB(*)\Received Bytes/sec
 }
 
-const (
-	virtualSMBDirectMappedSections   = "Direct-Mapped Sections"
-	virtualSMBDirectMappedPages      = "Direct-Mapped Pages"
-	virtualSMBWriteBytesRDMA         = "Write Bytes/sec (RDMA)"
-	virtualSMBWriteBytes             = "Write Bytes/sec"
-	virtualSMBReadBytesRDMA          = "Read Bytes/sec (RDMA)"
-	virtualSMBReadBytes              = "Read Bytes/sec"
-	virtualSMBFlushRequests          = "Flush Requests/sec"
-	virtualSMBWriteRequestsRDMA      = "Write Requests/sec (RDMA)"
-	virtualSMBWriteRequests          = "Write Requests/sec"
-	virtualSMBReadRequestsRDMA       = "Read Requests/sec (RDMA)"
-	virtualSMBReadRequests           = "Read Requests/sec"
-	virtualSMBCurrentPendingRequests = "Current Pending Requests"
-	virtualSMBCurrentOpenFileCount   = "Current Open File Count"
-	virtualSMBTreeConnectCount       = "Tree Connect Count"
-	virtualSMBRequests               = "Requests/sec"
-	virtualSMBSentBytes              = "Sent Bytes/sec"
-	virtualSMBReceivedBytes          = "Received Bytes/sec"
-)
+type perfDataCounterValuesVirtualSMB struct {
+	Name string
+
+	VirtualSMBDirectMappedSections   float64 `perfdata:"Direct-Mapped Sections"`
+	VirtualSMBDirectMappedPages      float64 `perfdata:"Direct-Mapped Pages"`
+	VirtualSMBWriteBytesRDMA         float64 `perfdata:"Write Bytes/sec (RDMA)"`
+	VirtualSMBWriteBytes             float64 `perfdata:"Write Bytes/sec"`
+	VirtualSMBReadBytesRDMA          float64 `perfdata:"Read Bytes/sec (RDMA)"`
+	VirtualSMBReadBytes              float64 `perfdata:"Read Bytes/sec"`
+	VirtualSMBFlushRequests          float64 `perfdata:"Flush Requests/sec"`
+	VirtualSMBWriteRequestsRDMA      float64 `perfdata:"Write Requests/sec (RDMA)"`
+	VirtualSMBWriteRequests          float64 `perfdata:"Write Requests/sec"`
+	VirtualSMBReadRequestsRDMA       float64 `perfdata:"Read Requests/sec (RDMA)"`
+	VirtualSMBReadRequests           float64 `perfdata:"Read Requests/sec"`
+	VirtualSMBCurrentPendingRequests float64 `perfdata:"Current Pending Requests"`
+	VirtualSMBCurrentOpenFileCount   float64 `perfdata:"Current Open File Count"`
+	VirtualSMBTreeConnectCount       float64 `perfdata:"Tree Connect Count"`
+	VirtualSMBRequests               float64 `perfdata:"Requests/sec"`
+	VirtualSMBSentBytes              float64 `perfdata:"Sent Bytes/sec"`
+	VirtualSMBReceivedBytes          float64 `perfdata:"Received Bytes/sec"`
+}
 
 func (c *Collector) buildVirtualSMB() error {
 	var err error
 
-	c.perfDataCollectorVirtualSMB, err = perfdata.NewCollector("Hyper-V Virtual SMB", perfdata.InstancesAll, []string{
-		virtualSMBDirectMappedSections,
-		virtualSMBDirectMappedPages,
-		virtualSMBWriteBytesRDMA,
-		virtualSMBWriteBytes,
-		virtualSMBReadBytesRDMA,
-		virtualSMBReadBytes,
-		virtualSMBFlushRequests,
-		virtualSMBWriteRequestsRDMA,
-		virtualSMBWriteRequests,
-		virtualSMBReadRequestsRDMA,
-		virtualSMBReadRequests,
-		virtualSMBCurrentPendingRequests,
-		virtualSMBCurrentOpenFileCount,
-		virtualSMBTreeConnectCount,
-		virtualSMBRequests,
-		virtualSMBSentBytes,
-		virtualSMBReceivedBytes,
-	})
+	c.perfDataCollectorVirtualSMB, err = pdh.NewCollector[perfDataCounterValuesVirtualSMB]("Hyper-V Virtual SMB", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create Hyper-V Virtual SMB collector: %w", err)
 	}
@@ -199,129 +184,129 @@ func (c *Collector) buildVirtualSMB() error {
 }
 
 func (c *Collector) collectVirtualSMB(ch chan<- prometheus.Metric) error {
-	data, err := c.perfDataCollectorVirtualSMB.Collect()
+	err := c.perfDataCollectorVirtualSMB.Collect(&c.perfDataObjectVirtualSMB)
 	if err != nil {
 		return fmt.Errorf("failed to collect Hyper-V Virtual SMB metrics: %w", err)
 	}
 
-	for name, smbData := range data {
+	for _, data := range c.perfDataObjectVirtualSMB {
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSMBDirectMappedSections,
 			prometheus.GaugeValue,
-			smbData[virtualSMBDirectMappedSections].FirstValue,
-			name,
+			data.VirtualSMBDirectMappedSections,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSMBDirectMappedPages,
 			prometheus.GaugeValue,
-			smbData[virtualSMBDirectMappedPages].FirstValue,
-			name,
+			data.VirtualSMBDirectMappedPages,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSMBWriteBytesRDMA,
 			prometheus.CounterValue,
-			smbData[virtualSMBWriteBytesRDMA].FirstValue,
-			name,
+			data.VirtualSMBWriteBytesRDMA,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSMBWriteBytes,
 			prometheus.CounterValue,
-			smbData[virtualSMBWriteBytes].FirstValue,
-			name,
+			data.VirtualSMBWriteBytes,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSMBReadBytesRDMA,
 			prometheus.CounterValue,
-			smbData[virtualSMBReadBytesRDMA].FirstValue,
-			name,
+			data.VirtualSMBReadBytesRDMA,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSMBReadBytes,
 			prometheus.CounterValue,
-			smbData[virtualSMBReadBytes].FirstValue,
-			name,
+			data.VirtualSMBReadBytes,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSMBFlushRequests,
 			prometheus.CounterValue,
-			smbData[virtualSMBFlushRequests].FirstValue,
-			name,
+			data.VirtualSMBFlushRequests,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSMBWriteRequestsRDMA,
 			prometheus.CounterValue,
-			smbData[virtualSMBWriteRequestsRDMA].FirstValue,
-			name,
+			data.VirtualSMBWriteRequestsRDMA,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSMBWriteRequests,
 			prometheus.CounterValue,
-			smbData[virtualSMBWriteRequests].FirstValue,
-			name,
+			data.VirtualSMBWriteRequests,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSMBReadRequestsRDMA,
 			prometheus.CounterValue,
-			smbData[virtualSMBReadRequestsRDMA].FirstValue,
-			name,
+			data.VirtualSMBReadRequestsRDMA,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSMBReadRequests,
 			prometheus.CounterValue,
-			smbData[virtualSMBReadRequests].FirstValue,
-			name,
+			data.VirtualSMBReadRequests,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSMBCurrentPendingRequests,
 			prometheus.GaugeValue,
-			smbData[virtualSMBCurrentPendingRequests].FirstValue,
-			name,
+			data.VirtualSMBCurrentPendingRequests,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSMBCurrentOpenFileCount,
 			prometheus.GaugeValue,
-			smbData[virtualSMBCurrentOpenFileCount].FirstValue,
-			name,
+			data.VirtualSMBCurrentOpenFileCount,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSMBTreeConnectCount,
 			prometheus.GaugeValue,
-			smbData[virtualSMBTreeConnectCount].FirstValue,
-			name,
+			data.VirtualSMBTreeConnectCount,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSMBRequests,
 			prometheus.CounterValue,
-			smbData[virtualSMBRequests].FirstValue,
-			name,
+			data.VirtualSMBRequests,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSMBSentBytes,
 			prometheus.CounterValue,
-			smbData[virtualSMBSentBytes].FirstValue,
-			name,
+			data.VirtualSMBSentBytes,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSMBReceivedBytes,
 			prometheus.CounterValue,
-			smbData[virtualSMBReceivedBytes].FirstValue,
-			name,
+			data.VirtualSMBReceivedBytes,
+			data.Name,
 		)
 	}
 

internal/collector/hyperv/hyperv_virtual_storage_device.go

@@ -18,14 +18,15 @@ package hyperv
 import (
 	"fmt"
 
-	"github.com/prometheus-community/windows_exporter/internal/perfdata"
+	"github.com/prometheus-community/windows_exporter/internal/pdh"
 	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 )
 
 // Hyper-V Virtual Storage Device metrics
 type collectorVirtualStorageDevice struct {
-	perfDataCollectorVirtualStorageDevice *perfdata.Collector
+	perfDataCollectorVirtualStorageDevice *pdh.Collector
+	perfDataObjectVirtualStorageDevice    []perfDataCounterValuesVirtualStorageDevice
 
 	virtualStorageDeviceErrorCount               *prometheus.Desc // \Hyper-V Virtual Storage Device(*)\Error Count
 	virtualStorageDeviceQueueLength              *prometheus.Desc // \Hyper-V Virtual Storage Device(*)\Queue Length
@@ -41,38 +42,27 @@ type collectorVirtualStorageDevice struct {
 	virtualStorageDeviceIOQuotaReplenishmentRate *prometheus.Desc // \Hyper-V Virtual Storage Device(*)\IO Quota Replenishment Rate
 }
 
-const (
-	virtualStorageDeviceErrorCount               = "Error Count"
-	virtualStorageDeviceQueueLength              = "Queue Length"
-	virtualStorageDeviceReadBytes                = "Read Bytes/sec"
-	virtualStorageDeviceReadOperations           = "Read Count"
-	virtualStorageDeviceWriteBytes               = "Write Bytes/sec"
-	virtualStorageDeviceWriteOperations          = "Write Count"
-	virtualStorageDeviceLatency                  = "Latency"
-	virtualStorageDeviceThroughput               = "Throughput"
-	virtualStorageDeviceNormalizedThroughput     = "Normalized Throughput"
-	virtualStorageDeviceLowerQueueLength         = "Lower Queue Length"
-	virtualStorageDeviceLowerLatency             = "Lower Latency"
-	virtualStorageDeviceIOQuotaReplenishmentRate = "IO Quota Replenishment Rate"
-)
+type perfDataCounterValuesVirtualStorageDevice struct {
+	Name string
+
+	VirtualStorageDeviceErrorCount               float64 `perfdata:"Error Count"`
+	VirtualStorageDeviceQueueLength              float64 `perfdata:"Queue Length"`
+	VirtualStorageDeviceReadBytes                float64 `perfdata:"Read Bytes/sec"`
+	VirtualStorageDeviceReadOperations           float64 `perfdata:"Read Count"`
+	VirtualStorageDeviceWriteBytes               float64 `perfdata:"Write Bytes/sec"`
+	VirtualStorageDeviceWriteOperations          float64 `perfdata:"Write Count"`
+	VirtualStorageDeviceLatency                  float64 `perfdata:"Latency"`
+	VirtualStorageDeviceThroughput               float64 `perfdata:"Throughput"`
+	VirtualStorageDeviceNormalizedThroughput     float64 `perfdata:"Normalized Throughput"`
+	VirtualStorageDeviceLowerQueueLength         float64 `perfdata:"Lower Queue Length"`
+	VirtualStorageDeviceLowerLatency             float64 `perfdata:"Lower Latency"`
+	VirtualStorageDeviceIOQuotaReplenishmentRate float64 `perfdata:"IO Quota Replenishment Rate"`
+}
 
 func (c *Collector) buildVirtualStorageDevice() error {
 	var err error
 
-	c.perfDataCollectorVirtualStorageDevice, err = perfdata.NewCollector("Hyper-V Virtual Storage Device", perfdata.InstancesAll, []string{
-		virtualStorageDeviceErrorCount,
-		virtualStorageDeviceQueueLength,
-		virtualStorageDeviceReadBytes,
-		virtualStorageDeviceReadOperations,
-		virtualStorageDeviceWriteBytes,
-		virtualStorageDeviceWriteOperations,
-		virtualStorageDeviceLatency,
-		virtualStorageDeviceThroughput,
-		virtualStorageDeviceNormalizedThroughput,
-		virtualStorageDeviceLowerQueueLength,
-		virtualStorageDeviceLowerLatency,
-		virtualStorageDeviceIOQuotaReplenishmentRate,
-	})
+	c.perfDataCollectorVirtualStorageDevice, err = pdh.NewCollector[perfDataCounterValuesVirtualStorageDevice]("Hyper-V Virtual Storage Device", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create Hyper-V Virtual Storage Device collector: %w", err)
 	}
@@ -154,94 +144,94 @@ func (c *Collector) buildVirtualStorageDevice() error {
 }
 
 func (c *Collector) collectVirtualStorageDevice(ch chan<- prometheus.Metric) error {
-	data, err := c.perfDataCollectorVirtualStorageDevice.Collect()
+	err := c.perfDataCollectorVirtualStorageDevice.Collect(&c.perfDataObjectVirtualStorageDevice)
 	if err != nil {
 		return fmt.Errorf("failed to collect Hyper-V Virtual Storage Device metrics: %w", err)
 	}
 
-	for name, device := range data {
+	for _, data := range c.perfDataObjectVirtualStorageDevice {
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualStorageDeviceErrorCount,
 			prometheus.CounterValue,
-			device[virtualStorageDeviceErrorCount].FirstValue,
-			name,
+			data.VirtualStorageDeviceErrorCount,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualStorageDeviceQueueLength,
 			prometheus.GaugeValue,
-			device[virtualStorageDeviceQueueLength].FirstValue,
-			name,
+			data.VirtualStorageDeviceQueueLength,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualStorageDeviceReadBytes,
 			prometheus.CounterValue,
-			device[virtualStorageDeviceReadBytes].FirstValue,
-			name,
+			data.VirtualStorageDeviceReadBytes,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualStorageDeviceReadOperations,
 			prometheus.CounterValue,
-			device[virtualStorageDeviceReadOperations].FirstValue,
-			name,
+			data.VirtualStorageDeviceReadOperations,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualStorageDeviceWriteBytes,
 			prometheus.CounterValue,
-			device[virtualStorageDeviceWriteBytes].FirstValue,
-			name,
+			data.VirtualStorageDeviceWriteBytes,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualStorageDeviceWriteOperations,
 			prometheus.CounterValue,
-			device[virtualStorageDeviceWriteOperations].FirstValue,
-			name,
+			data.VirtualStorageDeviceWriteOperations,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualStorageDeviceLatency,
 			prometheus.GaugeValue,
-			device[virtualStorageDeviceLatency].FirstValue,
-			name,
+			data.VirtualStorageDeviceLatency,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualStorageDeviceThroughput,
 			prometheus.GaugeValue,
-			device[virtualStorageDeviceThroughput].FirstValue,
-			name,
+			data.VirtualStorageDeviceThroughput,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualStorageDeviceNormalizedThroughput,
 			prometheus.GaugeValue,
-			device[virtualStorageDeviceNormalizedThroughput].FirstValue,
-			name,
+			data.VirtualStorageDeviceNormalizedThroughput,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualStorageDeviceLowerQueueLength,
 			prometheus.GaugeValue,
-			device[virtualStorageDeviceLowerQueueLength].FirstValue,
-			name,
+			data.VirtualStorageDeviceLowerQueueLength,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualStorageDeviceLowerLatency,
 			prometheus.GaugeValue,
-			device[virtualStorageDeviceLowerLatency].FirstValue,
-			name,
+			data.VirtualStorageDeviceLowerLatency,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualStorageDeviceIOQuotaReplenishmentRate,
 			prometheus.GaugeValue,
-			device[virtualStorageDeviceIOQuotaReplenishmentRate].FirstValue,
-			name,
+			data.VirtualStorageDeviceIOQuotaReplenishmentRate,
+			data.Name,
 		)
 	}
 

internal/collector/hyperv/hyperv_virtual_switch.go

@@ -18,14 +18,16 @@ package hyperv
 import (
 	"fmt"
 
-	"github.com/prometheus-community/windows_exporter/internal/perfdata"
+	"github.com/prometheus-community/windows_exporter/internal/pdh"
 	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 )
 
 // collectorVirtualMachineHealthSummary Hyper-V Virtual Switch Summary metrics
 type collectorVirtualSwitch struct {
-	perfDataCollectorVirtualSwitch                *perfdata.Collector
+	perfDataCollectorVirtualSwitch *pdh.Collector
+	perfDataObjectVirtualSwitch    []perfDataCounterValuesVirtualSwitch
+
 	virtualSwitchBroadcastPacketsReceived         *prometheus.Desc // \Hyper-V Virtual Switch(*)\Broadcast Packets Received/sec
 	virtualSwitchBroadcastPacketsSent             *prometheus.Desc // \Hyper-V Virtual Switch(*)\Broadcast Packets Sent/sec
 	virtualSwitchBytes                            *prometheus.Desc // \Hyper-V Virtual Switch(*)\Bytes/sec
@@ -49,56 +51,36 @@ type collectorVirtualSwitch struct {
 	virtualSwitchPurgedMacAddresses               *prometheus.Desc // \Hyper-V Virtual Switch(*)\Purged Mac Addresses
 }
 
-const (
-	virtualSwitchBroadcastPacketsReceived         = "Broadcast Packets Received/sec"
-	virtualSwitchBroadcastPacketsSent             = "Broadcast Packets Sent/sec"
-	virtualSwitchBytes                            = "Bytes/sec"
-	virtualSwitchBytesReceived                    = "Bytes Received/sec"
-	virtualSwitchBytesSent                        = "Bytes Sent/sec"
-	virtualSwitchDirectedPacketsReceived          = "Directed Packets Received/sec"
-	virtualSwitchDirectedPacketsSent              = "Directed Packets Sent/sec"
-	virtualSwitchDroppedPacketsIncoming           = "Dropped Packets Incoming/sec"
-	virtualSwitchDroppedPacketsOutgoing           = "Dropped Packets Outgoing/sec"
-	virtualSwitchExtensionsDroppedPacketsIncoming = "Extensions Dropped Packets Incoming/sec"
-	virtualSwitchExtensionsDroppedPacketsOutgoing = "Extensions Dropped Packets Outgoing/sec"
-	virtualSwitchLearnedMacAddresses              = "Learned Mac Addresses"
-	virtualSwitchMulticastPacketsReceived         = "Multicast Packets Received/sec"
-	virtualSwitchMulticastPacketsSent             = "Multicast Packets Sent/sec"
-	virtualSwitchNumberOfSendChannelMoves         = "Number of Send Channel Moves/sec"
-	virtualSwitchNumberOfVMQMoves                 = "Number of VMQ Moves/sec"
-	virtualSwitchPacketsFlooded                   = "Packets Flooded"
-	virtualSwitchPackets                          = "Packets/sec"
-	virtualSwitchPacketsReceived                  = "Packets Received/sec"
-	virtualSwitchPacketsSent                      = "Packets Sent/sec"
-	virtualSwitchPurgedMacAddresses               = "Purged Mac Addresses"
-)
+type perfDataCounterValuesVirtualSwitch struct {
+	Name string
+
+	VirtualSwitchBroadcastPacketsReceived         float64 `perfdata:"Broadcast Packets Received/sec"`
+	VirtualSwitchBroadcastPacketsSent             float64 `perfdata:"Broadcast Packets Sent/sec"`
+	VirtualSwitchBytes                            float64 `perfdata:"Bytes/sec"`
+	VirtualSwitchBytesReceived                    float64 `perfdata:"Bytes Received/sec"`
+	VirtualSwitchBytesSent                        float64 `perfdata:"Bytes Sent/sec"`
+	VirtualSwitchDirectedPacketsReceived          float64 `perfdata:"Directed Packets Received/sec"`
+	VirtualSwitchDirectedPacketsSent              float64 `perfdata:"Directed Packets Sent/sec"`
+	VirtualSwitchDroppedPacketsIncoming           float64 `perfdata:"Dropped Packets Incoming/sec"`
+	VirtualSwitchDroppedPacketsOutgoing           float64 `perfdata:"Dropped Packets Outgoing/sec"`
+	VirtualSwitchExtensionsDroppedPacketsIncoming float64 `perfdata:"Extensions Dropped Packets Incoming/sec"`
+	VirtualSwitchExtensionsDroppedPacketsOutgoing float64 `perfdata:"Extensions Dropped Packets Outgoing/sec"`
+	VirtualSwitchLearnedMacAddresses              float64 `perfdata:"Learned Mac Addresses"`
+	VirtualSwitchMulticastPacketsReceived         float64 `perfdata:"Multicast Packets Received/sec"`
+	VirtualSwitchMulticastPacketsSent             float64 `perfdata:"Multicast Packets Sent/sec"`
+	VirtualSwitchNumberOfSendChannelMoves         float64 `perfdata:"Number of Send Channel Moves/sec"`
+	VirtualSwitchNumberOfVMQMoves                 float64 `perfdata:"Number of VMQ Moves/sec"`
+	VirtualSwitchPacketsFlooded                   float64 `perfdata:"Packets Flooded"`
+	VirtualSwitchPackets                          float64 `perfdata:"Packets/sec"`
+	VirtualSwitchPacketsReceived                  float64 `perfdata:"Packets Received/sec"`
+	VirtualSwitchPacketsSent                      float64 `perfdata:"Packets Sent/sec"`
+	VirtualSwitchPurgedMacAddresses               float64 `perfdata:"Purged Mac Addresses"`
+}
 
 func (c *Collector) buildVirtualSwitch() error {
 	var err error
 
-	c.perfDataCollectorVirtualSwitch, err = perfdata.NewCollector("Hyper-V Virtual Switch", perfdata.InstancesAll, []string{
-		virtualSwitchBroadcastPacketsReceived,
-		virtualSwitchBroadcastPacketsSent,
-		virtualSwitchBytes,
-		virtualSwitchBytesReceived,
-		virtualSwitchBytesSent,
-		virtualSwitchDirectedPacketsReceived,
-		virtualSwitchDirectedPacketsSent,
-		virtualSwitchDroppedPacketsIncoming,
-		virtualSwitchDroppedPacketsOutgoing,
-		virtualSwitchExtensionsDroppedPacketsIncoming,
-		virtualSwitchExtensionsDroppedPacketsOutgoing,
-		virtualSwitchLearnedMacAddresses,
-		virtualSwitchMulticastPacketsReceived,
-		virtualSwitchMulticastPacketsSent,
-		virtualSwitchNumberOfSendChannelMoves,
-		virtualSwitchNumberOfVMQMoves,
-		virtualSwitchPacketsFlooded,
-		virtualSwitchPackets,
-		virtualSwitchPacketsReceived,
-		virtualSwitchPacketsSent,
-		virtualSwitchPurgedMacAddresses,
-	})
+	c.perfDataCollectorVirtualSwitch, err = pdh.NewCollector[perfDataCounterValuesVirtualSwitch]("Hyper-V Virtual Switch", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create Hyper-V Virtual Switch collector: %w", err)
 	}
@@ -234,147 +216,147 @@ func (c *Collector) buildVirtualSwitch() error {
 }
 
 func (c *Collector) collectVirtualSwitch(ch chan<- prometheus.Metric) error {
-	data, err := c.perfDataCollectorVirtualSwitch.Collect()
+	err := c.perfDataCollectorVirtualSwitch.Collect(&c.perfDataObjectVirtualSwitch)
 	if err != nil {
 		return fmt.Errorf("failed to collect Hyper-V Virtual Switch metrics: %w", err)
 	}
 
-	for name, switchData := range data {
+	for _, data := range c.perfDataObjectVirtualSwitch {
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSwitchBroadcastPacketsReceived,
 			prometheus.CounterValue,
-			switchData[virtualSwitchBroadcastPacketsReceived].FirstValue,
-			name,
+			data.VirtualSwitchBroadcastPacketsReceived,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSwitchBroadcastPacketsSent,
 			prometheus.CounterValue,
-			switchData[virtualSwitchBroadcastPacketsSent].FirstValue,
-			name,
+			data.VirtualSwitchBroadcastPacketsSent,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSwitchBytes,
 			prometheus.CounterValue,
-			switchData[virtualSwitchBytes].FirstValue,
-			name,
+			data.VirtualSwitchBytes,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSwitchBytesReceived,
 			prometheus.CounterValue,
-			switchData[virtualSwitchBytesReceived].FirstValue,
-			name,
+			data.VirtualSwitchBytesReceived,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSwitchBytesSent,
 			prometheus.CounterValue,
-			switchData[virtualSwitchBytesSent].FirstValue,
-			name,
+			data.VirtualSwitchBytesSent,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSwitchDirectedPacketsReceived,
 			prometheus.CounterValue,
-			switchData[virtualSwitchDirectedPacketsReceived].FirstValue,
-			name,
+			data.VirtualSwitchDirectedPacketsReceived,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSwitchDirectedPacketsSent,
 			prometheus.CounterValue,
-			switchData[virtualSwitchDirectedPacketsSent].FirstValue,
-			name,
+			data.VirtualSwitchDirectedPacketsSent,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSwitchDroppedPacketsIncoming,
 			prometheus.CounterValue,
-			switchData[virtualSwitchDroppedPacketsIncoming].FirstValue,
-			name,
+			data.VirtualSwitchDroppedPacketsIncoming,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSwitchDroppedPacketsOutgoing,
 			prometheus.CounterValue,
-			switchData[virtualSwitchDroppedPacketsOutgoing].FirstValue,
-			name,
+			data.VirtualSwitchDroppedPacketsOutgoing,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSwitchExtensionsDroppedPacketsIncoming,
 			prometheus.CounterValue,
-			switchData[virtualSwitchExtensionsDroppedPacketsIncoming].FirstValue,
-			name,
+			data.VirtualSwitchExtensionsDroppedPacketsIncoming,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSwitchExtensionsDroppedPacketsOutgoing,
 			prometheus.CounterValue,
-			switchData[virtualSwitchExtensionsDroppedPacketsOutgoing].FirstValue,
-			name,
+			data.VirtualSwitchExtensionsDroppedPacketsOutgoing,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSwitchLearnedMacAddresses,
 			prometheus.CounterValue,
-			switchData[virtualSwitchLearnedMacAddresses].FirstValue,
-			name,
+			data.VirtualSwitchLearnedMacAddresses,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSwitchMulticastPacketsReceived,
 			prometheus.CounterValue,
-			switchData[virtualSwitchMulticastPacketsReceived].FirstValue,
-			name,
+			data.VirtualSwitchMulticastPacketsReceived,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSwitchMulticastPacketsSent,
 			prometheus.CounterValue,
-			switchData[virtualSwitchMulticastPacketsSent].FirstValue,
-			name,
+			data.VirtualSwitchMulticastPacketsSent,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSwitchNumberOfSendChannelMoves,
 			prometheus.CounterValue,
-			switchData[virtualSwitchNumberOfSendChannelMoves].FirstValue,
-			name,
+			data.VirtualSwitchNumberOfSendChannelMoves,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSwitchNumberOfVMQMoves,
 			prometheus.CounterValue,
-			switchData[virtualSwitchNumberOfVMQMoves].FirstValue,
-			name,
+			data.VirtualSwitchNumberOfVMQMoves,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSwitchPacketsFlooded,
 			prometheus.CounterValue,
-			switchData[virtualSwitchPacketsFlooded].FirstValue,
-			name,
+			data.VirtualSwitchPacketsFlooded,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSwitchPackets,
 			prometheus.CounterValue,
-			switchData[virtualSwitchPackets].FirstValue,
-			name,
+			data.VirtualSwitchPackets,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSwitchPacketsReceived,
 			prometheus.CounterValue,
-			switchData[virtualSwitchPacketsReceived].FirstValue,
-			name,
+			data.VirtualSwitchPacketsReceived,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSwitchPacketsSent,
 			prometheus.CounterValue,
-			switchData[virtualSwitchPacketsSent].FirstValue,
-			name,
+			data.VirtualSwitchPacketsSent,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.virtualSwitchPurgedMacAddresses,
 			prometheus.CounterValue,
-			switchData[virtualSwitchPurgedMacAddresses].FirstValue,
-			name,
+			data.VirtualSwitchPurgedMacAddresses,
+			data.Name,
 		)
 	}