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

Signed-off-by: Jan-Otto Kröpke <mail@jkroepke.de>
2026-03-09 12:06:35 +00:00 · 2024-12-21 22:58:47 +01:00
parent 39c929eefe
commit a9f8b3b722
158 changed files with 7793 additions and 7748 deletions
--- a/internal/collector/exchange/exchange.go
+++ b/internal/collector/exchange/exchange.go
@@ -21,26 +21,26 @@ import (
 	"log/slog"
 	"os"
 	"strings"
+	"sync"

 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/mi"
-	"github.com/prometheus-community/windows_exporter/internal/perfdata"
 	"github.com/prometheus/client_golang/prometheus"
 )

 const Name = "exchange"

 const (
-	adAccessProcesses   = "ADAccessProcesses"
-	transportQueues     = "TransportQueues"
-	httpProxy           = "HttpProxy"
-	activeSync          = "ActiveSync"
-	availabilityService = "AvailabilityService"
-	outlookWebAccess    = "OutlookWebAccess"
-	autoDiscover        = "Autodiscover"
-	workloadManagement  = "WorkloadManagement"
-	rpcClientAccess     = "RpcClientAccess"
-	mapiHttpEmsmdb      = "MapiHttpEmsmdb"
+	subCollectorADAccessProcesses   = "ADAccessProcesses"
+	subCollectorTransportQueues     = "TransportQueues"
+	subCollectorHttpProxy           = "HttpProxy"
+	subCollectorActiveSync          = "ActiveSync"
+	subCollectorAvailabilityService = "AvailabilityService"
+	subCollectorOutlookWebAccess    = "OutlookWebAccess"
+	subCollectorAutoDiscover        = "Autodiscover"
+	subCollectorWorkloadManagement  = "WorkloadManagement"
+	subCollectorRpcClientAccess     = "RpcClientAccess"
+	subCollectorMapiHttpEmsmdb      = "MapiHttpEmsmdb"
 )

 type Config struct {
@@ -50,82 +50,35 @@ type Config struct {
 //nolint:gochecknoglobals
 var ConfigDefaults = Config{
 	CollectorsEnabled: []string{
-		adAccessProcesses,
-		transportQueues,
-		httpProxy,
-		activeSync,
-		availabilityService,
-		outlookWebAccess,
-		autoDiscover,
-		workloadManagement,
-		rpcClientAccess,
-		mapiHttpEmsmdb,
+		subCollectorADAccessProcesses,
+		subCollectorTransportQueues,
+		subCollectorHttpProxy,
+		subCollectorActiveSync,
+		subCollectorAvailabilityService,
+		subCollectorOutlookWebAccess,
+		subCollectorAutoDiscover,
+		subCollectorWorkloadManagement,
+		subCollectorRpcClientAccess,
+		subCollectorMapiHttpEmsmdb,
 	},
 }

 type Collector struct {
 	config Config

-	perfDataCollectorADAccessProcesses           *perfdata.Collector
-	perfDataCollectorTransportQueues             *perfdata.Collector
-	perfDataCollectorHttpProxy                   *perfdata.Collector
-	perfDataCollectorActiveSync                  *perfdata.Collector
-	perfDataCollectorAvailabilityService         *perfdata.Collector
-	perfDataCollectorOWA                         *perfdata.Collector
-	perfDataCollectorAutoDiscover                *perfdata.Collector
-	perfDataCollectorWorkloadManagementWorkloads *perfdata.Collector
-	perfDataCollectorRpcClientAccess             *perfdata.Collector
-	perfDataCollectorMapiHttpEmsmdb              *perfdata.Collector
+	collectorFns []func(ch chan<- prometheus.Metric) error
+	closeFns     []func()

-	activeMailboxDeliveryQueueLength        *prometheus.Desc
-	activeSyncRequestsPerSec                *prometheus.Desc
-	activeTasks                             *prometheus.Desc
-	activeUserCount                         *prometheus.Desc
-	activeUserCountMapiHttpEmsMDB           *prometheus.Desc
-	autoDiscoverRequestsPerSec              *prometheus.Desc
-	availabilityRequestsSec                 *prometheus.Desc
-	averageAuthenticationLatency            *prometheus.Desc
-	averageCASProcessingLatency             *prometheus.Desc
-	completedTasks                          *prometheus.Desc
-	connectionCount                         *prometheus.Desc
-	currentUniqueUsers                      *prometheus.Desc
-	externalActiveRemoteDeliveryQueueLength *prometheus.Desc
-	externalLargestDeliveryQueueLength      *prometheus.Desc
-	internalActiveRemoteDeliveryQueueLength *prometheus.Desc
-	internalLargestDeliveryQueueLength      *prometheus.Desc
-	isActive                                *prometheus.Desc
-	ldapReadTime                            *prometheus.Desc
-	ldapSearchTime                          *prometheus.Desc
-	ldapTimeoutErrorsPerSec                 *prometheus.Desc
-	ldapWriteTime                           *prometheus.Desc
-	longRunningLDAPOperationsPerMin         *prometheus.Desc
-	mailboxServerLocatorAverageLatency      *prometheus.Desc
-	mailboxServerProxyFailureRate           *prometheus.Desc
-	outstandingProxyRequests                *prometheus.Desc
-	owaRequestsPerSec                       *prometheus.Desc
-	pingCommandsPending                     *prometheus.Desc
-	poisonQueueLength                       *prometheus.Desc
-	proxyRequestsPerSec                     *prometheus.Desc
-	queuedTasks                             *prometheus.Desc
-	retryMailboxDeliveryQueueLength         *prometheus.Desc
-	rpcAveragedLatency                      *prometheus.Desc
-	rpcOperationsPerSec                     *prometheus.Desc
-	rpcRequests                             *prometheus.Desc
-	syncCommandsPerSec                      *prometheus.Desc
-	unreachableQueueLength                  *prometheus.Desc
-	userCount                               *prometheus.Desc
-	yieldedTasks                            *prometheus.Desc
-	messagesQueuedForDeliveryTotal          *prometheus.Desc
-	messagesSubmittedTotal                  *prometheus.Desc
-	messagesDelayedTotal                    *prometheus.Desc
-	messagesCompletedDeliveryTotal          *prometheus.Desc
-	shadowQueueLength                       *prometheus.Desc
-	submissionQueueLength                   *prometheus.Desc
-	delayQueueLength                        *prometheus.Desc
-	itemsCompletedDeliveryTotal             *prometheus.Desc
-	itemsQueuedForDeliveryExpiredTotal      *prometheus.Desc
-	itemsQueuedForDeliveryTotal             *prometheus.Desc
-	itemsResubmittedTotal                   *prometheus.Desc
+	collectorADAccessProcesses
+	collectorActiveSync
+	collectorAutoDiscover
+	collectorAvailabilityService
+	collectorHTTPProxy
+	collectorMapiHttpEmsmdb
+	collectorOWA
+	collectorRpcClientAccess
+	collectorTransportQueues
+	collectorWorkloadManagementWorkloads
 }

 func New(config *Config) *Collector {
@@ -167,16 +120,16 @@ func NewWithFlags(app *kingpin.Application) *Collector {
 	app.PreAction(func(*kingpin.ParseContext) error {
 		if listAllCollectors {
 			collectorDesc := map[string]string{
-				adAccessProcesses:   "[19108] MSExchange ADAccess Processes",
-				transportQueues:     "[20524] MSExchangeTransport Queues",
-				httpProxy:           "[36934] MSExchange HttpProxy",
-				activeSync:          "[25138] MSExchange ActiveSync",
-				availabilityService: "[24914] MSExchange Availability Service",
-				outlookWebAccess:    "[24618] MSExchange OWA",
-				autoDiscover:        "[29240] MSExchange Autodiscover",
-				workloadManagement:  "[19430] MSExchange WorkloadManagement Workloads",
-				rpcClientAccess:     "[29336] MSExchange RpcClientAccess",
-				mapiHttpEmsmdb:      "[26463] MSExchange MapiHttp Emsmdb",
+				subCollectorADAccessProcesses:   "[19108] MSExchange ADAccess Processes",
+				subCollectorTransportQueues:     "[20524] MSExchangeTransport Queues",
+				subCollectorHttpProxy:           "[36934] MSExchange HttpProxy",
+				subCollectorActiveSync:          "[25138] MSExchange ActiveSync",
+				subCollectorAvailabilityService: "[24914] MSExchange Availability Service",
+				subCollectorOutlookWebAccess:    "[24618] MSExchange OWA",
+				subCollectorAutoDiscover:        "[29240] MSExchange Autodiscover",
+				subCollectorWorkloadManagement:  "[19430] MSExchange WorkloadManagement Workloads",
+				subCollectorRpcClientAccess:     "[29336] MSExchange RpcClientAccess",
+				subCollectorMapiHttpEmsmdb:      "[26463] MSExchange MapiHttp Emsmdb",
 			}

 			sb := strings.Builder{}
@@ -208,51 +161,116 @@ func (c *Collector) GetName() string {
 }

 func (c *Collector) Close() error {
+	for _, fn := range c.closeFns {
+		fn()
+	}
+
 	return nil
 }

 func (c *Collector) Build(_ *slog.Logger, _ *mi.Session) error {
-	collectorFuncs := map[string]func() error{
-		adAccessProcesses:   c.buildADAccessProcesses,
-		transportQueues:     c.buildTransportQueues,
-		httpProxy:           c.buildHTTPProxy,
-		activeSync:          c.buildActiveSync,
-		availabilityService: c.buildAvailabilityService,
-		outlookWebAccess:    c.buildOWA,
-		autoDiscover:        c.buildAutoDiscover,
-		workloadManagement:  c.buildWorkloadManagementWorkloads,
-		rpcClientAccess:     c.buildRPC,
-		mapiHttpEmsmdb:      c.buildMapiHttpEmsmdb,
+	subCollectors := map[string]struct {
+		build   func() error
+		collect func(ch chan<- prometheus.Metric) error
+		close   func()
+	}{
+		subCollectorADAccessProcesses: {
+			build:   c.buildADAccessProcesses,
+			collect: c.collectADAccessProcesses,
+			close:   c.perfDataCollectorADAccessProcesses.Close,
+		},
+		subCollectorTransportQueues: {
+			build:   c.buildTransportQueues,
+			collect: c.collectTransportQueues,
+			close:   c.perfDataCollectorTransportQueues.Close,
+		},
+		subCollectorHttpProxy: {
+			build:   c.buildHTTPProxy,
+			collect: c.collectHTTPProxy,
+			close:   c.perfDataCollectorHTTPProxy.Close,
+		},
+		subCollectorActiveSync: {
+			build:   c.buildActiveSync,
+			collect: c.collectActiveSync,
+			close:   c.perfDataCollectorActiveSync.Close,
+		},
+		subCollectorAvailabilityService: {
+			build:   c.buildAvailabilityService,
+			collect: c.collectAvailabilityService,
+			close:   c.perfDataCollectorAvailabilityService.Close,
+		},
+		subCollectorOutlookWebAccess: {
+			build:   c.buildOWA,
+			collect: c.collectOWA,
+			close:   c.perfDataCollectorOWA.Close,
+		},
+		subCollectorAutoDiscover: {
+			build:   c.buildAutoDiscover,
+			collect: c.collectAutoDiscover,
+			close:   c.perfDataCollectorAutoDiscover.Close,
+		},
+		subCollectorWorkloadManagement: {
+			build:   c.buildWorkloadManagementWorkloads,
+			collect: c.collectWorkloadManagementWorkloads,
+			close:   c.perfDataCollectorWorkloadManagementWorkloads.Close,
+		},
+		subCollectorRpcClientAccess: {
+			build:   c.buildRpcClientAccess,
+			collect: c.collectRpcClientAccess,
+			close:   c.perfDataCollectorRpcClientAccess.Close,
+		},
+		subCollectorMapiHttpEmsmdb: {
+			build:   c.buildMapiHttpEmsmdb,
+			collect: c.collectMapiHttpEmsmdb,
+			close:   c.perfDataCollectorMapiHttpEmsmdb.Close,
+		},
 	}

-	for _, collectorName := range c.config.CollectorsEnabled {
-		if err := collectorFuncs[collectorName](); err != nil {
-			return err
+	errs := make([]error, 0, len(c.config.CollectorsEnabled))
+
+	for _, name := range c.config.CollectorsEnabled {
+		if _, ok := subCollectors[name]; !ok {
+			return fmt.Errorf("unknown collector: %s", name)
 		}
+
+		if err := subCollectors[name].build(); err != nil {
+			errs = append(errs, fmt.Errorf("failed to build %s collector: %w", name, err))
+
+			continue
+		}
+
+		c.collectorFns = append(c.collectorFns, subCollectors[name].collect)
+		c.closeFns = append(c.closeFns, subCollectors[name].close)
 	}

-	return nil
+	return errors.Join(errs...)
 }

 // Collect collects exchange metrics and sends them to prometheus.
 func (c *Collector) Collect(ch chan<- prometheus.Metric) error {
-	collectorFuncs := map[string]func(ch chan<- prometheus.Metric) error{
-		adAccessProcesses:   c.collectADAccessProcesses,
-		transportQueues:     c.collectTransportQueues,
-		httpProxy:           c.collectHTTPProxy,
-		activeSync:          c.collectActiveSync,
-		availabilityService: c.collectAvailabilityService,
-		outlookWebAccess:    c.collectOWA,
-		autoDiscover:        c.collectAutoDiscover,
-		workloadManagement:  c.collectWorkloadManagementWorkloads,
-		rpcClientAccess:     c.collectRPC,
-		mapiHttpEmsmdb:      c.collectMapiHttpEmsmdb,
+	errCh := make(chan error, len(c.collectorFns))
+	errs := make([]error, 0, len(c.collectorFns))
+
+	wg := sync.WaitGroup{}
+
+	for _, fn := range c.collectorFns {
+		wg.Add(1)
+
+		go func(fn func(ch chan<- prometheus.Metric) error) {
+			defer wg.Done()
+
+			if err := fn(ch); err != nil {
+				errCh <- err
+			}
+		}(fn)
 	}

-	errs := make([]error, len(c.config.CollectorsEnabled))
+	wg.Wait()

-	for i, collectorName := range c.config.CollectorsEnabled {
-		errs[i] = collectorFuncs[collectorName](ch)
+	close(errCh)
+
+	for err := range errCh {
+		errs = append(errs, err)
 	}

 	return errors.Join(errs...)
@@ -265,8 +283,3 @@ func (c *Collector) toLabelName(name string) string {

 	return s
 }
-
-// msToSec converts from ms to seconds.
-func (c *Collector) msToSec(t float64) float64 {
-	return t / 1000
-}
--- a/internal/collector/exchange/exchange_active_sync.go
+++ b/internal/collector/exchange/exchange_active_sync.go
@@ -18,27 +18,30 @@ package exchange
 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"
 )

-const (
-	requestsPerSec      = "Requests/sec"
-	pingCommandsPending = "Ping Commands Pending"
-	syncCommandsPerSec  = "Sync Commands/sec"
-)
+type collectorActiveSync struct {
+	perfDataCollectorActiveSync *pdh.Collector
+	perfDataObjectActiveSync    []perfDataCounterValuesActiveSync
+
+	activeSyncRequestsPerSec *prometheus.Desc
+	pingCommandsPending      *prometheus.Desc
+	syncCommandsPerSec       *prometheus.Desc
+}
+
+type perfDataCounterValuesActiveSync struct {
+	RequestsPerSec      float64 `perfdata:"Requests/sec"`
+	PingCommandsPending float64 `perfdata:"Ping Commands Pending"`
+	SyncCommandsPerSec  float64 `perfdata:"Sync Commands/sec"`
+}

 func (c *Collector) buildActiveSync() error {
-	counters := []string{
-		requestsPerSec,
-		pingCommandsPending,
-		syncCommandsPerSec,
-	}
-
 	var err error

-	c.perfDataCollectorActiveSync, err = perfdata.NewCollector("MSExchange ActiveSync", perfdata.InstancesAll, counters)
+	c.perfDataCollectorActiveSync, err = pdh.NewCollector[perfDataCounterValuesActiveSync]("MSExchange ActiveSync", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create MSExchange ActiveSync collector: %w", err)
 	}
@@ -66,30 +69,26 @@ func (c *Collector) buildActiveSync() error {
 }

 func (c *Collector) collectActiveSync(ch chan<- prometheus.Metric) error {
-	perfData, err := c.perfDataCollectorActiveSync.Collect()
+	err := c.perfDataCollectorActiveSync.Collect(&c.perfDataObjectActiveSync)
 	if err != nil {
 		return fmt.Errorf("failed to collect MSExchange ActiveSync metrics: %w", err)
 	}

-	if len(perfData) == 0 {
-		return fmt.Errorf("failed to collect MSExchange ActiveSync metrics: %w", types.ErrNoData)
-	}
-
-	for _, data := range perfData {
+	for _, data := range c.perfDataObjectActiveSync {
 		ch <- prometheus.MustNewConstMetric(
 			c.activeSyncRequestsPerSec,
 			prometheus.CounterValue,
-			data[requestsPerSec].FirstValue,
+			data.RequestsPerSec,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.pingCommandsPending,
 			prometheus.GaugeValue,
-			data[pingCommandsPending].FirstValue,
+			data.PingCommandsPending,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.syncCommandsPerSec,
 			prometheus.CounterValue,
-			data[syncCommandsPerSec].FirstValue,
+			data.SyncCommandsPerSec,
 		)
 	}

--- a/internal/collector/exchange/exchange_ad_access_processes.go
+++ b/internal/collector/exchange/exchange_ad_access_processes.go
@@ -18,31 +18,37 @@ package exchange
 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"
 )

-const (
-	ldapReadTime                    = "LDAP Read Time"
-	ldapSearchTime                  = "LDAP Search Time"
-	ldapWriteTime                   = "LDAP Write Time"
-	ldapTimeoutErrorsPerSec         = "LDAP Timeout Errors/sec"
-	longRunningLDAPOperationsPerMin = "Long Running LDAP Operations/min"
-)
+type collectorADAccessProcesses struct {
+	perfDataCollectorADAccessProcesses *pdh.Collector
+	perfDataObjectADAccessProcesses    []perfDataCounterValuesADAccessProcesses
+
+	ldapReadTime                    *prometheus.Desc
+	ldapSearchTime                  *prometheus.Desc
+	ldapTimeoutErrorsPerSec         *prometheus.Desc
+	ldapWriteTime                   *prometheus.Desc
+	longRunningLDAPOperationsPerMin *prometheus.Desc
+}
+
+type perfDataCounterValuesADAccessProcesses struct {
+	Name string
+
+	LdapReadTime                    float64 `perfdata:"LDAP Read Time"`
+	LdapSearchTime                  float64 `perfdata:"LDAP Search Time"`
+	LdapWriteTime                   float64 `perfdata:"LDAP Write Time"`
+	LdapTimeoutErrorsPerSec         float64 `perfdata:"LDAP Timeout Errors/sec"`
+	LongRunningLDAPOperationsPerMin float64 `perfdata:"Long Running LDAP Operations/min"`
+}

 func (c *Collector) buildADAccessProcesses() error {
-	counters := []string{
-		ldapReadTime,
-		ldapSearchTime,
-		ldapWriteTime,
-		ldapTimeoutErrorsPerSec,
-		longRunningLDAPOperationsPerMin,
-	}
-
 	var err error

-	c.perfDataCollectorADAccessProcesses, err = perfdata.NewCollector("MSExchange ADAccess Processes", perfdata.InstancesAll, counters)
+	c.perfDataCollectorADAccessProcesses, err = pdh.NewCollector[perfDataCounterValuesADAccessProcesses]("MSExchange ADAccess Processes", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create MSExchange ADAccess Processes collector: %w", err)
 	}
@@ -82,19 +88,15 @@ func (c *Collector) buildADAccessProcesses() error {
 }

 func (c *Collector) collectADAccessProcesses(ch chan<- prometheus.Metric) error {
-	perfData, err := c.perfDataCollectorADAccessProcesses.Collect()
+	err := c.perfDataCollectorADAccessProcesses.Collect(&c.perfDataObjectADAccessProcesses)
 	if err != nil {
 		return fmt.Errorf("failed to collect MSExchange ADAccess Processes metrics: %w", err)
 	}

-	if len(perfData) == 0 {
-		return fmt.Errorf("failed to collect MSExchange ADAccess Processes metrics: %w", types.ErrNoData)
-	}
-
 	labelUseCount := make(map[string]int)

-	for name, data := range perfData {
-		labelName := c.toLabelName(name)
+	for _, data := range c.perfDataObjectADAccessProcesses {
+		labelName := c.toLabelName(data.Name)

 		// Since we're not including the PID suffix from the instance names in the label names, we get an occasional duplicate.
 		// This seems to affect about 4 instances only of this object.
@@ -106,31 +108,31 @@ func (c *Collector) collectADAccessProcesses(ch chan<- prometheus.Metric) error
 		ch <- prometheus.MustNewConstMetric(
 			c.ldapReadTime,
 			prometheus.CounterValue,
-			c.msToSec(data[ldapReadTime].FirstValue),
+			utils.MilliSecToSec(data.LdapReadTime),
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.ldapSearchTime,
 			prometheus.CounterValue,
-			c.msToSec(data[ldapSearchTime].FirstValue),
+			utils.MilliSecToSec(data.LdapSearchTime),
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.ldapWriteTime,
 			prometheus.CounterValue,
-			c.msToSec(data[ldapWriteTime].FirstValue),
+			utils.MilliSecToSec(data.LdapWriteTime),
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.ldapTimeoutErrorsPerSec,
 			prometheus.CounterValue,
-			data[ldapTimeoutErrorsPerSec].FirstValue,
+			data.LdapTimeoutErrorsPerSec,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.longRunningLDAPOperationsPerMin,
 			prometheus.CounterValue,
-			data[longRunningLDAPOperationsPerMin].FirstValue*60,
+			data.LongRunningLDAPOperationsPerMin*60,
 			labelName,
 		)
 	}
--- a/internal/collector/exchange/exchange_autodiscover.go
+++ b/internal/collector/exchange/exchange_autodiscover.go
@@ -18,19 +18,26 @@ package exchange
 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"
 )

-func (c *Collector) buildAutoDiscover() error {
-	counters := []string{
-		requestsPerSec,
-	}
+type collectorAutoDiscover struct {
+	perfDataCollectorAutoDiscover *pdh.Collector
+	perfDataObjectAutoDiscover    []perfDataCounterValuesAutoDiscover

+	autoDiscoverRequestsPerSec *prometheus.Desc
+}
+
+type perfDataCounterValuesAutoDiscover struct {
+	RequestsPerSec float64 `perfdata:"Requests/sec"`
+}
+
+func (c *Collector) buildAutoDiscover() error {
 	var err error

-	c.perfDataCollectorAutoDiscover, err = perfdata.NewCollector("MSExchange Autodiscover", perfdata.InstancesAll, counters)
+	c.perfDataCollectorAutoDiscover, err = pdh.NewCollector[perfDataCounterValuesAutoDiscover]("MSExchange Autodiscover", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create MSExchange Autodiscover collector: %w", err)
 	}
@@ -46,20 +53,16 @@ func (c *Collector) buildAutoDiscover() error {
 }

 func (c *Collector) collectAutoDiscover(ch chan<- prometheus.Metric) error {
-	perfData, err := c.perfDataCollectorAutoDiscover.Collect()
+	err := c.perfDataCollectorAutoDiscover.Collect(&c.perfDataObjectAutoDiscover)
 	if err != nil {
 		return fmt.Errorf("failed to collect MSExchange Autodiscover metrics: %w", err)
 	}

-	if len(perfData) == 0 {
-		return fmt.Errorf("failed to collect MSExchange Autodiscover metrics: %w", types.ErrNoData)
-	}
-
-	for _, data := range perfData {
+	for _, data := range c.perfDataObjectAutoDiscover {
 		ch <- prometheus.MustNewConstMetric(
 			c.autoDiscoverRequestsPerSec,
 			prometheus.CounterValue,
-			data[requestsPerSec].FirstValue,
+			data.RequestsPerSec,
 		)
 	}

--- a/internal/collector/exchange/exchange_availability_service.go
+++ b/internal/collector/exchange/exchange_availability_service.go
@@ -18,19 +18,26 @@ package exchange
 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"
 )

-func (c *Collector) buildAvailabilityService() error {
-	counters := []string{
-		requestsPerSec,
-	}
+type collectorAvailabilityService struct {
+	perfDataCollectorAvailabilityService *pdh.Collector
+	perfDataObjectAvailabilityService    []perfDataCounterValuesAvailabilityService

+	availabilityRequestsSec *prometheus.Desc
+}
+
+type perfDataCounterValuesAvailabilityService struct {
+	RequestsPerSec float64 `perfdata:"Requests/sec"`
+}
+
+func (c *Collector) buildAvailabilityService() error {
 	var err error

-	c.perfDataCollectorAvailabilityService, err = perfdata.NewCollector("MSExchange Availability Service", perfdata.InstancesAll, counters)
+	c.perfDataCollectorAvailabilityService, err = pdh.NewCollector[perfDataCounterValuesAvailabilityService]("MSExchange Availability Service", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create MSExchange Availability Service collector: %w", err)
 	}
@@ -46,20 +53,16 @@ func (c *Collector) buildAvailabilityService() error {
 }

 func (c *Collector) collectAvailabilityService(ch chan<- prometheus.Metric) error {
-	perfData, err := c.perfDataCollectorAvailabilityService.Collect()
+	err := c.perfDataCollectorAvailabilityService.Collect(&c.perfDataObjectAvailabilityService)
 	if err != nil {
 		return fmt.Errorf("failed to collect MSExchange Availability Service metrics: %w", err)
 	}

-	if len(perfData) == 0 {
-		return fmt.Errorf("failed to collect MSExchange Availability Service metrics: %w", types.ErrNoData)
-	}
-
-	for _, data := range perfData {
+	for _, data := range c.perfDataObjectAvailabilityService {
 		ch <- prometheus.MustNewConstMetric(
 			c.availabilityRequestsSec,
 			prometheus.CounterValue,
-			data[requestsPerSec].FirstValue,
+			data.RequestsPerSec,
 		)
 	}

--- a/internal/collector/exchange/exchange_http_proxy.go
+++ b/internal/collector/exchange/exchange_http_proxy.go
@@ -18,33 +18,39 @@ package exchange
 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"
 )

-const (
-	mailboxServerLocatorAverageLatency = "MailboxServerLocator Average Latency (Moving Average)"
-	averageAuthenticationLatency       = "Average Authentication Latency"
-	averageCASProcessingLatency        = "Average ClientAccess Server Processing Latency"
-	mailboxServerProxyFailureRate      = "Mailbox Server Proxy Failure Rate"
-	outstandingProxyRequests           = "Outstanding Proxy Requests"
-	proxyRequestsPerSec                = "Proxy Requests/Sec"
-)
+type collectorHTTPProxy struct {
+	perfDataCollectorHTTPProxy *pdh.Collector
+	perfDataObjectHTTPProxy    []perfDataCounterValuesHTTPProxy
+
+	mailboxServerLocatorAverageLatency *prometheus.Desc
+	averageAuthenticationLatency       *prometheus.Desc
+	outstandingProxyRequests           *prometheus.Desc
+	proxyRequestsPerSec                *prometheus.Desc
+	averageCASProcessingLatency        *prometheus.Desc
+	mailboxServerProxyFailureRate      *prometheus.Desc
+}
+
+type perfDataCounterValuesHTTPProxy struct {
+	Name string
+
+	MailboxServerLocatorAverageLatency float64 `perfdata:"MailboxServerLocator Average Latency (Moving Average)"`
+	AverageAuthenticationLatency       float64 `perfdata:"Average Authentication Latency"`
+	AverageCASProcessingLatency        float64 `perfdata:"Average ClientAccess Server Processing Latency"`
+	MailboxServerProxyFailureRate      float64 `perfdata:"Mailbox Server Proxy Failure Rate"`
+	OutstandingProxyRequests           float64 `perfdata:"Outstanding Proxy Requests"`
+	ProxyRequestsPerSec                float64 `perfdata:"Proxy Requests/Sec"`
+}

 func (c *Collector) buildHTTPProxy() error {
-	counters := []string{
-		mailboxServerLocatorAverageLatency,
-		averageAuthenticationLatency,
-		averageCASProcessingLatency,
-		mailboxServerProxyFailureRate,
-		outstandingProxyRequests,
-		proxyRequestsPerSec,
-	}
-
 	var err error

-	c.perfDataCollectorHttpProxy, err = perfdata.NewCollector("MSExchange HttpProxy", perfdata.InstancesAll, counters)
+	c.perfDataCollectorHTTPProxy, err = pdh.NewCollector[perfDataCounterValuesHTTPProxy]("MSExchange HttpProxy", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create MSExchange HttpProxy collector: %w", err)
 	}
@@ -90,51 +96,47 @@ func (c *Collector) buildHTTPProxy() error {
 }

 func (c *Collector) collectHTTPProxy(ch chan<- prometheus.Metric) error {
-	perfData, err := c.perfDataCollectorHttpProxy.Collect()
+	err := c.perfDataCollectorHTTPProxy.Collect(&c.perfDataObjectHTTPProxy)
 	if err != nil {
 		return fmt.Errorf("failed to collect MSExchange HttpProxy Service metrics: %w", err)
 	}

-	if len(perfData) == 0 {
-		return fmt.Errorf("failed to collect MSExchange HttpProxy Service metrics: %w", types.ErrNoData)
-	}
-
-	for name, data := range perfData {
-		labelName := c.toLabelName(name)
+	for _, data := range c.perfDataObjectHTTPProxy {
+		labelName := c.toLabelName(data.Name)
 		ch <- prometheus.MustNewConstMetric(
 			c.mailboxServerLocatorAverageLatency,
 			prometheus.GaugeValue,
-			c.msToSec(data[mailboxServerLocatorAverageLatency].FirstValue),
+			utils.MilliSecToSec(data.MailboxServerLocatorAverageLatency),
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.averageAuthenticationLatency,
 			prometheus.GaugeValue,
-			data[averageAuthenticationLatency].FirstValue,
+			data.AverageAuthenticationLatency,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.averageCASProcessingLatency,
 			prometheus.GaugeValue,
-			c.msToSec(data[averageCASProcessingLatency].FirstValue),
+			utils.MilliSecToSec(data.AverageCASProcessingLatency),
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.mailboxServerProxyFailureRate,
 			prometheus.GaugeValue,
-			data[mailboxServerProxyFailureRate].FirstValue,
+			data.MailboxServerProxyFailureRate,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.outstandingProxyRequests,
 			prometheus.GaugeValue,
-			data[outstandingProxyRequests].FirstValue,
+			data.OutstandingProxyRequests,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.proxyRequestsPerSec,
 			prometheus.CounterValue,
-			data[proxyRequestsPerSec].FirstValue,
+			data.ProxyRequestsPerSec,
 			labelName,
 		)
 	}
--- a/internal/collector/exchange/exchange_mapi_http_emsmdb.go
+++ b/internal/collector/exchange/exchange_mapi_http_emsmdb.go
@@ -18,23 +18,26 @@ package exchange
 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"
 )

-const (
-	activeUserCount = "Active User Count"
-)
+type collectorMapiHttpEmsmdb struct {
+	perfDataCollectorMapiHttpEmsmdb *pdh.Collector
+	perfDataObjectMapiHttpEmsmdb    []perfDataCounterValuesMapiHttpEmsmdb
+
+	activeUserCountMapiHttpEmsMDB *prometheus.Desc
+}
+
+type perfDataCounterValuesMapiHttpEmsmdb struct {
+	ActiveUserCount float64 `perfdata:"Active User Count"`
+}

 func (c *Collector) buildMapiHttpEmsmdb() error {
-	counters := []string{
-		activeUserCount,
-	}
-
 	var err error

-	c.perfDataCollectorMapiHttpEmsmdb, err = perfdata.NewCollector("MSExchange MapiHttp Emsmdb", perfdata.InstancesAll, counters)
+	c.perfDataCollectorMapiHttpEmsmdb, err = pdh.NewCollector[perfDataCounterValuesMapiHttpEmsmdb]("MSExchange MapiHttp Emsmdb", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create MSExchange MapiHttp Emsmdb: %w", err)
 	}
@@ -50,20 +53,16 @@ func (c *Collector) buildMapiHttpEmsmdb() error {
 }

 func (c *Collector) collectMapiHttpEmsmdb(ch chan<- prometheus.Metric) error {
-	perfData, err := c.perfDataCollectorMapiHttpEmsmdb.Collect()
+	err := c.perfDataCollectorMapiHttpEmsmdb.Collect(&c.perfDataObjectMapiHttpEmsmdb)
 	if err != nil {
 		return fmt.Errorf("failed to collect MSExchange MapiHttp Emsmdb metrics: %w", err)
 	}

-	if len(perfData) == 0 {
-		return fmt.Errorf("failed to collect MSExchange MapiHttp Emsmdb metrics: %w", types.ErrNoData)
-	}
-
-	for _, data := range perfData {
+	for _, data := range c.perfDataObjectMapiHttpEmsmdb {
 		ch <- prometheus.MustNewConstMetric(
 			c.activeUserCountMapiHttpEmsMDB,
 			prometheus.GaugeValue,
-			data[activeUserCount].FirstValue,
+			data.ActiveUserCount,
 		)
 	}

--- a/internal/collector/exchange/exchange_outlook_web_access.go
+++ b/internal/collector/exchange/exchange_outlook_web_access.go
@@ -18,25 +18,28 @@ package exchange
 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"
 )

-const (
-	currentUniqueUsers = "Current Unique Users"
-	// requestsPerSec     = "Requests/sec"
-)
+type collectorOWA struct {
+	perfDataCollectorOWA *pdh.Collector
+	perfDataObjectOWA    []perfDataCounterValuesOWA
+
+	currentUniqueUsers *prometheus.Desc
+	owaRequestsPerSec  *prometheus.Desc
+}
+
+type perfDataCounterValuesOWA struct {
+	CurrentUniqueUsers float64 `perfdata:"Current Unique Users"`
+	RequestsPerSec     float64 `perfdata:"Requests/sec"`
+}

 func (c *Collector) buildOWA() error {
-	counters := []string{
-		currentUniqueUsers,
-		requestsPerSec,
-	}
-
 	var err error

-	c.perfDataCollectorOWA, err = perfdata.NewCollector("MSExchange OWA", perfdata.InstancesAll, counters)
+	c.perfDataCollectorOWA, err = pdh.NewCollector[perfDataCounterValuesOWA]("MSExchange OWA", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create MSExchange OWA collector: %w", err)
 	}
@@ -58,25 +61,21 @@ func (c *Collector) buildOWA() error {
 }

 func (c *Collector) collectOWA(ch chan<- prometheus.Metric) error {
-	perfData, err := c.perfDataCollectorOWA.Collect()
+	err := c.perfDataCollectorOWA.Collect(&c.perfDataObjectOWA)
 	if err != nil {
 		return fmt.Errorf("failed to collect MSExchange OWA metrics: %w", err)
 	}

-	if len(perfData) == 0 {
-		return fmt.Errorf("failed to collect MSExchange OWA metrics: %w", types.ErrNoData)
-	}
-
-	for _, data := range perfData {
+	for _, data := range c.perfDataObjectOWA {
 		ch <- prometheus.MustNewConstMetric(
 			c.currentUniqueUsers,
 			prometheus.GaugeValue,
-			data[currentUniqueUsers].FirstValue,
+			data.CurrentUniqueUsers,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.owaRequestsPerSec,
 			prometheus.CounterValue,
-			data[requestsPerSec].FirstValue,
+			data.RequestsPerSec,
 		)
 	}

--- a/internal/collector/exchange/exchange_rpc_client_access.go
+++ b/internal/collector/exchange/exchange_rpc_client_access.go
@@ -18,33 +18,37 @@ package exchange
 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"
 )

-const (
-	rpcAveragedLatency = "RPC Averaged Latency"
-	rpcRequests        = "RPC Requests"
-	// activeUserCount    = "Active User Count"
-	connectionCount     = "Connection Count"
-	rpcOperationsPerSec = "RPC Operations/sec"
-	userCount           = "User Count"
-)
+type collectorRpcClientAccess struct {
+	perfDataCollectorRpcClientAccess *pdh.Collector
+	perfDataObjectRpcClientAccess    []perfDataCounterValuesRpcClientAccess

-func (c *Collector) buildRPC() error {
-	counters := []string{
-		rpcAveragedLatency,
-		rpcRequests,
-		activeUserCount,
-		connectionCount,
-		rpcOperationsPerSec,
-		userCount,
-	}
+	activeUserCount     *prometheus.Desc
+	connectionCount     *prometheus.Desc
+	rpcAveragedLatency  *prometheus.Desc
+	rpcOperationsPerSec *prometheus.Desc
+	rpcRequests         *prometheus.Desc
+	userCount           *prometheus.Desc
+}

+type perfDataCounterValuesRpcClientAccess struct {
+	RpcAveragedLatency  float64 `perfdata:"RPC Averaged Latency"`
+	RpcRequests         float64 `perfdata:"RPC Requests"`
+	ActiveUserCount     float64 `perfdata:"Active User Count"`
+	ConnectionCount     float64 `perfdata:"Connection Count"`
+	RpcOperationsPerSec float64 `perfdata:"RPC Operations/sec"`
+	UserCount           float64 `perfdata:"User Count"`
+}
+
+func (c *Collector) buildRpcClientAccess() error {
 	var err error

-	c.perfDataCollectorRpcClientAccess, err = perfdata.NewCollector("MSExchange RpcClientAccess", perfdata.InstancesAll, counters)
+	c.perfDataCollectorRpcClientAccess, err = pdh.NewCollector[perfDataCounterValuesRpcClientAccess]("MSExchange RpcClientAccess", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create MSExchange RpcClientAccess collector: %w", err)
 	}
@@ -89,46 +93,42 @@ func (c *Collector) buildRPC() error {
 	return nil
 }

-func (c *Collector) collectRPC(ch chan<- prometheus.Metric) error {
-	perfData, err := c.perfDataCollectorRpcClientAccess.Collect()
+func (c *Collector) collectRpcClientAccess(ch chan<- prometheus.Metric) error {
+	err := c.perfDataCollectorRpcClientAccess.Collect(&c.perfDataObjectRpcClientAccess)
 	if err != nil {
 		return fmt.Errorf("failed to collect MSExchange RpcClientAccess: %w", err)
 	}

-	if len(perfData) == 0 {
-		return fmt.Errorf("failed to collect MSExchange RpcClientAccess metrics: %w", types.ErrNoData)
-	}
-
-	for _, data := range perfData {
+	for _, data := range c.perfDataObjectRpcClientAccess {
 		ch <- prometheus.MustNewConstMetric(
 			c.rpcAveragedLatency,
 			prometheus.GaugeValue,
-			c.msToSec(data[rpcAveragedLatency].FirstValue),
+			utils.MilliSecToSec(data.RpcAveragedLatency),
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.rpcRequests,
 			prometheus.GaugeValue,
-			data[rpcRequests].FirstValue,
+			data.RpcRequests,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.activeUserCount,
 			prometheus.GaugeValue,
-			data[activeUserCount].FirstValue,
+			data.ActiveUserCount,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.connectionCount,
 			prometheus.GaugeValue,
-			data[connectionCount].FirstValue,
+			data.ConnectionCount,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.rpcOperationsPerSec,
 			prometheus.CounterValue,
-			data[rpcOperationsPerSec].FirstValue,
+			data.RpcOperationsPerSec,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.userCount,
 			prometheus.GaugeValue,
-			data[userCount].FirstValue,
+			data.UserCount,
 		)
 	}

--- a/internal/collector/exchange/exchange_transport_queues.go
+++ b/internal/collector/exchange/exchange_transport_queues.go
@@ -18,59 +18,64 @@ package exchange
 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"
 )

-const (
-	externalActiveRemoteDeliveryQueueLength = "External Active Remote Delivery Queue Length"
-	internalActiveRemoteDeliveryQueueLength = "Internal Active Remote Delivery Queue Length"
-	activeMailboxDeliveryQueueLength        = "Active Mailbox Delivery Queue Length"
-	retryMailboxDeliveryQueueLength         = "Retry Mailbox Delivery Queue Length"
-	unreachableQueueLength                  = "Unreachable Queue Length"
-	externalLargestDeliveryQueueLength      = "External Largest Delivery Queue Length"
-	internalLargestDeliveryQueueLength      = "Internal Largest Delivery Queue Length"
-	poisonQueueLength                       = "Poison Queue Length"
-	messagesQueuedForDeliveryTotal          = "Messages Queued For Delivery Total"
-	messagesSubmittedTotal                  = "Messages Submitted Total"
-	messagesDelayedTotal                    = "Messages Delayed Total"
-	messagesCompletedDeliveryTotal          = "Messages Completed Delivery Total"
-	shadowQueueLength                       = "Shadow Queue Length"
-	submissionQueueLength                   = "Submission Queue Length"
-	delayQueueLength                        = "Delay Queue Length"
-	itemsCompletedDeliveryTotal             = "Items Completed Delivery Total"
-	itemsQueuedForDeliveryExpiredTotal      = "Items Queued For Delivery Expired Total"
-	itemsQueuedForDeliveryTotal             = "Items Queued For Delivery Total"
-	itemsResubmittedTotal                   = "Items Resubmitted Total"
-)
+type collectorTransportQueues struct {
+	perfDataCollectorTransportQueues *pdh.Collector
+	perfDataObjectTransportQueues    []perfDataCounterValuesTransportQueues
+
+	activeMailboxDeliveryQueueLength        *prometheus.Desc
+	externalActiveRemoteDeliveryQueueLength *prometheus.Desc
+	externalLargestDeliveryQueueLength      *prometheus.Desc
+	internalActiveRemoteDeliveryQueueLength *prometheus.Desc
+	internalLargestDeliveryQueueLength      *prometheus.Desc
+	poisonQueueLength                       *prometheus.Desc
+	retryMailboxDeliveryQueueLength         *prometheus.Desc
+	unreachableQueueLength                  *prometheus.Desc
+	messagesQueuedForDeliveryTotal          *prometheus.Desc
+	messagesSubmittedTotal                  *prometheus.Desc
+	messagesDelayedTotal                    *prometheus.Desc
+	messagesCompletedDeliveryTotal          *prometheus.Desc
+	shadowQueueLength                       *prometheus.Desc
+	submissionQueueLength                   *prometheus.Desc
+	delayQueueLength                        *prometheus.Desc
+	itemsCompletedDeliveryTotal             *prometheus.Desc
+	itemsQueuedForDeliveryExpiredTotal      *prometheus.Desc
+	itemsQueuedForDeliveryTotal             *prometheus.Desc
+	itemsResubmittedTotal                   *prometheus.Desc
+}
+
+type perfDataCounterValuesTransportQueues struct {
+	Name string
+
+	ExternalActiveRemoteDeliveryQueueLength float64 `perfdata:"External Active Remote Delivery Queue Length"`
+	InternalActiveRemoteDeliveryQueueLength float64 `perfdata:"Internal Active Remote Delivery Queue Length"`
+	ActiveMailboxDeliveryQueueLength        float64 `perfdata:"Active Mailbox Delivery Queue Length"`
+	RetryMailboxDeliveryQueueLength         float64 `perfdata:"Retry Mailbox Delivery Queue Length"`
+	UnreachableQueueLength                  float64 `perfdata:"Unreachable Queue Length"`
+	ExternalLargestDeliveryQueueLength      float64 `perfdata:"External Largest Delivery Queue Length"`
+	InternalLargestDeliveryQueueLength      float64 `perfdata:"Internal Largest Delivery Queue Length"`
+	PoisonQueueLength                       float64 `perfdata:"Poison Queue Length"`
+	MessagesQueuedForDeliveryTotal          float64 `perfdata:"Messages Queued For Delivery Total"`
+	MessagesSubmittedTotal                  float64 `perfdata:"Messages Submitted Total"`
+	MessagesDelayedTotal                    float64 `perfdata:"Messages Delayed Total"`
+	MessagesCompletedDeliveryTotal          float64 `perfdata:"Messages Completed Delivery Total"`
+	ShadowQueueLength                       float64 `perfdata:"Shadow Queue Length"`
+	SubmissionQueueLength                   float64 `perfdata:"Submission Queue Length"`
+	DelayQueueLength                        float64 `perfdata:"Delay Queue Length"`
+	ItemsCompletedDeliveryTotal             float64 `perfdata:"Items Completed Delivery Total"`
+	ItemsQueuedForDeliveryExpiredTotal      float64 `perfdata:"Items Queued For Delivery Expired Total"`
+	ItemsQueuedForDeliveryTotal             float64 `perfdata:"Items Queued For Delivery Total"`
+	ItemsResubmittedTotal                   float64 `perfdata:"Items Resubmitted Total"`
+}

 func (c *Collector) buildTransportQueues() error {
-	counters := []string{
-		externalActiveRemoteDeliveryQueueLength,
-		internalActiveRemoteDeliveryQueueLength,
-		activeMailboxDeliveryQueueLength,
-		retryMailboxDeliveryQueueLength,
-		unreachableQueueLength,
-		externalLargestDeliveryQueueLength,
-		internalLargestDeliveryQueueLength,
-		poisonQueueLength,
-		messagesQueuedForDeliveryTotal,
-		messagesSubmittedTotal,
-		messagesDelayedTotal,
-		messagesCompletedDeliveryTotal,
-		shadowQueueLength,
-		submissionQueueLength,
-		delayQueueLength,
-		itemsCompletedDeliveryTotal,
-		itemsQueuedForDeliveryExpiredTotal,
-		itemsQueuedForDeliveryTotal,
-		itemsResubmittedTotal,
-	}
-
 	var err error

-	c.perfDataCollectorTransportQueues, err = perfdata.NewCollector("MSExchangeTransport Queues", perfdata.InstancesAll, counters)
+	c.perfDataCollectorTransportQueues, err = pdh.NewCollector[perfDataCounterValuesTransportQueues]("MSExchangeTransport Queues", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create MSExchangeTransport Queues collector: %w", err)
 	}
@@ -194,130 +199,126 @@ func (c *Collector) buildTransportQueues() error {
 }

 func (c *Collector) collectTransportQueues(ch chan<- prometheus.Metric) error {
-	perfData, err := c.perfDataCollectorTransportQueues.Collect()
+	err := c.perfDataCollectorTransportQueues.Collect(&c.perfDataObjectTransportQueues)
 	if err != nil {
 		return fmt.Errorf("failed to collect MSExchangeTransport Queues: %w", err)
 	}

-	if len(perfData) == 0 {
-		return fmt.Errorf("failed to collect MSExchangeTransport Queues metrics: %w", types.ErrNoData)
-	}
-
-	for name, data := range perfData {
-		labelName := c.toLabelName(name)
+	for _, data := range c.perfDataObjectTransportQueues {
+		labelName := c.toLabelName(data.Name)

 		ch <- prometheus.MustNewConstMetric(
 			c.externalActiveRemoteDeliveryQueueLength,
 			prometheus.GaugeValue,
-			data[externalActiveRemoteDeliveryQueueLength].FirstValue,
+			data.ExternalActiveRemoteDeliveryQueueLength,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.internalActiveRemoteDeliveryQueueLength,
 			prometheus.GaugeValue,
-			data[internalActiveRemoteDeliveryQueueLength].FirstValue,
+			data.InternalActiveRemoteDeliveryQueueLength,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.activeMailboxDeliveryQueueLength,
 			prometheus.GaugeValue,
-			data[activeMailboxDeliveryQueueLength].FirstValue,
+			data.ActiveMailboxDeliveryQueueLength,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.retryMailboxDeliveryQueueLength,
 			prometheus.GaugeValue,
-			data[retryMailboxDeliveryQueueLength].FirstValue,
+			data.RetryMailboxDeliveryQueueLength,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.unreachableQueueLength,
 			prometheus.GaugeValue,
-			data[unreachableQueueLength].FirstValue,
+			data.UnreachableQueueLength,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.externalLargestDeliveryQueueLength,
 			prometheus.GaugeValue,
-			data[externalLargestDeliveryQueueLength].FirstValue,
+			data.ExternalLargestDeliveryQueueLength,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.internalLargestDeliveryQueueLength,
 			prometheus.GaugeValue,
-			data[internalLargestDeliveryQueueLength].FirstValue,
+			data.InternalLargestDeliveryQueueLength,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.poisonQueueLength,
 			prometheus.GaugeValue,
-			data[poisonQueueLength].FirstValue,
+			data.PoisonQueueLength,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.messagesQueuedForDeliveryTotal,
 			prometheus.CounterValue,
-			data[messagesQueuedForDeliveryTotal].FirstValue,
+			data.MessagesQueuedForDeliveryTotal,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.messagesSubmittedTotal,
 			prometheus.CounterValue,
-			data[messagesSubmittedTotal].FirstValue,
+			data.MessagesSubmittedTotal,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.messagesDelayedTotal,
 			prometheus.CounterValue,
-			data[messagesDelayedTotal].FirstValue,
+			data.MessagesDelayedTotal,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.messagesCompletedDeliveryTotal,
 			prometheus.CounterValue,
-			data[messagesCompletedDeliveryTotal].FirstValue,
+			data.MessagesCompletedDeliveryTotal,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.shadowQueueLength,
 			prometheus.GaugeValue,
-			data[shadowQueueLength].FirstValue,
+			data.ShadowQueueLength,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.submissionQueueLength,
 			prometheus.GaugeValue,
-			data[submissionQueueLength].FirstValue,
+			data.SubmissionQueueLength,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.delayQueueLength,
 			prometheus.GaugeValue,
-			data[delayQueueLength].FirstValue,
+			data.DelayQueueLength,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.itemsCompletedDeliveryTotal,
 			prometheus.CounterValue,
-			data[itemsCompletedDeliveryTotal].FirstValue,
+			data.ItemsCompletedDeliveryTotal,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.itemsQueuedForDeliveryExpiredTotal,
 			prometheus.CounterValue,
-			data[itemsQueuedForDeliveryExpiredTotal].FirstValue,
+			data.ItemsQueuedForDeliveryExpiredTotal,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.itemsQueuedForDeliveryTotal,
 			prometheus.CounterValue,
-			data[itemsQueuedForDeliveryTotal].FirstValue,
+			data.ItemsQueuedForDeliveryTotal,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.itemsResubmittedTotal,
 			prometheus.CounterValue,
-			data[itemsResubmittedTotal].FirstValue,
+			data.ItemsResubmittedTotal,
 			labelName,
 		)
 	}
--- a/internal/collector/exchange/exchange_workload_management.go
+++ b/internal/collector/exchange/exchange_workload_management.go
@@ -18,31 +18,36 @@ package exchange
 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"
 )

-const (
-	activeTasks    = "ActiveTasks"
-	completedTasks = "CompletedTasks"
-	queuedTasks    = "QueuedTasks"
-	yieldedTasks   = "YieldedTasks"
-	isActive       = "Active"
-)
+type collectorWorkloadManagementWorkloads struct {
+	perfDataCollectorWorkloadManagementWorkloads *pdh.Collector
+	perfDataObjectWorkloadManagementWorkloads    []perfDataCounterValuesWorkloadManagementWorkloads
+
+	activeTasks    *prometheus.Desc
+	isActive       *prometheus.Desc
+	completedTasks *prometheus.Desc
+	queuedTasks    *prometheus.Desc
+	yieldedTasks   *prometheus.Desc
+}
+
+type perfDataCounterValuesWorkloadManagementWorkloads struct {
+	Name string
+
+	ActiveTasks    float64 `perfdata:"ActiveTasks"`
+	CompletedTasks float64 `perfdata:"CompletedTasks"`
+	QueuedTasks    float64 `perfdata:"QueuedTasks"`
+	YieldedTasks   float64 `perfdata:"YieldedTasks"`
+	IsActive       float64 `perfdata:"Active"`
+}

 func (c *Collector) buildWorkloadManagementWorkloads() error {
-	counters := []string{
-		activeTasks,
-		completedTasks,
-		queuedTasks,
-		yieldedTasks,
-		isActive,
-	}
-
 	var err error

-	c.perfDataCollectorWorkloadManagementWorkloads, err = perfdata.NewCollector("MSExchange WorkloadManagement Workloads", perfdata.InstancesAll, counters)
+	c.perfDataCollectorWorkloadManagementWorkloads, err = pdh.NewCollector[perfDataCounterValuesWorkloadManagementWorkloads]("MSExchange WorkloadManagement Workloads", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create MSExchange WorkloadManagement Workloads collector: %w", err)
 	}
@@ -82,46 +87,42 @@ func (c *Collector) buildWorkloadManagementWorkloads() error {
 }

 func (c *Collector) collectWorkloadManagementWorkloads(ch chan<- prometheus.Metric) error {
-	perfData, err := c.perfDataCollectorWorkloadManagementWorkloads.Collect()
+	err := c.perfDataCollectorWorkloadManagementWorkloads.Collect(&c.perfDataObjectWorkloadManagementWorkloads)
 	if err != nil {
 		return fmt.Errorf("failed to collect MSExchange WorkloadManagement Workloads: %w", err)
 	}

-	if len(perfData) == 0 {
-		return fmt.Errorf("failed to collect MSExchange WorkloadManagement Workloads metrics: %w", types.ErrNoData)
-	}
-
-	for name, data := range perfData {
-		labelName := c.toLabelName(name)
+	for _, data := range c.perfDataObjectWorkloadManagementWorkloads {
+		labelName := c.toLabelName(data.Name)

 		ch <- prometheus.MustNewConstMetric(
 			c.activeTasks,
 			prometheus.GaugeValue,
-			data[activeTasks].FirstValue,
+			data.ActiveTasks,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.completedTasks,
 			prometheus.CounterValue,
-			data[completedTasks].FirstValue,
+			data.CompletedTasks,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.queuedTasks,
 			prometheus.CounterValue,
-			data[queuedTasks].FirstValue,
+			data.QueuedTasks,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.yieldedTasks,
 			prometheus.CounterValue,
-			data[yieldedTasks].FirstValue,
+			data.YieldedTasks,
 			labelName,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.isActive,
 			prometheus.GaugeValue,
-			data[isActive].FirstValue,
+			data.IsActive,
 			labelName,
 		)
 	}