ci: pin wix toolset version to avoid installing incompatible extensions (#1885)

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

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,40 @@
+
+
+<!--
+    Please give your PR a title in the form "area: short description".  For example "cpu: reduce usage by 95%" or "docs: fix typo in installation.md".
+
+    If your PR is to fix an issue, put "Fixes #issue-number" in the description.
+
+    Don't forget!
+
+    - Please sign CNCF's Developer Certificate of Origin and sign-off your commits by adding the -s / --signoff flag to `git commit`. See https://github.com/apps/dco for more information.
+
+    - If the PR adds or changes a behaviour or fixes a bug of an exported API it would need a unit/e2e test.
+
+    - Performance improvements would need a benchmark test to prove it.
+
+    - All comments should start with a capital letter and end with a full stop.
+ -->
+
+
+#### What this PR does / why we need it
+
+#### Which issue this PR fixes
+
+*(optional, in `fixes #<issue number>(, fixes #<issue_number>, ...)` format, will close that issue when PR gets merged)*: fixes #
+
+- fixes #
+
+#### Special notes for your reviewer
+
+#### Particularly user-facing changes
+
+#### Checklist
+
+Complete these before marking the PR as `ready to review`:
+
+<!-- [Place an '[x]' (no spaces) in all applicable fields.] -->
+
+- [ ] [DCO](https://github.com/prometheus-community/helm-charts/blob/main/CONTRIBUTING.md#sign-off-your-work) signed
+- [ ] The PR title has a summary of the changes and the area they affect
+- [ ] The PR body has a summary to reflect any significant (and particularly user-facing) changes introduced by this PR

.github/workflows/release.yml

@@ -22,6 +22,7 @@ env:
 jobs:
   build:
     runs-on: windows-2022
+    environment: build
     steps:
       - uses: actions/checkout@v4
         with:
@@ -32,13 +33,14 @@ jobs:
           go-version-file: 'go.mod'
 
       - name: Install WiX
-        run: dotnet tool install --global wix
+        run: |
+          dotnet tool install --global wix --version 5.0.2
 
       - name: Install WiX extensions
         run: |
-          wix extension add -g WixToolset.Util.wixext
-          wix extension add -g WixToolset.Ui.wixext
-          wix extension add -g WixToolset.Firewall.wixext
+          wix extension add -g WixToolset.Util.wixext/5.0.2
+          wix extension add -g WixToolset.Ui.wixext/5.0.2
+          wix extension add -g WixToolset.Firewall.wixext/5.0.2
 
       - name: Install Build deps
         run: |
@@ -68,6 +70,40 @@ jobs:
 
           Get-ChildItem -Path output
 
+      - name: Sign build artifacts
+        if: ${{ (github.event_name != 'pull_request' && github.repository == 'prometheus-community/windows_exporter') || (github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name == 'prometheus-community/windows_exporter') }}
+        run: |
+          $ErrorActionPreference = "Stop"
+          $Version = Get-Content VERSION
+
+          $b64      = $env:CODE_SIGN_KEY
+          $filename = 'windows_exporter_CodeSign.pfx'
+
+          $bytes = [Convert]::FromBase64String($b64)
+          [IO.File]::WriteAllBytes($filename, $bytes)
+
+          $basePath = "C:\Program Files (x86)\Windows Kits\10\bin"
+          $latestSigntool = Get-ChildItem -Path $basePath -Directory |
+          Where-Object { $_.Name -match "^\d+\.\d+\.\d+\.\d+$" } |
+          Sort-Object { [Version]$_.Name } -Descending |
+          Select-Object -First 1 |
+          ForEach-Object { Join-Path $_.FullName "x64\signtool.exe" }
+
+          if (Test-Path $latestSigntool) {
+            Write-Output $latestSigntool
+          } else {
+            Write-Output "signtool.exe not found"
+          }
+
+          foreach($Arch in "amd64", "arm64") {
+            & $latestSigntool sign /v /tr "http://timestamp.digicert.com" /d "Prometheus exporter for Windows machines" /td SHA256 /fd SHA256 /a /f "windows_exporter_CodeSign.pfx" /p $env:CODE_SIGN_PASSWORD "output\windows_exporter-$Version-$Arch.exe"
+          }
+
+          rm windows_exporter_CodeSign.pfx
+        env:
+          CODE_SIGN_KEY: ${{ secrets.CODE_SIGN_KEY }}
+          CODE_SIGN_PASSWORD: ${{ secrets.CODE_SIGN_PASSWORD }}
+
       - name: Build Release Artifacts
         run: |
           $ErrorActionPreference = "Stop"
@@ -83,6 +119,40 @@ jobs:
 
           promu checksum output\
 
+      - name: Sign installer artifacts
+        if: ${{ (github.event_name != 'pull_request' && github.repository == 'prometheus-community/windows_exporter') || (github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name == 'prometheus-community/windows_exporter') }}
+        run: |
+          $ErrorActionPreference = "Stop"
+          $Version = Get-Content VERSION
+
+          $b64      = $env:CODE_SIGN_KEY
+          $filename = 'windows_exporter_CodeSign.pfx'
+
+          $bytes = [Convert]::FromBase64String($b64)
+          [IO.File]::WriteAllBytes($filename, $bytes)
+
+          $basePath = "C:\Program Files (x86)\Windows Kits\10\bin"
+          $latestSigntool = Get-ChildItem -Path $basePath -Directory |
+          Where-Object { $_.Name -match "^\d+\.\d+\.\d+\.\d+$" } |
+          Sort-Object { [Version]$_.Name } -Descending |
+          Select-Object -First 1 |
+          ForEach-Object { Join-Path $_.FullName "x64\signtool.exe" }
+
+          if (Test-Path $latestSigntool) {
+            Write-Output $latestSigntool
+          } else {
+            Write-Output "signtool.exe not found"
+          }
+
+          foreach($Arch in "amd64", "arm64") {
+            & $latestSigntool sign /v /tr "http://timestamp.digicert.com" /d "Prometheus exporter for Windows machines" /td SHA256 /fd SHA256 /a /f "windows_exporter_CodeSign.pfx" /p $env:CODE_SIGN_PASSWORD "output\windows_exporter-$Version-$Arch.msi"
+          }
+
+          rm windows_exporter_CodeSign.pfx
+        env:
+          CODE_SIGN_KEY: ${{ secrets.CODE_SIGN_KEY }}
+          CODE_SIGN_PASSWORD: ${{ secrets.CODE_SIGN_PASSWORD }}
+
       - name: Upload Artifacts
         uses: actions/upload-artifact@v4
         with:
@@ -103,6 +173,9 @@ jobs:
     runs-on: ubuntu-latest
     needs:
       - build
+    env:
+      DOCKER_BUILD_SUMMARY: false
+      DOCKER_BUILD_RECORD_UPLOAD: false
     steps:
       - uses: actions/checkout@v4
         with:
@@ -165,3 +238,4 @@ jobs:
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
           platforms: windows/amd64
+          annotations: ${{ steps.meta.outputs.labels }}

.github/workflows/stale-close.yml

@@ -11,7 +11,7 @@ jobs:
     if: github.repository_owner == 'prometheus' || github.repository_owner == 'prometheus-community' # Don't run this workflow on forks.
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@28ca1036281a5e5922ead5184a1bbf96e5fc984e # v9.0.0
+      - uses: actions/stale@5bef64f19d7facfb25b37b414482c7164d639639 # v9.1.0
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           # opt out of defaults to avoid marking issues as stale and closing them

.github/workflows/stale.yml

@@ -11,7 +11,7 @@ jobs:
     if: github.repository_owner == 'prometheus' || github.repository_owner == 'prometheus-community' # Don't run this workflow on forks.
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@28ca1036281a5e5922ead5184a1bbf96e5fc984e # v9.0.0
+      - uses: actions/stale@5bef64f19d7facfb25b37b414482c7164d639639 # v9.1.0
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           # opt out of defaults to avoid marking issues as stale and closing them

.run/all.run.xml

@@ -2,7 +2,7 @@
   <configuration default="false" name="all" type="GoApplicationRunConfiguration" factoryName="Go Application" folderName="run">
     <module name="windows_exporter" />
     <working_directory value="$PROJECT_DIR$" />
-    <parameters value="--web.listen-address=127.0.0.1:9182 --log.level=debug --collectors.enabled=ad,adcs,adfs,cache,container,cpu,cpu_info,cs,dfsr,dhcp,diskdrive,dns,exchange,filetime,fsrmquota,hyperv,iis,license,logical_disk,logon,memory,mscluster,msmq,mssql,net,netframework,nps,os,pagefile,perfdata,physical_disk,printer,process,remote_fx,scheduled_task,service,smb,smbclient,smtp,system,tcp,terminal_services,textfile,thermalzone,time,udp,update,vmware" />
+    <parameters value="--web.listen-address=127.0.0.1:9182 --log.level=info --collectors.enabled=ad,adcs,adfs,cache,container,cpu,cpu_info,cs,dfsr,dhcp,diskdrive,dns,exchange,filetime,fsrmquota,hyperv,iis,license,logical_disk,logon,memory,mscluster,msmq,mssql,net,netframework,nps,os,pagefile,performancecounter,physical_disk,printer,process,remote_fx,scheduled_task,service,smb,smbclient,smtp,system,tcp,terminal_services,thermalzone,time,udp,update,vmware,performancecounter --debug.enabled --collector.performancecounter.objects='[{ &quot;name&quot;: &quot;memory&quot;, &quot;type&quot;: &quot;formatted&quot;, &quot;object&quot;: &quot;Memory&quot;, &quot;counters&quot;: [{ &quot;name&quot;:&quot;Cache Faults/sec&quot;, &quot;type&quot;:&quot;counter&quot; }]}]'" />
     <sudo value="true" />
     <kind value="PACKAGE" />
     <package value="github.com/prometheus-community/windows_exporter/cmd/windows_exporter" />

CONTRIBUTING.md

@@ -0,0 +1,82 @@
+# Contributing
+
+windows_exporter uses GitHub to manage reviews of pull requests.
+
+* If you are a new contributor see: [Steps to Contribute](#steps-to-contribute)
+
+* If you have a trivial fix or improvement, go ahead and create a pull request,
+  addressing (with `@...`) a suitable maintainer of this repository (see
+  [MAINTAINERS.md](MAINTAINERS.md)) in the description of the pull request.
+
+* If you plan to do something more involved, first discuss your ideas
+  as [github issue](https://github.com/prometheus-community/windows_exporter/issues).
+  This will avoid unnecessary work and surely give you and us a good deal
+  of inspiration. New collectors are unlikely to be accepted, since the
+  `performancecounter` collector is the preferred way to collect metrics.
+
+* Relevant coding style guidelines are the [Go Code Review
+  Comments](https://code.google.com/p/go-wiki/wiki/CodeReviewComments)
+  and the _Formatting and style_ section of Peter Bourgon's [Go: Best
+  Practices for Production
+  Environments](https://peter.bourgon.org/go-in-production/#formatting-and-style).
+  gofmt and [golangci-lint](https://github.com/golangci/golangci-lint) are your friends.
+
+* Be sure to sign off on the [DCO](https://github.com/probot/dco#how-it-works).
+
+## Steps to Contribute
+
+Should you wish to work on an issue, please claim it first by commenting on the GitHub issue that you want to work on it. This is to prevent duplicated efforts from contributors on the same issue.
+For quickly compiling and testing your changes do:
+
+```bash
+# For building.
+go build -o windows_exporter.exe ./cmd/windows_exporter/
+./windows_exporter.exe
+
+# For testing.
+make test         # Make sure all the tests pass before you commit and push :)
+```
+
+To run a collection of Go linters through [`golangci-lint`](https://github.com/golangci/golangci-lint), do:
+```bash
+make lint
+```
+
+If it reports an issue and you think that the warning needs to be disregarded or is a false-positive, you can add a special comment `//nolint:linter1[,linter2,...]` before the offending line. Use this sparingly though, fixing the code to comply with the linter's recommendation is in general the preferred course of action. See [this section of the golangci-lint documentation](https://golangci-lint.run/usage/false-positives/#nolint-directive) for more information.
+
+All our issues are regularly tagged so that you can also filter down the issues involving the components you want to work on. For our labeling policy refer [the wiki page](https://github.com/prometheus/prometheus/wiki/Label-Names-and-Descriptions).
+
+## Pull Request Checklist
+
+* Branch from the main branch and, if needed, rebase to the current main branch before submitting your pull request. If it doesn't merge cleanly with main you may be asked to rebase your changes.
+
+* Commits should be as small as possible, while ensuring that each commit is correct independently (i.e., each commit should compile and pass tests).
+
+* The PR title should be of the format: `subsystem: what this PR does` (for example, `cpu: Add support for thing` or `docs: fix typo`).
+
+* If your patch is not getting reviewed or you need a specific person to review it, you can @-reply a reviewer asking for a review in the pull request or a comment.
+
+* Add tests relevant to the fixed bug or new feature.
+
+## Dependency management
+
+The Prometheus project uses [Go modules](https://golang.org/cmd/go/#hdr-Modules__module_versions__and_more) to manage dependencies on external packages.
+
+To add or update a new dependency, use the `go get` command:
+
+```bash
+# Pick the latest tagged release.
+go get example.com/some/module/pkg@latest
+
+# Pick a specific version.
+go get example.com/some/module/pkg@vX.Y.Z
+```
+
+Tidy up the `go.mod` and `go.sum` files:
+
+```bash
+# The GO111MODULE variable can be omitted when the code isn't located in GOPATH.
+GO111MODULE=on go mod tidy
+```
+
+You have to commit the changes to `go.mod` and `go.sum` before submitting the pull request.

LICENSE

@@ -1,6 +1,7 @@
 The MIT License (MIT)
 
 Copyright (c) 2016 Martin Lindhe
+Copyright (c) 2021 The Prometheus Authors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -42,7 +42,7 @@ Name     | Description | Enabled by default
 [net](docs/collector.net.md) | Network interface I/O | ✓
 [os](docs/collector.os.md) | OS metrics (memory, processes, users) | ✓
 [pagefile](docs/collector.pagefile.md) | pagefile metrics |
-[perfdata](docs/collector.perfdata.md) | Custom perfdata metrics |
+[performancecounter](docs/collector.performancecounter.md) | Custom performance counter metrics |
 [physical_disk](docs/collector.physical_disk.md) | physical disk metrics | ✓
 [printer](docs/collector.printer.md) | Printer metrics |
 [process](docs/collector.process.md) | Per-process metrics |
@@ -88,7 +88,7 @@ windows_exporter accepts flags to configure certain behaviours. The ones configu
 | `--web.listen-address`               | host:port for exporter.                                                                                                                                                                          | `:9182`       |
 | `--telemetry.path`                   | URL path for surfacing collected metrics.                                                                                                                                                        | `/metrics`    |
 | `--telemetry.max-requests`           | Maximum number of concurrent requests. 0 to disable.                                                                                                                                             | `5`           |
-| `--collectors.enabled`               | Comma-separated list of collectors to use. Use `[defaults]` as a placeholder which gets expanded containing all the collectors enabled by default."                                              | `[defaults]`  |
+| `--collectors.enabled`               | Comma-separated list of collectors to use. Use `[defaults]` as a placeholder which gets expanded containing all the collectors enabled by default.                                               | `[defaults]`  |
 | `--collectors.print`                 | If true, print available collectors and exit.                                                                                                                                                    |               |
 | `--scrape.timeout-margin`            | Seconds to subtract from the timeout allowed by the client. Tune to allow for overhead or high loads.                                                                                            | `0.5`         |
 | `--web.config.file`                  | A [web config][web_config] for setting up TLS and Auth                                                                                                                                           | None          |
@@ -100,6 +100,9 @@ windows_exporter accepts flags to configure certain behaviours. The ones configu
 
 The latest release can be downloaded from the [releases page](https://github.com/prometheus-community/windows_exporter/releases).
 
+All binaries and installation packages are signed with an self-signed certificate. The public key can be found [here](https://github.com/prometheus-community/windows_exporter/blob/master/installer/codesign.cer).
+Once import into the trusted root certificate store, the binaries and installation packages will be trusted.
+
 Each release provides a .msi installer. The installer will setup the windows_exporter as a Windows service, as well as create an exception in the Windows Firewall.
 
 If the installer is run without any parameters, the exporter will run with default settings for enabled collectors, ports, etc.
@@ -199,6 +202,14 @@ Windows Server 2012 and 2012R2 are supported as best-effort only, but not guaran
 
 The prometheus metrics will be exposed on [localhost:9182](http://localhost:9182)
 
+### HTTP Endpoints
+
+windows_exporter provides the following HTTP endpoints:
+
+* `/metrics`: Exposes metrics in the [Prometheus text format](https://prometheus.io/docs/instrumenting/exposition_formats/).
+* `/health`: Returns 200 OK when the exporter is running.
+* `/debug/pprof/`: Exposes the [pprof](https://golang.org/pkg/net/http/pprof/) endpoints. Only, if `--debug.enabled` is set.
+
 ## Examples
 
 ### Enable only service collector and specify a custom query

cmd/windows_exporter/0_service.go

@@ -0,0 +1,151 @@
+// Copyright 2025 The Prometheus Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"golang.org/x/sys/windows"
+	"golang.org/x/sys/windows/svc"
+	"golang.org/x/sys/windows/svc/eventlog"
+)
+
+const serviceName = "windows_exporter"
+
+//nolint:gochecknoglobals
+var (
+	// exitCodeCh is a channel to send an exit code from the main function to the service manager.
+	// Additionally, if there is an error in the IsService var declaration,
+	// the exit code is sent to the service manager as well.
+	exitCodeCh = make(chan int, 1)
+
+	// stopCh is a channel to send a signal to the service manager that the service is stopping.
+	stopCh = make(chan struct{})
+
+	// serviceManagerFinishedCh is a channel to send a signal to the main function that the service manager has stopped the service.
+	serviceManagerFinishedCh = make(chan struct{})
+)
+
+// IsService variable declaration allows initiating time-sensitive components like registering the Windows service
+// as early as possible in the startup process.
+// init functions are called in the order they are declared, so this package should be imported first.
+//
+// Ref: https://github.com/prometheus-community/windows_exporter/issues/551#issuecomment-1220774835
+//
+// Declare imports on this package should be avoided where possible.
+// var declaration run before init function, so it guarantees that windows_exporter respond to service manager early
+// and avoid timeout.
+// The order of the var declaration and init functions depends on the filename as well. The filename should be 0_service.go
+// Ref: https://medium.com/@markbates/go-init-order-dafa89fcef22
+//
+//nolint:gochecknoglobals
+var IsService = func() bool {
+	var err error
+
+	isService, err := svc.IsWindowsService()
+	if err != nil {
+		//nolint:gosec
+		_ = os.WriteFile("C:\\Program Files\\windows_exporter\\start-service.error.log", []byte(fmt.Sprintf("failed to detect service: %v", err)), 0o644)
+
+		return false
+	}
+
+	if !isService {
+		return false
+	}
+
+	defer func() {
+		go func() {
+			err := svc.Run(serviceName, &windowsExporterService{})
+			if err != nil {
+				_ = logToEventToLog(windows.EVENTLOG_ERROR_TYPE, fmt.Sprintf("failed to start service: %v", err))
+			}
+
+			serviceManagerFinishedCh <- struct{}{}
+		}()
+	}()
+
+	if err := logToEventToLog(windows.EVENTLOG_INFORMATION_TYPE, "attempting to start exporter service"); err != nil {
+		//nolint:gosec
+		_ = os.WriteFile("C:\\Program Files\\windows_exporter\\start-service.error.log", []byte(fmt.Sprintf("failed sent log to event log: %v", err)), 0o644)
+
+		exitCodeCh <- 2
+	}
+
+	return true
+}()
+
+type windowsExporterService struct{}
+
+// Execute is the entry point for the Windows service manager.
+func (s *windowsExporterService) Execute(_ []string, r <-chan svc.ChangeRequest, changes chan<- svc.Status) (bool, uint32) {
+	changes <- svc.Status{State: svc.StartPending}
+	changes <- svc.Status{State: svc.Running, Accepts: svc.AcceptStop | svc.AcceptShutdown}
+
+	for {
+		select {
+		case exitCodeCh := <-exitCodeCh:
+			// Stop the service if an exit code from the main function is received.
+			changes <- svc.Status{State: svc.StopPending}
+
+			return true, uint32(exitCodeCh)
+		case c := <-r:
+			// Handle the service control request.
+			switch c.Cmd {
+			case svc.Interrogate:
+				changes <- c.CurrentStatus
+			case svc.Stop, svc.Shutdown:
+				// Stop the service if a stop or shutdown request is received.
+				_ = logToEventToLog(windows.EVENTLOG_INFORMATION_TYPE, "service stop received")
+
+				changes <- svc.Status{State: svc.StopPending}
+
+				// Send a signal to the main function to stop the service.
+				stopCh <- struct{}{}
+
+				// Wait for the main function to stop the service.
+				return false, uint32(<-exitCodeCh)
+			default:
+				_ = logToEventToLog(windows.EVENTLOG_ERROR_TYPE, fmt.Sprintf("unexpected control request #%d", c))
+			}
+		}
+	}
+}
+
+// logToEventToLog logs a message to the Windows event log.
+func logToEventToLog(eType uint16, msg string) error {
+	eventLog, err := eventlog.Open(serviceName)
+	if err != nil {
+		return fmt.Errorf("failed to open event log: %w", err)
+	}
+	defer func(eventLog *eventlog.Log) {
+		_ = eventLog.Close()
+	}(eventLog)
+
+	switch eType {
+	case windows.EVENTLOG_ERROR_TYPE:
+		err = eventLog.Error(102, msg)
+	case windows.EVENTLOG_WARNING_TYPE:
+		err = eventLog.Warning(101, msg)
+	case windows.EVENTLOG_INFORMATION_TYPE:
+		err = eventLog.Info(100, msg)
+	}
+
+	if err != nil {
+		return fmt.Errorf("error report event: %w", err)
+	}
+
+	return nil
+}

cmd/windows_exporter/main.go

@@ -17,12 +17,7 @@
 
 package main
 
-//goland:noinspection GoUnsortedImport
-//nolint:gofumpt
 import (
-	// Its important that we do these first so that we can register with the Windows service control ASAP to avoid timeouts.
-	"github.com/prometheus-community/windows_exporter/internal/windowsservice"
-
 	"context"
 	"errors"
 	"fmt"
@@ -33,6 +28,7 @@ import (
 	"os/signal"
 	"os/user"
 	"runtime"
+	"runtime/debug"
 	"slices"
 	"strings"
 	"time"
@@ -54,18 +50,19 @@ func main() {
 	exitCode := run()
 
 	// If we are running as a service, we need to signal the service control manager that we are done.
-	if !windowsservice.IsService {
+	if !IsService {
 		os.Exit(exitCode)
 	}
 
-	windowsservice.ExitCodeCh <- exitCode
+	exitCodeCh <- exitCode
 
 	// Wait for the service control manager to signal that we are done.
-	<-windowsservice.StopCh
+	<-serviceManagerFinishedCh
 }
 
 func run() int {
 	startTime := time.Now()
+	ctx := context.Background()
 
 	app := kingpin.New("windows_exporter", "A metrics collector for Windows.")
 
@@ -87,10 +84,6 @@ func run() int {
 			"web.disable-exporter-metrics",
 			"Exclude metrics about the exporter itself (promhttp_*, process_*, go_*).",
 		).Bool()
-		maxRequests = app.Flag(
-			"telemetry.max-requests",
-			"Maximum number of concurrent requests. 0 to disable.",
-		).Default("5").Int()
 		enabledCollectors = app.Flag(
 			"collectors.enabled",
 			"Comma-separated list of collectors to use. Use '[defaults]' as a placeholder for all the collectors enabled by default.").
@@ -107,9 +100,20 @@ func run() int {
 			"process.priority",
 			"Priority of the exporter process. Higher priorities may improve exporter responsiveness during periods of system load. Can be one of [\"realtime\", \"high\", \"abovenormal\", \"normal\", \"belownormal\", \"low\"]",
 		).Default("normal").String()
+		memoryLimit = app.Flag(
+			"process.memory-limit",
+			"Limit memory usage in bytes. This is a soft-limit and not guaranteed. 0 means no limit. Read more at https://pkg.go.dev/runtime/debug#SetMemoryLimit .",
+		).Default("200000000").Int64()
 	)
 
-	logConfig := &log.Config{}
+	logFile := &log.AllowedFile{}
+
+	_ = logFile.Set("stdout")
+	if IsService {
+		_ = logFile.Set("eventlog")
+	}
+
+	logConfig := &log.Config{File: logFile}
 	flag.AddFlags(app, logConfig)
 
 	app.Version(version.Print("windows_exporter"))
@@ -129,6 +133,8 @@ func run() int {
 		return 1
 	}
 
+	debug.SetMemoryLimit(*memoryLimit)
+
 	logger, err := log.New(logConfig)
 	if err != nil {
 		//nolint:sloglint // we do not have an logger yet
@@ -140,7 +146,7 @@ func run() int {
 	}
 
 	if *configFile != "" {
-		resolver, err := config.NewResolver(*configFile, logger, *insecureSkipVerify)
+		resolver, err := config.NewResolver(ctx, *configFile, logger, *insecureSkipVerify)
 		if err != nil {
 			logger.Error("could not load config file",
 				slog.Any("err", err),
@@ -150,7 +156,16 @@ func run() int {
 		}
 
 		if err = resolver.Bind(app, os.Args[1:]); err != nil {
-			logger.Error("Failed to bind configuration",
+			logger.ErrorContext(ctx, "failed to bind configuration",
+				slog.Any("err", err),
+			)
+
+			return 1
+		}
+
+		// Parse flags once more to include those discovered in configuration file(s).
+		if _, err = app.Parse(os.Args[1:]); err != nil {
+			logger.ErrorContext(ctx, "failed to parse CLI args from YAML file",
 				slog.Any("err", err),
 			)
 
@@ -160,16 +175,8 @@ func run() int {
 		// NOTE: This is temporary fix for issue #1092, calling kingpin.Parse
 		// twice makes slices flags duplicate its value, this clean up
 		// the first parse before the second call.
-		*webConfig.WebListenAddresses = (*webConfig.WebListenAddresses)[1:]
-
-		// Parse flags once more to include those discovered in configuration file(s).
-		if _, err = app.Parse(os.Args[1:]); err != nil {
-			logger.Error("Failed to parse CLI args from YAML file",
-				slog.Any("err", err),
-			)
-
-			return 1
-		}
+		slices.Sort(*webConfig.WebListenAddresses)
+		*webConfig.WebListenAddresses = slices.Clip(slices.Compact(*webConfig.WebListenAddresses))
 
 		logger, err = log.New(logConfig)
 		if err != nil {
@@ -182,7 +189,7 @@ func run() int {
 		}
 	}
 
-	logger.Debug("Logging has Started")
+	logger.LogAttrs(ctx, slog.LevelDebug, "logging has Started")
 
 	if err = setPriorityWindows(logger, os.Getpid(), *processPriority); err != nil {
 		logger.Error("failed to set process priority",
@@ -204,15 +211,17 @@ func run() int {
 	// Initialize collectors before loading
 	if err = collectors.Build(logger); err != nil {
 		for _, err := range utils.SplitError(err) {
-			logger.Warn("couldn't initialize collector",
+			logger.Error("couldn't initialize collector",
 				slog.Any("err", err),
 			)
+
+			return 1
 		}
 	}
 
 	logCurrentUser(logger)
 
-	logger.Info("Enabled collectors: " + strings.Join(enabledCollectorList, ", "))
+	logger.InfoContext(ctx, "Enabled collectors: "+strings.Join(enabledCollectorList, ", "))
 
 	mux := http.NewServeMux()
 	mux.Handle("GET /health", httphandler.NewHealthHandler())
@@ -220,7 +229,6 @@ func run() int {
 	mux.Handle("GET "+*metricsPath, httphandler.New(logger, collectors, &httphandler.Options{
 		DisableExporterMetrics: *disableExporterMetrics,
 		TimeoutMargin:          *timeoutMargin,
-		MaxRequests:            *maxRequests,
 	}))
 
 	if *debugEnabled {
@@ -231,7 +239,7 @@ func run() int {
 		mux.HandleFunc("GET /debug/pprof/trace", pprof.Trace)
 	}
 
-	logger.Info(fmt.Sprintf("starting windows_exporter in %s", time.Since(startTime)),
+	logger.LogAttrs(ctx, slog.LevelInfo, fmt.Sprintf("starting windows_exporter in %s", time.Since(startTime)),
 		slog.String("version", version.Version),
 		slog.String("branch", version.Branch),
 		slog.String("revision", version.GetRevision()),
@@ -258,17 +266,17 @@ func run() int {
 		close(errCh)
 	}()
 
-	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, os.Kill)
+	ctx, stop := signal.NotifyContext(ctx, os.Interrupt, os.Kill)
 	defer stop()
 
 	select {
 	case <-ctx.Done():
 		logger.Info("Shutting down windows_exporter via kill signal")
-	case <-windowsservice.StopCh:
+	case <-stopCh:
 		logger.Info("Shutting down windows_exporter via service control")
 	case err := <-errCh:
 		if err != nil {
-			logger.Error("Failed to start windows_exporter",
+			logger.ErrorContext(ctx, "Failed to start windows_exporter",
 				slog.Any("err", err),
 			)
 
@@ -281,7 +289,7 @@ func run() int {
 
 	_ = server.Shutdown(ctx)
 
-	logger.Info("windows_exporter has shut down")
+	logger.InfoContext(ctx, "windows_exporter has shut down")
 
 	return 0
 }
@@ -318,11 +326,11 @@ func setPriorityWindows(logger *slog.Logger, pid int, priority string) error {
 	winPriority, ok := priorityStringToInt[priority]
 
 	// Only set process priority if a non-default and valid value has been set
-	if !ok || winPriority != windows.NORMAL_PRIORITY_CLASS {
+	if !ok || winPriority == windows.NORMAL_PRIORITY_CLASS {
 		return nil
 	}
 
-	logger.Debug("setting process priority to " + priority)
+	logger.LogAttrs(context.Background(), slog.LevelDebug, "setting process priority to "+priority)
 
 	// https://learn.microsoft.com/en-us/windows/win32/procthread/process-security-and-access-rights
 	handle, err := windows.OpenProcess(

config.yaml

@@ -1,9 +1,23 @@
 # example configuration file for windows_exporter
 
 collectors:
-  enabled: cpu,cpu_info,exchange,iis,logical_disk,logon,memory,net,os,process,remote_fx,service,system,tcp,time,terminal_services,textfile
+  enabled: cpu,cpu_info,exchange,iis,logical_disk,logon,memory,net,os,performancecounter,process,remote_fx,service,system,tcp,time,terminal_services,textfile
 collector:
   service:
     include: "windows_exporter"
+  performancecounter:
+    objects: |-
+      - name: photon_udp
+        object: "Photon Socket Server: UDP"
+        instances: ["*"]
+        counters:
+          - name: "UDP: Datagrams in"
+            metric: "photon_udp_datagrams"
+            labels:
+              direction: "in"
+          - name: "UDP: Datagrams out"
+            metric: "photon_udp_datagrams"
+            labels:
+              direction: "out"
 log:
   level: warn

docs/README.md

@@ -18,6 +18,7 @@ This directory contains documentation of the collectors in the windows_exporter,
 - [`fsrmquota`](collector.fsrmquota.md)
 - [`hyperv`](collector.hyperv.md)
 - [`iis`](collector.iis.md)
+- [`license`](collector.license.md)
 - [`logical_disk`](collector.logical_disk.md)
 - [`logon`](collector.logon.md)
 - [`memory`](collector.memory.md)
@@ -28,12 +29,16 @@ This directory contains documentation of the collectors in the windows_exporter,
 - [`netframework`](collector.netframework.md)
 - [`nps`](collector.nps.md)
 - [`os`](collector.os.md)
+- [`pagefile`](collector.pagefile.md)
+- [`performancecounter`](collector.performancecounter.md)
 - [`physical_disk`](collector.physical_disk.md)
+- [`printer`](collector.printer.md)
 - [`process`](collector.process.md)
 - [`remote_fx`](collector.remote_fx.md)
 - [`scheduled_task`](collector.scheduled_task.md)
 - [`service`](collector.service.md)
 - [`smb`](collector.smb.md)
+- [`smbclient`](collector.smbclient.md)
 - [`smtp`](collector.smtp.md)
 - [`system`](collector.system.md)
 - [`tcp`](collector.tcp.md)

docs/collector.dhcp.md

@@ -2,49 +2,177 @@
 
 The dhcp collector exposes DHCP Server metrics
 
-|||
--|-
-Metric name prefix  | `dhcp`
-Data source         | Perflib
-Classes             | `DHCP Server`
-Enabled by default? | No
+|                     |               |
+|---------------------|---------------|
+| Metric name prefix  | `dhcp`        |
+| Data source         | Perflib       |
+| Classes             | `DHCP Server` |
+| Enabled by default? | No            |
 
 ## Flags
 
-None
+### `--collector.dhcp.enabled`
+
+Comma-separated list of collectors to use. Defaults to all, if not specified.
 
 ## Metrics
 
-Name | Description | Type | Labels
------|-------------|------|-------
-`packets_received_total` | Total number of packets received by the DHCP server | counter | None
-`duplicates_dropped_total` | Total number of duplicate packets received by the DHCP server | counter | None
-`packets_expired_total` | Total number of packets expired in the DHCP server message queue | counter | None
-`active_queue_length` | Number of packets in the processing queue of the DHCP server | gauge | None
-`conflict_check_queue_length` | Number of packets in the DHCP server queue waiting on conflict detection (ping) | gauge | None
-`discovers_total` | Total DHCP Discovers received by the DHCP server | counter | None
-`offers_total` | Total DHCP Offers sent by the DHCP server | counter | None
-`requests_total` | Total DHCP Requests received by the DHCP server | counter | None
-`informs_total` | Total DHCP Informs received by the DHCP server | counter | None
-`acks_total` | Total DHCP Acks sent by the DHCP server | counter | None
-`nacks_total` | Total DHCP Nacks sent by the DHCP server | counter | None
-`declines_total` | Total DHCP Declines received by the DHCP server | counter | None
-`releases_total` | Total DHCP Releases received by the DHCP server | counter | None
-`offer_queue_length` | Number of packets in the offer queue of the DHCP server | gauge | None
-`denied_due_to_match_total` | Total number of DHCP requests denied, based on matches from the Deny List | gauge | None
-`denied_due_to_nonmatch_total` | Total number of DHCP requests denied, based on non-matches from the Allow List | gauge | None
-`failover_bndupd_sent_total` | Number of DHCP failover Binding Update messages sent | counter | None
-`failover_bndupd_received_total` | Number of DHCP failover Binding Update messages received | counter | None
-`failover_bndack_sent_total` | Number of DHCP failover Binding Ack messages sent | counter | None
-`failover_bndack_received_total` | Number of DHCP failover Binding Ack messages received | counter | None
-`failover_bndupd_pending_in_outbound_queue` | Number of pending outbound DHCP failover Binding Update messages | counter | None
-`failover_transitions_communicationinterrupted_state_total` | Total number of transitions into COMMUNICATION INTERRUPTED state | counter | None
-`failover_transitions_partnerdown_state_total` | Total number of transitions into PARTNER DOWN state | counter | None
-`failover_transitions_recover_total` | Total number of transitions into RECOVER state | counter | None
-`failover_bndupd_dropped_total` | Total number of DHCP faileover Binding Updates dropped | counter | None
+| Name                                                                     | Description                                                                    | Type    | Labels                                              |
+|--------------------------------------------------------------------------|--------------------------------------------------------------------------------|---------|-----------------------------------------------------|
+| `windows_dhcp_ack_total`                                                 | Total DHCP Acks sent by the DHCP server                                        | counter | None                                                |
+| `windows_dhcp_denied_due_to_match_total`                                 | Total number of DHCP requests denied, based on matches from the Deny List      | gauge   | None                                                |
+| `windows_dhcp_denied_due_to_nonmatch_total`                              | Total number of DHCP requests denied, based on non-matches from the Allow List | gauge   | None                                                |
+| `windows_dhcp_declines_total`                                            | Total DHCP Declines received by the DHCP server                                | counter | None                                                |
+| `windows_dhcp_discovers_total`                                           | Total DHCP Discovers received by the DHCP server                               | counter | None                                                |
+| `windows_dhcp_failover_bndack_received_total`                            | Number of DHCP failover Binding Ack messages received                          | counter | None                                                |
+| `windows_dhcp_failover_bndack_sent_total`                                | Number of DHCP failover Binding Ack messages sent                              | counter | None                                                |
+| `windows_dhcp_failover_bndupd_dropped_total`                             | Total number of DHCP failover Binding Updates dropped                          | counter | None                                                |
+| `windows_dhcp_failover_bndupd_received_total`                            | Number of DHCP failover Binding Update messages received                       | counter | None                                                |
+| `windows_dhcp_failover_bndupd_sent_total`                                | Number of DHCP failover Binding Update messages sent                           | counter | None                                                |
+| `windows_dhcp_failover_bndupd_pending_in_outbound_queue`                 | Number of pending outbound DHCP failover Binding Update messages               | counter | None                                                |
+| `windows_dhcp_failover_transitions_communicationinterrupted_state_total` | Total number of transitions into COMMUNICATION INTERRUPTED state               | counter | None                                                |
+| `windows_dhcp_failover_transitions_partnerdown_state_total`              | Total number of transitions into PARTNER DOWN state                            | counter | None                                                |
+| `windows_dhcp_failover_transitions_recover_total`                        | Total number of transitions into RECOVER state                                 | counter | None                                                |
+| `windows_dhcp_informs_total`                                             | Total DHCP Informs received by the DHCP server                                 | counter | None                                                |
+| `windows_dhcp_nacks_total`                                               | Total DHCP Nacks sent by the DHCP server                                       | counter | None                                                |
+| `windows_dhcp_offers_total`                                              | Total DHCP Offers sent by the DHCP server                                      | counter | None                                                |
+| `windows_dhcp_packets_expired_total`                                     | Total number of packets expired in the DHCP server message queue               | counter | None                                                |
+| `windows_dhcp_packets_received_total`                                    | Total number of packets received by the DHCP server                            | counter | None                                                |
+| `windows_dhcp_pending_offers_total`                                      | Total number of pending offers in the DHCP server                              | counter | None                                                |
+| `windows_dhcp_releases_total`                                            | Total DHCP Releases received by the DHCP server                                | counter | None                                                |
+| `windows_dhcp_requests_total`                                            | Total DHCP Requests received by the DHCP server                                | counter | None                                                |
+| `windows_dhcp_scope_addresses_free_on_this_server`                       | DHCP Scope free addresses on this server                                       | gauge   | `scope`                                             |
+| `windows_dhcp_scope_addresses_free_on_partner_server`                    | DHCP Scope free addresses on partner server                                    | gauge   | `scope`                                             |
+| `windows_dhcp_scope_addresses_free`                                      | DHCP Scope free addresses                                                      | gauge   | `scope`                                             |
+| `windows_dhcp_scope_addresses_in_use_on_this_server`                     | DHCP Scope addresses in use on this server                                     | gauge   | `scope`                                             |
+| `windows_dhcp_scope_addresses_in_use_on_partner_server`                  | DHCP Scope addresses in use on partner server                                  | gauge   | `scope`                                             |
+| `windows_dhcp_scope_addresses_in_use`                                    | DHCP Scope addresses in use                                                    | gauge   | `scope`                                             |
+| `windows_dhcp_scope_info`                                                | DHCP Scope information                                                         | gauge   | `name`, `superscope_name`, `superscope_id`, `scope` |
+| `windows_dhcp_scope_pending_offers`                                      | DHCP Scope pending offers                                                      | gauge   | `scope`                                             |
+| `windows_dhcp_scope_reserved_address`                                    | DHCP Scope reserved addresses                                                  | gauge   | `scope`                                             |
+| `windows_dhcp_scope_state`                                               | DHCP Scope state                                                               | gauge   | `scope`, `state`                                    |
+
 
 ### Example metric
-_This collector does not yet have explained examples, we would appreciate your help adding them!_
+```
+# HELP windows_dhcp_acks_total Total DHCP Acks sent by the DHCP server (AcksTotal)
+# TYPE windows_dhcp_acks_total counter
+windows_dhcp_acks_total 0
+# HELP windows_dhcp_active_queue_length Number of packets in the processing queue of the DHCP server (ActiveQueueLength)
+# TYPE windows_dhcp_active_queue_length gauge
+windows_dhcp_active_queue_length 0
+# HELP windows_dhcp_conflict_check_queue_length Number of packets in the DHCP server queue waiting on conflict detection (ping). (ConflictCheckQueueLength)
+# TYPE windows_dhcp_conflict_check_queue_length gauge
+windows_dhcp_conflict_check_queue_length 0
+# HELP windows_dhcp_declines_total Total DHCP Declines received by the DHCP server (DeclinesTotal)
+# TYPE windows_dhcp_declines_total counter
+windows_dhcp_declines_total 0
+# HELP windows_dhcp_denied_due_to_match_total Total number of DHCP requests denied, based on matches from the Deny list (DeniedDueToMatch)
+# TYPE windows_dhcp_denied_due_to_match_total counter
+windows_dhcp_denied_due_to_match_total 0
+# HELP windows_dhcp_denied_due_to_nonmatch_total Total number of DHCP requests denied, based on non-matches from the Allow list (DeniedDueToNonMatch)
+# TYPE windows_dhcp_denied_due_to_nonmatch_total counter
+windows_dhcp_denied_due_to_nonmatch_total 0
+# HELP windows_dhcp_discovers_total Total DHCP Discovers received by the DHCP server (DiscoversTotal)
+# TYPE windows_dhcp_discovers_total counter
+windows_dhcp_discovers_total 0
+# HELP windows_dhcp_duplicates_dropped_total Total number of duplicate packets received by the DHCP server (DuplicatesDroppedTotal)
+# TYPE windows_dhcp_duplicates_dropped_total counter
+windows_dhcp_duplicates_dropped_total 0
+# HELP windows_dhcp_failover_bndack_received_total Number of DHCP fail over Binding Ack messages received (FailoverBndackReceivedTotal)
+# TYPE windows_dhcp_failover_bndack_received_total counter
+windows_dhcp_failover_bndack_received_total 0
+# HELP windows_dhcp_failover_bndack_sent_total Number of DHCP fail over Binding Ack messages sent (FailoverBndackSentTotal)
+# TYPE windows_dhcp_failover_bndack_sent_total counter
+windows_dhcp_failover_bndack_sent_total 0
+# HELP windows_dhcp_failover_bndupd_dropped_total Total number of DHCP fail over Binding Updates dropped (FailoverBndupdDropped)
+# TYPE windows_dhcp_failover_bndupd_dropped_total counter
+windows_dhcp_failover_bndupd_dropped_total 0
+# HELP windows_dhcp_failover_bndupd_pending_in_outbound_queue Number of pending outbound DHCP fail over Binding Update messages (FailoverBndupdPendingOutboundQueue)
+# TYPE windows_dhcp_failover_bndupd_pending_in_outbound_queue gauge
+windows_dhcp_failover_bndupd_pending_in_outbound_queue 0
+# HELP windows_dhcp_failover_bndupd_received_total Number of DHCP fail over Binding Update messages received (FailoverBndupdReceivedTotal)
+# TYPE windows_dhcp_failover_bndupd_received_total counter
+windows_dhcp_failover_bndupd_received_total 0
+# HELP windows_dhcp_failover_bndupd_sent_total Number of DHCP fail over Binding Update messages sent (FailoverBndupdSentTotal)
+# TYPE windows_dhcp_failover_bndupd_sent_total counter
+windows_dhcp_failover_bndupd_sent_total 0
+# HELP windows_dhcp_failover_transitions_communicationinterrupted_state_total Total number of transitions into COMMUNICATION INTERRUPTED state (FailoverTransitionsCommunicationinterruptedState)
+# TYPE windows_dhcp_failover_transitions_communicationinterrupted_state_total counter
+windows_dhcp_failover_transitions_communicationinterrupted_state_total 0
+# HELP windows_dhcp_failover_transitions_partnerdown_state_total Total number of transitions into PARTNER DOWN state (FailoverTransitionsPartnerdownState)
+# TYPE windows_dhcp_failover_transitions_partnerdown_state_total counter
+windows_dhcp_failover_transitions_partnerdown_state_total 0
+# HELP windows_dhcp_failover_transitions_recover_total Total number of transitions into RECOVER state (FailoverTransitionsRecoverState)
+# TYPE windows_dhcp_failover_transitions_recover_total counter
+windows_dhcp_failover_transitions_recover_total 0
+# HELP windows_dhcp_informs_total Total DHCP Informs received by the DHCP server (InformsTotal)
+# TYPE windows_dhcp_informs_total counter
+windows_dhcp_informs_total 0
+# HELP windows_dhcp_nacks_total Total DHCP Nacks sent by the DHCP server (NacksTotal)
+# TYPE windows_dhcp_nacks_total counter
+windows_dhcp_nacks_total 0
+# HELP windows_dhcp_offer_queue_length Number of packets in the offer queue of the DHCP server (OfferQueueLength)
+# TYPE windows_dhcp_offer_queue_length gauge
+windows_dhcp_offer_queue_length 0
+# HELP windows_dhcp_offers_total Total DHCP Offers sent by the DHCP server (OffersTotal)
+# TYPE windows_dhcp_offers_total counter
+windows_dhcp_offers_total 0
+# HELP windows_dhcp_packets_expired_total Total number of packets expired in the DHCP server message queue (PacketsExpiredTotal)
+# TYPE windows_dhcp_packets_expired_total counter
+windows_dhcp_packets_expired_total 0
+# HELP windows_dhcp_packets_received_total Total number of packets received by the DHCP server (PacketsReceivedTotal)
+# TYPE windows_dhcp_packets_received_total counter
+windows_dhcp_packets_received_total 0
+# HELP windows_dhcp_releases_total Total DHCP Releases received by the DHCP server (ReleasesTotal)
+# TYPE windows_dhcp_releases_total counter
+windows_dhcp_releases_total 0
+# HELP windows_dhcp_requests_total Total DHCP Requests received by the DHCP server (RequestsTotal)
+# TYPE windows_dhcp_requests_total counter
+windows_dhcp_requests_total 0
+# HELP windows_dhcp_scope_addresses_free_total DHCP Scope free addresses
+# TYPE windows_dhcp_scope_addresses_free_total gauge
+windows_dhcp_scope_addresses_free_total{scope="10.11.12.0/25"} 0
+windows_dhcp_scope_addresses_free_total{scope="172.16.0.0/24"} 0
+windows_dhcp_scope_addresses_free_total{scope="192.168.0.0/24"} 231
+# HELP windows_dhcp_scope_addresses_in_use_total DHCP Scope addresses in use
+# TYPE windows_dhcp_scope_addresses_in_use_total gauge
+windows_dhcp_scope_addresses_in_use_total{scope="10.11.12.0/25"} 0
+windows_dhcp_scope_addresses_in_use_total{scope="172.16.0.0/24"} 0
+windows_dhcp_scope_addresses_in_use_total{scope="192.168.0.0/24"} 0
+# HELP windows_dhcp_scope_info DHCP Scope information
+# TYPE windows_dhcp_scope_info gauge
+windows_dhcp_scope_info{name="SUBSUPERSCOPE",scope="172.16.0.0/24",superscope_id="2",superscope_name="SUPERSCOPE"} 1
+windows_dhcp_scope_info{name="TEST",scope="192.168.0.0/24",superscope_id="0",superscope_name=""} 1
+windows_dhcp_scope_info{name="TEST2",scope="10.11.12.0/25",superscope_id="2",superscope_name="SUPERSCOPE"} 1
+# HELP windows_dhcp_scope_pending_offers_total DHCP Scope pending offers
+# TYPE windows_dhcp_scope_pending_offers_total gauge
+windows_dhcp_scope_pending_offers_total{scope="10.11.12.0/25"} 0
+windows_dhcp_scope_pending_offers_total{scope="172.16.0.0/24"} 0
+windows_dhcp_scope_pending_offers_total{scope="192.168.0.0/24"} 0
+# HELP windows_dhcp_scope_reserved_address_total DHCP Scope reserved addresses
+# TYPE windows_dhcp_scope_reserved_address_total gauge
+windows_dhcp_scope_reserved_address_total{scope="10.11.12.0/25"} 0
+windows_dhcp_scope_reserved_address_total{scope="172.16.0.0/24"} 0
+windows_dhcp_scope_reserved_address_total{scope="192.168.0.0/24"} 2
+# HELP windows_dhcp_scope_state DHCP Scope state
+# TYPE windows_dhcp_scope_state gauge
+windows_dhcp_scope_state{scope="10.11.12.0/25",state="Disabled"} 1
+windows_dhcp_scope_state{scope="10.11.12.0/25",state="DisabledSwitched"} 0
+windows_dhcp_scope_state{scope="10.11.12.0/25",state="Enabled"} 0
+windows_dhcp_scope_state{scope="10.11.12.0/25",state="EnabledSwitched"} 0
+windows_dhcp_scope_state{scope="10.11.12.0/25",state="InvalidState"} 0
+windows_dhcp_scope_state{scope="172.16.0.0/24",state="Disabled"} 1
+windows_dhcp_scope_state{scope="172.16.0.0/24",state="DisabledSwitched"} 0
+windows_dhcp_scope_state{scope="172.16.0.0/24",state="Enabled"} 0
+windows_dhcp_scope_state{scope="172.16.0.0/24",state="EnabledSwitched"} 0
+windows_dhcp_scope_state{scope="172.16.0.0/24",state="InvalidState"} 0
+windows_dhcp_scope_state{scope="192.168.0.0/24",state="Disabled"} 0
+windows_dhcp_scope_state{scope="192.168.0.0/24",state="DisabledSwitched"} 0
+windows_dhcp_scope_state{scope="192.168.0.0/24",state="Enabled"} 1
+windows_dhcp_scope_state{scope="192.168.0.0/24",state="EnabledSwitched"} 0
+windows_dhcp_scope_state{scope="192.168.0.0/24",state="InvalidState"} 0
+```
 
 ## Useful queries
 _This collector does not yet have any useful queries added, we would appreciate your help adding them!_

docs/collector.mssql.md

@@ -18,15 +18,10 @@ Comma-separated list of MSSQL WMI classes to use. Supported values are `accessme
 
 If true, print available mssql WMI classes and exit.  Only displays if the mssql collector is enabled.fman`, `databases`, `dbreplica`, `genstats`, `locks`, `memmgr`, `sqlstats`, `sqlerrors`, `transactions`, and `waitstats`.
 
-### `--collector.mssql.port`
-
-Port of MSSQL server used for `windows_mssql_info` metric. Default is `1433`.
-
 ## Metrics
 
 | Name                                                               | Description                                                                                                                                                                                                                                                                                  | Type    | Labels                        |
 |--------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|-------------------------------|
-| `windows_mssql_info`                                               | Returns information about the MSSQL server running on port 1433                                                                                                                                                                                                                              | gauge   | `version`                     |
 | `windows_mssql_collector_duration_seconds`                         | The time taken for each sub-collector to return                                                                                                                                                                                                                                              | gauge   | `collector`, `mssql_instance` |
 | `windows_mssql_collector_success`                                  | 1 if sub-collector succeeded, 0 otherwise                                                                                                                                                                                                                                                    | gauge   | `collector`, `mssql_instance` |
 | `windows_mssql_accessmethods_au_batch_cleanups`                    | The total number of batches that were completed successfully by the background task that cleans up deferred dropped allocation units                                                                                                                                                         | counter | `mssql_instance`              |
@@ -197,6 +192,7 @@ Port of MSSQL server used for `windows_mssql_info` metric. Default is `1433`.
 | `windows_mssql_genstats_trace_event_notification_queue_size`       | Number of trace event notification instances waiting in the internal queue to be sent through Service Broker                                                                                                                                                                                 | gauge   | `mssql_instance`              |
 | `windows_mssql_genstats_transactions`                              | Number of transaction enlistments (local, DTC, bound all combined)                                                                                                                                                                                                                           | gauge   | `mssql_instance`              |
 | `windows_mssql_genstats_user_connections`                          | Counts the number of users currently connected to SQL Server                                                                                                                                                                                                                                 | gauge   | `mssql_instance`              |
+| `windows_mssql_instance_info `                                               | Returns information about the MSSQL server running on port 1433                                                                                                                                                                                                                              | gauge   | `version`                     |
 | `windows_mssql_locks_average_wait_seconds`                         | Average amount of wait time (in milliseconds) for each lock request that resulted in a wait                                                                                                                                                                                                  | gauge   | `mssql_instance`, `resource`  |
 | `windows_mssql_locks_lock_requests`                                | Number of new locks and lock conversions per second requested from the lock manager                                                                                                                                                                                                          | counter | `mssql_instance`, `resource`  |
 | `windows_mssql_locks_lock_timeouts`                                | Number of lock requests per second that timed out, including requests for NOWAIT locks                                                                                                                                                                                                       | counter | `mssql_instance`, `resource`  |

docs/collector.net.md

@@ -19,6 +19,10 @@ If given, an interface name needs to match the include regexp in order for the c
 
 If given, an interface name needs to *not* match the exclude regexp in order for the corresponding metrics to be reported
 
+### `--collector.net.enabled`
+
+Comma-separated list of collectors to use. Defaults to all, if not specified.
+
 ## Metrics
 
 Name | Description | Type | Labels

docs/collector.netframework.md

@@ -10,7 +10,9 @@ The netframework collector exposes metrics about dotnet framework.
 
 ## Flags
 
-None
+### `--collector.netframework.enabled`
+
+Comma-separated list of collectors to use. Defaults to all, if not specified.
 
 ## Metrics
 

docs/collector.perfdata.md

@@ -1,114 +0,0 @@
-# Perfdata collector
-
-The perfdata collector exposes any configured metric.
-
-|                     |                         |
-|---------------------|-------------------------|
-| Metric name prefix  | `perfdata`              |
-| Data source         | Performance Data Helper |
-| Enabled by default? | No                      |
-
-## Flags
-
-
-### `--collector.perfdata.objects`
-
-Objects is a list of objects to collect metrics from. The value takes the form of a JSON array of strings. YAML is also supported.
-
-The collector supports only english named counter. Localized counter-names are not supported.
-
-#### Schema
-
-YAML: 
-```yaml
-- object: "Processor Information"
-  instances: ["*"]
-  instance_label: "core"
-  counters:
-    "% Processor Time": {}
-- object: "Memory"
-  counters:
-    "Cache Faults/sec":
-      type: "counter"
-```
-
-JSON:
-
-```json
-[
-  {"object":"Processor Information","instance_label": "core","instances":["*"],"counters": {"% Processor Time": {}}},
-  {"object":"Memory","counters": {"Cache Faults/sec": {"type": "counter"}}}
-]
-```
-
-#### name
-
-ObjectName is the Object to query for, like Processor, DirectoryServices, LogicalDisk or similar.
-
-The collector supports only english named counter. Localized counter-names are not supported.
-
-#### instances
-
-The instances key (this is an array) declares the instances of a counter you would like returned, it can be one or more values.
-
-Example: Instances = `["C:","D:","E:"]`
-
-This will return only for the instances C:, D: and E: where relevant. To get all instances of a Counter, use `["*"]` only. 
-
-Some Objects like `Memory` do not have instances to select from at all. In this case, the `instances` key can be omitted.
-
-#### counters
-
-The Counters key (this is an object) declares the counters of the ObjectName you would like returned, it can also be one or more values.
-
-Example: Counters = `{"% Idle Time": {}, "% Disk Read Time": {}, "% Disk Write Time": {}}`
-
-This must be specified for every counter you want the results. Wildcards are not supported.
-
-#### counters Sub-Schema
-
-##### type
-
-This key is optional. It indicates the type of the counter. The value can be `counter` or `gauge`. 
-If not specified, the windows_exporter will try to determine the type based on the counter type.
-
-### Example
-
-```
-# HELP windows_perfdata_memory_cache_faults_sec 
-# TYPE windows_perfdata_memory_cache_faults_sec counter
-windows_perfdata_memory_cache_faults_sec 2.369977e+07
-# HELP windows_perfdata_processor_information__processor_time 
-# TYPE windows_perfdata_processor_information__processor_time gauge
-windows_perfdata_processor_information__processor_time{instance="0,0"} 1.7259640625e+11
-windows_perfdata_processor_information__processor_time{instance="0,1"} 1.7576796875e+11
-windows_perfdata_processor_information__processor_time{instance="0,10"} 2.2704234375e+11
-windows_perfdata_processor_information__processor_time{instance="0,11"} 2.3069296875e+11
-windows_perfdata_processor_information__processor_time{instance="0,12"} 2.3302265625e+11
-windows_perfdata_processor_information__processor_time{instance="0,13"} 2.32851875e+11
-windows_perfdata_processor_information__processor_time{instance="0,14"} 2.3282421875e+11
-windows_perfdata_processor_information__processor_time{instance="0,15"} 2.3271234375e+11
-windows_perfdata_processor_information__processor_time{instance="0,16"} 2.329590625e+11
-windows_perfdata_processor_information__processor_time{instance="0,17"} 2.32800625e+11
-windows_perfdata_processor_information__processor_time{instance="0,18"} 2.3194359375e+11
-windows_perfdata_processor_information__processor_time{instance="0,19"} 2.32380625e+11
-windows_perfdata_processor_information__processor_time{instance="0,2"} 1.954765625e+11
-windows_perfdata_processor_information__processor_time{instance="0,20"} 2.3259765625e+11
-windows_perfdata_processor_information__processor_time{instance="0,21"} 2.3268515625e+11
-windows_perfdata_processor_information__processor_time{instance="0,22"} 2.3301765625e+11
-windows_perfdata_processor_information__processor_time{instance="0,23"} 2.3264328125e+11
-windows_perfdata_processor_information__processor_time{instance="0,3"} 1.94745625e+11
-windows_perfdata_processor_information__processor_time{instance="0,4"} 2.2011453125e+11
-windows_perfdata_processor_information__processor_time{instance="0,5"} 2.27244375e+11
-windows_perfdata_processor_information__processor_time{instance="0,6"} 2.25501875e+11
-windows_perfdata_processor_information__processor_time{instance="0,7"} 2.2995265625e+11
-windows_perfdata_processor_information__processor_time{instance="0,8"} 2.2929890625e+11
-windows_perfdata_processor_information__processor_time{instance="0,9"} 2.313540625e+11
-windows_perfdata_processor_information__processor_time{instance="0,_Total"} 2.23009459635e+11
-```
-
-## Metrics
-
-The perfdata collector returns metrics based on the user configuration. 
-The metrics are named based on the object name and the counter name.
-The instance name is added as a label to the metric.

docs/collector.performancecounter.md

@@ -0,0 +1,262 @@
+# performancecounter collector
+
+The performancecounter collector exposes any configured metric.
+
+|                     |                         |
+|---------------------|-------------------------|
+| Metric name prefix  | `performancecounter`              |
+| Data source         | Performance Data Helper |
+| Enabled by default? | No                      |
+
+## Flags
+
+
+### `--collector.performancecounter.objects`
+
+Objects is a list of objects to collect metrics from. The value takes the form of a JSON array of strings.
+YAML is supported.
+
+The collector supports only English-named counter. Localized counter-names aren’t supported.
+
+> [!CAUTION]
+> If you are using a configuration file, the value must be kept as a string.
+>
+> Use a `|-` to keep the value as a string.
+
+#### Example
+
+```yaml
+collector:
+  performancecounter:
+    objects: |-
+      - name: memory
+        object: "Memory"
+        counters:
+          - name: "Cache Faults/sec"
+            type: "counter" # optional
+```
+
+#### Schema
+
+YAML:
+
+<details>
+<summary>Click to expand YAML schema</summary>
+
+```yaml
+- name: cpu # free text name
+  object: "Processor Information" # Performance counter object name
+  instances: ["*"]
+  instance_label: "core"
+  counters:
+    - name: "% Processor Time"
+      metric: windows_performancecounter_processor_information_processor_time # optional
+      labels:
+        state: active
+    - name: "% Idle Time"
+      metric: windows_performancecounter_processor_information_processor_time # optional
+      labels:
+        state: idle
+- name: memory
+  object: "Memory"
+  type: "formatted"
+  counters:
+    - name: "Cache Faults/sec"
+      type: "counter" # optional
+```
+
+</details>
+
+<details>
+<summary>Click to expand JSON schema</summary>
+
+```json
+[
+  {
+    "name": "cpu",
+    "object": "Processor Information",
+    "instances": [
+      "*"
+    ],
+    "instance_label": "core",
+    "counters": [
+      {
+        "name": "% Processor Time",
+        "metric": "windows_performancecounter_processor_information_processor_time",
+        "labels": {
+          "state": "active"
+        }
+      },
+      {
+        "name": "% Idle Time",
+        "metric": "windows_performancecounter_processor_information_processor_time",
+        "labels": {
+          "state": "idle"
+        }
+      }
+    ]
+  },
+  {
+    "name": "memory",
+    "object": "Memory",
+    "type": "formatted",
+    "counters": [
+      {
+        "name": "Cache Faults/sec",
+        "type": "counter"
+      }
+    ]
+  }
+]
+```
+</details>
+
+#### name
+
+The name is used to identify the object in the logs and metrics.
+Must unique across all objects.
+
+#### object
+
+ObjectName is the Object to query for, like Processor, DirectoryServices, LogicalDisk or similar.
+
+The collector supports only english named counter. Localized counter-names are not supported.
+
+#### type
+
+The counter-type. The value can be `raw` or `formatted`. Optional and defaults to `raw`.
+
+- `raw` returns the raw value of the counter. This is the default.
+- `formatted` returns the formatted value of the counter. This is useful for counters like `Processor Information` where the value is a percentage.
+
+The difference between a raw Windows Performance Counter and a formatted Windows Performance Counter is about how the data is presented and processed:
+
+1. Raw Windows Performance Counter:
+
+   This provides the counter's data in its basic, unprocessed form.
+   The values may represent cumulative counts, time intervals, or other uncalibrated metrics.
+   Interpreting these values often requires more calculations or context, such as calculating deltas or normalizing values over time.
+
+2. Formatted Windows Performance Counter:
+
+   This presents data that has already been processed and interpreted according to the counter type (e.g., rates per second, averages, percentages).
+   Formatted counters are easier to understand directly since the necessary calculations have been applied.
+   These are often what monitoring tools display to users because they are meaningful at a glance.
+
+For example:
+
+* A raw counter for CPU time might give the total number of clock ticks used since the system started.
+* A formatted counter would convert this into a percentage of CPU utilization over a specific time interval.
+
+
+#### instances
+
+The instances key (this is an array) declares the instances of a counter you would like returned, it can be one or more values.
+
+Example: Instances = `["C:","D:","E:"]`
+
+This will return only for the instances C:, D: and E: where relevant. To get all instances of a Counter, use `["*"]` only.
+
+Some Objects like `Memory` do not have instances to select from at all. In this case, the `instances` key can be omitted.
+
+#### counters
+
+List of counters to collect from the object. See the counters sub-schema for more information.
+
+#### counters Sub-Schema
+
+##### name
+
+The name of the counter to collect.
+
+##### metric
+
+It indicates the name of the metric to be exposed. If not specified, the metric name will be generated based on the object name and the counter name.
+
+This key is optional.
+
+##### type
+
+It indicates the type of the counter. The value can be `counter` or `gauge`.
+If not specified, the windows_exporter will try to determine the type based on the counter type.
+
+This key is optional.
+
+##### labels
+
+Labels is a map of key-value pairs that will be added as labels to the metric.
+
+### Example
+
+```
+# HELP windows_performancecounter_memory_cache_faults_sec
+# TYPE windows_performancecounter_memory_cache_faults_sec counter
+windows_performancecounter_memory_cache_faults_sec 7.028097e+06
+# HELP windows_performancecounter_processor_information_processor_time
+# TYPE windows_performancecounter_processor_information_processor_time counter
+windows_performancecounter_processor_information_processor_time{core="0,0",state="active"} 8.3809375e+10
+windows_performancecounter_processor_information_processor_time{core="0,0",state="idle"} 8380.9375
+windows_performancecounter_processor_information_processor_time{core="0,1",state="active"} 8.2868125e+10
+windows_performancecounter_processor_information_processor_time{core="0,1",state="idle"} 8286.8125
+windows_performancecounter_processor_information_processor_time{core="0,10",state="active"} 9.720046875e+10
+windows_performancecounter_processor_information_processor_time{core="0,10",state="idle"} 9720.046875
+windows_performancecounter_processor_information_processor_time{core="0,11",state="active"} 9.994921875e+10
+windows_performancecounter_processor_information_processor_time{core="0,11",state="idle"} 9994.921875
+windows_performancecounter_processor_information_processor_time{core="0,12",state="active"} 1.014403125e+11
+windows_performancecounter_processor_information_processor_time{core="0,12",state="idle"} 10144.03125
+windows_performancecounter_processor_information_processor_time{core="0,13",state="active"} 1.0155453125e+11
+windows_performancecounter_processor_information_processor_time{core="0,13",state="idle"} 10155.453125
+windows_performancecounter_processor_information_processor_time{core="0,14",state="active"} 1.01290625e+11
+windows_performancecounter_processor_information_processor_time{core="0,14",state="idle"} 10129.0625
+windows_performancecounter_processor_information_processor_time{core="0,15",state="active"} 1.0134890625e+11
+windows_performancecounter_processor_information_processor_time{core="0,15",state="idle"} 10134.890625
+windows_performancecounter_processor_information_processor_time{core="0,16",state="active"} 1.01405625e+11
+windows_performancecounter_processor_information_processor_time{core="0,16",state="idle"} 10140.5625
+windows_performancecounter_processor_information_processor_time{core="0,17",state="active"} 1.0153421875e+11
+windows_performancecounter_processor_information_processor_time{core="0,17",state="idle"} 10153.421875
+windows_performancecounter_processor_information_processor_time{core="0,18",state="active"} 1.0086390625e+11
+windows_performancecounter_processor_information_processor_time{core="0,18",state="idle"} 10086.390625
+windows_performancecounter_processor_information_processor_time{core="0,19",state="active"} 1.0123453125e+11
+windows_performancecounter_processor_information_processor_time{core="0,19",state="idle"} 10123.453125
+windows_performancecounter_processor_information_processor_time{core="0,2",state="active"} 8.3548125e+10
+windows_performancecounter_processor_information_processor_time{core="0,2",state="idle"} 8354.8125
+windows_performancecounter_processor_information_processor_time{core="0,20",state="active"} 1.011703125e+11
+windows_performancecounter_processor_information_processor_time{core="0,20",state="idle"} 10117.03125
+windows_performancecounter_processor_information_processor_time{core="0,21",state="active"} 1.0140984375e+11
+windows_performancecounter_processor_information_processor_time{core="0,21",state="idle"} 10140.984375
+windows_performancecounter_processor_information_processor_time{core="0,22",state="active"} 1.014615625e+11
+windows_performancecounter_processor_information_processor_time{core="0,22",state="idle"} 10146.15625
+windows_performancecounter_processor_information_processor_time{core="0,23",state="active"} 1.0145125e+11
+windows_performancecounter_processor_information_processor_time{core="0,23",state="idle"} 10145.125
+windows_performancecounter_processor_information_processor_time{core="0,3",state="active"} 8.488953125e+10
+windows_performancecounter_processor_information_processor_time{core="0,3",state="idle"} 8488.953125
+windows_performancecounter_processor_information_processor_time{core="0,4",state="active"} 9.338234375e+10
+windows_performancecounter_processor_information_processor_time{core="0,4",state="idle"} 9338.234375
+windows_performancecounter_processor_information_processor_time{core="0,5",state="active"} 9.776453125e+10
+windows_performancecounter_processor_information_processor_time{core="0,5",state="idle"} 9776.453125
+windows_performancecounter_processor_information_processor_time{core="0,6",state="active"} 9.736265625e+10
+windows_performancecounter_processor_information_processor_time{core="0,6",state="idle"} 9736.265625
+windows_performancecounter_processor_information_processor_time{core="0,7",state="active"} 9.959375e+10
+windows_performancecounter_processor_information_processor_time{core="0,7",state="idle"} 9959.375
+windows_performancecounter_processor_information_processor_time{core="0,8",state="active"} 9.939421875e+10
+windows_performancecounter_processor_information_processor_time{core="0,8",state="idle"} 9939.421875
+windows_performancecounter_processor_information_processor_time{core="0,9",state="active"} 1.0059484375e+11
+windows_performancecounter_processor_information_processor_time{core="0,9",state="idle"} 10059.484375
+```
+> [!NOTE]
+> If you are using a configuration file, the value must be keep as string.
+
+Example:
+
+```yaml
+collector:
+  performancecounter:
+    objects: |
+```
+
+
+## Metrics
+
+The perfdata collector returns metrics based on the user configuration.
+The metrics are named based on the object name and the counter name.
+The instance name is added as a label to the metric.

docs/collector.system.md

@@ -14,16 +14,16 @@ None
 
 ## Metrics
 
-| Name                                        | Description                                                                                                                                                                                                       | Type    | Labels |
-|---------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|--------|
-| `windows_system_context_switches_total`     | Total number of [context switches](https://en.wikipedia.org/wiki/Context_switch)                                                                                                                                  | counter | None   |
-| `windows_system_exception_dispatches_total` | Total exceptions dispatched by the system                                                                                                                                                                         | counter | None   |
-| `windows_system_processes`                  | Number of process contexts currently loaded or running on the operating system                                                                                                                                    | gauge   | None   |
-| `windows_system_process_limit`              | The size of the user-mode portion of the virtual address space of the calling process, in bytes. This value depends on the type of process, the type of processor, and the configuration of the operating system. | gauge   | None   |
-| `windows_system_processor_queue_length`     | Number of threads in the processor queue. There is a single queue for processor time even on computers with multiple processors.                                                                                  | gauge   | None   |
-| `windows_system_system_calls_total`         | Total combined calls to Windows NT system service routines by all processes running on the computer                                                                                                               | counter | None   |
-| `windows_system_system_up_time`             | Time of last boot of system                                                                                                                                                                                       | gauge   | None   |
-| `windows_system_threads`                    | Number of Windows system [threads](https://en.wikipedia.org/wiki/Thread_(computing))                                                                                                                              | gauge   | None   |
+| Name                                         | Description                                                                                                                                                                                                       | Type    | Labels |
+|----------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|--------|
+| `windows_system_boot_time_timestamp_seconds` | Unix timestamp of last system boot                                                                                                                                                                                | gauge   | None   |
+| `windows_system_context_switches_total`      | Total number of [context switches](https://en.wikipedia.org/wiki/Context_switch)                                                                                                                                  | counter | None   |
+| `windows_system_exception_dispatches_total`  | Total exceptions dispatched by the system                                                                                                                                                                         | counter | None   |
+| `windows_system_processes`                   | Number of process contexts currently loaded or running on the operating system                                                                                                                                    | gauge   | None   |
+| `windows_system_process_limit`               | The size of the user-mode portion of the virtual address space of the calling process, in bytes. This value depends on the type of process, the type of processor, and the configuration of the operating system. | gauge   | None   |
+| `windows_system_processor_queue_length`      | Number of threads in the processor queue. There is a single queue for processor time even on computers with multiple processors.                                                                                  | gauge   | None   |
+| `windows_system_system_calls_total`          | Total combined calls to Windows NT system service routines by all processes running on the computer                                                                                                               | counter | None   |
+| `windows_system_threads`                     | Number of Windows system [threads](https://en.wikipedia.org/wiki/Thread_(computing))                                                                                                                              | gauge   | None   |
 
 
 
@@ -41,7 +41,7 @@ windows_system_processes{instance="localhost"}
 ## Useful queries
 Find hosts that have rebooted in the last 24 hours
 ```
-time() - windows_system_system_up_time < 86400
+time() - windows_system_boot_time_timestamp_seconds < 86400
 ```
 
 ## Alerting examples

go.mod

@@ -3,34 +3,33 @@ module github.com/prometheus-community/windows_exporter
 go 1.23
 
 require (
-	github.com/Microsoft/go-winio v0.6.2
 	github.com/Microsoft/hcsshim v0.12.9
 	github.com/alecthomas/kingpin/v2 v2.4.0
-	github.com/bmatcuk/doublestar/v4 v4.7.1
+	github.com/bmatcuk/doublestar/v4 v4.8.1
 	github.com/dimchansky/utfbom v1.1.1
 	github.com/go-ole/go-ole v1.3.0
-	github.com/google/uuid v1.6.0
-	github.com/prometheus/client_golang v1.20.5
+	github.com/prometheus/client_golang v1.21.0-rc.0
 	github.com/prometheus/client_model v0.6.1
-	github.com/prometheus/common v0.60.1
-	github.com/prometheus/exporter-toolkit v0.13.1
+	github.com/prometheus/common v0.62.0
+	github.com/prometheus/exporter-toolkit v0.14.0
 	github.com/stretchr/testify v1.10.0
-	golang.org/x/sys v0.27.0
+	golang.org/x/sys v0.30.0
 	gopkg.in/yaml.v3 v3.0.1
 )
 
 require (
+	github.com/Microsoft/go-winio v0.6.2 // indirect
 	github.com/alecthomas/units v0.0.0-20240927000941-0f3dac36c52b // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
-	github.com/containerd/cgroups/v3 v3.0.3 // indirect
-	github.com/containerd/errdefs v0.3.0 // indirect
+	github.com/containerd/cgroups/v3 v3.0.5 // indirect
+	github.com/containerd/errdefs v1.0.0 // indirect
 	github.com/containerd/errdefs/pkg v0.3.0 // indirect
-	github.com/containerd/typeurl/v2 v2.2.0 // indirect
+	github.com/containerd/typeurl/v2 v2.2.3 // indirect
 	github.com/coreos/go-systemd/v22 v22.5.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
-	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
+	github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect
 	github.com/jpillora/backoff v1.0.0 // indirect
 	github.com/klauspost/compress v1.17.11 // indirect
 	github.com/mdlayher/socket v0.5.1 // indirect
@@ -43,13 +42,13 @@ require (
 	github.com/sirupsen/logrus v1.9.3 // indirect
 	github.com/xhit/go-str2duration/v2 v2.1.0 // indirect
 	go.opencensus.io v0.24.0 // indirect
-	golang.org/x/crypto v0.28.0 // indirect
-	golang.org/x/net v0.30.0 // indirect
-	golang.org/x/oauth2 v0.23.0 // indirect
-	golang.org/x/sync v0.8.0 // indirect
-	golang.org/x/text v0.19.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20241015192408-796eee8c2d53 // indirect
-	google.golang.org/grpc v1.67.1 // indirect
-	google.golang.org/protobuf v1.35.1 // indirect
+	golang.org/x/crypto v0.32.0 // indirect
+	golang.org/x/net v0.34.0 // indirect
+	golang.org/x/oauth2 v0.26.0 // indirect
+	golang.org/x/sync v0.11.0 // indirect
+	golang.org/x/text v0.22.0 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20250204164813-702378808489 // indirect
+	google.golang.org/grpc v1.70.0 // indirect
+	google.golang.org/protobuf v1.36.5 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 )

go.sum

@@ -10,21 +10,21 @@ github.com/alecthomas/units v0.0.0-20240927000941-0f3dac36c52b h1:mimo19zliBX/vS
 github.com/alecthomas/units v0.0.0-20240927000941-0f3dac36c52b/go.mod h1:fvzegU4vN3H1qMT+8wDmzjAcDONcgo2/SZ/TyfdUOFs=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
-github.com/bmatcuk/doublestar/v4 v4.7.1 h1:fdDeAqgT47acgwd9bd9HxJRDmc9UAmPpc+2m0CXv75Q=
-github.com/bmatcuk/doublestar/v4 v4.7.1/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc=
+github.com/bmatcuk/doublestar/v4 v4.8.1 h1:54Bopc5c2cAvhLRAzqOGCYHYyhcDHsFF4wWIR5wKP38=
+github.com/bmatcuk/doublestar/v4 v4.8.1/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
 github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
-github.com/containerd/cgroups/v3 v3.0.3 h1:S5ByHZ/h9PMe5IOQoN7E+nMc2UcLEM/V48DGDJ9kip0=
-github.com/containerd/cgroups/v3 v3.0.3/go.mod h1:8HBe7V3aWGLFPd/k03swSIsGjZhHI2WzJmticMgVuz0=
-github.com/containerd/errdefs v0.3.0 h1:FSZgGOeK4yuT/+DnF07/Olde/q4KBoMsaamhXxIMDp4=
-github.com/containerd/errdefs v0.3.0/go.mod h1:+YBYIdtsnF4Iw6nWZhJcqGSg/dwvV7tyJ/kCkyJ2k+M=
+github.com/containerd/cgroups/v3 v3.0.5 h1:44na7Ud+VwyE7LIoJ8JTNQOa549a8543BmzaJHo6Bzo=
+github.com/containerd/cgroups/v3 v3.0.5/go.mod h1:SA5DLYnXO8pTGYiAHXz94qvLQTKfVM5GEVisn4jpins=
+github.com/containerd/errdefs v1.0.0 h1:tg5yIfIlQIrxYtu9ajqY42W3lpS19XqdxRQeEwYG8PI=
+github.com/containerd/errdefs v1.0.0/go.mod h1:+YBYIdtsnF4Iw6nWZhJcqGSg/dwvV7tyJ/kCkyJ2k+M=
 github.com/containerd/errdefs/pkg v0.3.0 h1:9IKJ06FvyNlexW690DXuQNx2KA2cUJXx151Xdx3ZPPE=
 github.com/containerd/errdefs/pkg v0.3.0/go.mod h1:NJw6s9HwNuRhnjJhM7pylWwMyAkmCQvQ4GpJHEqRLVk=
-github.com/containerd/typeurl/v2 v2.2.0 h1:6NBDbQzr7I5LHgp34xAXYF5DOTQDn05X58lsPEmzLso=
-github.com/containerd/typeurl/v2 v2.2.0/go.mod h1:8XOOxnyatxSWuG8OfsZXVnAF4iZfedjS/8UHSPJnX4g=
+github.com/containerd/typeurl/v2 v2.2.3 h1:yNA/94zxWdvYACdYO8zofhrTVuQY73fFU1y++dYSw40=
+github.com/containerd/typeurl/v2 v2.2.3/go.mod h1:95ljDnPfD3bAbDJRugOiShd/DlAAsxGtUBhJxIn7SCk=
 github.com/coreos/go-systemd/v22 v22.5.0 h1:RrqgGjYQKalulkV8NGVIfkXQf6YYmOyiJKk8iXXhfZs=
 github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -43,8 +43,8 @@ github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
 github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
 github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE=
-github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ=
+github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUvekVysuuOpQKo3191zZyTpiI6se1N1ULghS0sw=
 github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
@@ -55,6 +55,8 @@ github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:W
 github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
 github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
 github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
+github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
@@ -64,8 +66,6 @@ github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
-github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/jpillora/backoff v1.0.0 h1:uvFg412JmmHBHw7iwprIxkPMI+sGQ4kzOWsMeHnm2EA=
 github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=
 github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
@@ -90,15 +90,15 @@ github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/prometheus/client_golang v1.20.5 h1:cxppBPuYhUnsO6yo/aoRol4L7q7UFfdm+bR9r+8l63Y=
-github.com/prometheus/client_golang v1.20.5/go.mod h1:PIEt8X02hGcP8JWbeHyeZ53Y/jReSnHgO035n//V5WE=
+github.com/prometheus/client_golang v1.21.0-rc.0 h1:bR+RxBlwcr4q8hXkgSOA/J18j6n0/qH0Gb0DH+8c+RY=
+github.com/prometheus/client_golang v1.21.0-rc.0/go.mod h1:U9NM32ykUErtVBxdvD3zfi+EuFkkaBvMb09mIfe0Zgg=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
 github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
-github.com/prometheus/common v0.60.1 h1:FUas6GcOw66yB/73KC+BOZoFJmbo/1pojoILArPAaSc=
-github.com/prometheus/common v0.60.1/go.mod h1:h0LYf1R1deLSKtD4Vdg8gy4RuOvENW2J/h19V5NADQw=
-github.com/prometheus/exporter-toolkit v0.13.1 h1:Evsh0gWQo2bdOHlnz9+0Nm7/OFfIwhE2Ws4A2jIlR04=
-github.com/prometheus/exporter-toolkit v0.13.1/go.mod h1:ujdv2YIOxtdFxxqtloLpbqmxd5J0Le6IITUvIRSWjj0=
+github.com/prometheus/common v0.62.0 h1:xasJaQlnWAeyHdUBeGjXmutelfJHWMRr+Fg4QszZ2Io=
+github.com/prometheus/common v0.62.0/go.mod h1:vyBcEuLSvWos9B1+CyL7JZ2up+uFzXhkqml0W5zIY1I=
+github.com/prometheus/exporter-toolkit v0.14.0 h1:NMlswfibpcZZ+H0sZBiTjrA3/aBFHkNZqE+iCj5EmRg=
+github.com/prometheus/exporter-toolkit v0.14.0/go.mod h1:Gu5LnVvt7Nr/oqTBUC23WILZepW0nffNo10XdhQcwWA=
 github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc=
 github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=
 github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
@@ -126,8 +126,8 @@ go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.28.0 h1:GBDwsMXVQi34v5CCYUm2jkJvu4cbtru2U4TN2PSyQnw=
-golang.org/x/crypto v0.28.0/go.mod h1:rmgy+3RHxRZMyY0jjAJShp2zgEdOqj2AO7U0pYmeQ7U=
+golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
+golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
@@ -143,30 +143,30 @@ golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLL
 golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.30.0 h1:AcW1SDZMkb8IpzCdQUaIq2sP4sZ4zw+55h6ynffypl4=
-golang.org/x/net v0.30.0/go.mod h1:2wGyMJ5iFasEhkwi13ChkO/t1ECNC4X4eBKkVFyYFlU=
+golang.org/x/net v0.34.0 h1:Mb7Mrk043xzHgnRM88suvJFwzVrRfHEHJEl5/71CKw0=
+golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
-golang.org/x/oauth2 v0.23.0 h1:PbgcYx2W7i4LvjJWEbf0ngHV6qJYr86PkAV3bXdLEbs=
-golang.org/x/oauth2 v0.23.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI=
+golang.org/x/oauth2 v0.26.0 h1:afQXWNNaeC4nvZ0Ed9XvCCzXM6UHJG7iCg0W4fPqSBE=
+golang.org/x/oauth2 v0.26.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
-golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=
+golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s=
-golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
+golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.19.0 h1:kTxAhCbGbxhK0IwgSKiMO5awPoDQ0RpfiVYBfK860YM=
-golang.org/x/text v0.19.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
+golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
@@ -184,15 +184,15 @@ google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7
 google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
 google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
 google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20241015192408-796eee8c2d53 h1:X58yt85/IXCx0Y3ZwN6sEIKZzQtDEYaBWrDvErdXrRE=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20241015192408-796eee8c2d53/go.mod h1:GX3210XPVPUjJbTUbvwI8f2IpZDMZuPJWDzDuebbviI=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250204164813-702378808489 h1:5bKytslY8ViY0Cj/ewmRtrWHW64bNF03cAatUUFCdFI=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250204164813-702378808489/go.mod h1:8BS3B93F/U1juMFq9+EDk+qOT5CO1R9IzXxG3PTqiRk=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
 google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
 google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
 google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
 google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
-google.golang.org/grpc v1.67.1 h1:zWnc1Vrcno+lHZCOofnIMvycFcc0QRGIzm9dhnDX68E=
-google.golang.org/grpc v1.67.1/go.mod h1:1gLDyUQU7CTLJI90u3nXZ9ekeghjeM7pTDZlqFNg2AA=
+google.golang.org/grpc v1.70.0 h1:pWFv03aZoHzlRKHWicjsZytKAiYCtNS0dHbXnIdq7jQ=
+google.golang.org/grpc v1.70.0/go.mod h1:ofIJqVKDXx/JiXrwr2IG4/zwdH9txy3IlF40RmcJSQw=
 google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
 google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
 google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
@@ -202,8 +202,8 @@ google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2
 google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
 google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
 google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
-google.golang.org/protobuf v1.35.1 h1:m3LfL6/Ca+fqnjnlqQXNpFPABW1UD7mjh8KO2mKFytA=
-google.golang.org/protobuf v1.35.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+google.golang.org/protobuf v1.36.5 h1:tPhr+woSbjfYvY6/GPufUoYizxw1cF/yFoxJ2fmpwlM=
+google.golang.org/protobuf v1.36.5/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=

installer/build.ps1

@@ -28,7 +28,7 @@ Copy-Item -Force $PathToExecutable Work/windows_exporter.exe
 Write-Verbose "Creating windows_exporter-${Version}-${Arch}.msi"
 $wixArch = @{"amd64" = "x64"; "arm64" = "arm64"}[$Arch]
 
-Invoke-Expression "wix build -arch $wixArch -o .\windows_exporter-$($Version)-$($Arch).msi .\files.wxs .\main.wxs -d ProductName=windows_exporter -d Version=$($MsiVersion) -ext WixToolset.Firewall.wixext -ext WixToolset.UI.wixext -ext WixToolset.Util.wixext"
+Invoke-Expression "wix build -sw1149 -arch $wixArch -o .\windows_exporter-$($Version)-$($Arch).msi .\files.wxs .\main.wxs -d ProductName=windows_exporter -d Version=$($MsiVersion) -ext WixToolset.Firewall.wixext -ext WixToolset.UI.wixext -ext WixToolset.Util.wixext"
 
 Write-Verbose "Done!"
 Pop-Location

installer/files.wxs

@@ -13,8 +13,8 @@
   ~ limitations under the License.
   -->
 
-<Wix xmlns="http://wixtoolset.org/schemas/v4/wxs"
-     xmlns:util="http://wixtoolset.org/schemas/v4/wxs/util">
+<Wix xmlns:util="http://wixtoolset.org/schemas/v4/wxs/util"
+     xmlns="http://wixtoolset.org/schemas/v4/wxs">
     <Fragment>
         <DirectoryRef Id="APPLICATIONFOLDER">
             <Component Transitive="yes">
@@ -27,10 +27,15 @@
                     ErrorControl="normal"
                     Start="auto"
                     Type="ownProcess"
+                    Interactive="no"
                     Vital="yes"
-                    Arguments="--log.file eventlog [ConfigFileFlag] [CollectorsFlag] [ListenFlag] [MetricsPathFlag] [TextfileDirsFlag] [ExtraFlags]">
+                    Arguments="[ConfigFileFlag] [CollectorsFlag] [ListenFlag] [MetricsPathFlag] [TextfileDirsFlag] [ExtraFlags]">
+                    <ServiceConfig
+                        DelayedAutoStart="yes"
+                        OnInstall="yes"
+                        OnReinstall="yes" />
                     <util:ServiceConfig
-                        ResetPeriodInDays="1"
+                        ResetPeriodInDays="0"
                         FirstFailureActionType="restart"
                         SecondFailureActionType="restart"
                         ThirdFailureActionType="restart"
@@ -39,6 +44,12 @@
                     <ServiceDependency Id="wmiApSrv" />
                 </ServiceInstall>
                 <ServiceControl Id="ServiceStateControl" Name="windows_exporter" Remove="uninstall" Start="install" Stop="both"/>
+                <!-- The "Name" field must match the argument to eventlog.Open() -->
+                <util:EventSource Log="Application" Name="windows_exporter"
+                                  EventMessageFile="%SystemRoot%\System32\EventCreate.exe"
+                                  SupportsErrors="yes"
+                                  SupportsInformationals="yes"
+                                  SupportsWarnings="yes"/>
             </Component>
             <Component Id="CreateTextfileDirectory" Directory="textfile_inputs" Guid="d03ef58a-9cbf-4165-ad39-d143e9b27e14">
                 <CreateFolder />

installer/main.wxs

@@ -24,9 +24,9 @@
   ~ limitations under the License.
   -->
 
-<Wix xmlns="http://wixtoolset.org/schemas/v4/wxs"
-     xmlns:fw="http://wixtoolset.org/schemas/v4/wxs/firewall"
-     xmlns:ui="http://wixtoolset.org/schemas/v4/wxs/ui">
+<Wix xmlns:fw="http://wixtoolset.org/schemas/v4/wxs/firewall"
+     xmlns:ui="http://wixtoolset.org/schemas/v4/wxs/ui"
+     xmlns="http://wixtoolset.org/schemas/v4/wxs">
     <Package UpgradeCode="66a6eb5b-1fc2-4b14-a362-5ceec6413308" Name="$(var.ProductName)" Version="$(var.Version)"
              Manufacturer="prometheus-community" Language="1033" Scope="perMachine">
         <SummaryInformation Manufacturer="prometheus-community" Description="$(var.ProductName) $(var.Version) installer" />
@@ -43,6 +43,9 @@
                             Property="OLDERVERSIONBEINGUPGRADED" />
         </Upgrade>
 
+        <CustomAction Id="CheckExtraFlags"
+                      Error="The parameter '--config.file' must not be included in EXTRA_FLAGS. Use CONFIG_FILE instead. Please remove it and try again." />
+
         <CustomAction Id="set_maintenance" Property="MAINTENANCE" Value="true" />
 
         <!-- Set to reinstall all features. -->
@@ -54,12 +57,12 @@
         <CustomAction Id="set_reinstallmode_property"
                       Property="REINSTALLMODE"
                       Value="amus" />
+        <!-- START CUSTOM ACTION FOR CONFIG FILE CREATION -->
         <SetProperty
             Id="CreateConfigFile"
             Value="&quot;[%ComSpec]&quot; /c TYPE NUL >>&quot;[ConfigFile_NonDefault][ConfigFile_Default]&quot;"
             Before="CreateConfigFile"
             Sequence="execute"
-            Condition="ConfigFile_NonDefault OR ConfigFile_Default"
         />
         <CustomAction
             Id="CreateConfigFile"
@@ -69,6 +72,24 @@
             Return="check"
             Impersonate="no"
         />
+        <!-- END CUSTOM ACTION FOR CONFIG FILE CREATION -->
+
+        <!-- START CUSTOM ACTION FOR KILLING THE PROCESS -->
+        <SetProperty
+            Id="KillProcess"
+            Value="&quot;[WindowsFolder]\System32\taskkill.exe&quot; /T /F /IM windows_exporter.exe"
+            Before="KillProcess"
+            Sequence="execute"
+        />
+        <CustomAction
+            Id="KillProcess"
+            BinaryRef="Wix4UtilCA_$(sys.BUILDARCHSHORT)"
+            DllEntry="WixQuietExec"
+            Execute="deferred"
+            Return="ignore"
+            Impersonate="no"
+        />
+        <!-- END CUSTOM ACTION FOR KILLING THE PROCESS -->
 
         <InstallExecuteSequence>
             <!-- Set REINSTALL=all and REINSTALLMODE=amus if the user reruns the
@@ -78,6 +99,10 @@
             <Custom Action="set_reinstall_all_property" Before="set_reinstallmode_property" Condition="MAINTENANCE"/>
             <Custom Action="set_reinstallmode_property" Before="LaunchConditions" Condition="MAINTENANCE"/>
             <Custom Action="CreateConfigFile" Before="InstallServices" Condition="ConfigFile_NonDefault OR ConfigFile_Default" />
+            <Custom Action="KillProcess" Before="RemoveFiles" />
+
+            <Custom Action="CheckExtraFlags" Before="InstallInitialize"
+                    Condition="EXTRA_FLAGS AND (EXTRA_FLAGS&gt;&lt;&quot;--config.file&quot;)" />
         </InstallExecuteSequence>
 
         <Media Id="1" Cabinet="windows_exporter.cab" EmbedCab="yes"  />
@@ -90,9 +115,10 @@
         <SetProperty Id="ExtraFlags" After="InstallFiles" Sequence="execute" Value="[EXTRA_FLAGS]" Condition="EXTRA_FLAGS" />
 
         <Property Id="CONFIG_FILE" Secure="yes" Value="config.yaml" />
-        <SetProperty Id="ConfigFile_NonDefault" After="InstallFiles" Sequence="execute" Value="[CONFIG_FILE]" Condition="CONFIG_FILE AND CONFIG_FILE&lt;&gt;&quot;config.yaml&quot;" />
+        <SetProperty Id="ConfigFile_Remote" After="InstallFiles" Sequence="execute" Value="[CONFIG_FILE]" Condition="CONFIG_FILE AND (CONFIG_FILE&lt;&lt;&quot;http://&quot; OR CONFIG_FILE&lt;&lt;&quot;https://&quot;)" />
+        <SetProperty Id="ConfigFile_NonDefault" After="InstallFiles" Sequence="execute" Value="[CONFIG_FILE]" Condition="CONFIG_FILE AND CONFIG_FILE&lt;&gt;&quot;config.yaml&quot; AND NOT (CONFIG_FILE&lt;&lt;&quot;http://&quot; OR CONFIG_FILE&lt;&lt;&quot;https://&quot;)" />
         <SetProperty Id="ConfigFile_Default" After="InstallFiles" Sequence="execute" Value="[APPLICATIONFOLDER]config.yaml" Condition="CONFIG_FILE=&quot;config.yaml&quot;" />
-        <SetProperty Id="ConfigFileFlag" After="InstallFiles" Sequence="execute" Value="--config.file=&quot;[ConfigFile_NonDefault][ConfigFile_Default]&quot;" Condition="ConfigFile_NonDefault OR ConfigFile_Default" />
+        <SetProperty Id="ConfigFileFlag" After="InstallFiles" Sequence="execute" Value="--config.file=&quot;[ConfigFile_Remote][ConfigFile_NonDefault][ConfigFile_Default]&quot;" Condition="ConfigFile_Remote OR ConfigFile_NonDefault OR ConfigFile_Default" />
 
         <Property Id="LISTEN_PORT" Secure="yes" Value="9182" />
         <SetProperty Id="ListenFlag" After="InstallFiles" Sequence="execute" Value="--web.listen-address [LISTEN_ADDR]:[LISTEN_PORT]" Condition="LISTEN_ADDR&lt;&gt;&quot;&quot; OR LISTEN_PORT&lt;&gt;9182" />

internal/collector/ad/ad.go

@@ -21,7 +21,7 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/mi"
-	"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"
 )
@@ -36,7 +36,8 @@ var ConfigDefaults = Config{}
 type Collector struct {
 	config Config
 
-	perfDataCollector *perfdata.Collector
+	perfDataCollector *pdh.Collector
+	perfDataObject    []perfDataCounterValues
 
 	addressBookClientSessions                           *prometheus.Desc
 	addressBookOperationsTotal                          *prometheus.Desc
@@ -129,156 +130,9 @@ func (c *Collector) Close() error {
 }
 
 func (c *Collector) Build(_ *slog.Logger, _ *mi.Session) error {
-	counters := []string{
-		abANRPerSec,
-		abBrowsesPerSec,
-		abClientSessions,
-		abMatchesPerSec,
-		abPropertyReadsPerSec,
-		abProxyLookupsPerSec,
-		abSearchesPerSec,
-		approximateHighestDNT,
-		atqEstimatedQueueDelay,
-		atqOutstandingQueuedRequests,
-		atqRequestLatency,
-		atqThreadsLDAP,
-		atqThreadsOther,
-		atqThreadsTotal,
-		baseSearchesPerSec,
-		databaseAddsPerSec,
-		databaseDeletesPerSec,
-		databaseModifiesPerSec,
-		databaseRecyclesPerSec,
-		digestBindsPerSec,
-		draHighestUSNCommittedHighPart,
-		draHighestUSNCommittedLowPart,
-		draHighestUSNIssuedHighPart,
-		draHighestUSNIssuedLowPart,
-		draInboundBytesCompressedBetweenSitesAfterCompressionSinceBoot,
-		draInboundBytesCompressedBetweenSitesAfterCompressionPerSec,
-		draInboundBytesCompressedBetweenSitesBeforeCompressionSinceBoot,
-		draInboundBytesCompressedBetweenSitesBeforeCompressionPerSec,
-		draInboundBytesNotCompressedWithinSiteSinceBoot,
-		draInboundBytesNotCompressedWithinSitePerSec,
-		draInboundBytesTotalSinceBoot,
-		draInboundBytesTotalPerSec,
-		draInboundFullSyncObjectsRemaining,
-		draInboundLinkValueUpdatesRemainingInPacket,
-		draInboundObjectUpdatesRemainingInPacket,
-		draInboundObjectsAppliedPerSec,
-		draInboundObjectsFilteredPerSec,
-		draInboundObjectsPerSec,
-		draInboundPropertiesAppliedPerSec,
-		draInboundPropertiesFilteredPerSec,
-		draInboundPropertiesTotalPerSec,
-		draInboundTotalUpdatesRemainingInPacket,
-		draInboundValuesDNsOnlyPerSec,
-		draInboundValuesTotalPerSec,
-		draOutboundBytesCompressedBetweenSitesAfterCompressionSinceBoot,
-		draOutboundBytesCompressedBetweenSitesAfterCompressionPerSec,
-		draOutboundBytesCompressedBetweenSitesBeforeCompressionSinceBoot,
-		draOutboundBytesCompressedBetweenSitesBeforeCompressionPerSec,
-		draOutboundBytesNotCompressedWithinSiteSinceBoot,
-		draOutboundBytesNotCompressedWithinSitePerSec,
-		draOutboundBytesTotalSinceBoot,
-		draOutboundBytesTotalPerSec,
-		draOutboundObjectsFilteredPerSec,
-		draOutboundObjectsPerSec,
-		draOutboundPropertiesPerSec,
-		draOutboundValuesDNsOnlyPerSec,
-		draOutboundValuesTotalPerSec,
-		draPendingReplicationOperations,
-		draPendingReplicationSynchronizations,
-		draSyncFailuresOnSchemaMismatch,
-		draSyncRequestsMade,
-		draSyncRequestsSuccessful,
-		draThreadsGettingNCChanges,
-		draThreadsGettingNCChangesHoldingSemaphore,
-		dsPercentReadsFromDRA,
-		dsPercentReadsFromKCC,
-		dsPercentReadsFromLSA,
-		dsPercentReadsFromNSPI,
-		dsPercentReadsFromNTDSAPI,
-		dsPercentReadsFromSAM,
-		dsPercentReadsOther,
-		dsPercentSearchesFromDRA,
-		dsPercentSearchesFromKCC,
-		dsPercentSearchesFromLDAP,
-		dsPercentSearchesFromLSA,
-		dsPercentSearchesFromNSPI,
-		dsPercentSearchesFromNTDSAPI,
-		dsPercentSearchesFromSAM,
-		dsPercentSearchesOther,
-		dsPercentWritesFromDRA,
-		dsPercentWritesFromKCC,
-		dsPercentWritesFromLDAP,
-		dsPercentWritesFromLSA,
-		dsPercentWritesFromNSPI,
-		dsPercentWritesFromNTDSAPI,
-		dsPercentWritesFromSAM,
-		dsPercentWritesOther,
-		dsClientBindsPerSec,
-		dsClientNameTranslationsPerSec,
-		dsDirectoryReadsPerSec,
-		dsDirectorySearchesPerSec,
-		dsDirectoryWritesPerSec,
-		dsMonitorListSize,
-		dsNameCacheHitRate,
-		dsNotifyQueueSize,
-		dsSearchSubOperationsPerSec,
-		dsSecurityDescriptorPropagationsEvents,
-		dsSecurityDescriptorPropagatorAverageExclusionTime,
-		dsSecurityDescriptorPropagatorRuntimeQueue,
-		dsSecurityDescriptorSubOperationsPerSec,
-		dsServerBindsPerSec,
-		dsServerNameTranslationsPerSec,
-		dsThreadsInUse,
-		externalBindsPerSec,
-		fastBindsPerSec,
-		ldapActiveThreads,
-		ldapBindTime,
-		ldapClientSessions,
-		ldapClosedConnectionsPerSec,
-		ldapNewConnectionsPerSec,
-		ldapNewSSLConnectionsPerSec,
-		ldapSearchesPerSec,
-		ldapSuccessfulBindsPerSec,
-		ldapUDPOperationsPerSec,
-		ldapWritesPerSec,
-		linkValuesCleanedPerSec,
-		negotiatedBindsPerSec,
-		ntlmBindsPerSec,
-		oneLevelSearchesPerSec,
-		phantomsCleanedPerSec,
-		phantomsVisitedPerSec,
-		samAccountGroupEvaluationLatency,
-		samDisplayInformationQueriesPerSec,
-		samDomainLocalGroupMembershipEvaluationsPerSec,
-		samEnumerationsPerSec,
-		samGCEvaluationsPerSec,
-		samGlobalGroupMembershipEvaluationsPerSec,
-		samMachineCreationAttemptsPerSec,
-		samMembershipChangesPerSec,
-		samNonTransitiveMembershipEvaluationsPerSec,
-		samPasswordChangesPerSec,
-		samResourceGroupEvaluationLatency,
-		samSuccessfulComputerCreationsPerSecIncludesAllRequests,
-		samSuccessfulUserCreationsPerSec,
-		samTransitiveMembershipEvaluationsPerSec,
-		samUniversalGroupMembershipEvaluationsPerSec,
-		samUserCreationAttemptsPerSec,
-		simpleBindsPerSec,
-		subtreeSearchesPerSec,
-		tombstonesGarbageCollectedPerSec,
-		tombstonesVisitedPerSec,
-		transitiveOperationsMillisecondsRun,
-		transitiveOperationsPerSec,
-		transitiveSubOperationsPerSec,
-	}
-
 	var err error
 
-	c.perfDataCollector, err = perfdata.NewCollector("DirectoryServices", perfdata.InstancesAll, counters)
+	c.perfDataCollector, err = pdh.NewCollector[perfDataCounterValues](pdh.CounterTypeRaw, "DirectoryServices", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create DirectoryServices collector: %w", err)
 	}
@@ -663,210 +517,204 @@ func (c *Collector) Build(_ *slog.Logger, _ *mi.Session) error {
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
 func (c *Collector) Collect(ch chan<- prometheus.Metric) error {
-	perfData, err := c.perfDataCollector.Collect()
+	err := c.perfDataCollector.Collect(&c.perfDataObject)
 	if err != nil {
 		return fmt.Errorf("failed to collect DirectoryServices (AD) metrics: %w", err)
 	}
 
-	data, ok := perfData["NTDS"]
-
-	if !ok {
-		return fmt.Errorf("failed to collect DirectoryServices (AD) metrics: %w", types.ErrNoData)
-	}
-
 	ch <- prometheus.MustNewConstMetric(
 		c.addressBookOperationsTotal,
 		prometheus.CounterValue,
-		data[abANRPerSec].FirstValue,
+		c.perfDataObject[0].AbANRPerSec,
 		"ambiguous_name_resolution",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.addressBookOperationsTotal,
 		prometheus.CounterValue,
-		data[abBrowsesPerSec].FirstValue,
+		c.perfDataObject[0].AbBrowsesPerSec,
 		"browse",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.addressBookOperationsTotal,
 		prometheus.CounterValue,
-		data[abMatchesPerSec].FirstValue,
+		c.perfDataObject[0].AbMatchesPerSec,
 		"find",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.addressBookOperationsTotal,
 		prometheus.CounterValue,
-		data[abPropertyReadsPerSec].FirstValue,
+		c.perfDataObject[0].AbPropertyReadsPerSec,
 		"property_read",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.addressBookOperationsTotal,
 		prometheus.CounterValue,
-		data[abSearchesPerSec].FirstValue,
+		c.perfDataObject[0].AbSearchesPerSec,
 		"search",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.addressBookOperationsTotal,
 		prometheus.CounterValue,
-		data[abProxyLookupsPerSec].FirstValue,
+		c.perfDataObject[0].AbProxyLookupsPerSec,
 		"proxy_search",
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.addressBookClientSessions,
 		prometheus.GaugeValue,
-		data[abClientSessions].FirstValue,
+		c.perfDataObject[0].AbClientSessions,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.approximateHighestDistinguishedNameTag,
 		prometheus.GaugeValue,
-		data[approximateHighestDNT].FirstValue,
+		c.perfDataObject[0].ApproximateHighestDNT,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.atqEstimatedDelaySeconds,
 		prometheus.GaugeValue,
-		data[atqEstimatedQueueDelay].FirstValue/1000,
+		c.perfDataObject[0].AtqEstimatedQueueDelay/1000,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.atqOutstandingRequests,
 		prometheus.GaugeValue,
-		data[atqOutstandingQueuedRequests].FirstValue,
+		c.perfDataObject[0].AtqOutstandingQueuedRequests,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.atqAverageRequestLatency,
 		prometheus.GaugeValue,
-		data[atqRequestLatency].FirstValue,
+		c.perfDataObject[0].AtqRequestLatency,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.atqCurrentThreads,
 		prometheus.GaugeValue,
-		data[atqThreadsLDAP].FirstValue,
+		c.perfDataObject[0].AtqThreadsLDAP,
 		"ldap",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.atqCurrentThreads,
 		prometheus.GaugeValue,
-		data[atqThreadsOther].FirstValue,
+		c.perfDataObject[0].AtqThreadsOther,
 		"other",
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.searchesTotal,
 		prometheus.CounterValue,
-		data[baseSearchesPerSec].FirstValue,
+		c.perfDataObject[0].BaseSearchesPerSec,
 		"base",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.searchesTotal,
 		prometheus.CounterValue,
-		data[subtreeSearchesPerSec].FirstValue,
+		c.perfDataObject[0].SubtreeSearchesPerSec,
 		"subtree",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.searchesTotal,
 		prometheus.CounterValue,
-		data[oneLevelSearchesPerSec].FirstValue,
+		c.perfDataObject[0].OneLevelSearchesPerSec,
 		"one_level",
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.databaseOperationsTotal,
 		prometheus.CounterValue,
-		data[databaseAddsPerSec].FirstValue,
+		c.perfDataObject[0].DatabaseAddsPerSec,
 		"add",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.databaseOperationsTotal,
 		prometheus.CounterValue,
-		data[databaseDeletesPerSec].FirstValue,
+		c.perfDataObject[0].DatabaseDeletesPerSec,
 		"delete",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.databaseOperationsTotal,
 		prometheus.CounterValue,
-		data[databaseModifiesPerSec].FirstValue,
+		c.perfDataObject[0].DatabaseModifiesPerSec,
 		"modify",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.databaseOperationsTotal,
 		prometheus.CounterValue,
-		data[databaseRecyclesPerSec].FirstValue,
+		c.perfDataObject[0].DatabaseRecyclesPerSec,
 		"recycle",
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.bindsTotal,
 		prometheus.CounterValue,
-		data[digestBindsPerSec].FirstValue,
+		c.perfDataObject[0].DigestBindsPerSec,
 		"digest",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.bindsTotal,
 		prometheus.CounterValue,
-		data[dsClientBindsPerSec].FirstValue,
+		c.perfDataObject[0].DsClientBindsPerSec,
 		"ds_client",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.bindsTotal,
 		prometheus.CounterValue,
-		data[dsServerBindsPerSec].FirstValue,
+		c.perfDataObject[0].DsServerBindsPerSec,
 		"ds_server",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.bindsTotal,
 		prometheus.CounterValue,
-		data[externalBindsPerSec].FirstValue,
+		c.perfDataObject[0].ExternalBindsPerSec,
 		"external",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.bindsTotal,
 		prometheus.CounterValue,
-		data[fastBindsPerSec].FirstValue,
+		c.perfDataObject[0].FastBindsPerSec,
 		"fast",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.bindsTotal,
 		prometheus.CounterValue,
-		data[negotiatedBindsPerSec].FirstValue,
+		c.perfDataObject[0].NegotiatedBindsPerSec,
 		"negotiate",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.bindsTotal,
 		prometheus.CounterValue,
-		data[ntlmBindsPerSec].FirstValue,
+		c.perfDataObject[0].NTLMBindsPerSec,
 		"ntlm",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.bindsTotal,
 		prometheus.CounterValue,
-		data[simpleBindsPerSec].FirstValue,
+		c.perfDataObject[0].SimpleBindsPerSec,
 		"simple",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.bindsTotal,
 		prometheus.CounterValue,
-		data[ldapSuccessfulBindsPerSec].FirstValue,
+		c.perfDataObject[0].LdapSuccessfulBindsPerSec,
 		"ldap",
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.replicationHighestUsn,
 		prometheus.CounterValue,
-		float64(uint64(data[draHighestUSNCommittedHighPart].FirstValue)<<32)+data[draHighestUSNCommittedLowPart].FirstValue,
+		float64(uint64(c.perfDataObject[0].DRAHighestUSNCommittedHighPart)<<32)+c.perfDataObject[0].DRAHighestUSNCommittedLowPart,
 		"committed",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.replicationHighestUsn,
 		prometheus.CounterValue,
-		float64(uint64(data[draHighestUSNIssuedHighPart].FirstValue)<<32)+data[draHighestUSNIssuedLowPart].FirstValue,
+		float64(uint64(c.perfDataObject[0].DRAHighestUSNIssuedHighPart)<<32)+c.perfDataObject[0].DRAHighestUSNIssuedLowPart,
 		"issued",
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.interSiteReplicationDataBytesTotal,
 		prometheus.CounterValue,
-		data[draInboundBytesCompressedBetweenSitesAfterCompressionPerSec].FirstValue,
+		c.perfDataObject[0].DRAInboundBytesCompressedBetweenSitesAfterCompressionPerSec,
 		"inbound",
 	)
 	// The pre-compression perfData size seems to have little value? Skipping for now
@@ -879,7 +727,7 @@ func (c *Collector) Collect(ch chan<- prometheus.Metric) error {
 	ch <- prometheus.MustNewConstMetric(
 		c.interSiteReplicationDataBytesTotal,
 		prometheus.CounterValue,
-		data[draOutboundBytesCompressedBetweenSitesAfterCompressionPerSec].FirstValue,
+		c.perfDataObject[0].DRAOutboundBytesCompressedBetweenSitesAfterCompressionPerSec,
 		"outbound",
 	)
 	// ch <- prometheus.MustNewConstMetric(
@@ -891,270 +739,270 @@ func (c *Collector) Collect(ch chan<- prometheus.Metric) error {
 	ch <- prometheus.MustNewConstMetric(
 		c.intraSiteReplicationDataBytesTotal,
 		prometheus.CounterValue,
-		data[draInboundBytesNotCompressedWithinSitePerSec].FirstValue,
+		c.perfDataObject[0].DRAInboundBytesNotCompressedWithinSitePerSec,
 		"inbound",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.intraSiteReplicationDataBytesTotal,
 		prometheus.CounterValue,
-		data[draOutboundBytesNotCompressedWithinSitePerSec].FirstValue,
+		c.perfDataObject[0].DRAOutboundBytesNotCompressedWithinSitePerSec,
 		"outbound",
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.replicationInboundSyncObjectsRemaining,
 		prometheus.GaugeValue,
-		data[draInboundFullSyncObjectsRemaining].FirstValue,
+		c.perfDataObject[0].DRAInboundFullSyncObjectsRemaining,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.replicationInboundLinkValueUpdatesRemaining,
 		prometheus.GaugeValue,
-		data[draInboundLinkValueUpdatesRemainingInPacket].FirstValue,
+		c.perfDataObject[0].DRAInboundLinkValueUpdatesRemainingInPacket,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.replicationInboundObjectsUpdatedTotal,
 		prometheus.CounterValue,
-		data[draInboundObjectsAppliedPerSec].FirstValue,
+		c.perfDataObject[0].DRAInboundObjectsAppliedPerSec,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.replicationInboundObjectsFilteredTotal,
 		prometheus.CounterValue,
-		data[draInboundObjectsFilteredPerSec].FirstValue,
+		c.perfDataObject[0].DRAInboundObjectsFilteredPerSec,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.replicationInboundPropertiesUpdatedTotal,
 		prometheus.CounterValue,
-		data[draInboundPropertiesAppliedPerSec].FirstValue,
+		c.perfDataObject[0].DRAInboundPropertiesAppliedPerSec,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.replicationInboundPropertiesFilteredTotal,
 		prometheus.CounterValue,
-		data[draInboundPropertiesFilteredPerSec].FirstValue,
+		c.perfDataObject[0].DRAInboundPropertiesFilteredPerSec,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.replicationPendingOperations,
 		prometheus.GaugeValue,
-		data[draPendingReplicationOperations].FirstValue,
+		c.perfDataObject[0].DRAPendingReplicationOperations,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.replicationPendingSynchronizations,
 		prometheus.GaugeValue,
-		data[draPendingReplicationSynchronizations].FirstValue,
+		c.perfDataObject[0].DRAPendingReplicationSynchronizations,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.replicationSyncRequestsTotal,
 		prometheus.CounterValue,
-		data[draSyncRequestsMade].FirstValue,
+		c.perfDataObject[0].DRASyncRequestsMade,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.replicationSyncRequestsSuccessTotal,
 		prometheus.CounterValue,
-		data[draSyncRequestsSuccessful].FirstValue,
+		c.perfDataObject[0].DRASyncRequestsSuccessful,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.replicationSyncRequestsSchemaMismatchFailureTotal,
 		prometheus.CounterValue,
-		data[draSyncFailuresOnSchemaMismatch].FirstValue,
+		c.perfDataObject[0].DRASyncFailuresOnSchemaMismatch,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.nameTranslationsTotal,
 		prometheus.CounterValue,
-		data[dsClientNameTranslationsPerSec].FirstValue,
+		c.perfDataObject[0].DsClientNameTranslationsPerSec,
 		"client",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.nameTranslationsTotal,
 		prometheus.CounterValue,
-		data[dsServerNameTranslationsPerSec].FirstValue,
+		c.perfDataObject[0].DsServerNameTranslationsPerSec,
 		"server",
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.changeMonitorsRegistered,
 		prometheus.GaugeValue,
-		data[dsMonitorListSize].FirstValue,
+		c.perfDataObject[0].DsMonitorListSize,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.changeMonitorUpdatesPending,
 		prometheus.GaugeValue,
-		data[dsNotifyQueueSize].FirstValue,
+		c.perfDataObject[0].DsNotifyQueueSize,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.nameCacheHitsTotal,
 		prometheus.CounterValue,
-		data[dsNameCacheHitRate].FirstValue,
+		c.perfDataObject[0].DsNameCacheHitRate,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.nameCacheLookupsTotal,
 		prometheus.CounterValue,
-		data[dsNameCacheHitRate].SecondValue,
+		c.perfDataObject[0].DsNameCacheHitRateSecondValue,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.directoryOperationsTotal,
 		prometheus.CounterValue,
-		data[dsPercentReadsFromDRA].FirstValue,
+		c.perfDataObject[0].DsPercentReadsFromDRA,
 		"read",
 		"replication_agent",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.directoryOperationsTotal,
 		prometheus.CounterValue,
-		data[dsPercentReadsFromKCC].FirstValue,
+		c.perfDataObject[0].DsPercentReadsFromKCC,
 		"read",
 		"knowledge_consistency_checker",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.directoryOperationsTotal,
 		prometheus.CounterValue,
-		data[dsPercentReadsFromLSA].FirstValue,
+		c.perfDataObject[0].DsPercentReadsFromLSA,
 		"read",
 		"local_security_authority",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.directoryOperationsTotal,
 		prometheus.CounterValue,
-		data[dsPercentReadsFromNSPI].FirstValue,
+		c.perfDataObject[0].DsPercentReadsFromNSPI,
 		"read",
 		"name_service_provider_interface",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.directoryOperationsTotal,
 		prometheus.CounterValue,
-		data[dsPercentReadsFromNTDSAPI].FirstValue,
+		c.perfDataObject[0].DsPercentReadsFromNTDSAPI,
 		"read",
 		"directory_service_api",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.directoryOperationsTotal,
 		prometheus.CounterValue,
-		data[dsPercentReadsFromSAM].FirstValue,
+		c.perfDataObject[0].DsPercentReadsFromSAM,
 		"read",
 		"security_account_manager",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.directoryOperationsTotal,
 		prometheus.CounterValue,
-		data[dsPercentReadsOther].FirstValue,
+		c.perfDataObject[0].DsPercentReadsOther,
 		"read",
 		"other",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.directoryOperationsTotal,
 		prometheus.CounterValue,
-		data[dsPercentSearchesFromDRA].FirstValue,
+		c.perfDataObject[0].DsPercentSearchesFromDRA,
 		"search",
 		"replication_agent",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.directoryOperationsTotal,
 		prometheus.CounterValue,
-		data[dsPercentSearchesFromKCC].FirstValue,
+		c.perfDataObject[0].DsPercentSearchesFromKCC,
 		"search",
 		"knowledge_consistency_checker",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.directoryOperationsTotal,
 		prometheus.CounterValue,
-		data[dsPercentSearchesFromLDAP].FirstValue,
+		c.perfDataObject[0].DsPercentSearchesFromLDAP,
 		"search",
 		"ldap",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.directoryOperationsTotal,
 		prometheus.CounterValue,
-		data[dsPercentSearchesFromLSA].FirstValue,
+		c.perfDataObject[0].DsPercentSearchesFromLSA,
 		"search",
 		"local_security_authority",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.directoryOperationsTotal,
 		prometheus.CounterValue,
-		data[dsPercentSearchesFromNSPI].FirstValue,
+		c.perfDataObject[0].DsPercentSearchesFromNSPI,
 		"search",
 		"name_service_provider_interface",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.directoryOperationsTotal,
 		prometheus.CounterValue,
-		data[dsPercentSearchesFromNTDSAPI].FirstValue,
+		c.perfDataObject[0].DsPercentSearchesFromNTDSAPI,
 		"search",
 		"directory_service_api",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.directoryOperationsTotal,
 		prometheus.CounterValue,
-		data[dsPercentSearchesFromSAM].FirstValue,
+		c.perfDataObject[0].DsPercentSearchesFromSAM,
 		"search",
 		"security_account_manager",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.directoryOperationsTotal,
 		prometheus.CounterValue,
-		data[dsPercentSearchesOther].FirstValue,
+		c.perfDataObject[0].DsPercentSearchesOther,
 		"search",
 		"other",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.directoryOperationsTotal,
 		prometheus.CounterValue,
-		data[dsPercentWritesFromDRA].FirstValue,
+		c.perfDataObject[0].DsPercentWritesFromDRA,
 		"write",
 		"replication_agent",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.directoryOperationsTotal,
 		prometheus.CounterValue,
-		data[dsPercentWritesFromKCC].FirstValue,
+		c.perfDataObject[0].DsPercentWritesFromKCC,
 		"write",
 		"knowledge_consistency_checker",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.directoryOperationsTotal,
 		prometheus.CounterValue,
-		data[dsPercentWritesFromLDAP].FirstValue,
+		c.perfDataObject[0].DsPercentWritesFromLDAP,
 		"write",
 		"ldap",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.directoryOperationsTotal,
 		prometheus.CounterValue,
-		data[dsPercentSearchesFromLSA].FirstValue,
+		c.perfDataObject[0].DsPercentSearchesFromLSA,
 		"write",
 		"local_security_authority",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.directoryOperationsTotal,
 		prometheus.CounterValue,
-		data[dsPercentWritesFromNSPI].FirstValue,
+		c.perfDataObject[0].DsPercentWritesFromNSPI,
 		"write",
 		"name_service_provider_interface",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.directoryOperationsTotal,
 		prometheus.CounterValue,
-		data[dsPercentWritesFromNTDSAPI].FirstValue,
+		c.perfDataObject[0].DsPercentWritesFromNTDSAPI,
 		"write",
 		"directory_service_api",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.directoryOperationsTotal,
 		prometheus.CounterValue,
-		data[dsPercentWritesFromSAM].FirstValue,
+		c.perfDataObject[0].DsPercentWritesFromSAM,
 		"write",
 		"security_account_manager",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.directoryOperationsTotal,
 		prometheus.CounterValue,
-		data[dsPercentWritesOther].FirstValue,
+		c.perfDataObject[0].DsPercentWritesOther,
 		"write",
 		"other",
 	)
@@ -1162,207 +1010,207 @@ func (c *Collector) Collect(ch chan<- prometheus.Metric) error {
 	ch <- prometheus.MustNewConstMetric(
 		c.directorySearchSubOperationsTotal,
 		prometheus.CounterValue,
-		data[dsSearchSubOperationsPerSec].FirstValue,
+		c.perfDataObject[0].DsSearchSubOperationsPerSec,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.securityDescriptorPropagationEventsTotal,
 		prometheus.CounterValue,
-		data[dsSecurityDescriptorSubOperationsPerSec].FirstValue,
+		c.perfDataObject[0].DsSecurityDescriptorSubOperationsPerSec,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.securityDescriptorPropagationEventsQueued,
 		prometheus.GaugeValue,
-		data[dsSecurityDescriptorPropagationsEvents].FirstValue,
+		c.perfDataObject[0].DsSecurityDescriptorPropagationsEvents,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.securityDescriptorPropagationAccessWaitTotalSeconds,
 		prometheus.GaugeValue,
-		data[dsSecurityDescriptorPropagatorAverageExclusionTime].FirstValue,
+		c.perfDataObject[0].DsSecurityDescriptorPropagatorAverageExclusionTime,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.securityDescriptorPropagationItemsQueuedTotal,
 		prometheus.CounterValue,
-		data[dsSecurityDescriptorPropagatorRuntimeQueue].FirstValue,
+		c.perfDataObject[0].DsSecurityDescriptorPropagatorRuntimeQueue,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.directoryServiceThreads,
 		prometheus.GaugeValue,
-		data[dsThreadsInUse].FirstValue,
+		c.perfDataObject[0].DsThreadsInUse,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.ldapClosedConnectionsTotal,
 		prometheus.CounterValue,
-		data[ldapClosedConnectionsPerSec].FirstValue,
+		c.perfDataObject[0].LdapClosedConnectionsPerSec,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.ldapOpenedConnectionsTotal,
 		prometheus.CounterValue,
-		data[ldapNewConnectionsPerSec].FirstValue,
+		c.perfDataObject[0].LdapNewConnectionsPerSec,
 		"ldap",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.ldapOpenedConnectionsTotal,
 		prometheus.CounterValue,
-		data[ldapNewSSLConnectionsPerSec].FirstValue,
+		c.perfDataObject[0].LdapNewSSLConnectionsPerSec,
 		"ldaps",
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.ldapActiveThreads,
 		prometheus.GaugeValue,
-		data[ldapActiveThreads].FirstValue,
+		c.perfDataObject[0].LdapActiveThreads,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.ldapLastBindTimeSeconds,
 		prometheus.GaugeValue,
-		data[ldapBindTime].FirstValue/1000,
+		c.perfDataObject[0].LdapBindTime/1000,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.ldapSearchesTotal,
 		prometheus.CounterValue,
-		data[ldapSearchesPerSec].FirstValue,
+		c.perfDataObject[0].LdapSearchesPerSec,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.ldapUdpOperationsTotal,
 		prometheus.CounterValue,
-		data[ldapUDPOperationsPerSec].FirstValue,
+		c.perfDataObject[0].LdapUDPOperationsPerSec,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.ldapWritesTotal,
 		prometheus.CounterValue,
-		data[ldapWritesPerSec].FirstValue,
+		c.perfDataObject[0].LdapWritesPerSec,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.ldapClientSessions,
 		prometheus.GaugeValue,
-		data[ldapClientSessions].FirstValue,
+		c.perfDataObject[0].LdapClientSessions,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.linkValuesCleanedTotal,
 		prometheus.CounterValue,
-		data[linkValuesCleanedPerSec].FirstValue,
+		c.perfDataObject[0].LinkValuesCleanedPerSec,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.phantomObjectsCleanedTotal,
 		prometheus.CounterValue,
-		data[phantomsCleanedPerSec].FirstValue,
+		c.perfDataObject[0].PhantomsCleanedPerSec,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.phantomObjectsVisitedTotal,
 		prometheus.CounterValue,
-		data[phantomsVisitedPerSec].FirstValue,
+		c.perfDataObject[0].PhantomsVisitedPerSec,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.samGroupMembershipEvaluationsTotal,
 		prometheus.CounterValue,
-		data[samGlobalGroupMembershipEvaluationsPerSec].FirstValue,
+		c.perfDataObject[0].SamGlobalGroupMembershipEvaluationsPerSec,
 		"global",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.samGroupMembershipEvaluationsTotal,
 		prometheus.CounterValue,
-		data[samDomainLocalGroupMembershipEvaluationsPerSec].FirstValue,
+		c.perfDataObject[0].SamDomainLocalGroupMembershipEvaluationsPerSec,
 		"domain_local",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.samGroupMembershipEvaluationsTotal,
 		prometheus.CounterValue,
-		data[samUniversalGroupMembershipEvaluationsPerSec].FirstValue,
+		c.perfDataObject[0].SamUniversalGroupMembershipEvaluationsPerSec,
 		"universal",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.samGroupMembershipGlobalCatalogEvaluationsTotal,
 		prometheus.CounterValue,
-		data[samGCEvaluationsPerSec].FirstValue,
+		c.perfDataObject[0].SamGCEvaluationsPerSec,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.samGroupMembershipEvaluationsNonTransitiveTotal,
 		prometheus.CounterValue,
-		data[samNonTransitiveMembershipEvaluationsPerSec].FirstValue,
+		c.perfDataObject[0].SamNonTransitiveMembershipEvaluationsPerSec,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.samGroupMembershipEvaluationsTransitiveTotal,
 		prometheus.CounterValue,
-		data[samTransitiveMembershipEvaluationsPerSec].FirstValue,
+		c.perfDataObject[0].SamTransitiveMembershipEvaluationsPerSec,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.samGroupEvaluationLatency,
 		prometheus.GaugeValue,
-		data[samAccountGroupEvaluationLatency].FirstValue,
+		c.perfDataObject[0].SamAccountGroupEvaluationLatency,
 		"account_group",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.samGroupEvaluationLatency,
 		prometheus.GaugeValue,
-		data[samResourceGroupEvaluationLatency].FirstValue,
+		c.perfDataObject[0].SamResourceGroupEvaluationLatency,
 		"resource_group",
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.samComputerCreationRequestsTotal,
 		prometheus.CounterValue,
-		data[samSuccessfulComputerCreationsPerSecIncludesAllRequests].FirstValue,
+		c.perfDataObject[0].SamSuccessfulComputerCreationsPerSecIncludesAllRequests,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.samComputerCreationSuccessfulRequestsTotal,
 		prometheus.CounterValue,
-		data[samMachineCreationAttemptsPerSec].FirstValue,
+		c.perfDataObject[0].SamMachineCreationAttemptsPerSec,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.samUserCreationRequestsTotal,
 		prometheus.CounterValue,
-		data[samUserCreationAttemptsPerSec].FirstValue,
+		c.perfDataObject[0].SamUserCreationAttemptsPerSec,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.samUserCreationSuccessfulRequestsTotal,
 		prometheus.CounterValue,
-		data[samSuccessfulUserCreationsPerSec].FirstValue,
+		c.perfDataObject[0].SamSuccessfulUserCreationsPerSec,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.samQueryDisplayRequestsTotal,
 		prometheus.CounterValue,
-		data[samDisplayInformationQueriesPerSec].FirstValue,
+		c.perfDataObject[0].SamDisplayInformationQueriesPerSec,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.samEnumerationsTotal,
 		prometheus.CounterValue,
-		data[samEnumerationsPerSec].FirstValue,
+		c.perfDataObject[0].SamEnumerationsPerSec,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.samMembershipChangesTotal,
 		prometheus.CounterValue,
-		data[samMembershipChangesPerSec].FirstValue,
+		c.perfDataObject[0].SamMembershipChangesPerSec,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.samPasswordChangesTotal,
 		prometheus.CounterValue,
-		data[samPasswordChangesPerSec].FirstValue,
+		c.perfDataObject[0].SamPasswordChangesPerSec,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.tombstonesObjectsCollectedTotal,
 		prometheus.CounterValue,
-		data[tombstonesGarbageCollectedPerSec].FirstValue,
+		c.perfDataObject[0].TombstonesGarbageCollectedPerSec,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.tombstonesObjectsVisitedTotal,
 		prometheus.CounterValue,
-		data[tombstonesVisitedPerSec].FirstValue,
+		c.perfDataObject[0].TombstonesVisitedPerSec,
 	)
 
 	return nil

internal/collector/ad/ad_test.go

@@ -25,3 +25,7 @@ import (
 func BenchmarkCollector(b *testing.B) {
 	testutils.FuncBenchmarkCollector(b, ad.Name, ad.NewWithFlags)
 }
+
+func TestCollector(t *testing.T) {
+	testutils.TestCollector(t, ad.New, nil)
+}

internal/collector/ad/const.go

@@ -1,222 +0,0 @@
-// Copyright 2024 The Prometheus Authors
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//go:build windows
-
-package ad
-
-const (
-	abANRPerSec                                                      = "AB ANR/sec"
-	abBrowsesPerSec                                                  = "AB Browses/sec"
-	abClientSessions                                                 = "AB Client Sessions"
-	abMatchesPerSec                                                  = "AB Matches/sec"
-	abPropertyReadsPerSec                                            = "AB Property Reads/sec"
-	abProxyLookupsPerSec                                             = "AB Proxy Lookups/sec"
-	abSearchesPerSec                                                 = "AB Searches/sec"
-	approximateHighestDNT                                            = "Approximate highest DNT"
-	atqEstimatedQueueDelay                                           = "ATQ Estimated Queue Delay"
-	atqOutstandingQueuedRequests                                     = "ATQ Outstanding Queued Requests"
-	_                                                                = "ATQ Queue Latency"
-	atqRequestLatency                                                = "ATQ Request Latency"
-	atqThreadsLDAP                                                   = "ATQ Threads LDAP"
-	atqThreadsOther                                                  = "ATQ Threads Other"
-	atqThreadsTotal                                                  = "ATQ Threads Total"
-	baseSearchesPerSec                                               = "Base searches/sec"
-	databaseAddsPerSec                                               = "Database adds/sec"
-	databaseDeletesPerSec                                            = "Database deletes/sec"
-	databaseModifiesPerSec                                           = "Database modifys/sec"
-	databaseRecyclesPerSec                                           = "Database recycles/sec"
-	digestBindsPerSec                                                = "Digest Binds/sec"
-	_                                                                = "DirSync session throttling rate"
-	_                                                                = "DirSync sessions in progress"
-	draHighestUSNCommittedHighPart                                   = "DRA Highest USN Committed (High part)"
-	draHighestUSNCommittedLowPart                                    = "DRA Highest USN Committed (Low part)"
-	draHighestUSNIssuedHighPart                                      = "DRA Highest USN Issued (High part)"
-	draHighestUSNIssuedLowPart                                       = "DRA Highest USN Issued (Low part)"
-	draInboundBytesCompressedBetweenSitesAfterCompressionSinceBoot   = "DRA Inbound Bytes Compressed (Between Sites, After Compression) Since Boot"
-	draInboundBytesCompressedBetweenSitesAfterCompressionPerSec      = "DRA Inbound Bytes Compressed (Between Sites, After Compression)/sec"
-	draInboundBytesCompressedBetweenSitesBeforeCompressionSinceBoot  = "DRA Inbound Bytes Compressed (Between Sites, Before Compression) Since Boot"
-	draInboundBytesCompressedBetweenSitesBeforeCompressionPerSec     = "DRA Inbound Bytes Compressed (Between Sites, Before Compression)/sec"
-	draInboundBytesNotCompressedWithinSiteSinceBoot                  = "DRA Inbound Bytes Not Compressed (Within Site) Since Boot"
-	draInboundBytesNotCompressedWithinSitePerSec                     = "DRA Inbound Bytes Not Compressed (Within Site)/sec"
-	draInboundBytesTotalSinceBoot                                    = "DRA Inbound Bytes Total Since Boot"
-	draInboundBytesTotalPerSec                                       = "DRA Inbound Bytes Total/sec"
-	draInboundFullSyncObjectsRemaining                               = "DRA Inbound Full Sync Objects Remaining"
-	draInboundLinkValueUpdatesRemainingInPacket                      = "DRA Inbound Link Value Updates Remaining in Packet"
-	_                                                                = "DRA Inbound Link Values/sec"
-	draInboundObjectUpdatesRemainingInPacket                         = "DRA Inbound Object Updates Remaining in Packet"
-	draInboundObjectsAppliedPerSec                                   = "DRA Inbound Objects Applied/sec"
-	draInboundObjectsFilteredPerSec                                  = "DRA Inbound Objects Filtered/sec"
-	draInboundObjectsPerSec                                          = "DRA Inbound Objects/sec"
-	draInboundPropertiesAppliedPerSec                                = "DRA Inbound Properties Applied/sec"
-	draInboundPropertiesFilteredPerSec                               = "DRA Inbound Properties Filtered/sec"
-	draInboundPropertiesTotalPerSec                                  = "DRA Inbound Properties Total/sec"
-	_                                                                = "DRA Inbound Sync Link Deletion/sec"
-	draInboundTotalUpdatesRemainingInPacket                          = "DRA Inbound Total Updates Remaining in Packet"
-	draInboundValuesDNsOnlyPerSec                                    = "DRA Inbound Values (DNs only)/sec"
-	draInboundValuesTotalPerSec                                      = "DRA Inbound Values Total/sec"
-	_                                                                = "DRA number of NC replication calls since boot"
-	_                                                                = "DRA number of successful NC replication calls since boot"
-	draOutboundBytesCompressedBetweenSitesAfterCompressionSinceBoot  = "DRA Outbound Bytes Compressed (Between Sites, After Compression) Since Boot"
-	draOutboundBytesCompressedBetweenSitesAfterCompressionPerSec     = "DRA Outbound Bytes Compressed (Between Sites, After Compression)/sec"
-	draOutboundBytesCompressedBetweenSitesBeforeCompressionSinceBoot = "DRA Outbound Bytes Compressed (Between Sites, Before Compression) Since Boot"
-	draOutboundBytesCompressedBetweenSitesBeforeCompressionPerSec    = "DRA Outbound Bytes Compressed (Between Sites, Before Compression)/sec"
-	draOutboundBytesNotCompressedWithinSiteSinceBoot                 = "DRA Outbound Bytes Not Compressed (Within Site) Since Boot"
-	draOutboundBytesNotCompressedWithinSitePerSec                    = "DRA Outbound Bytes Not Compressed (Within Site)/sec"
-	draOutboundBytesTotalSinceBoot                                   = "DRA Outbound Bytes Total Since Boot"
-	draOutboundBytesTotalPerSec                                      = "DRA Outbound Bytes Total/sec"
-	draOutboundObjectsFilteredPerSec                                 = "DRA Outbound Objects Filtered/sec"
-	draOutboundObjectsPerSec                                         = "DRA Outbound Objects/sec"
-	draOutboundPropertiesPerSec                                      = "DRA Outbound Properties/sec"
-	draOutboundValuesDNsOnlyPerSec                                   = "DRA Outbound Values (DNs only)/sec"
-	draOutboundValuesTotalPerSec                                     = "DRA Outbound Values Total/sec"
-	draPendingReplicationOperations                                  = "DRA Pending Replication Operations"
-	draPendingReplicationSynchronizations                            = "DRA Pending Replication Synchronizations"
-	draSyncFailuresOnSchemaMismatch                                  = "DRA Sync Failures on Schema Mismatch"
-	draSyncRequestsMade                                              = "DRA Sync Requests Made"
-	draSyncRequestsSuccessful                                        = "DRA Sync Requests Successful"
-	draThreadsGettingNCChanges                                       = "DRA Threads Getting NC Changes"
-	draThreadsGettingNCChangesHoldingSemaphore                       = "DRA Threads Getting NC Changes Holding Semaphore"
-	_                                                                = "DRA total number of Busy failures since boot"
-	_                                                                = "DRA total number of MissingParent failures since boot"
-	_                                                                = "DRA total number of NotEnoughAttrs/MissingObject failures since boot"
-	_                                                                = "DRA total number of Preempted failures since boot"
-	_                                                                = "DRA total time of applying replication package since boot"
-	_                                                                = "DRA total time of NC replication calls since boot"
-	_                                                                = "DRA total time of successful NC replication calls since boot"
-	_                                                                = "DRA total time of successfully applying replication package since boot"
-	_                                                                = "DRA total time on waiting async replication packages since boot"
-	_                                                                = "DRA total time on waiting sync replication packages since boot"
-	dsPercentReadsFromDRA                                            = "DS % Reads from DRA"
-	dsPercentReadsFromKCC                                            = "DS % Reads from KCC"
-	dsPercentReadsFromLSA                                            = "DS % Reads from LSA"
-	dsPercentReadsFromNSPI                                           = "DS % Reads from NSPI"
-	dsPercentReadsFromNTDSAPI                                        = "DS % Reads from NTDSAPI"
-	dsPercentReadsFromSAM                                            = "DS % Reads from SAM"
-	dsPercentReadsOther                                              = "DS % Reads Other"
-	dsPercentSearchesFromDRA                                         = "DS % Searches from DRA"
-	dsPercentSearchesFromKCC                                         = "DS % Searches from KCC"
-	dsPercentSearchesFromLDAP                                        = "DS % Searches from LDAP"
-	dsPercentSearchesFromLSA                                         = "DS % Searches from LSA"
-	dsPercentSearchesFromNSPI                                        = "DS % Searches from NSPI"
-	dsPercentSearchesFromNTDSAPI                                     = "DS % Searches from NTDSAPI"
-	dsPercentSearchesFromSAM                                         = "DS % Searches from SAM"
-	dsPercentSearchesOther                                           = "DS % Searches Other"
-	dsPercentWritesFromDRA                                           = "DS % Writes from DRA"
-	dsPercentWritesFromKCC                                           = "DS % Writes from KCC"
-	dsPercentWritesFromLDAP                                          = "DS % Writes from LDAP"
-	dsPercentWritesFromLSA                                           = "DS % Writes from LSA"
-	dsPercentWritesFromNSPI                                          = "DS % Writes from NSPI"
-	dsPercentWritesFromNTDSAPI                                       = "DS % Writes from NTDSAPI"
-	dsPercentWritesFromSAM                                           = "DS % Writes from SAM"
-	dsPercentWritesOther                                             = "DS % Writes Other"
-	dsClientBindsPerSec                                              = "DS Client Binds/sec"
-	dsClientNameTranslationsPerSec                                   = "DS Client Name Translations/sec"
-	dsDirectoryReadsPerSec                                           = "DS Directory Reads/sec"
-	dsDirectorySearchesPerSec                                        = "DS Directory Searches/sec"
-	dsDirectoryWritesPerSec                                          = "DS Directory Writes/sec"
-	dsMonitorListSize                                                = "DS Monitor List Size"
-	dsNameCacheHitRate                                               = "DS Name Cache hit rate"
-	dsNotifyQueueSize                                                = "DS Notify Queue Size"
-	dsSearchSubOperationsPerSec                                      = "DS Search sub-operations/sec"
-	dsSecurityDescriptorPropagationsEvents                           = "DS Security Descriptor Propagations Events"
-	dsSecurityDescriptorPropagatorAverageExclusionTime               = "DS Security Descriptor Propagator Average Exclusion Time"
-	dsSecurityDescriptorPropagatorRuntimeQueue                       = "DS Security Descriptor Propagator Runtime Queue"
-	dsSecurityDescriptorSubOperationsPerSec                          = "DS Security Descriptor sub-operations/sec"
-	dsServerBindsPerSec                                              = "DS Server Binds/sec"
-	dsServerNameTranslationsPerSec                                   = "DS Server Name Translations/sec"
-	dsThreadsInUse                                                   = "DS Threads in Use"
-	_                                                                = "Error eventlogs since boot"
-	_                                                                = "Error events since boot"
-	externalBindsPerSec                                              = "External Binds/sec"
-	fastBindsPerSec                                                  = "Fast Binds/sec"
-	_                                                                = "Fatal events since boot"
-	_                                                                = "Info eventlogs since boot"
-	ldapActiveThreads                                                = "LDAP Active Threads"
-	_                                                                = "LDAP Add Operations"
-	_                                                                = "LDAP Add Operations/sec"
-	_                                                                = "LDAP batch slots available"
-	ldapBindTime                                                     = "LDAP Bind Time"
-	_                                                                = "LDAP busy retries"
-	_                                                                = "LDAP busy retries/sec"
-	ldapClientSessions                                               = "LDAP Client Sessions"
-	ldapClosedConnectionsPerSec                                      = "LDAP Closed Connections/sec"
-	_                                                                = "LDAP Delete Operations"
-	_                                                                = "LDAP Delete Operations/sec"
-	_                                                                = "LDAP Modify DN Operations"
-	_                                                                = "LDAP Modify DN Operations/sec"
-	_                                                                = "LDAP Modify Operations"
-	_                                                                = "LDAP Modify Operations/sec"
-	ldapNewConnectionsPerSec                                         = "LDAP New Connections/sec"
-	ldapNewSSLConnectionsPerSec                                      = "LDAP New SSL Connections/sec"
-	_                                                                = "LDAP Outbound Bytes"
-	_                                                                = "LDAP Outbound Bytes/sec"
-	_                                                                = "LDAP Page Search Cache entries count"
-	_                                                                = "LDAP Page Search Cache size"
-	ldapSearchesPerSec                                               = "LDAP Searches/sec"
-	ldapSuccessfulBindsPerSec                                        = "LDAP Successful Binds/sec"
-	_                                                                = "LDAP Threads Sleeping on BUSY"
-	ldapUDPOperationsPerSec                                          = "LDAP UDP operations/sec"
-	ldapWritesPerSec                                                 = "LDAP Writes/sec"
-	linkValuesCleanedPerSec                                          = "Link Values Cleaned/sec"
-	_                                                                = "Links added"
-	_                                                                = "Links added/sec"
-	_                                                                = "Links visited"
-	_                                                                = "Links visited/sec"
-	_                                                                = "Logical link deletes"
-	_                                                                = "Logical link deletes/sec"
-	negotiatedBindsPerSec                                            = "Negotiated Binds/sec"
-	ntlmBindsPerSec                                                  = "NTLM Binds/sec"
-	_                                                                = "Objects returned"
-	_                                                                = "Objects returned/sec"
-	_                                                                = "Objects visited"
-	_                                                                = "Objects visited/sec"
-	oneLevelSearchesPerSec                                           = "Onelevel searches/sec"
-	_                                                                = "PDC failed password update notifications"
-	_                                                                = "PDC password update notifications/sec"
-	_                                                                = "PDC successful password update notifications"
-	phantomsCleanedPerSec                                            = "Phantoms Cleaned/sec"
-	phantomsVisitedPerSec                                            = "Phantoms Visited/sec"
-	_                                                                = "Physical link deletes"
-	_                                                                = "Physical link deletes/sec"
-	_                                                                = "Replicate Single Object operations"
-	_                                                                = "Replicate Single Object operations/sec"
-	_                                                                = "RID Pool invalidations since boot"
-	_                                                                = "RID Pool request failures since boot"
-	_                                                                = "RID Pool request successes since boot"
-	samAccountGroupEvaluationLatency                                 = "SAM Account Group Evaluation Latency"
-	samDisplayInformationQueriesPerSec                               = "SAM Display Information Queries/sec"
-	samDomainLocalGroupMembershipEvaluationsPerSec                   = "SAM Domain Local Group Membership Evaluations/sec"
-	samEnumerationsPerSec                                            = "SAM Enumerations/sec"
-	samGCEvaluationsPerSec                                           = "SAM GC Evaluations/sec"
-	samGlobalGroupMembershipEvaluationsPerSec                        = "SAM Global Group Membership Evaluations/sec"
-	samMachineCreationAttemptsPerSec                                 = "SAM Machine Creation Attempts/sec"
-	samMembershipChangesPerSec                                       = "SAM Membership Changes/sec"
-	samNonTransitiveMembershipEvaluationsPerSec                      = "SAM Non-Transitive Membership Evaluations/sec"
-	samPasswordChangesPerSec                                         = "SAM Password Changes/sec"
-	samResourceGroupEvaluationLatency                                = "SAM Resource Group Evaluation Latency"
-	samSuccessfulComputerCreationsPerSecIncludesAllRequests          = "SAM Successful Computer Creations/sec: Includes all requests"
-	samSuccessfulUserCreationsPerSec                                 = "SAM Successful User Creations/sec"
-	samTransitiveMembershipEvaluationsPerSec                         = "SAM Transitive Membership Evaluations/sec"
-	samUniversalGroupMembershipEvaluationsPerSec                     = "SAM Universal Group Membership Evaluations/sec"
-	samUserCreationAttemptsPerSec                                    = "SAM User Creation Attempts/sec"
-	simpleBindsPerSec                                                = "Simple Binds/sec"
-	subtreeSearchesPerSec                                            = "Subtree searches/sec"
-	tombstonesGarbageCollectedPerSec                                 = "Tombstones Garbage Collected/sec"
-	tombstonesVisitedPerSec                                          = "Tombstones Visited/sec"
-	transitiveOperationsMillisecondsRun                              = "Transitive operations milliseconds run"
-	transitiveOperationsPerSec                                       = "Transitive operations/sec"
-	transitiveSubOperationsPerSec                                    = "Transitive suboperations/sec"
-	_                                                                = "Warning eventlogs since boot"
-	_                                                                = "Warning events since boot"
-)

internal/collector/ad/types.go

@@ -0,0 +1,223 @@
+// Copyright 2024 The Prometheus Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//go:build windows
+
+package ad
+
+type perfDataCounterValues struct {
+	AbANRPerSec                                                      float64 `perfdata:"AB ANR/sec"`
+	AbBrowsesPerSec                                                  float64 `perfdata:"AB Browses/sec"`
+	AbClientSessions                                                 float64 `perfdata:"AB Client Sessions"`
+	AbMatchesPerSec                                                  float64 `perfdata:"AB Matches/sec"`
+	AbPropertyReadsPerSec                                            float64 `perfdata:"AB Property Reads/sec"`
+	AbProxyLookupsPerSec                                             float64 `perfdata:"AB Proxy Lookups/sec"`
+	AbSearchesPerSec                                                 float64 `perfdata:"AB Searches/sec"`
+	ApproximateHighestDNT                                            float64 `perfdata:"Approximate highest DNT"`
+	AtqEstimatedQueueDelay                                           float64 `perfdata:"ATQ Estimated Queue Delay"`
+	AtqOutstandingQueuedRequests                                     float64 `perfdata:"ATQ Outstanding Queued Requests"`
+	_                                                                float64 `perfdata:"ATQ Queue Latency"`
+	AtqRequestLatency                                                float64 `perfdata:"ATQ Request Latency"`
+	AtqThreadsLDAP                                                   float64 `perfdata:"ATQ Threads LDAP"`
+	AtqThreadsOther                                                  float64 `perfdata:"ATQ Threads Other"`
+	AtqThreadsTotal                                                  float64 `perfdata:"ATQ Threads Total"`
+	BaseSearchesPerSec                                               float64 `perfdata:"Base searches/sec"`
+	DatabaseAddsPerSec                                               float64 `perfdata:"Database adds/sec"`
+	DatabaseDeletesPerSec                                            float64 `perfdata:"Database deletes/sec"`
+	DatabaseModifiesPerSec                                           float64 `perfdata:"Database modifys/sec"`
+	DatabaseRecyclesPerSec                                           float64 `perfdata:"Database recycles/sec"`
+	DigestBindsPerSec                                                float64 `perfdata:"Digest Binds/sec"`
+	_                                                                float64 `perfdata:"DirSync session throttling rate"`
+	_                                                                float64 `perfdata:"DirSync sessions in progress"`
+	DRAHighestUSNCommittedHighPart                                   float64 `perfdata:"DRA Highest USN Committed (High part)"`
+	DRAHighestUSNCommittedLowPart                                    float64 `perfdata:"DRA Highest USN Committed (Low part)"`
+	DRAHighestUSNIssuedHighPart                                      float64 `perfdata:"DRA Highest USN Issued (High part)"`
+	DRAHighestUSNIssuedLowPart                                       float64 `perfdata:"DRA Highest USN Issued (Low part)"`
+	DRAInboundBytesCompressedBetweenSitesAfterCompressionSinceBoot   float64 `perfdata:"DRA Inbound Bytes Compressed (Between Sites, After Compression) Since Boot"`
+	DRAInboundBytesCompressedBetweenSitesAfterCompressionPerSec      float64 `perfdata:"DRA Inbound Bytes Compressed (Between Sites, After Compression)/sec"`
+	DRAInboundBytesCompressedBetweenSitesBeforeCompressionSinceBoot  float64 `perfdata:"DRA Inbound Bytes Compressed (Between Sites, Before Compression) Since Boot"`
+	DRAInboundBytesCompressedBetweenSitesBeforeCompressionPerSec     float64 `perfdata:"DRA Inbound Bytes Compressed (Between Sites, Before Compression)/sec"`
+	DRAInboundBytesNotCompressedWithinSiteSinceBoot                  float64 `perfdata:"DRA Inbound Bytes Not Compressed (Within Site) Since Boot"`
+	DRAInboundBytesNotCompressedWithinSitePerSec                     float64 `perfdata:"DRA Inbound Bytes Not Compressed (Within Site)/sec"`
+	DRAInboundBytesTotalSinceBoot                                    float64 `perfdata:"DRA Inbound Bytes Total Since Boot"`
+	DRAInboundBytesTotalPerSec                                       float64 `perfdata:"DRA Inbound Bytes Total/sec"`
+	DRAInboundFullSyncObjectsRemaining                               float64 `perfdata:"DRA Inbound Full Sync Objects Remaining"`
+	DRAInboundLinkValueUpdatesRemainingInPacket                      float64 `perfdata:"DRA Inbound Link Value Updates Remaining in Packet"`
+	_                                                                float64 `perfdata:"DRA Inbound Link Values/sec"`
+	DRAInboundObjectUpdatesRemainingInPacket                         float64 `perfdata:"DRA Inbound Object Updates Remaining in Packet"`
+	DRAInboundObjectsAppliedPerSec                                   float64 `perfdata:"DRA Inbound Objects Applied/sec"`
+	DRAInboundObjectsFilteredPerSec                                  float64 `perfdata:"DRA Inbound Objects Filtered/sec"`
+	DRAInboundObjectsPerSec                                          float64 `perfdata:"DRA Inbound Objects/sec"`
+	DRAInboundPropertiesAppliedPerSec                                float64 `perfdata:"DRA Inbound Properties Applied/sec"`
+	DRAInboundPropertiesFilteredPerSec                               float64 `perfdata:"DRA Inbound Properties Filtered/sec"`
+	DRAInboundPropertiesTotalPerSec                                  float64 `perfdata:"DRA Inbound Properties Total/sec"`
+	_                                                                float64 `perfdata:"DRA Inbound Sync Link Deletion/sec"`
+	DRAInboundTotalUpdatesRemainingInPacket                          float64 `perfdata:"DRA Inbound Total Updates Remaining in Packet"`
+	DRAInboundValuesDNsOnlyPerSec                                    float64 `perfdata:"DRA Inbound Values (DNs only)/sec"`
+	DRAInboundValuesTotalPerSec                                      float64 `perfdata:"DRA Inbound Values Total/sec"`
+	_                                                                float64 `perfdata:"DRA number of NC replication calls since boot"`
+	_                                                                float64 `perfdata:"DRA number of successful NC replication calls since boot"`
+	DRAOutboundBytesCompressedBetweenSitesAfterCompressionSinceBoot  float64 `perfdata:"DRA Outbound Bytes Compressed (Between Sites, After Compression) Since Boot"`
+	DRAOutboundBytesCompressedBetweenSitesAfterCompressionPerSec     float64 `perfdata:"DRA Outbound Bytes Compressed (Between Sites, After Compression)/sec"`
+	DRAOutboundBytesCompressedBetweenSitesBeforeCompressionSinceBoot float64 `perfdata:"DRA Outbound Bytes Compressed (Between Sites, Before Compression) Since Boot"`
+	DRAOutboundBytesCompressedBetweenSitesBeforeCompressionPerSec    float64 `perfdata:"DRA Outbound Bytes Compressed (Between Sites, Before Compression)/sec"`
+	DRAOutboundBytesNotCompressedWithinSiteSinceBoot                 float64 `perfdata:"DRA Outbound Bytes Not Compressed (Within Site) Since Boot"`
+	DRAOutboundBytesNotCompressedWithinSitePerSec                    float64 `perfdata:"DRA Outbound Bytes Not Compressed (Within Site)/sec"`
+	DRAOutboundBytesTotalSinceBoot                                   float64 `perfdata:"DRA Outbound Bytes Total Since Boot"`
+	DRAOutboundBytesTotalPerSec                                      float64 `perfdata:"DRA Outbound Bytes Total/sec"`
+	DRAOutboundObjectsFilteredPerSec                                 float64 `perfdata:"DRA Outbound Objects Filtered/sec"`
+	DRAOutboundObjectsPerSec                                         float64 `perfdata:"DRA Outbound Objects/sec"`
+	DRAOutboundPropertiesPerSec                                      float64 `perfdata:"DRA Outbound Properties/sec"`
+	DRAOutboundValuesDNsOnlyPerSec                                   float64 `perfdata:"DRA Outbound Values (DNs only)/sec"`
+	DRAOutboundValuesTotalPerSec                                     float64 `perfdata:"DRA Outbound Values Total/sec"`
+	DRAPendingReplicationOperations                                  float64 `perfdata:"DRA Pending Replication Operations"`
+	DRAPendingReplicationSynchronizations                            float64 `perfdata:"DRA Pending Replication Synchronizations"`
+	DRASyncFailuresOnSchemaMismatch                                  float64 `perfdata:"DRA Sync Failures on Schema Mismatch"`
+	DRASyncRequestsMade                                              float64 `perfdata:"DRA Sync Requests Made"`
+	DRASyncRequestsSuccessful                                        float64 `perfdata:"DRA Sync Requests Successful"`
+	DRAThreadsGettingNCChanges                                       float64 `perfdata:"DRA Threads Getting NC Changes"`
+	DRAThreadsGettingNCChangesHoldingSemaphore                       float64 `perfdata:"DRA Threads Getting NC Changes Holding Semaphore"`
+	_                                                                float64 `perfdata:"DRA total number of Busy failures since boot"`
+	_                                                                float64 `perfdata:"DRA total number of MissingParent failures since boot"`
+	_                                                                float64 `perfdata:"DRA total number of NotEnoughAttrs/MissingObject failures since boot"`
+	_                                                                float64 `perfdata:"DRA total number of Preempted failures since boot"`
+	_                                                                float64 `perfdata:"DRA total time of applying replication package since boot"`
+	_                                                                float64 `perfdata:"DRA total time of NC replication calls since boot"`
+	_                                                                float64 `perfdata:"DRA total time of successful NC replication calls since boot"`
+	_                                                                float64 `perfdata:"DRA total time of successfully applying replication package since boot"`
+	_                                                                float64 `perfdata:"DRA total time on waiting async replication packages since boot"`
+	_                                                                float64 `perfdata:"DRA total time on waiting sync replication packages since boot"`
+	DsPercentReadsFromDRA                                            float64 `perfdata:"DS % Reads from DRA"`
+	DsPercentReadsFromKCC                                            float64 `perfdata:"DS % Reads from KCC"`
+	DsPercentReadsFromLSA                                            float64 `perfdata:"DS % Reads from LSA"`
+	DsPercentReadsFromNSPI                                           float64 `perfdata:"DS % Reads from NSPI"`
+	DsPercentReadsFromNTDSAPI                                        float64 `perfdata:"DS % Reads from NTDSAPI"`
+	DsPercentReadsFromSAM                                            float64 `perfdata:"DS % Reads from SAM"`
+	DsPercentReadsOther                                              float64 `perfdata:"DS % Reads Other"`
+	DsPercentSearchesFromDRA                                         float64 `perfdata:"DS % Searches from DRA"`
+	DsPercentSearchesFromKCC                                         float64 `perfdata:"DS % Searches from KCC"`
+	DsPercentSearchesFromLDAP                                        float64 `perfdata:"DS % Searches from LDAP"`
+	DsPercentSearchesFromLSA                                         float64 `perfdata:"DS % Searches from LSA"`
+	DsPercentSearchesFromNSPI                                        float64 `perfdata:"DS % Searches from NSPI"`
+	DsPercentSearchesFromNTDSAPI                                     float64 `perfdata:"DS % Searches from NTDSAPI"`
+	DsPercentSearchesFromSAM                                         float64 `perfdata:"DS % Searches from SAM"`
+	DsPercentSearchesOther                                           float64 `perfdata:"DS % Searches Other"`
+	DsPercentWritesFromDRA                                           float64 `perfdata:"DS % Writes from DRA"`
+	DsPercentWritesFromKCC                                           float64 `perfdata:"DS % Writes from KCC"`
+	DsPercentWritesFromLDAP                                          float64 `perfdata:"DS % Writes from LDAP"`
+	DsPercentWritesFromLSA                                           float64 `perfdata:"DS % Writes from LSA"`
+	DsPercentWritesFromNSPI                                          float64 `perfdata:"DS % Writes from NSPI"`
+	DsPercentWritesFromNTDSAPI                                       float64 `perfdata:"DS % Writes from NTDSAPI"`
+	DsPercentWritesFromSAM                                           float64 `perfdata:"DS % Writes from SAM"`
+	DsPercentWritesOther                                             float64 `perfdata:"DS % Writes Other"`
+	DsClientBindsPerSec                                              float64 `perfdata:"DS Client Binds/sec"`
+	DsClientNameTranslationsPerSec                                   float64 `perfdata:"DS Client Name Translations/sec"`
+	DsDirectoryReadsPerSec                                           float64 `perfdata:"DS Directory Reads/sec"`
+	DsDirectorySearchesPerSec                                        float64 `perfdata:"DS Directory Searches/sec"`
+	DsDirectoryWritesPerSec                                          float64 `perfdata:"DS Directory Writes/sec"`
+	DsMonitorListSize                                                float64 `perfdata:"DS Monitor List Size"`
+	DsNameCacheHitRate                                               float64 `perfdata:"DS Name Cache hit rate"`
+	DsNameCacheHitRateSecondValue                                    float64 `perfdata:"DS Name Cache hit rate,secondvalue"`
+	DsNotifyQueueSize                                                float64 `perfdata:"DS Notify Queue Size"`
+	DsSearchSubOperationsPerSec                                      float64 `perfdata:"DS Search sub-operations/sec"`
+	DsSecurityDescriptorPropagationsEvents                           float64 `perfdata:"DS Security Descriptor Propagations Events"`
+	DsSecurityDescriptorPropagatorAverageExclusionTime               float64 `perfdata:"DS Security Descriptor Propagator Average Exclusion Time"`
+	DsSecurityDescriptorPropagatorRuntimeQueue                       float64 `perfdata:"DS Security Descriptor Propagator Runtime Queue"`
+	DsSecurityDescriptorSubOperationsPerSec                          float64 `perfdata:"DS Security Descriptor sub-operations/sec"`
+	DsServerBindsPerSec                                              float64 `perfdata:"DS Server Binds/sec"`
+	DsServerNameTranslationsPerSec                                   float64 `perfdata:"DS Server Name Translations/sec"`
+	DsThreadsInUse                                                   float64 `perfdata:"DS Threads in Use"`
+	_                                                                float64 `perfdata:"Error eventlogs since boot"`
+	_                                                                float64 `perfdata:"Error events since boot"`
+	ExternalBindsPerSec                                              float64 `perfdata:"External Binds/sec"`
+	FastBindsPerSec                                                  float64 `perfdata:"Fast Binds/sec"`
+	_                                                                float64 `perfdata:"Fatal events since boot"`
+	_                                                                float64 `perfdata:"Info eventlogs since boot"`
+	LdapActiveThreads                                                float64 `perfdata:"LDAP Active Threads"`
+	_                                                                float64 `perfdata:"LDAP Add Operations"`
+	_                                                                float64 `perfdata:"LDAP Add Operations/sec"`
+	_                                                                float64 `perfdata:"LDAP batch slots available"`
+	LdapBindTime                                                     float64 `perfdata:"LDAP Bind Time"`
+	_                                                                float64 `perfdata:"LDAP busy retries"`
+	_                                                                float64 `perfdata:"LDAP busy retries/sec"`
+	LdapClientSessions                                               float64 `perfdata:"LDAP Client Sessions"`
+	LdapClosedConnectionsPerSec                                      float64 `perfdata:"LDAP Closed Connections/sec"`
+	_                                                                float64 `perfdata:"LDAP Delete Operations"`
+	_                                                                float64 `perfdata:"LDAP Delete Operations/sec"`
+	_                                                                float64 `perfdata:"LDAP Modify DN Operations"`
+	_                                                                float64 `perfdata:"LDAP Modify DN Operations/sec"`
+	_                                                                float64 `perfdata:"LDAP Modify Operations"`
+	_                                                                float64 `perfdata:"LDAP Modify Operations/sec"`
+	LdapNewConnectionsPerSec                                         float64 `perfdata:"LDAP New Connections/sec"`
+	LdapNewSSLConnectionsPerSec                                      float64 `perfdata:"LDAP New SSL Connections/sec"`
+	_                                                                float64 `perfdata:"LDAP Outbound Bytes"`
+	_                                                                float64 `perfdata:"LDAP Outbound Bytes/sec"`
+	_                                                                float64 `perfdata:"LDAP Page Search Cache entries count"`
+	_                                                                float64 `perfdata:"LDAP Page Search Cache size"`
+	LdapSearchesPerSec                                               float64 `perfdata:"LDAP Searches/sec"`
+	LdapSuccessfulBindsPerSec                                        float64 `perfdata:"LDAP Successful Binds/sec"`
+	_                                                                float64 `perfdata:"LDAP Threads Sleeping on BUSY"`
+	LdapUDPOperationsPerSec                                          float64 `perfdata:"LDAP UDP operations/sec"`
+	LdapWritesPerSec                                                 float64 `perfdata:"LDAP Writes/sec"`
+	LinkValuesCleanedPerSec                                          float64 `perfdata:"Link Values Cleaned/sec"`
+	_                                                                float64 `perfdata:"Links added"`
+	_                                                                float64 `perfdata:"Links added/sec"`
+	_                                                                float64 `perfdata:"Links visited"`
+	_                                                                float64 `perfdata:"Links visited/sec"`
+	_                                                                float64 `perfdata:"Logical link deletes"`
+	_                                                                float64 `perfdata:"Logical link deletes/sec"`
+	NegotiatedBindsPerSec                                            float64 `perfdata:"Negotiated Binds/sec"`
+	NTLMBindsPerSec                                                  float64 `perfdata:"NTLM Binds/sec"`
+	_                                                                float64 `perfdata:"Objects returned"`
+	_                                                                float64 `perfdata:"Objects returned/sec"`
+	_                                                                float64 `perfdata:"Objects visited"`
+	_                                                                float64 `perfdata:"Objects visited/sec"`
+	OneLevelSearchesPerSec                                           float64 `perfdata:"Onelevel searches/sec"`
+	_                                                                float64 `perfdata:"PDC failed password update notifications"`
+	_                                                                float64 `perfdata:"PDC password update notifications/sec"`
+	_                                                                float64 `perfdata:"PDC successful password update notifications"`
+	PhantomsCleanedPerSec                                            float64 `perfdata:"Phantoms Cleaned/sec"`
+	PhantomsVisitedPerSec                                            float64 `perfdata:"Phantoms Visited/sec"`
+	_                                                                float64 `perfdata:"Physical link deletes"`
+	_                                                                float64 `perfdata:"Physical link deletes/sec"`
+	_                                                                float64 `perfdata:"Replicate Single Object operations"`
+	_                                                                float64 `perfdata:"Replicate Single Object operations/sec"`
+	_                                                                float64 `perfdata:"RID Pool invalidations since boot"`
+	_                                                                float64 `perfdata:"RID Pool request failures since boot"`
+	_                                                                float64 `perfdata:"RID Pool request successes since boot"`
+	SamAccountGroupEvaluationLatency                                 float64 `perfdata:"SAM Account Group Evaluation Latency"`
+	SamDisplayInformationQueriesPerSec                               float64 `perfdata:"SAM Display Information Queries/sec"`
+	SamDomainLocalGroupMembershipEvaluationsPerSec                   float64 `perfdata:"SAM Domain Local Group Membership Evaluations/sec"`
+	SamEnumerationsPerSec                                            float64 `perfdata:"SAM Enumerations/sec"`
+	SamGCEvaluationsPerSec                                           float64 `perfdata:"SAM GC Evaluations/sec"`
+	SamGlobalGroupMembershipEvaluationsPerSec                        float64 `perfdata:"SAM Global Group Membership Evaluations/sec"`
+	SamMachineCreationAttemptsPerSec                                 float64 `perfdata:"SAM Machine Creation Attempts/sec"`
+	SamMembershipChangesPerSec                                       float64 `perfdata:"SAM Membership Changes/sec"`
+	SamNonTransitiveMembershipEvaluationsPerSec                      float64 `perfdata:"SAM Non-Transitive Membership Evaluations/sec"`
+	SamPasswordChangesPerSec                                         float64 `perfdata:"SAM Password Changes/sec"`
+	SamResourceGroupEvaluationLatency                                float64 `perfdata:"SAM Resource Group Evaluation Latency"`
+	SamSuccessfulComputerCreationsPerSecIncludesAllRequests          float64 `perfdata:"SAM Successful Computer Creations/sec: Includes all requests"`
+	SamSuccessfulUserCreationsPerSec                                 float64 `perfdata:"SAM Successful User Creations/sec"`
+	SamTransitiveMembershipEvaluationsPerSec                         float64 `perfdata:"SAM Transitive Membership Evaluations/sec"`
+	SamUniversalGroupMembershipEvaluationsPerSec                     float64 `perfdata:"SAM Universal Group Membership Evaluations/sec"`
+	SamUserCreationAttemptsPerSec                                    float64 `perfdata:"SAM User Creation Attempts/sec"`
+	SimpleBindsPerSec                                                float64 `perfdata:"Simple Binds/sec"`
+	SubtreeSearchesPerSec                                            float64 `perfdata:"Subtree searches/sec"`
+	TombstonesGarbageCollectedPerSec                                 float64 `perfdata:"Tombstones Garbage Collected/sec"`
+	TombstonesVisitedPerSec                                          float64 `perfdata:"Tombstones Visited/sec"`
+	TransitiveOperationsMillisecondsRun                              float64 `perfdata:"Transitive operations milliseconds run"`
+	TransitiveOperationsPerSec                                       float64 `perfdata:"Transitive operations/sec"`
+	TransitiveSubOperationsPerSec                                    float64 `perfdata:"Transitive suboperations/sec"`
+	_                                                                float64 `perfdata:"Warning eventlogs since boot"`
+	_                                                                float64 `perfdata:"Warning events since boot"`
+}

internal/collector/adcs/adcs.go

@@ -21,7 +21,7 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/mi"
-	"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"
@@ -37,7 +37,8 @@ var ConfigDefaults = Config{}
 type Collector struct {
 	config Config
 
-	perfDataCollector *perfdata.Collector
+	perfDataCollector *pdh.Collector
+	perfDataObject    []perfDataCounterValues
 
 	challengeResponseProcessingTime              *prometheus.Desc
 	challengeResponsesPerSecond                  *prometheus.Desc
@@ -83,21 +84,7 @@ func (c *Collector) Close() error {
 func (c *Collector) Build(_ *slog.Logger, _ *mi.Session) error {
 	var err error
 
-	c.perfDataCollector, err = perfdata.NewCollector("Certification Authority", perfdata.InstancesAll, []string{
-		requestsPerSecond,
-		requestProcessingTime,
-		retrievalsPerSecond,
-		retrievalProcessingTime,
-		failedRequestsPerSecond,
-		issuedRequestsPerSecond,
-		pendingRequestsPerSecond,
-		requestCryptographicSigningTime,
-		requestPolicyModuleProcessingTime,
-		challengeResponsesPerSecond,
-		challengeResponseProcessingTime,
-		signedCertificateTimestampListsPerSecond,
-		signedCertificateTimestampListProcessingTime,
-	})
+	c.perfDataCollector, err = pdh.NewCollector[perfDataCounterValues](pdh.CounterTypeRaw, "Certification Authority", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create Certification Authority collector: %w", err)
 	}
@@ -185,93 +172,89 @@ func (c *Collector) Build(_ *slog.Logger, _ *mi.Session) error {
 }
 
 func (c *Collector) Collect(ch chan<- prometheus.Metric) error {
-	perfData, err := c.perfDataCollector.Collect()
+	err := c.perfDataCollector.Collect(&c.perfDataObject)
 	if err != nil {
 		return fmt.Errorf("failed to collect Certification Authority (ADCS) metrics: %w", err)
 	}
 
-	if len(perfData) == 0 {
-		return fmt.Errorf("failed to collect Certification Authority (ADCS) metrics: %w", types.ErrNoData)
-	}
-
-	for name, data := range perfData {
+	for _, data := range c.perfDataObject {
 		ch <- prometheus.MustNewConstMetric(
 			c.requestsPerSecond,
 			prometheus.CounterValue,
-			data[requestsPerSecond].FirstValue,
-			name,
+			data.RequestsPerSecond,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.requestProcessingTime,
 			prometheus.GaugeValue,
-			utils.MilliSecToSec(data[requestProcessingTime].FirstValue),
-			name,
+			utils.MilliSecToSec(data.RequestProcessingTime),
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.retrievalsPerSecond,
 			prometheus.CounterValue,
-			data[retrievalsPerSecond].FirstValue,
-			name,
+			data.RetrievalsPerSecond,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.retrievalProcessingTime,
 			prometheus.GaugeValue,
-			utils.MilliSecToSec(data[retrievalProcessingTime].FirstValue),
-			name,
+			utils.MilliSecToSec(data.RetrievalProcessingTime),
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.failedRequestsPerSecond,
 			prometheus.CounterValue,
-			data[failedRequestsPerSecond].FirstValue,
-			name,
+			data.FailedRequestsPerSecond,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.issuedRequestsPerSecond,
 			prometheus.CounterValue,
-			data[issuedRequestsPerSecond].FirstValue,
-			name,
+			data.IssuedRequestsPerSecond,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.pendingRequestsPerSecond,
 			prometheus.CounterValue,
-			data[pendingRequestsPerSecond].FirstValue,
-			name,
+			data.PendingRequestsPerSecond,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.requestCryptographicSigningTime,
 			prometheus.GaugeValue,
-			utils.MilliSecToSec(data[requestCryptographicSigningTime].FirstValue),
-			name,
+			utils.MilliSecToSec(data.RequestCryptographicSigningTime),
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.requestPolicyModuleProcessingTime,
 			prometheus.GaugeValue,
-			utils.MilliSecToSec(data[requestPolicyModuleProcessingTime].FirstValue),
-			name,
+			utils.MilliSecToSec(data.RequestPolicyModuleProcessingTime),
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.challengeResponsesPerSecond,
 			prometheus.CounterValue,
-			data[challengeResponsesPerSecond].FirstValue,
-			name,
+			data.ChallengeResponsesPerSecond,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.challengeResponseProcessingTime,
 			prometheus.GaugeValue,
-			utils.MilliSecToSec(data[challengeResponseProcessingTime].FirstValue),
-			name,
+			utils.MilliSecToSec(data.ChallengeResponseProcessingTime),
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.signedCertificateTimestampListsPerSecond,
 			prometheus.CounterValue,
-			data[signedCertificateTimestampListsPerSecond].FirstValue,
-			name,
+			data.SignedCertificateTimestampListsPerSecond,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.signedCertificateTimestampListProcessingTime,
 			prometheus.GaugeValue,
-			utils.MilliSecToSec(data[signedCertificateTimestampListProcessingTime].FirstValue),
-			name,
+			utils.MilliSecToSec(data.SignedCertificateTimestampListProcessingTime),
+			data.Name,
 		)
 	}
 

internal/collector/adcs/adcs_test.go

@@ -25,3 +25,7 @@ import (
 func BenchmarkCollector(b *testing.B) {
 	testutils.FuncBenchmarkCollector(b, adcs.Name, adcs.NewWithFlags)
 }
+
+func TestCollector(t *testing.T) {
+	testutils.TestCollector(t, adcs.New, nil)
+}

internal/collector/adcs/const.go

@@ -1,32 +0,0 @@
-// Copyright 2024 The Prometheus Authors
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//go:build windows
-
-package adcs
-
-const (
-	challengeResponseProcessingTime              = "Challenge Response processing time (ms)"
-	challengeResponsesPerSecond                  = "Challenge Responses/sec"
-	failedRequestsPerSecond                      = "Failed Requests/sec"
-	issuedRequestsPerSecond                      = "Issued Requests/sec"
-	pendingRequestsPerSecond                     = "Pending Requests/sec"
-	requestCryptographicSigningTime              = "Request cryptographic signing time (ms)"
-	requestPolicyModuleProcessingTime            = "Request policy module processing time (ms)"
-	requestProcessingTime                        = "Request processing time (ms)"
-	requestsPerSecond                            = "Requests/sec"
-	retrievalProcessingTime                      = "Retrieval processing time (ms)"
-	retrievalsPerSecond                          = "Retrievals/sec"
-	signedCertificateTimestampListProcessingTime = "Signed Certificate Timestamp List processing time (ms)"
-	signedCertificateTimestampListsPerSecond     = "Signed Certificate Timestamp Lists/sec"
-)

internal/collector/adcs/types.go

@@ -0,0 +1,34 @@
+// Copyright 2024 The Prometheus Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//go:build windows
+
+package adcs
+
+type perfDataCounterValues struct {
+	Name string
+
+	ChallengeResponseProcessingTime              float64 `perfdata:"Challenge Response processing time (ms)"`
+	ChallengeResponsesPerSecond                  float64 `perfdata:"Challenge Responses/sec"`
+	FailedRequestsPerSecond                      float64 `perfdata:"Failed Requests/sec"`
+	IssuedRequestsPerSecond                      float64 `perfdata:"Issued Requests/sec"`
+	PendingRequestsPerSecond                     float64 `perfdata:"Pending Requests/sec"`
+	RequestCryptographicSigningTime              float64 `perfdata:"Request cryptographic signing time (ms)"`
+	RequestPolicyModuleProcessingTime            float64 `perfdata:"Request policy module processing time (ms)"`
+	RequestProcessingTime                        float64 `perfdata:"Request processing time (ms)"`
+	RequestsPerSecond                            float64 `perfdata:"Requests/sec"`
+	RetrievalProcessingTime                      float64 `perfdata:"Retrieval processing time (ms)"`
+	RetrievalsPerSecond                          float64 `perfdata:"Retrievals/sec"`
+	SignedCertificateTimestampListProcessingTime float64 `perfdata:"Signed Certificate Timestamp List processing time (ms)"`
+	SignedCertificateTimestampListsPerSecond     float64 `perfdata:"Signed Certificate Timestamp Lists/sec"`
+}

internal/collector/adfs/adfs.go

@@ -18,13 +18,11 @@ package adfs
 import (
 	"fmt"
 	"log/slog"
-	"maps"
 	"math"
-	"slices"
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/mi"
-	"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"
 )
@@ -39,7 +37,8 @@ var ConfigDefaults = Config{}
 type Collector struct {
 	config Config
 
-	perfDataCollector *perfdata.Collector
+	perfDataCollector *pdh.Collector
+	perfDataObject    []perfDataCounterValues
 
 	adLoginConnectionFailures                          *prometheus.Desc
 	artifactDBFailures                                 *prometheus.Desc
@@ -115,51 +114,7 @@ func (c *Collector) Close() error {
 func (c *Collector) Build(_ *slog.Logger, _ *mi.Session) error {
 	var err error
 
-	c.perfDataCollector, err = perfdata.NewCollector("AD FS", nil, []string{
-		adLoginConnectionFailures,
-		certificateAuthentications,
-		deviceAuthentications,
-		extranetAccountLockouts,
-		federatedAuthentications,
-		passportAuthentications,
-		passiveRequests,
-		passwordChangeFailed,
-		passwordChangeSucceeded,
-		tokenRequests,
-		windowsIntegratedAuthentications,
-		oAuthAuthZRequests,
-		oAuthClientAuthentications,
-		oAuthClientAuthenticationFailures,
-		oAuthClientCredentialRequestFailures,
-		oAuthClientCredentialRequests,
-		oAuthClientPrivateKeyJWTAuthenticationFailures,
-		oAuthClientPrivateKeyJWTAuthentications,
-		oAuthClientBasicAuthenticationFailures,
-		oAuthClientBasicAuthentications,
-		oAuthClientSecretPostAuthenticationFailures,
-		oAuthClientSecretPostAuthentications,
-		oAuthClientWindowsAuthenticationFailures,
-		oAuthClientWindowsAuthentications,
-		oAuthLogonCertRequestFailures,
-		oAuthLogonCertTokenRequests,
-		oAuthPasswordGrantRequestFailures,
-		oAuthPasswordGrantRequests,
-		oAuthTokenRequests,
-		samlPTokenRequests,
-		ssoAuthenticationFailures,
-		ssoAuthentications,
-		wsFedTokenRequests,
-		wsTrustTokenRequests,
-		usernamePasswordAuthenticationFailures,
-		usernamePasswordAuthentications,
-		externalAuthentications,
-		externalAuthNFailures,
-		artifactDBFailures,
-		avgArtifactDBQueryTime,
-		configDBFailures,
-		avgConfigDBQueryTime,
-		federationMetadataRequests,
-	})
+	c.perfDataCollector, err = pdh.NewCollector[perfDataCounterValues](pdh.CounterTypeRaw, "AD FS", nil)
 	if err != nil {
 		return fmt.Errorf("failed to create AD FS collector: %w", err)
 	}
@@ -427,279 +382,267 @@ func (c *Collector) Build(_ *slog.Logger, _ *mi.Session) error {
 }
 
 func (c *Collector) Collect(ch chan<- prometheus.Metric) error {
-	data, err := c.perfDataCollector.Collect()
+	err := c.perfDataCollector.Collect(&c.perfDataObject)
 	if err != nil {
 		return fmt.Errorf("failed to collect ADFS metrics: %w", err)
 	}
 
-	instanceKey := slices.Collect(maps.Keys(data))
-
-	if len(instanceKey) == 0 {
-		return fmt.Errorf("failed to collect ADFS metrics: %w", types.ErrNoData)
-	}
-
-	adfsData, ok := data[instanceKey[0]]
-
-	if !ok {
-		return fmt.Errorf("failed to collect ADFS metrics: %w", types.ErrNoData)
-	}
-
 	ch <- prometheus.MustNewConstMetric(
 		c.adLoginConnectionFailures,
 		prometheus.CounterValue,
-		adfsData[adLoginConnectionFailures].FirstValue,
+		c.perfDataObject[0].AdLoginConnectionFailures,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.certificateAuthentications,
 		prometheus.CounterValue,
-		adfsData[certificateAuthentications].FirstValue,
+		c.perfDataObject[0].CertificateAuthentications,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.deviceAuthentications,
 		prometheus.CounterValue,
-		adfsData[deviceAuthentications].FirstValue,
+		c.perfDataObject[0].DeviceAuthentications,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.extranetAccountLockouts,
 		prometheus.CounterValue,
-		adfsData[extranetAccountLockouts].FirstValue,
+		c.perfDataObject[0].ExtranetAccountLockouts,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.federatedAuthentications,
 		prometheus.CounterValue,
-		adfsData[federatedAuthentications].FirstValue,
+		c.perfDataObject[0].FederatedAuthentications,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.passportAuthentications,
 		prometheus.CounterValue,
-		adfsData[passportAuthentications].FirstValue,
+		c.perfDataObject[0].PassportAuthentications,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.passiveRequests,
 		prometheus.CounterValue,
-		adfsData[passiveRequests].FirstValue,
+		c.perfDataObject[0].PassiveRequests,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.passwordChangeFailed,
 		prometheus.CounterValue,
-		adfsData[passwordChangeFailed].FirstValue,
+		c.perfDataObject[0].PasswordChangeFailed,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.passwordChangeSucceeded,
 		prometheus.CounterValue,
-		adfsData[passwordChangeSucceeded].FirstValue,
+		c.perfDataObject[0].PasswordChangeSucceeded,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.tokenRequests,
 		prometheus.CounterValue,
-		adfsData[tokenRequests].FirstValue,
+		c.perfDataObject[0].TokenRequests,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.windowsIntegratedAuthentications,
 		prometheus.CounterValue,
-		adfsData[windowsIntegratedAuthentications].FirstValue,
+		c.perfDataObject[0].WindowsIntegratedAuthentications,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.oAuthAuthZRequests,
 		prometheus.CounterValue,
-		adfsData[oAuthAuthZRequests].FirstValue,
+		c.perfDataObject[0].OAuthAuthZRequests,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.oAuthClientAuthentications,
 		prometheus.CounterValue,
-		adfsData[oAuthClientAuthentications].FirstValue,
+		c.perfDataObject[0].OAuthClientAuthentications,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.oAuthClientAuthenticationsFailures,
 		prometheus.CounterValue,
-		adfsData[oAuthClientAuthenticationFailures].FirstValue,
+		c.perfDataObject[0].OAuthClientAuthenticationFailures,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.oAuthClientCredentialsRequestFailures,
 		prometheus.CounterValue,
-		adfsData[oAuthClientCredentialRequestFailures].FirstValue,
+		c.perfDataObject[0].OAuthClientCredentialRequestFailures,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.oAuthClientCredentialsRequests,
 		prometheus.CounterValue,
-		adfsData[oAuthClientCredentialRequests].FirstValue,
+		c.perfDataObject[0].OAuthClientCredentialRequests,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.oAuthClientPrivateKeyJwtAuthenticationFailures,
 		prometheus.CounterValue,
-		adfsData[oAuthClientPrivateKeyJWTAuthenticationFailures].FirstValue,
+		c.perfDataObject[0].OAuthClientPrivateKeyJWTAuthenticationFailures,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.oAuthClientPrivateKeyJwtAuthentications,
 		prometheus.CounterValue,
-		adfsData[oAuthClientPrivateKeyJWTAuthentications].FirstValue,
+		c.perfDataObject[0].OAuthClientPrivateKeyJWTAuthentications,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.oAuthClientSecretBasicAuthenticationFailures,
 		prometheus.CounterValue,
-		adfsData[oAuthClientBasicAuthenticationFailures].FirstValue,
+		c.perfDataObject[0].OAuthClientBasicAuthenticationFailures,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.oAuthClientSecretBasicAuthentications,
 		prometheus.CounterValue,
-		adfsData[oAuthClientBasicAuthentications].FirstValue,
+		c.perfDataObject[0].OAuthClientBasicAuthentications,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.oAuthClientSecretPostAuthenticationFailures,
 		prometheus.CounterValue,
-		adfsData[oAuthClientSecretPostAuthenticationFailures].FirstValue,
+		c.perfDataObject[0].OAuthClientSecretPostAuthenticationFailures,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.oAuthClientSecretPostAuthentications,
 		prometheus.CounterValue,
-		adfsData[oAuthClientSecretPostAuthentications].FirstValue,
+		c.perfDataObject[0].OAuthClientSecretPostAuthentications,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.oAuthClientWindowsIntegratedAuthenticationFailures,
 		prometheus.CounterValue,
-		adfsData[oAuthClientWindowsAuthenticationFailures].FirstValue,
+		c.perfDataObject[0].OAuthClientWindowsAuthenticationFailures,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.oAuthClientWindowsIntegratedAuthentications,
 		prometheus.CounterValue,
-		adfsData[oAuthClientWindowsAuthentications].FirstValue,
+		c.perfDataObject[0].OAuthClientWindowsAuthentications,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.oAuthLogonCertificateRequestFailures,
 		prometheus.CounterValue,
-		adfsData[oAuthLogonCertRequestFailures].FirstValue,
+		c.perfDataObject[0].OAuthLogonCertRequestFailures,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.oAuthLogonCertificateTokenRequests,
 		prometheus.CounterValue,
-		adfsData[oAuthLogonCertTokenRequests].FirstValue,
+		c.perfDataObject[0].OAuthLogonCertTokenRequests,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.oAuthPasswordGrantRequestFailures,
 		prometheus.CounterValue,
-		adfsData[oAuthPasswordGrantRequestFailures].FirstValue,
+		c.perfDataObject[0].OAuthPasswordGrantRequestFailures,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.oAuthPasswordGrantRequests,
 		prometheus.CounterValue,
-		adfsData[oAuthPasswordGrantRequests].FirstValue,
+		c.perfDataObject[0].OAuthPasswordGrantRequests,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.oAuthTokenRequests,
 		prometheus.CounterValue,
-		adfsData[oAuthTokenRequests].FirstValue,
+		c.perfDataObject[0].OAuthTokenRequests,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.samlPTokenRequests,
 		prometheus.CounterValue,
-		adfsData[samlPTokenRequests].FirstValue,
+		c.perfDataObject[0].SamlPTokenRequests,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.ssoAuthenticationFailures,
 		prometheus.CounterValue,
-		adfsData[ssoAuthenticationFailures].FirstValue,
+		c.perfDataObject[0].SsoAuthenticationFailures,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.ssoAuthentications,
 		prometheus.CounterValue,
-		adfsData[ssoAuthentications].FirstValue,
+		c.perfDataObject[0].SsoAuthentications,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.wsFedTokenRequests,
 		prometheus.CounterValue,
-		adfsData[wsFedTokenRequests].FirstValue,
+		c.perfDataObject[0].WsFedTokenRequests,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.wsTrustTokenRequests,
 		prometheus.CounterValue,
-		adfsData[wsTrustTokenRequests].FirstValue,
+		c.perfDataObject[0].WsTrustTokenRequests,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.upAuthenticationFailures,
 		prometheus.CounterValue,
-		adfsData[usernamePasswordAuthenticationFailures].FirstValue,
+		c.perfDataObject[0].UsernamePasswordAuthenticationFailures,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.upAuthentications,
 		prometheus.CounterValue,
-		adfsData[usernamePasswordAuthentications].FirstValue,
+		c.perfDataObject[0].UsernamePasswordAuthentications,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.externalAuthenticationFailures,
 		prometheus.CounterValue,
-		adfsData[externalAuthNFailures].FirstValue,
+		c.perfDataObject[0].ExternalAuthNFailures,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.externalAuthentications,
 		prometheus.CounterValue,
-		adfsData[externalAuthentications].FirstValue,
+		c.perfDataObject[0].ExternalAuthentications,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.artifactDBFailures,
 		prometheus.CounterValue,
-		adfsData[artifactDBFailures].FirstValue,
+		c.perfDataObject[0].ArtifactDBFailures,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.avgArtifactDBQueryTime,
 		prometheus.CounterValue,
-		adfsData[avgArtifactDBQueryTime].FirstValue*math.Pow(10, -8),
+		c.perfDataObject[0].AvgArtifactDBQueryTime*math.Pow(10, -8),
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.configDBFailures,
 		prometheus.CounterValue,
-		adfsData[configDBFailures].FirstValue,
+		c.perfDataObject[0].ConfigDBFailures,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.avgConfigDBQueryTime,
 		prometheus.CounterValue,
-		adfsData[avgConfigDBQueryTime].FirstValue*math.Pow(10, -8),
+		c.perfDataObject[0].AvgConfigDBQueryTime*math.Pow(10, -8),
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.federationMetadataRequests,
 		prometheus.CounterValue,
-		adfsData[federationMetadataRequests].FirstValue,
+		c.perfDataObject[0].FederationMetadataRequests,
 	)
 
 	return nil

internal/collector/adfs/adfs_test.go

@@ -25,3 +25,7 @@ import (
 func BenchmarkCollector(b *testing.B) {
 	testutils.FuncBenchmarkCollector(b, adfs.Name, adfs.NewWithFlags)
 }
+
+func TestCollector(t *testing.T) {
+	testutils.TestCollector(t, adfs.New, nil)
+}

internal/collector/adfs/const.go

@@ -1,62 +0,0 @@
-// Copyright 2024 The Prometheus Authors
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//go:build windows
-
-package adfs
-
-const (
-	adLoginConnectionFailures                      = "AD Login Connection Failures"
-	artifactDBFailures                             = "Artifact Database Connection Failures"
-	avgArtifactDBQueryTime                         = "Average Artifact Database Query Time"
-	avgConfigDBQueryTime                           = "Average Config Database Query Time"
-	certificateAuthentications                     = "Certificate Authentications"
-	configDBFailures                               = "Configuration Database Connection Failures"
-	deviceAuthentications                          = "Device Authentications"
-	externalAuthentications                        = "External Authentications"
-	externalAuthNFailures                          = "External Authentication Failures"
-	extranetAccountLockouts                        = "Extranet Account Lockouts"
-	federatedAuthentications                       = "Federated Authentications"
-	federationMetadataRequests                     = "Federation Metadata Requests"
-	oAuthAuthZRequests                             = "OAuth AuthZ Requests"
-	oAuthClientAuthenticationFailures              = "OAuth Client Authentications Failures"
-	oAuthClientAuthentications                     = "OAuth Client Authentications"
-	oAuthClientBasicAuthenticationFailures         = "OAuth Client Secret Basic Authentication Failures"
-	oAuthClientBasicAuthentications                = "OAuth Client Secret Basic Authentications"
-	oAuthClientCredentialRequestFailures           = "OAuth Client Credentials Request Failures"
-	oAuthClientCredentialRequests                  = "OAuth Client Credentials Requests"
-	oAuthClientPrivateKeyJWTAuthenticationFailures = "OAuth Client Private Key Jwt Authentication Failures"
-	oAuthClientPrivateKeyJWTAuthentications        = "OAuth Client Private Key Jwt Authentications"
-	oAuthClientSecretPostAuthenticationFailures    = "OAuth Client Secret Post Authentication Failures"
-	oAuthClientSecretPostAuthentications           = "OAuth Client Secret Post Authentications"
-	oAuthClientWindowsAuthenticationFailures       = "OAuth Client Windows Integrated Authentication Failures"
-	oAuthClientWindowsAuthentications              = "OAuth Client Windows Integrated Authentications"
-	oAuthLogonCertRequestFailures                  = "OAuth Logon Certificate Request Failures"
-	oAuthLogonCertTokenRequests                    = "OAuth Logon Certificate Token Requests"
-	oAuthPasswordGrantRequestFailures              = "OAuth Password Grant Request Failures"
-	oAuthPasswordGrantRequests                     = "OAuth Password Grant Requests"
-	oAuthTokenRequests                             = "OAuth Token Requests"
-	passiveRequests                                = "Passive Requests"
-	passportAuthentications                        = "Microsoft Passport Authentications"
-	passwordChangeFailed                           = "Password Change Failed Requests"
-	passwordChangeSucceeded                        = "Password Change Successful Requests"
-	samlPTokenRequests                             = "SAML-P Token Requests"
-	ssoAuthenticationFailures                      = "SSO Authentication Failures"
-	ssoAuthentications                             = "SSO Authentications"
-	tokenRequests                                  = "Token Requests"
-	usernamePasswordAuthenticationFailures         = "U/P Authentication Failures"
-	usernamePasswordAuthentications                = "U/P Authentications"
-	windowsIntegratedAuthentications               = "Windows Integrated Authentications"
-	wsFedTokenRequests                             = "WS-Fed Token Requests"
-	wsTrustTokenRequests                           = "WS-Trust Token Requests"
-)

internal/collector/adfs/types.go

@@ -0,0 +1,62 @@
+// Copyright 2024 The Prometheus Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//go:build windows
+
+package adfs
+
+type perfDataCounterValues struct {
+	AdLoginConnectionFailures                      float64 `perfdata:"AD Login Connection Failures"`
+	ArtifactDBFailures                             float64 `perfdata:"Artifact Database Connection Failures"`
+	AvgArtifactDBQueryTime                         float64 `perfdata:"Average Artifact Database Query Time"`
+	AvgConfigDBQueryTime                           float64 `perfdata:"Average Config Database Query Time"`
+	CertificateAuthentications                     float64 `perfdata:"Certificate Authentications"`
+	ConfigDBFailures                               float64 `perfdata:"Configuration Database Connection Failures"`
+	DeviceAuthentications                          float64 `perfdata:"Device Authentications"`
+	ExternalAuthentications                        float64 `perfdata:"External Authentications"`
+	ExternalAuthNFailures                          float64 `perfdata:"External Authentication Failures"`
+	ExtranetAccountLockouts                        float64 `perfdata:"Extranet Account Lockouts"`
+	FederatedAuthentications                       float64 `perfdata:"Federated Authentications"`
+	FederationMetadataRequests                     float64 `perfdata:"Federation Metadata Requests"`
+	OAuthAuthZRequests                             float64 `perfdata:"OAuth AuthZ Requests"`
+	OAuthClientAuthenticationFailures              float64 `perfdata:"OAuth Client Authentications Failures"`
+	OAuthClientAuthentications                     float64 `perfdata:"OAuth Client Authentications"`
+	OAuthClientBasicAuthenticationFailures         float64 `perfdata:"OAuth Client Secret Basic Authentication Failures"`
+	OAuthClientBasicAuthentications                float64 `perfdata:"OAuth Client Secret Basic Authentications"`
+	OAuthClientCredentialRequestFailures           float64 `perfdata:"OAuth Client Credentials Request Failures"`
+	OAuthClientCredentialRequests                  float64 `perfdata:"OAuth Client Credentials Requests"`
+	OAuthClientPrivateKeyJWTAuthenticationFailures float64 `perfdata:"OAuth Client Private Key Jwt Authentication Failures"`
+	OAuthClientPrivateKeyJWTAuthentications        float64 `perfdata:"OAuth Client Private Key Jwt Authentications"`
+	OAuthClientSecretPostAuthenticationFailures    float64 `perfdata:"OAuth Client Secret Post Authentication Failures"`
+	OAuthClientSecretPostAuthentications           float64 `perfdata:"OAuth Client Secret Post Authentications"`
+	OAuthClientWindowsAuthenticationFailures       float64 `perfdata:"OAuth Client Windows Integrated Authentication Failures"`
+	OAuthClientWindowsAuthentications              float64 `perfdata:"OAuth Client Windows Integrated Authentications"`
+	OAuthLogonCertRequestFailures                  float64 `perfdata:"OAuth Logon Certificate Request Failures"`
+	OAuthLogonCertTokenRequests                    float64 `perfdata:"OAuth Logon Certificate Token Requests"`
+	OAuthPasswordGrantRequestFailures              float64 `perfdata:"OAuth Password Grant Request Failures"`
+	OAuthPasswordGrantRequests                     float64 `perfdata:"OAuth Password Grant Requests"`
+	OAuthTokenRequests                             float64 `perfdata:"OAuth Token Requests"`
+	PassiveRequests                                float64 `perfdata:"Passive Requests"`
+	PassportAuthentications                        float64 `perfdata:"Microsoft Passport Authentications"`
+	PasswordChangeFailed                           float64 `perfdata:"Password Change Failed Requests"`
+	PasswordChangeSucceeded                        float64 `perfdata:"Password Change Successful Requests"`
+	SamlPTokenRequests                             float64 `perfdata:"SAML-P Token Requests"`
+	SsoAuthenticationFailures                      float64 `perfdata:"SSO Authentication Failures"`
+	SsoAuthentications                             float64 `perfdata:"SSO Authentications"`
+	TokenRequests                                  float64 `perfdata:"Token Requests"`
+	UsernamePasswordAuthenticationFailures         float64 `perfdata:"U/P Authentication Failures"`
+	UsernamePasswordAuthentications                float64 `perfdata:"U/P Authentications"`
+	WindowsIntegratedAuthentications               float64 `perfdata:"Windows Integrated Authentications"`
+	WsFedTokenRequests                             float64 `perfdata:"WS-Fed Token Requests"`
+	WsTrustTokenRequests                           float64 `perfdata:"WS-Trust Token Requests"`
+}

internal/collector/cache/cache.go

@@ -21,7 +21,7 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/mi"
-	"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"
 )
@@ -37,7 +37,8 @@ var ConfigDefaults = Config{}
 type Collector struct {
 	config Config
 
-	perfDataCollector *perfdata.Collector
+	perfDataCollector *pdh.Collector
+	perfDataObject    []perfDataCounterValues
 
 	asyncCopyReadsTotal         *prometheus.Desc
 	asyncDataMapsTotal          *prometheus.Desc
@@ -99,37 +100,7 @@ func (c *Collector) Close() error {
 func (c *Collector) Build(_ *slog.Logger, _ *mi.Session) error {
 	var err error
 
-	c.perfDataCollector, err = perfdata.NewCollector("Cache", perfdata.InstancesAll, []string{
-		asyncCopyReadsTotal,
-		asyncDataMapsTotal,
-		asyncFastReadsTotal,
-		asyncMDLReadsTotal,
-		asyncPinReadsTotal,
-		copyReadHitsTotal,
-		copyReadsTotal,
-		dataFlushesTotal,
-		dataFlushPagesTotal,
-		dataMapHitsPercent,
-		dataMapPinsTotal,
-		dataMapsTotal,
-		dirtyPages,
-		dirtyPageThreshold,
-		fastReadNotPossiblesTotal,
-		fastReadResourceMissesTotal,
-		fastReadsTotal,
-		lazyWriteFlushesTotal,
-		lazyWritePagesTotal,
-		mdlReadHitsTotal,
-		mdlReadsTotal,
-		pinReadHitsTotal,
-		pinReadsTotal,
-		readAheadsTotal,
-		syncCopyReadsTotal,
-		syncDataMapsTotal,
-		syncFastReadsTotal,
-		syncMDLReadsTotal,
-		syncPinReadsTotal,
-	})
+	c.perfDataCollector, err = pdh.NewCollector[perfDataCounterValues](pdh.CounterTypeRaw, "Cache", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create Cache collector: %w", err)
 	}
@@ -314,189 +285,183 @@ func (c *Collector) Build(_ *slog.Logger, _ *mi.Session) error {
 
 // Collect implements the Collector interface.
 func (c *Collector) Collect(ch chan<- prometheus.Metric) error {
-	data, err := c.perfDataCollector.Collect()
+	err := c.perfDataCollector.Collect(&c.perfDataObject)
 	if err != nil {
 		return fmt.Errorf("failed to collect Cache metrics: %w", err)
 	}
 
-	cacheData, ok := data[perfdata.InstanceEmpty]
-
-	if !ok {
-		return fmt.Errorf("failed to collect Cache metrics: %w", types.ErrNoData)
-	}
-
 	ch <- prometheus.MustNewConstMetric(
 		c.asyncCopyReadsTotal,
 		prometheus.CounterValue,
-		cacheData[asyncCopyReadsTotal].FirstValue,
+		c.perfDataObject[0].AsyncCopyReadsTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.asyncDataMapsTotal,
 		prometheus.CounterValue,
-		cacheData[asyncDataMapsTotal].FirstValue,
+		c.perfDataObject[0].AsyncDataMapsTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.asyncFastReadsTotal,
 		prometheus.CounterValue,
-		cacheData[asyncFastReadsTotal].FirstValue,
+		c.perfDataObject[0].AsyncFastReadsTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.asyncMDLReadsTotal,
 		prometheus.CounterValue,
-		cacheData[asyncMDLReadsTotal].FirstValue,
+		c.perfDataObject[0].AsyncMDLReadsTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.asyncPinReadsTotal,
 		prometheus.CounterValue,
-		cacheData[asyncPinReadsTotal].FirstValue,
+		c.perfDataObject[0].AsyncPinReadsTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.copyReadHitsTotal,
 		prometheus.GaugeValue,
-		cacheData[copyReadHitsTotal].FirstValue,
+		c.perfDataObject[0].CopyReadHitsTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.copyReadsTotal,
 		prometheus.CounterValue,
-		cacheData[copyReadsTotal].FirstValue,
+		c.perfDataObject[0].CopyReadsTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.dataFlushesTotal,
 		prometheus.CounterValue,
-		cacheData[dataFlushesTotal].FirstValue,
+		c.perfDataObject[0].DataFlushesTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.dataFlushPagesTotal,
 		prometheus.CounterValue,
-		cacheData[dataFlushPagesTotal].FirstValue,
+		c.perfDataObject[0].DataFlushPagesTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.dataMapHitsPercent,
 		prometheus.GaugeValue,
-		cacheData[dataMapHitsPercent].FirstValue,
+		c.perfDataObject[0].DataMapHitsPercent,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.dataMapPinsTotal,
 		prometheus.CounterValue,
-		cacheData[dataMapPinsTotal].FirstValue,
+		c.perfDataObject[0].DataMapPinsTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.dataMapsTotal,
 		prometheus.CounterValue,
-		cacheData[dataMapsTotal].FirstValue,
+		c.perfDataObject[0].DataMapsTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.dirtyPages,
 		prometheus.GaugeValue,
-		cacheData[dirtyPages].FirstValue,
+		c.perfDataObject[0].DirtyPages,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.dirtyPageThreshold,
 		prometheus.GaugeValue,
-		cacheData[dirtyPageThreshold].FirstValue,
+		c.perfDataObject[0].DirtyPageThreshold,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.fastReadNotPossiblesTotal,
 		prometheus.CounterValue,
-		cacheData[fastReadNotPossiblesTotal].FirstValue,
+		c.perfDataObject[0].FastReadNotPossiblesTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.fastReadResourceMissesTotal,
 		prometheus.CounterValue,
-		cacheData[fastReadResourceMissesTotal].FirstValue,
+		c.perfDataObject[0].FastReadResourceMissesTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.fastReadsTotal,
 		prometheus.CounterValue,
-		cacheData[fastReadsTotal].FirstValue,
+		c.perfDataObject[0].FastReadsTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.lazyWriteFlushesTotal,
 		prometheus.CounterValue,
-		cacheData[lazyWriteFlushesTotal].FirstValue,
+		c.perfDataObject[0].LazyWriteFlushesTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.lazyWritePagesTotal,
 		prometheus.CounterValue,
-		cacheData[lazyWritePagesTotal].FirstValue,
+		c.perfDataObject[0].LazyWritePagesTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.mdlReadHitsTotal,
 		prometheus.CounterValue,
-		cacheData[mdlReadHitsTotal].FirstValue,
+		c.perfDataObject[0].MdlReadHitsTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.mdlReadsTotal,
 		prometheus.CounterValue,
-		cacheData[mdlReadsTotal].FirstValue,
+		c.perfDataObject[0].MdlReadsTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.pinReadHitsTotal,
 		prometheus.CounterValue,
-		cacheData[pinReadHitsTotal].FirstValue,
+		c.perfDataObject[0].PinReadHitsTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.pinReadsTotal,
 		prometheus.CounterValue,
-		cacheData[pinReadsTotal].FirstValue,
+		c.perfDataObject[0].PinReadsTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.readAheadsTotal,
 		prometheus.CounterValue,
-		cacheData[readAheadsTotal].FirstValue,
+		c.perfDataObject[0].ReadAheadsTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.syncCopyReadsTotal,
 		prometheus.CounterValue,
-		cacheData[syncCopyReadsTotal].FirstValue,
+		c.perfDataObject[0].SyncCopyReadsTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.syncDataMapsTotal,
 		prometheus.CounterValue,
-		cacheData[syncDataMapsTotal].FirstValue,
+		c.perfDataObject[0].SyncDataMapsTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.syncFastReadsTotal,
 		prometheus.CounterValue,
-		cacheData[syncFastReadsTotal].FirstValue,
+		c.perfDataObject[0].SyncFastReadsTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.syncMDLReadsTotal,
 		prometheus.CounterValue,
-		cacheData[syncMDLReadsTotal].FirstValue,
+		c.perfDataObject[0].SyncMDLReadsTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.syncPinReadsTotal,
 		prometheus.CounterValue,
-		cacheData[syncPinReadsTotal].FirstValue,
+		c.perfDataObject[0].SyncPinReadsTotal,
 	)
 
 	return nil

internal/collector/cache/cache_test.go

@@ -25,3 +25,7 @@ import (
 func BenchmarkCollector(b *testing.B) {
 	testutils.FuncBenchmarkCollector(b, cache.Name, cache.NewWithFlags)
 }
+
+func TestCollector(t *testing.T) {
+	testutils.TestCollector(t, cache.New, nil)
+}

internal/collector/cache/const.go

@@ -1,50 +0,0 @@
-// Copyright 2024 The Prometheus Authors
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//go:build windows
-
-package cache
-
-// Perflib "Cache":
-// - https://docs.microsoft.com/en-us/previous-versions/aa394267(v=vs.85)
-const (
-	asyncCopyReadsTotal         = "Async Copy Reads/sec"
-	asyncDataMapsTotal          = "Async Data Maps/sec"
-	asyncFastReadsTotal         = "Async Fast Reads/sec"
-	asyncMDLReadsTotal          = "Async MDL Reads/sec"
-	asyncPinReadsTotal          = "Async Pin Reads/sec"
-	copyReadHitsTotal           = "Copy Read Hits %"
-	copyReadsTotal              = "Copy Reads/sec"
-	dataFlushesTotal            = "Data Flushes/sec"
-	dataFlushPagesTotal         = "Data Flush Pages/sec"
-	dataMapHitsPercent          = "Data Map Hits %"
-	dataMapPinsTotal            = "Data Map Pins/sec"
-	dataMapsTotal               = "Data Maps/sec"
-	dirtyPages                  = "Dirty Pages"
-	dirtyPageThreshold          = "Dirty Page Threshold"
-	fastReadNotPossiblesTotal   = "Fast Read Not Possibles/sec"
-	fastReadResourceMissesTotal = "Fast Read Resource Misses/sec"
-	fastReadsTotal              = "Fast Reads/sec"
-	lazyWriteFlushesTotal       = "Lazy Write Flushes/sec"
-	lazyWritePagesTotal         = "Lazy Write Pages/sec"
-	mdlReadHitsTotal            = "MDL Read Hits %"
-	mdlReadsTotal               = "MDL Reads/sec"
-	pinReadHitsTotal            = "Pin Read Hits %"
-	pinReadsTotal               = "Pin Reads/sec"
-	readAheadsTotal             = "Read Aheads/sec"
-	syncCopyReadsTotal          = "Sync Copy Reads/sec"
-	syncDataMapsTotal           = "Sync Data Maps/sec"
-	syncFastReadsTotal          = "Sync Fast Reads/sec"
-	syncMDLReadsTotal           = "Sync MDL Reads/sec"
-	syncPinReadsTotal           = "Sync Pin Reads/sec"
-)

internal/collector/cache/types.go

@@ -0,0 +1,50 @@
+// Copyright 2024 The Prometheus Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//go:build windows
+
+package cache
+
+// Perflib "Cache":
+// - https://docs.microsoft.com/en-us/previous-versions/aa394267(v=vs.85)
+type perfDataCounterValues struct {
+	AsyncCopyReadsTotal         float64 `perfdata:"Async Copy Reads/sec"`
+	AsyncDataMapsTotal          float64 `perfdata:"Async Data Maps/sec"`
+	AsyncFastReadsTotal         float64 `perfdata:"Async Fast Reads/sec"`
+	AsyncMDLReadsTotal          float64 `perfdata:"Async MDL Reads/sec"`
+	AsyncPinReadsTotal          float64 `perfdata:"Async Pin Reads/sec"`
+	CopyReadHitsTotal           float64 `perfdata:"Copy Read Hits %"`
+	CopyReadsTotal              float64 `perfdata:"Copy Reads/sec"`
+	DataFlushesTotal            float64 `perfdata:"Data Flushes/sec"`
+	DataFlushPagesTotal         float64 `perfdata:"Data Flush Pages/sec"`
+	DataMapHitsPercent          float64 `perfdata:"Data Map Hits %"`
+	DataMapPinsTotal            float64 `perfdata:"Data Map Pins/sec"`
+	DataMapsTotal               float64 `perfdata:"Data Maps/sec"`
+	DirtyPages                  float64 `perfdata:"Dirty Pages"`
+	DirtyPageThreshold          float64 `perfdata:"Dirty Page Threshold"`
+	FastReadNotPossiblesTotal   float64 `perfdata:"Fast Read Not Possibles/sec"`
+	FastReadResourceMissesTotal float64 `perfdata:"Fast Read Resource Misses/sec"`
+	FastReadsTotal              float64 `perfdata:"Fast Reads/sec"`
+	LazyWriteFlushesTotal       float64 `perfdata:"Lazy Write Flushes/sec"`
+	LazyWritePagesTotal         float64 `perfdata:"Lazy Write Pages/sec"`
+	MdlReadHitsTotal            float64 `perfdata:"MDL Read Hits %"`
+	MdlReadsTotal               float64 `perfdata:"MDL Reads/sec"`
+	PinReadHitsTotal            float64 `perfdata:"Pin Read Hits %"`
+	PinReadsTotal               float64 `perfdata:"Pin Reads/sec"`
+	ReadAheadsTotal             float64 `perfdata:"Read Aheads/sec"`
+	SyncCopyReadsTotal          float64 `perfdata:"Sync Copy Reads/sec"`
+	SyncDataMapsTotal           float64 `perfdata:"Sync Data Maps/sec"`
+	SyncFastReadsTotal          float64 `perfdata:"Sync Fast Reads/sec"`
+	SyncMDLReadsTotal           float64 `perfdata:"Sync MDL Reads/sec"`
+	SyncPinReadsTotal           float64 `perfdata:"Sync Pin Reads/sec"`
+}

internal/collector/container/container.go

@@ -24,7 +24,7 @@ import (
 	"github.com/Microsoft/hcsshim"
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/mi"
-	"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"
 )
@@ -322,19 +322,19 @@ func (c *Collector) collectContainer(ch chan<- prometheus.Metric, containerDetai
 	ch <- prometheus.MustNewConstMetric(
 		c.runtimeTotal,
 		prometheus.CounterValue,
-		float64(containerStats.Processor.TotalRuntime100ns)*perfdata.TicksToSecondScaleFactor,
+		float64(containerStats.Processor.TotalRuntime100ns)*pdh.TicksToSecondScaleFactor,
 		containerIdWithPrefix,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.runtimeUser,
 		prometheus.CounterValue,
-		float64(containerStats.Processor.RuntimeUser100ns)*perfdata.TicksToSecondScaleFactor,
+		float64(containerStats.Processor.RuntimeUser100ns)*pdh.TicksToSecondScaleFactor,
 		containerIdWithPrefix,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.runtimeKernel,
 		prometheus.CounterValue,
-		float64(containerStats.Processor.RuntimeKernel100ns)*perfdata.TicksToSecondScaleFactor,
+		float64(containerStats.Processor.RuntimeKernel100ns)*pdh.TicksToSecondScaleFactor,
 		containerIdWithPrefix,
 	)
 	ch <- prometheus.MustNewConstMetric(

internal/collector/container/container_test.go

@@ -25,3 +25,7 @@ import (
 func BenchmarkCollector(b *testing.B) {
 	testutils.FuncBenchmarkCollector(b, container.Name, container.NewWithFlags)
 }
+
+func TestCollector(t *testing.T) {
+	testutils.TestCollector(t, container.New, nil)
+}

internal/collector/cpu/const.go

@@ -1,43 +0,0 @@
-// Copyright 2024 The Prometheus Authors
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//go:build windows
-
-package cpu
-
-// Processor performance counters.
-const (
-	c1TimeSeconds            = "% C1 Time"
-	c2TimeSeconds            = "% C2 Time"
-	c3TimeSeconds            = "% C3 Time"
-	c1TransitionsTotal       = "C1 Transitions/sec"
-	c2TransitionsTotal       = "C2 Transitions/sec"
-	c3TransitionsTotal       = "C3 Transitions/sec"
-	clockInterruptsTotal     = "Clock Interrupts/sec"
-	dpcQueuedPerSecond       = "DPCs Queued/sec"
-	dpcTimeSeconds           = "% DPC Time"
-	idleBreakEventsTotal     = "Idle Break Events/sec"
-	idleTimeSeconds          = "% Idle Time"
-	interruptsTotal          = "Interrupts/sec"
-	interruptTimeSeconds     = "% Interrupt Time"
-	parkingStatus            = "Parking Status"
-	performanceLimitPercent  = "% Performance Limit"
-	priorityTimeSeconds      = "% Priority Time"
-	privilegedTimeSeconds    = "% Privileged Time"
-	privilegedUtilitySeconds = "% Privileged Utility"
-	processorFrequencyMHz    = "Processor Frequency"
-	processorPerformance     = "% Processor Performance"
-	processorTimeSeconds     = "% Processor Time"
-	processorUtilityRate     = "% Processor Utility"
-	userTimeSeconds          = "% User Time"
-)

internal/collector/cpu/cpu.go

@@ -22,7 +22,7 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/mi"
-	"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"
@@ -38,7 +38,8 @@ var ConfigDefaults = Config{}
 type Collector struct {
 	config Config
 
-	perfDataCollector *perfdata.Collector
+	perfDataCollector *pdh.Collector
+	perfDataObject    []perfDataCounterValues
 
 	mu sync.Mutex
 
@@ -92,31 +93,7 @@ func (c *Collector) Build(_ *slog.Logger, _ *mi.Session) error {
 
 	c.mu = sync.Mutex{}
 
-	c.perfDataCollector, err = perfdata.NewCollector("Processor Information", perfdata.InstancesAll, []string{
-		c1TimeSeconds,
-		c2TimeSeconds,
-		c3TimeSeconds,
-		c1TransitionsTotal,
-		c2TransitionsTotal,
-		c3TransitionsTotal,
-		clockInterruptsTotal,
-		dpcQueuedPerSecond,
-		dpcTimeSeconds,
-		idleBreakEventsTotal,
-		idleTimeSeconds,
-		interruptsTotal,
-		interruptTimeSeconds,
-		parkingStatus,
-		performanceLimitPercent,
-		priorityTimeSeconds,
-		privilegedTimeSeconds,
-		privilegedUtilitySeconds,
-		processorFrequencyMHz,
-		processorPerformance,
-		processorTimeSeconds,
-		processorUtilityRate,
-		userTimeSeconds,
-	})
+	c.perfDataCollector, err = pdh.NewCollector[perfDataCounterValues](pdh.CounterTypeRaw, "Processor Information", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create Processor Information collector: %w", err)
 	}
@@ -216,14 +193,15 @@ func (c *Collector) Collect(ch chan<- prometheus.Metric) error {
 	c.mu.Lock() // Lock is needed to prevent concurrent map access to c.processorRTCValues
 	defer c.mu.Unlock()
 
-	data, err := c.perfDataCollector.Collect()
+	err := c.perfDataCollector.Collect(&c.perfDataObject)
 	if err != nil {
 		return fmt.Errorf("failed to collect Processor Information metrics: %w", err)
 	}
 
 	var coreCount float64
 
-	for core, coreData := range data {
+	for _, coreData := range c.perfDataObject {
+		core := coreData.Name
 		coreCount++
 
 		var (
@@ -233,17 +211,17 @@ func (c *Collector) Collect(ch chan<- prometheus.Metric) error {
 		)
 
 		if counterProcessorRTCValues, ok = c.processorRTCValues[core]; ok {
-			counterProcessorRTCValues.AddValue(uint32(coreData[processorUtilityRate].SecondValue))
+			counterProcessorRTCValues.AddValue(uint32(coreData.ProcessorUtilityRateSecondValue))
 		} else {
-			counterProcessorRTCValues = utils.NewCounter(uint32(coreData[privilegedUtilitySeconds].SecondValue))
+			counterProcessorRTCValues = utils.NewCounter(uint32(coreData.ProcessorUtilityRateSecondValue))
 		}
 
 		c.processorRTCValues[core] = counterProcessorRTCValues
 
 		if counterProcessorMPerfValues, ok = c.processorMPerfValues[core]; ok {
-			counterProcessorMPerfValues.AddValue(uint32(coreData[processorPerformance].SecondValue))
+			counterProcessorMPerfValues.AddValue(uint32(coreData.ProcessorPerformanceSecondValue))
 		} else {
-			counterProcessorMPerfValues = utils.NewCounter(uint32(coreData[processorPerformance].SecondValue))
+			counterProcessorMPerfValues = utils.NewCounter(uint32(coreData.ProcessorPerformanceSecondValue))
 		}
 
 		c.processorMPerfValues[core] = counterProcessorMPerfValues
@@ -251,95 +229,95 @@ func (c *Collector) Collect(ch chan<- prometheus.Metric) error {
 		ch <- prometheus.MustNewConstMetric(
 			c.cStateSecondsTotal,
 			prometheus.CounterValue,
-			coreData[c1TimeSeconds].FirstValue,
+			coreData.C1TimeSeconds,
 			core, "c1",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.cStateSecondsTotal,
 			prometheus.CounterValue,
-			coreData[c2TimeSeconds].FirstValue,
+			coreData.C2TimeSeconds,
 			core, "c2",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.cStateSecondsTotal,
 			prometheus.CounterValue,
-			coreData[c3TimeSeconds].FirstValue,
+			coreData.C3TimeSeconds,
 			core, "c3",
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.timeTotal,
 			prometheus.CounterValue,
-			coreData[idleTimeSeconds].FirstValue,
+			coreData.IdleTimeSeconds,
 			core, "idle",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.timeTotal,
 			prometheus.CounterValue,
-			coreData[interruptTimeSeconds].FirstValue,
+			coreData.InterruptTimeSeconds,
 			core, "interrupt",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.timeTotal,
 			prometheus.CounterValue,
-			coreData[dpcTimeSeconds].FirstValue,
+			coreData.DpcTimeSeconds,
 			core, "dpc",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.timeTotal,
 			prometheus.CounterValue,
-			coreData[privilegedTimeSeconds].FirstValue,
+			coreData.PrivilegedTimeSeconds,
 			core, "privileged",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.timeTotal,
 			prometheus.CounterValue,
-			coreData[userTimeSeconds].FirstValue,
+			coreData.UserTimeSeconds,
 			core, "user",
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.interruptsTotal,
 			prometheus.CounterValue,
-			coreData[interruptsTotal].FirstValue,
+			coreData.InterruptsTotal,
 			core,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.dpcsTotal,
 			prometheus.CounterValue,
-			coreData[dpcQueuedPerSecond].FirstValue,
+			coreData.DpcQueuedPerSecond,
 			core,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.clockInterruptsTotal,
 			prometheus.CounterValue,
-			coreData[clockInterruptsTotal].FirstValue,
+			coreData.ClockInterruptsTotal,
 			core,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.idleBreakEventsTotal,
 			prometheus.CounterValue,
-			coreData[idleBreakEventsTotal].FirstValue,
+			coreData.IdleBreakEventsTotal,
 			core,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.parkingStatus,
 			prometheus.GaugeValue,
-			coreData[parkingStatus].FirstValue,
+			coreData.ParkingStatus,
 			core,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.processorFrequencyMHz,
 			prometheus.GaugeValue,
-			coreData[processorFrequencyMHz].FirstValue,
+			coreData.ProcessorFrequencyMHz,
 			core,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.processorPerformance,
 			prometheus.CounterValue,
-			coreData[processorPerformance].FirstValue,
+			coreData.ProcessorPerformance,
 			core,
 		)
 		ch <- prometheus.MustNewConstMetric(
@@ -357,13 +335,13 @@ func (c *Collector) Collect(ch chan<- prometheus.Metric) error {
 		ch <- prometheus.MustNewConstMetric(
 			c.processorUtility,
 			prometheus.CounterValue,
-			coreData[processorUtilityRate].FirstValue,
+			coreData.ProcessorUtilityRate,
 			core,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.processorPrivilegedUtility,
 			prometheus.CounterValue,
-			coreData[privilegedUtilitySeconds].FirstValue,
+			coreData.PrivilegedUtilitySeconds,
 			core,
 		)
 	}

internal/collector/cpu/types.go

@@ -0,0 +1,47 @@
+// Copyright 2024 The Prometheus Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//go:build windows
+
+package cpu
+
+// Processor performance counters.
+type perfDataCounterValues struct {
+	Name string
+
+	C1TimeSeconds                   float64 `perfdata:"% C1 Time"`
+	C2TimeSeconds                   float64 `perfdata:"% C2 Time"`
+	C3TimeSeconds                   float64 `perfdata:"% C3 Time"`
+	C1TransitionsTotal              float64 `perfdata:"C1 Transitions/sec"`
+	C2TransitionsTotal              float64 `perfdata:"C2 Transitions/sec"`
+	C3TransitionsTotal              float64 `perfdata:"C3 Transitions/sec"`
+	ClockInterruptsTotal            float64 `perfdata:"Clock Interrupts/sec"`
+	DpcQueuedPerSecond              float64 `perfdata:"DPCs Queued/sec"`
+	DpcTimeSeconds                  float64 `perfdata:"% DPC Time"`
+	IdleBreakEventsTotal            float64 `perfdata:"Idle Break Events/sec"`
+	IdleTimeSeconds                 float64 `perfdata:"% Idle Time"`
+	InterruptsTotal                 float64 `perfdata:"Interrupts/sec"`
+	InterruptTimeSeconds            float64 `perfdata:"% Interrupt Time"`
+	ParkingStatus                   float64 `perfdata:"Parking Status"`
+	PerformanceLimitPercent         float64 `perfdata:"% Performance Limit"`
+	PriorityTimeSeconds             float64 `perfdata:"% Priority Time"`
+	PrivilegedTimeSeconds           float64 `perfdata:"% Privileged Time"`
+	PrivilegedUtilitySeconds        float64 `perfdata:"% Privileged Utility"`
+	ProcessorFrequencyMHz           float64 `perfdata:"Processor Frequency"`
+	ProcessorPerformance            float64 `perfdata:"% Processor Performance"`
+	ProcessorPerformanceSecondValue float64 `perfdata:"% Processor Performance,secondvalue"`
+	ProcessorTimeSeconds            float64 `perfdata:"% Processor Time"`
+	ProcessorUtilityRate            float64 `perfdata:"% Processor Utility"`
+	ProcessorUtilityRateSecondValue float64 `perfdata:"% Processor Utility,secondvalue"`
+	UserTimeSeconds                 float64 `perfdata:"% User Time"`
+}

internal/collector/cs/cs.go

@@ -37,7 +37,7 @@ type Collector struct {
 	config Config
 
 	// physicalMemoryBytes
-	// Deprecated: Use windows_physical_memory_total_bytes instead
+	// Deprecated: Use windows_memory_physical_total_bytes instead
 	physicalMemoryBytes *prometheus.Desc
 	// logicalProcessors
 	// Deprecated: Use windows_cpu_logical_processor instead
@@ -85,7 +85,7 @@ func (c *Collector) Build(logger *slog.Logger, _ *mi.Session) error {
 	)
 	c.physicalMemoryBytes = prometheus.NewDesc(
 		prometheus.BuildFQName(types.Namespace, Name, "physical_memory_bytes"),
-		"Deprecated: Use windows_physical_memory_total_bytes instead",
+		"Deprecated: Use windows_memory_physical_total_bytes instead",
 		nil,
 		nil,
 	)

internal/collector/cs/cs_test.go

@@ -25,3 +25,7 @@ import (
 func BenchmarkCollector(b *testing.B) {
 	testutils.FuncBenchmarkCollector(b, cs.Name, cs.NewWithFlags)
 }
+
+func TestCollector(t *testing.T) {
+	testutils.TestCollector(t, cs.New, nil)
+}

internal/collector/dfsr/const.go

@@ -1,57 +0,0 @@
-// Copyright 2024 The Prometheus Authors
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//go:build windows
-
-package dfsr
-
-const (
-	// Connection Perflib: "DFS Replication Service Connections".
-	bytesReceivedTotal = "Total Bytes Received"
-
-	// Folder Perflib: "DFS Replicated Folder".
-	bandwidthSavingsUsingDFSReplicationTotal = "Bandwidth Savings Using DFS Replication"
-	compressedSizeOfFilesReceivedTotal       = "Compressed Size of Files Received"
-	conflictBytesCleanedUpTotal              = "Conflict Bytes Cleaned Up"
-	conflictBytesGeneratedTotal              = "Conflict Bytes Generated"
-	conflictFilesCleanedUpTotal              = "Conflict Files Cleaned Up"
-	conflictFilesGeneratedTotal              = "Conflict Files Generated"
-	conflictFolderCleanupsCompletedTotal     = "Conflict folder Cleanups Completed"
-	conflictSpaceInUse                       = "Conflict Space In Use"
-	deletedSpaceInUse                        = "Deleted Space In Use"
-	deletedBytesCleanedUpTotal               = "Deleted Bytes Cleaned Up"
-	deletedBytesGeneratedTotal               = "Deleted Bytes Generated"
-	deletedFilesCleanedUpTotal               = "Deleted Files Cleaned Up"
-	deletedFilesGeneratedTotal               = "Deleted Files Generated"
-	fileInstallsRetriedTotal                 = "File Installs Retried"
-	fileInstallsSucceededTotal               = "File Installs Succeeded"
-	filesReceivedTotal                       = "Total Files Received"
-	rdcBytesReceivedTotal                    = "RDC Bytes Received"
-	rdcCompressedSizeOfFilesReceivedTotal    = "RDC Compressed Size of Files Received"
-	rdcNumberOfFilesReceivedTotal            = "RDC Number of Files Received"
-	rdcSizeOfFilesReceivedTotal              = "RDC Size of Files Received"
-	sizeOfFilesReceivedTotal                 = "Size of Files Received"
-	stagingSpaceInUse                        = "Staging Space In Use"
-	stagingBytesCleanedUpTotal               = "Staging Bytes Cleaned Up"
-	stagingBytesGeneratedTotal               = "Staging Bytes Generated"
-	stagingFilesCleanedUpTotal               = "Staging Files Cleaned Up"
-	stagingFilesGeneratedTotal               = "Staging Files Generated"
-	updatesDroppedTotal                      = "Updates Dropped"
-
-	// Volume Perflib: "DFS Replication Service Volumes".
-	databaseCommitsTotal           = "Database Commits"
-	databaseLookupsTotal           = "Database Lookups"
-	usnJournalRecordsReadTotal     = "USN Journal Records Read"
-	usnJournalRecordsAcceptedTotal = "USN Journal Records Accepted"
-	usnJournalUnreadPercentage     = "USN Journal Unread Percentage"
-)

internal/collector/dfsr/dfsr.go

@@ -24,7 +24,7 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/mi"
-	"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"
 )
@@ -44,9 +44,12 @@ var ConfigDefaults = Config{
 type Collector struct {
 	config Config
 
-	perfDataCollectorConnection *perfdata.Collector
-	perfDataCollectorFolder     *perfdata.Collector
-	perfDataCollectorVolume     *perfdata.Collector
+	perfDataCollectorConnection *pdh.Collector
+	perfDataCollectorFolder     *pdh.Collector
+	perfDataCollectorVolume     *pdh.Collector
+	perfDataObjectConnection    []perfDataCounterValuesConnection
+	perfDataObjectFolder        []perfDataCounterValuesFolder
+	perfDataObjectVolume        []perfDataCounterValuesVolume
 
 	// connection source
 	connectionBandwidthSavingsUsingDFSReplicationTotal *prometheus.Desc
@@ -160,69 +163,26 @@ func (c *Collector) Build(logger *slog.Logger, _ *mi.Session) error {
 	var err error
 
 	if slices.Contains(c.config.CollectorsEnabled, "connection") {
-		c.perfDataCollectorConnection, err = perfdata.NewCollector("DFS Replication Connections", perfdata.InstancesAll, []string{
-			bandwidthSavingsUsingDFSReplicationTotal,
-			bytesReceivedTotal,
-			compressedSizeOfFilesReceivedTotal,
-			filesReceivedTotal,
-			rdcBytesReceivedTotal,
-			rdcCompressedSizeOfFilesReceivedTotal,
-			rdcNumberOfFilesReceivedTotal,
-			rdcSizeOfFilesReceivedTotal,
-			sizeOfFilesReceivedTotal,
-		})
+		c.perfDataCollectorConnection, err = pdh.NewCollector[perfDataCounterValuesConnection](pdh.CounterTypeRaw, "DFS Replication Connections", pdh.InstancesAll)
 		if err != nil {
 			return fmt.Errorf("failed to create DFS Replication Connections collector: %w", err)
 		}
 	}
 
 	if slices.Contains(c.config.CollectorsEnabled, "folder") {
-		c.perfDataCollectorFolder, err = perfdata.NewCollector("DFS Replicated Folders", perfdata.InstancesAll, []string{
-			bandwidthSavingsUsingDFSReplicationTotal,
-			compressedSizeOfFilesReceivedTotal,
-			conflictBytesCleanedUpTotal,
-			conflictBytesGeneratedTotal,
-			conflictFilesCleanedUpTotal,
-			conflictFilesGeneratedTotal,
-			conflictFolderCleanupsCompletedTotal,
-			conflictSpaceInUse,
-			deletedSpaceInUse,
-			deletedBytesCleanedUpTotal,
-			deletedBytesGeneratedTotal,
-			deletedFilesCleanedUpTotal,
-			deletedFilesGeneratedTotal,
-			fileInstallsRetriedTotal,
-			fileInstallsSucceededTotal,
-			filesReceivedTotal,
-			rdcBytesReceivedTotal,
-			rdcCompressedSizeOfFilesReceivedTotal,
-			rdcNumberOfFilesReceivedTotal,
-			rdcSizeOfFilesReceivedTotal,
-			sizeOfFilesReceivedTotal,
-			stagingSpaceInUse,
-			stagingBytesCleanedUpTotal,
-			stagingBytesGeneratedTotal,
-			stagingFilesCleanedUpTotal,
-			stagingFilesGeneratedTotal,
-			updatesDroppedTotal,
-		})
+		c.perfDataCollectorFolder, err = pdh.NewCollector[perfDataCounterValuesFolder](pdh.CounterTypeRaw, "DFS Replicated Folders", pdh.InstancesAll)
 		if err != nil {
 			return fmt.Errorf("failed to create DFS Replicated Folders collector: %w", err)
 		}
 	}
 
 	if slices.Contains(c.config.CollectorsEnabled, "volume") {
-		c.perfDataCollectorVolume, err = perfdata.NewCollector("DFS Replication Service Volumes", perfdata.InstancesAll, []string{
-			databaseCommitsTotal,
-			databaseLookupsTotal,
-			usnJournalRecordsReadTotal,
-			usnJournalRecordsAcceptedTotal,
-			usnJournalUnreadPercentage,
-		})
+		c.perfDataCollectorVolume, err = pdh.NewCollector[perfDataCounterValuesVolume](pdh.CounterTypeRaw, "DFS Replication Service Volumes", pdh.InstancesAll)
 		if err != nil {
 			return fmt.Errorf("failed to create DFS Replication Service Volumes collector: %w", err)
 		}
 	}
+
 	// connection
 	c.connectionBandwidthSavingsUsingDFSReplicationTotal = prometheus.NewDesc(
 		prometheus.BuildFQName(types.Namespace, Name, "connection_bandwidth_savings_using_dfs_replication_bytes_total"),
@@ -537,76 +497,74 @@ func (c *Collector) Collect(ch chan<- prometheus.Metric) error {
 }
 
 func (c *Collector) collectPDHConnection(ch chan<- prometheus.Metric) error {
-	perfData, err := c.perfDataCollectorConnection.Collect()
+	err := c.perfDataCollectorConnection.Collect(&c.perfDataObjectConnection)
 	if err != nil {
 		return fmt.Errorf("failed to collect DFS Replication Connections metrics: %w", err)
 	}
 
-	if len(perfData) == 0 {
-		return fmt.Errorf("failed to collect DFS Replication Connections metrics: %w", types.ErrNoData)
-	}
+	for _, connection := range c.perfDataObjectConnection {
+		name := connection.Name
 
-	for name, connection := range perfData {
 		ch <- prometheus.MustNewConstMetric(
 			c.connectionBandwidthSavingsUsingDFSReplicationTotal,
 			prometheus.CounterValue,
-			connection[bandwidthSavingsUsingDFSReplicationTotal].FirstValue,
+			connection.BandwidthSavingsUsingDFSReplicationTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.connectionBytesReceivedTotal,
 			prometheus.CounterValue,
-			connection[bytesReceivedTotal].FirstValue,
+			connection.BytesReceivedTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.connectionCompressedSizeOfFilesReceivedTotal,
 			prometheus.CounterValue,
-			connection[compressedSizeOfFilesReceivedTotal].FirstValue,
+			connection.CompressedSizeOfFilesReceivedTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.connectionFilesReceivedTotal,
 			prometheus.CounterValue,
-			connection[filesReceivedTotal].FirstValue,
+			connection.FilesReceivedTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.connectionRDCBytesReceivedTotal,
 			prometheus.CounterValue,
-			connection[rdcBytesReceivedTotal].FirstValue,
+			connection.RdcBytesReceivedTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.connectionRDCCompressedSizeOfFilesReceivedTotal,
 			prometheus.CounterValue,
-			connection[rdcCompressedSizeOfFilesReceivedTotal].FirstValue,
+			connection.RdcCompressedSizeOfFilesReceivedTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.connectionRDCSizeOfFilesReceivedTotal,
 			prometheus.CounterValue,
-			connection[rdcSizeOfFilesReceivedTotal].FirstValue,
+			connection.RdcSizeOfFilesReceivedTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.connectionRDCNumberOfFilesReceivedTotal,
 			prometheus.CounterValue,
-			connection[rdcNumberOfFilesReceivedTotal].FirstValue,
+			connection.RdcNumberOfFilesReceivedTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.connectionSizeOfFilesReceivedTotal,
 			prometheus.CounterValue,
-			connection[sizeOfFilesReceivedTotal].FirstValue,
+			connection.SizeOfFilesReceivedTotal,
 			name,
 		)
 	}
@@ -615,202 +573,200 @@ func (c *Collector) collectPDHConnection(ch chan<- prometheus.Metric) error {
 }
 
 func (c *Collector) collectPDHFolder(ch chan<- prometheus.Metric) error {
-	perfData, err := c.perfDataCollectorFolder.Collect()
+	err := c.perfDataCollectorFolder.Collect(&c.perfDataObjectFolder)
 	if err != nil {
 		return fmt.Errorf("failed to collect DFS Replicated Folders metrics: %w", err)
 	}
 
-	if len(perfData) == 0 {
-		return fmt.Errorf("failed to collect DFS Replicated Folders metrics: %w", types.ErrNoData)
-	}
+	for _, folder := range c.perfDataObjectFolder {
+		name := folder.Name
 
-	for name, folder := range perfData {
 		ch <- prometheus.MustNewConstMetric(
 			c.folderBandwidthSavingsUsingDFSReplicationTotal,
 			prometheus.CounterValue,
-			folder[bandwidthSavingsUsingDFSReplicationTotal].FirstValue,
+			folder.BandwidthSavingsUsingDFSReplicationTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderCompressedSizeOfFilesReceivedTotal,
 			prometheus.CounterValue,
-			folder[compressedSizeOfFilesReceivedTotal].FirstValue,
+			folder.CompressedSizeOfFilesReceivedTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderConflictBytesCleanedUpTotal,
 			prometheus.CounterValue,
-			folder[conflictBytesCleanedUpTotal].FirstValue,
+			folder.ConflictBytesCleanedUpTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderConflictBytesGeneratedTotal,
 			prometheus.CounterValue,
-			folder[conflictBytesGeneratedTotal].FirstValue,
+			folder.ConflictBytesGeneratedTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderConflictFilesCleanedUpTotal,
 			prometheus.CounterValue,
-			folder[conflictFilesCleanedUpTotal].FirstValue,
+			folder.ConflictFilesCleanedUpTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderConflictFilesGeneratedTotal,
 			prometheus.CounterValue,
-			folder[conflictFilesGeneratedTotal].FirstValue,
+			folder.ConflictFilesGeneratedTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderConflictFolderCleanupsCompletedTotal,
 			prometheus.CounterValue,
-			folder[conflictFolderCleanupsCompletedTotal].FirstValue,
+			folder.ConflictFolderCleanupsCompletedTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderConflictSpaceInUse,
 			prometheus.GaugeValue,
-			folder[conflictSpaceInUse].FirstValue,
+			folder.ConflictSpaceInUse,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderDeletedSpaceInUse,
 			prometheus.GaugeValue,
-			folder[deletedSpaceInUse].FirstValue,
+			folder.DeletedSpaceInUse,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderDeletedBytesCleanedUpTotal,
 			prometheus.CounterValue,
-			folder[deletedBytesCleanedUpTotal].FirstValue,
+			folder.DeletedBytesCleanedUpTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderDeletedBytesGeneratedTotal,
 			prometheus.CounterValue,
-			folder[deletedBytesGeneratedTotal].FirstValue,
+			folder.DeletedBytesGeneratedTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderDeletedFilesCleanedUpTotal,
 			prometheus.CounterValue,
-			folder[deletedFilesCleanedUpTotal].FirstValue,
+			folder.DeletedFilesCleanedUpTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderDeletedFilesGeneratedTotal,
 			prometheus.CounterValue,
-			folder[deletedFilesGeneratedTotal].FirstValue,
+			folder.DeletedFilesGeneratedTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderFileInstallsRetriedTotal,
 			prometheus.CounterValue,
-			folder[fileInstallsRetriedTotal].FirstValue,
+			folder.FileInstallsRetriedTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderFileInstallsSucceededTotal,
 			prometheus.CounterValue,
-			folder[fileInstallsSucceededTotal].FirstValue,
+			folder.FileInstallsSucceededTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderFilesReceivedTotal,
 			prometheus.CounterValue,
-			folder[filesReceivedTotal].FirstValue,
+			folder.FilesReceivedTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderRDCBytesReceivedTotal,
 			prometheus.CounterValue,
-			folder[rdcBytesReceivedTotal].FirstValue,
+			folder.RdcBytesReceivedTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderRDCCompressedSizeOfFilesReceivedTotal,
 			prometheus.CounterValue,
-			folder[rdcCompressedSizeOfFilesReceivedTotal].FirstValue,
+			folder.RdcCompressedSizeOfFilesReceivedTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderRDCNumberOfFilesReceivedTotal,
 			prometheus.CounterValue,
-			folder[rdcNumberOfFilesReceivedTotal].FirstValue,
+			folder.RdcNumberOfFilesReceivedTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderRDCSizeOfFilesReceivedTotal,
 			prometheus.CounterValue,
-			folder[rdcSizeOfFilesReceivedTotal].FirstValue,
+			folder.RdcSizeOfFilesReceivedTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderSizeOfFilesReceivedTotal,
 			prometheus.CounterValue,
-			folder[sizeOfFilesReceivedTotal].FirstValue,
+			folder.SizeOfFilesReceivedTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderStagingSpaceInUse,
 			prometheus.GaugeValue,
-			folder[stagingSpaceInUse].FirstValue,
+			folder.StagingSpaceInUse,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderStagingBytesCleanedUpTotal,
 			prometheus.CounterValue,
-			folder[stagingBytesCleanedUpTotal].FirstValue,
+			folder.StagingBytesCleanedUpTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderStagingBytesGeneratedTotal,
 			prometheus.CounterValue,
-			folder[stagingBytesGeneratedTotal].FirstValue,
+			folder.StagingBytesGeneratedTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderStagingFilesCleanedUpTotal,
 			prometheus.CounterValue,
-			folder[stagingFilesCleanedUpTotal].FirstValue,
+			folder.StagingFilesCleanedUpTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderStagingFilesGeneratedTotal,
 			prometheus.CounterValue,
-			folder[stagingFilesGeneratedTotal].FirstValue,
+			folder.StagingFilesGeneratedTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.folderUpdatesDroppedTotal,
 			prometheus.CounterValue,
-			folder[updatesDroppedTotal].FirstValue,
+			folder.UpdatesDroppedTotal,
 			name,
 		)
 	}
@@ -819,48 +775,45 @@ func (c *Collector) collectPDHFolder(ch chan<- prometheus.Metric) error {
 }
 
 func (c *Collector) collectPDHVolume(ch chan<- prometheus.Metric) error {
-	perfData, err := c.perfDataCollectorVolume.Collect()
+	err := c.perfDataCollectorVolume.Collect(&c.perfDataObjectVolume)
 	if err != nil {
 		return fmt.Errorf("failed to collect DFS Replication Volumes metrics: %w", err)
 	}
 
-	if len(perfData) == 0 {
-		return fmt.Errorf("failed to collect DFS Replication Volumes metrics: %w", types.ErrNoData)
-	}
-
-	for name, volume := range perfData {
+	for _, volume := range c.perfDataObjectVolume {
+		name := volume.Name
 		ch <- prometheus.MustNewConstMetric(
 			c.volumeDatabaseLookupsTotal,
 			prometheus.CounterValue,
-			volume[databaseLookupsTotal].FirstValue,
+			volume.DatabaseLookupsTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.volumeDatabaseCommitsTotal,
 			prometheus.CounterValue,
-			volume[databaseCommitsTotal].FirstValue,
+			volume.DatabaseCommitsTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.volumeUSNJournalRecordsAcceptedTotal,
 			prometheus.CounterValue,
-			volume[usnJournalRecordsAcceptedTotal].FirstValue,
+			volume.UsnJournalRecordsAcceptedTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.volumeUSNJournalRecordsReadTotal,
 			prometheus.CounterValue,
-			volume[usnJournalRecordsReadTotal].FirstValue,
+			volume.UsnJournalRecordsReadTotal,
 			name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.volumeUSNJournalUnreadPercentage,
 			prometheus.GaugeValue,
-			volume[usnJournalUnreadPercentage].FirstValue,
+			volume.UsnJournalUnreadPercentage,
 			name,
 		)
 	}

internal/collector/dfsr/dfsr_test.go

@@ -25,3 +25,7 @@ import (
 func BenchmarkCollector(b *testing.B) {
 	testutils.FuncBenchmarkCollector(b, dfsr.Name, dfsr.NewWithFlags)
 }
+
+func TestCollector(t *testing.T) {
+	testutils.TestCollector(t, dfsr.New, nil)
+}

internal/collector/dfsr/types.go

@@ -0,0 +1,75 @@
+// Copyright 2024 The Prometheus Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//go:build windows
+
+package dfsr
+
+// Connection Perflib: "DFS Replication Service Connections".
+type perfDataCounterValuesConnection struct {
+	Name string
+
+	BandwidthSavingsUsingDFSReplicationTotal float64 `perfdata:"Bandwidth Savings Using DFS Replication"`
+	BytesReceivedTotal                       float64 `perfdata:"Total Bytes Received"`
+	CompressedSizeOfFilesReceivedTotal       float64 `perfdata:"Compressed Size of Files Received"`
+	FilesReceivedTotal                       float64 `perfdata:"Total Files Received"`
+	RdcBytesReceivedTotal                    float64 `perfdata:"RDC Bytes Received"`
+	RdcCompressedSizeOfFilesReceivedTotal    float64 `perfdata:"RDC Compressed Size of Files Received"`
+	RdcNumberOfFilesReceivedTotal            float64 `perfdata:"RDC Number of Files Received"`
+	RdcSizeOfFilesReceivedTotal              float64 `perfdata:"RDC Size of Files Received"`
+	SizeOfFilesReceivedTotal                 float64 `perfdata:"Size of Files Received"`
+}
+
+// Folder Perflib: "DFS Replicated Folder".
+type perfDataCounterValuesFolder struct {
+	Name string
+
+	BandwidthSavingsUsingDFSReplicationTotal float64 `perfdata:"Bandwidth Savings Using DFS Replication"`
+	CompressedSizeOfFilesReceivedTotal       float64 `perfdata:"Compressed Size of Files Received"`
+	ConflictBytesCleanedUpTotal              float64 `perfdata:"Conflict Bytes Cleaned Up"`
+	ConflictBytesGeneratedTotal              float64 `perfdata:"Conflict Bytes Generated"`
+	ConflictFilesCleanedUpTotal              float64 `perfdata:"Conflict Files Cleaned Up"`
+	ConflictFilesGeneratedTotal              float64 `perfdata:"Conflict Files Generated"`
+	ConflictFolderCleanupsCompletedTotal     float64 `perfdata:"Conflict folder Cleanups Completed"`
+	ConflictSpaceInUse                       float64 `perfdata:"Conflict Space In Use"`
+	DeletedSpaceInUse                        float64 `perfdata:"Deleted Space In Use"`
+	DeletedBytesCleanedUpTotal               float64 `perfdata:"Deleted Bytes Cleaned Up"`
+	DeletedBytesGeneratedTotal               float64 `perfdata:"Deleted Bytes Generated"`
+	DeletedFilesCleanedUpTotal               float64 `perfdata:"Deleted Files Cleaned Up"`
+	DeletedFilesGeneratedTotal               float64 `perfdata:"Deleted Files Generated"`
+	FileInstallsRetriedTotal                 float64 `perfdata:"File Installs Retried"`
+	FileInstallsSucceededTotal               float64 `perfdata:"File Installs Succeeded"`
+	FilesReceivedTotal                       float64 `perfdata:"Total Files Received"`
+	RdcBytesReceivedTotal                    float64 `perfdata:"RDC Bytes Received"`
+	RdcCompressedSizeOfFilesReceivedTotal    float64 `perfdata:"RDC Compressed Size of Files Received"`
+	RdcNumberOfFilesReceivedTotal            float64 `perfdata:"RDC Number of Files Received"`
+	RdcSizeOfFilesReceivedTotal              float64 `perfdata:"RDC Size of Files Received"`
+	SizeOfFilesReceivedTotal                 float64 `perfdata:"Size of Files Received"`
+	StagingSpaceInUse                        float64 `perfdata:"Staging Space In Use"`
+	StagingBytesCleanedUpTotal               float64 `perfdata:"Staging Bytes Cleaned Up"`
+	StagingBytesGeneratedTotal               float64 `perfdata:"Staging Bytes Generated"`
+	StagingFilesCleanedUpTotal               float64 `perfdata:"Staging Files Cleaned Up"`
+	StagingFilesGeneratedTotal               float64 `perfdata:"Staging Files Generated"`
+	UpdatesDroppedTotal                      float64 `perfdata:"Updates Dropped"`
+}
+
+// Volume Perflib: "DFS Replication Service Volumes".
+type perfDataCounterValuesVolume struct {
+	Name string
+
+	DatabaseCommitsTotal           float64 `perfdata:"Database Commits"`
+	DatabaseLookupsTotal           float64 `perfdata:"Database Lookups"`
+	UsnJournalRecordsReadTotal     float64 `perfdata:"USN Journal Records Read"`
+	UsnJournalRecordsAcceptedTotal float64 `perfdata:"USN Journal Records Accepted"`
+	UsnJournalUnreadPercentage     float64 `perfdata:"USN Journal Unread Percentage"`
+}

internal/collector/dhcp/const.go

@@ -1,44 +0,0 @@
-// Copyright 2024 The Prometheus Authors
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//go:build windows
-
-package dhcp
-
-const (
-	acksTotal                                        = "Acks/sec"
-	activeQueueLength                                = "Active Queue Length"
-	conflictCheckQueueLength                         = "Conflict Check Queue Length"
-	declinesTotal                                    = "Declines/sec"
-	deniedDueToMatch                                 = "Denied due to match."
-	deniedDueToNonMatch                              = "Denied due to match."
-	discoversTotal                                   = "Discovers/sec"
-	duplicatesDroppedTotal                           = "Duplicates Dropped/sec"
-	failoverBndAckReceivedTotal                      = "Failover: BndAck received/sec."
-	failoverBndAckSentTotal                          = "Failover: BndAck sent/sec."
-	failoverBndUpdDropped                            = "Failover: BndUpd Dropped."
-	failoverBndUpdPendingOutboundQueue               = "Failover: BndUpd pending in outbound queue."
-	failoverBndUpdReceivedTotal                      = "Failover: BndUpd received/sec."
-	failoverBndUpdSentTotal                          = "Failover: BndUpd sent/sec."
-	failoverTransitionsCommunicationInterruptedState = "Failover: Transitions to COMMUNICATION-INTERRUPTED state."
-	failoverTransitionsPartnerDownState              = "Failover: Transitions to PARTNER-DOWN state."
-	failoverTransitionsRecoverState                  = "Failover: Transitions to RECOVER state."
-	informsTotal                                     = "Informs/sec"
-	nacksTotal                                       = "Nacks/sec"
-	offerQueueLength                                 = "Offer Queue Length"
-	offersTotal                                      = "Offers/sec"
-	packetsExpiredTotal                              = "Packets Expired/sec"
-	packetsReceivedTotal                             = "Packets Received/sec"
-	releasesTotal                                    = "Releases/sec"
-	requestsTotal                                    = "Requests/sec"
-)

internal/collector/dhcp/dhcp.go

@@ -16,28 +16,46 @@
 package dhcp
 
 import (
+	"errors"
 	"fmt"
 	"log/slog"
+	"slices"
+	"strconv"
+	"strings"
 
 	"github.com/alecthomas/kingpin/v2"
+	"github.com/prometheus-community/windows_exporter/internal/headers/dhcpsapi"
 	"github.com/prometheus-community/windows_exporter/internal/mi"
-	"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 Name = "dhcp"
+const (
+	Name = "dhcp"
 
-type Config struct{}
+	subCollectorServerMetrics = "server_metrics"
+	subCollectorScopeMetrics  = "scope_metrics"
+)
+
+type Config struct {
+	CollectorsEnabled []string `yaml:"collectors_enabled"`
+}
 
 //nolint:gochecknoglobals
-var ConfigDefaults = Config{}
+var ConfigDefaults = Config{
+	CollectorsEnabled: []string{
+		subCollectorServerMetrics,
+		subCollectorScopeMetrics,
+	},
+}
 
 // A Collector is a Prometheus Collector perflib DHCP metrics.
 type Collector struct {
 	config Config
 
-	perfDataCollector *perfdata.Collector
+	perfDataCollector *pdh.Collector
+	perfDataObject    []perfDataCounterValues
 
 	acksTotal                                        *prometheus.Desc
 	activeQueueLength                                *prometheus.Desc
@@ -64,6 +82,17 @@ type Collector struct {
 	packetsReceivedTotal                             *prometheus.Desc
 	releasesTotal                                    *prometheus.Desc
 	requestsTotal                                    *prometheus.Desc
+
+	scopeInfo                               *prometheus.Desc
+	scopeState                              *prometheus.Desc
+	scopeAddressesFreeTotal                 *prometheus.Desc
+	scopeAddressesFreeOnPartnerServerTotal  *prometheus.Desc
+	scopeAddressesFreeOnThisServerTotal     *prometheus.Desc
+	scopeAddressesInUseTotal                *prometheus.Desc
+	scopeAddressesInUseOnPartnerServerTotal *prometheus.Desc
+	scopeAddressesInUseOnThisServerTotal    *prometheus.Desc
+	scopePendingOffersTotal                 *prometheus.Desc
+	scopeReservedAddressTotal               *prometheus.Desc
 }
 
 func New(config *Config) *Collector {
@@ -71,6 +100,10 @@ func New(config *Config) *Collector {
 		config = &ConfigDefaults
 	}
 
+	if config.CollectorsEnabled == nil {
+		config.CollectorsEnabled = ConfigDefaults.CollectorsEnabled
+	}
+
 	c := &Collector{
 		config: *config,
 	}
@@ -78,8 +111,26 @@ func New(config *Config) *Collector {
 	return c
 }
 
-func NewWithFlags(_ *kingpin.Application) *Collector {
-	return &Collector{}
+func NewWithFlags(app *kingpin.Application) *Collector {
+	c := &Collector{
+		config: ConfigDefaults,
+	}
+	c.config.CollectorsEnabled = make([]string, 0)
+
+	var collectorsEnabled string
+
+	app.Flag(
+		"collector.dhcp.enabled",
+		"Comma-separated list of collectors to use. Defaults to all, if not specified.",
+	).Default(strings.Join(ConfigDefaults.CollectorsEnabled, ",")).StringVar(&collectorsEnabled)
+
+	app.Action(func(*kingpin.ParseContext) error {
+		c.config.CollectorsEnabled = strings.Split(collectorsEnabled, ",")
+
+		return nil
+	})
+
+	return c
 }
 
 func (c *Collector) GetName() string {
@@ -87,7 +138,9 @@ func (c *Collector) GetName() string {
 }
 
 func (c *Collector) Close() error {
-	c.perfDataCollector.Close()
+	if slices.Contains(c.config.CollectorsEnabled, subCollectorServerMetrics) {
+		c.perfDataCollector.Close()
+	}
 
 	return nil
 }
@@ -95,351 +148,522 @@ func (c *Collector) Close() error {
 func (c *Collector) Build(_ *slog.Logger, _ *mi.Session) error {
 	var err error
 
-	c.perfDataCollector, err = perfdata.NewCollector("DHCP Server", nil, []string{
-		acksTotal,
-		activeQueueLength,
-		conflictCheckQueueLength,
-		declinesTotal,
-		deniedDueToMatch,
-		deniedDueToNonMatch,
-		discoversTotal,
-		duplicatesDroppedTotal,
-		failoverBndAckReceivedTotal,
-		failoverBndAckSentTotal,
-		failoverBndUpdDropped,
-		failoverBndUpdPendingOutboundQueue,
-		failoverBndUpdReceivedTotal,
-		failoverBndUpdSentTotal,
-		failoverTransitionsCommunicationInterruptedState,
-		failoverTransitionsPartnerDownState,
-		failoverTransitionsRecoverState,
-		informsTotal,
-		nacksTotal,
-		offerQueueLength,
-		offersTotal,
-		packetsExpiredTotal,
-		packetsReceivedTotal,
-		releasesTotal,
-		requestsTotal,
-	})
-	if err != nil {
-		return fmt.Errorf("failed to create DHCP Server collector: %w", err)
+	if slices.Contains(c.config.CollectorsEnabled, subCollectorServerMetrics) {
+		c.perfDataCollector, err = pdh.NewCollector[perfDataCounterValues](pdh.CounterTypeRaw, "DHCP Server", nil)
+		if err != nil {
+			return fmt.Errorf("failed to create DHCP Server collector: %w", err)
+		}
+
+		c.packetsReceivedTotal = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "packets_received_total"),
+			"Total number of packets received by the DHCP server (PacketsReceivedTotal)",
+			nil,
+			nil,
+		)
+		c.duplicatesDroppedTotal = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "duplicates_dropped_total"),
+			"Total number of duplicate packets received by the DHCP server (DuplicatesDroppedTotal)",
+			nil,
+			nil,
+		)
+		c.packetsExpiredTotal = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "packets_expired_total"),
+			"Total number of packets expired in the DHCP server message queue (PacketsExpiredTotal)",
+			nil,
+			nil,
+		)
+		c.activeQueueLength = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "active_queue_length"),
+			"Number of packets in the processing queue of the DHCP server (ActiveQueueLength)",
+			nil,
+			nil,
+		)
+		c.conflictCheckQueueLength = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "conflict_check_queue_length"),
+			"Number of packets in the DHCP server queue waiting on conflict detection (ping). (ConflictCheckQueueLength)",
+			nil,
+			nil,
+		)
+		c.discoversTotal = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "discovers_total"),
+			"Total DHCP Discovers received by the DHCP server (DiscoversTotal)",
+			nil,
+			nil,
+		)
+		c.offersTotal = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "offers_total"),
+			"Total DHCP Offers sent by the DHCP server (OffersTotal)",
+			nil,
+			nil,
+		)
+		c.requestsTotal = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "requests_total"),
+			"Total DHCP Requests received by the DHCP server (RequestsTotal)",
+			nil,
+			nil,
+		)
+		c.informsTotal = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "informs_total"),
+			"Total DHCP Informs received by the DHCP server (InformsTotal)",
+			nil,
+			nil,
+		)
+		c.acksTotal = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "acks_total"),
+			"Total DHCP Acks sent by the DHCP server (AcksTotal)",
+			nil,
+			nil,
+		)
+		c.nACKsTotal = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "nacks_total"),
+			"Total DHCP Nacks sent by the DHCP server (NacksTotal)",
+			nil,
+			nil,
+		)
+		c.declinesTotal = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "declines_total"),
+			"Total DHCP Declines received by the DHCP server (DeclinesTotal)",
+			nil,
+			nil,
+		)
+		c.releasesTotal = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "releases_total"),
+			"Total DHCP Releases received by the DHCP server (ReleasesTotal)",
+			nil,
+			nil,
+		)
+		c.offerQueueLength = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "offer_queue_length"),
+			"Number of packets in the offer queue of the DHCP server (OfferQueueLength)",
+			nil,
+			nil,
+		)
+		c.deniedDueToMatch = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "denied_due_to_match_total"),
+			"Total number of DHCP requests denied, based on matches from the Deny list (DeniedDueToMatch)",
+			nil,
+			nil,
+		)
+		c.deniedDueToNonMatch = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "denied_due_to_nonmatch_total"),
+			"Total number of DHCP requests denied, based on non-matches from the Allow list (DeniedDueToNonMatch)",
+			nil,
+			nil,
+		)
+		c.failoverBndUpdSentTotal = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "failover_bndupd_sent_total"),
+			"Number of DHCP fail over Binding Update messages sent (FailoverBndupdSentTotal)",
+			nil,
+			nil,
+		)
+		c.failoverBndUpdReceivedTotal = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "failover_bndupd_received_total"),
+			"Number of DHCP fail over Binding Update messages received (FailoverBndupdReceivedTotal)",
+			nil,
+			nil,
+		)
+		c.failoverBndAckSentTotal = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "failover_bndack_sent_total"),
+			"Number of DHCP fail over Binding Ack messages sent (FailoverBndackSentTotal)",
+			nil,
+			nil,
+		)
+		c.failoverBndAckReceivedTotal = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "failover_bndack_received_total"),
+			"Number of DHCP fail over Binding Ack messages received (FailoverBndackReceivedTotal)",
+			nil,
+			nil,
+		)
+		c.failoverBndUpdPendingOutboundQueue = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "failover_bndupd_pending_in_outbound_queue"),
+			"Number of pending outbound DHCP fail over Binding Update messages (FailoverBndupdPendingOutboundQueue)",
+			nil,
+			nil,
+		)
+		c.failoverTransitionsCommunicationInterruptedState = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "failover_transitions_communicationinterrupted_state_total"),
+			"Total number of transitions into COMMUNICATION INTERRUPTED state (FailoverTransitionsCommunicationinterruptedState)",
+			nil,
+			nil,
+		)
+		c.failoverTransitionsPartnerDownState = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "failover_transitions_partnerdown_state_total"),
+			"Total number of transitions into PARTNER DOWN state (FailoverTransitionsPartnerdownState)",
+			nil,
+			nil,
+		)
+		c.failoverTransitionsRecoverState = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "failover_transitions_recover_total"),
+			"Total number of transitions into RECOVER state (FailoverTransitionsRecoverState)",
+			nil,
+			nil,
+		)
+		c.failoverBndUpdDropped = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "failover_bndupd_dropped_total"),
+			"Total number of DHCP fail over Binding Updates dropped (FailoverBndupdDropped)",
+			nil,
+			nil,
+		)
 	}
 
-	c.packetsReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types.Namespace, Name, "packets_received_total"),
-		"Total number of packets received by the DHCP server (PacketsReceivedTotal)",
-		nil,
-		nil,
-	)
-	c.duplicatesDroppedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types.Namespace, Name, "duplicates_dropped_total"),
-		"Total number of duplicate packets received by the DHCP server (DuplicatesDroppedTotal)",
-		nil,
-		nil,
-	)
-	c.packetsExpiredTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types.Namespace, Name, "packets_expired_total"),
-		"Total number of packets expired in the DHCP server message queue (PacketsExpiredTotal)",
-		nil,
-		nil,
-	)
-	c.activeQueueLength = prometheus.NewDesc(
-		prometheus.BuildFQName(types.Namespace, Name, "active_queue_length"),
-		"Number of packets in the processing queue of the DHCP server (ActiveQueueLength)",
-		nil,
-		nil,
-	)
-	c.conflictCheckQueueLength = prometheus.NewDesc(
-		prometheus.BuildFQName(types.Namespace, Name, "conflict_check_queue_length"),
-		"Number of packets in the DHCP server queue waiting on conflict detection (ping). (ConflictCheckQueueLength)",
-		nil,
-		nil,
-	)
-	c.discoversTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types.Namespace, Name, "discovers_total"),
-		"Total DHCP Discovers received by the DHCP server (DiscoversTotal)",
-		nil,
-		nil,
-	)
-	c.offersTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types.Namespace, Name, "offers_total"),
-		"Total DHCP Offers sent by the DHCP server (OffersTotal)",
-		nil,
-		nil,
-	)
-	c.requestsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types.Namespace, Name, "requests_total"),
-		"Total DHCP Requests received by the DHCP server (RequestsTotal)",
-		nil,
-		nil,
-	)
-	c.informsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types.Namespace, Name, "informs_total"),
-		"Total DHCP Informs received by the DHCP server (InformsTotal)",
-		nil,
-		nil,
-	)
-	c.acksTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types.Namespace, Name, "acks_total"),
-		"Total DHCP Acks sent by the DHCP server (AcksTotal)",
-		nil,
-		nil,
-	)
-	c.nACKsTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types.Namespace, Name, "nacks_total"),
-		"Total DHCP Nacks sent by the DHCP server (NacksTotal)",
-		nil,
-		nil,
-	)
-	c.declinesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types.Namespace, Name, "declines_total"),
-		"Total DHCP Declines received by the DHCP server (DeclinesTotal)",
-		nil,
-		nil,
-	)
-	c.releasesTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types.Namespace, Name, "releases_total"),
-		"Total DHCP Releases received by the DHCP server (ReleasesTotal)",
-		nil,
-		nil,
-	)
-	c.offerQueueLength = prometheus.NewDesc(
-		prometheus.BuildFQName(types.Namespace, Name, "offer_queue_length"),
-		"Number of packets in the offer queue of the DHCP server (OfferQueueLength)",
-		nil,
-		nil,
-	)
-	c.deniedDueToMatch = prometheus.NewDesc(
-		prometheus.BuildFQName(types.Namespace, Name, "denied_due_to_match_total"),
-		"Total number of DHCP requests denied, based on matches from the Deny list (DeniedDueToMatch)",
-		nil,
-		nil,
-	)
-	c.deniedDueToNonMatch = prometheus.NewDesc(
-		prometheus.BuildFQName(types.Namespace, Name, "denied_due_to_nonmatch_total"),
-		"Total number of DHCP requests denied, based on non-matches from the Allow list (DeniedDueToNonMatch)",
-		nil,
-		nil,
-	)
-	c.failoverBndUpdSentTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types.Namespace, Name, "failover_bndupd_sent_total"),
-		"Number of DHCP fail over Binding Update messages sent (FailoverBndupdSentTotal)",
-		nil,
-		nil,
-	)
-	c.failoverBndUpdReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types.Namespace, Name, "failover_bndupd_received_total"),
-		"Number of DHCP fail over Binding Update messages received (FailoverBndupdReceivedTotal)",
-		nil,
-		nil,
-	)
-	c.failoverBndAckSentTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types.Namespace, Name, "failover_bndack_sent_total"),
-		"Number of DHCP fail over Binding Ack messages sent (FailoverBndackSentTotal)",
-		nil,
-		nil,
-	)
-	c.failoverBndAckReceivedTotal = prometheus.NewDesc(
-		prometheus.BuildFQName(types.Namespace, Name, "failover_bndack_received_total"),
-		"Number of DHCP fail over Binding Ack messages received (FailoverBndackReceivedTotal)",
-		nil,
-		nil,
-	)
-	c.failoverBndUpdPendingOutboundQueue = prometheus.NewDesc(
-		prometheus.BuildFQName(types.Namespace, Name, "failover_bndupd_pending_in_outbound_queue"),
-		"Number of pending outbound DHCP fail over Binding Update messages (FailoverBndupdPendingOutboundQueue)",
-		nil,
-		nil,
-	)
-	c.failoverTransitionsCommunicationInterruptedState = prometheus.NewDesc(
-		prometheus.BuildFQName(types.Namespace, Name, "failover_transitions_communicationinterrupted_state_total"),
-		"Total number of transitions into COMMUNICATION INTERRUPTED state (FailoverTransitionsCommunicationinterruptedState)",
-		nil,
-		nil,
-	)
-	c.failoverTransitionsPartnerDownState = prometheus.NewDesc(
-		prometheus.BuildFQName(types.Namespace, Name, "failover_transitions_partnerdown_state_total"),
-		"Total number of transitions into PARTNER DOWN state (FailoverTransitionsPartnerdownState)",
-		nil,
-		nil,
-	)
-	c.failoverTransitionsRecoverState = prometheus.NewDesc(
-		prometheus.BuildFQName(types.Namespace, Name, "failover_transitions_recover_total"),
-		"Total number of transitions into RECOVER state (FailoverTransitionsRecoverState)",
-		nil,
-		nil,
-	)
-	c.failoverBndUpdDropped = prometheus.NewDesc(
-		prometheus.BuildFQName(types.Namespace, Name, "failover_bndupd_dropped_total"),
-		"Total number of DHCP fail over Binding Updates dropped (FailoverBndupdDropped)",
-		nil,
-		nil,
-	)
+	if slices.Contains(c.config.CollectorsEnabled, subCollectorScopeMetrics) {
+		c.scopeInfo = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "scope_info"),
+			"DHCP Scope information",
+			[]string{"name", "superscope_name", "superscope_id", "scope"},
+			nil,
+		)
+
+		c.scopeState = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "scope_state"),
+			"DHCP Scope state",
+			[]string{"scope", "state"},
+			nil,
+		)
+
+		c.scopeAddressesFreeTotal = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "scope_addresses_free"),
+			"DHCP Scope free addresses",
+			[]string{"scope"},
+			nil,
+		)
+
+		c.scopeAddressesFreeOnPartnerServerTotal = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "scope_addresses_free_on_partner_server"),
+			"DHCP Scope free addresses on partner server",
+			[]string{"scope"},
+			nil,
+		)
+
+		c.scopeAddressesFreeOnThisServerTotal = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "scope_addresses_free_on_this_server"),
+			"DHCP Scope free addresses on this server",
+			[]string{"scope"},
+			nil,
+		)
+
+		c.scopeAddressesInUseTotal = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "scope_addresses_in_use"),
+			"DHCP Scope addresses in use",
+			[]string{"scope"},
+			nil,
+		)
+
+		c.scopeAddressesInUseOnPartnerServerTotal = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "scope_addresses_in_use_on_partner_server"),
+			"DHCP Scope addresses in use on partner server",
+			[]string{"scope"},
+			nil,
+		)
+
+		c.scopeAddressesInUseOnThisServerTotal = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "scope_addresses_in_use_on_this_server"),
+			"DHCP Scope addresses in use on this server",
+			[]string{"scope"},
+			nil,
+		)
+
+		c.scopePendingOffersTotal = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "scope_pending_offers"),
+			"DHCP Scope pending offers",
+			[]string{"scope"},
+			nil,
+		)
+
+		c.scopeReservedAddressTotal = prometheus.NewDesc(
+			prometheus.BuildFQName(types.Namespace, Name, "scope_reserved_address"),
+			"DHCP Scope reserved addresses",
+			[]string{"scope"},
+			nil,
+		)
+	}
 
 	return nil
 }
 
 func (c *Collector) Collect(ch chan<- prometheus.Metric) error {
-	perfData, err := c.perfDataCollector.Collect()
-	if err != nil {
-		return fmt.Errorf("failed to collect DHCP Server metrics: %w", err)
+	var errs []error
+
+	if slices.Contains(c.config.CollectorsEnabled, subCollectorServerMetrics) {
+		if err := c.collectServerMetrics(ch); err != nil {
+			errs = append(errs, err)
+		}
 	}
 
-	data, ok := perfData[perfdata.InstanceEmpty]
-	if !ok {
-		return fmt.Errorf("failed to collect DHCP Server metrics: %w", types.ErrNoData)
+	if slices.Contains(c.config.CollectorsEnabled, subCollectorScopeMetrics) {
+		if err := c.collectScopeMetrics(ch); err != nil {
+			errs = append(errs, err)
+		}
+	}
+
+	return errors.Join(errs...)
+}
+
+func (c *Collector) collectServerMetrics(ch chan<- prometheus.Metric) error {
+	err := c.perfDataCollector.Collect(&c.perfDataObject)
+	if err != nil {
+		return fmt.Errorf("failed to collect DHCP Server metrics: %w", err)
 	}
 
 	ch <- prometheus.MustNewConstMetric(
 		c.packetsReceivedTotal,
 		prometheus.CounterValue,
-		data[packetsReceivedTotal].FirstValue,
+		c.perfDataObject[0].PacketsReceivedTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.duplicatesDroppedTotal,
 		prometheus.CounterValue,
-		data[duplicatesDroppedTotal].FirstValue,
+		c.perfDataObject[0].DuplicatesDroppedTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.packetsExpiredTotal,
 		prometheus.CounterValue,
-		data[packetsExpiredTotal].FirstValue,
+		c.perfDataObject[0].PacketsExpiredTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.activeQueueLength,
 		prometheus.GaugeValue,
-		data[activeQueueLength].FirstValue,
+		c.perfDataObject[0].ActiveQueueLength,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.conflictCheckQueueLength,
 		prometheus.GaugeValue,
-		data[conflictCheckQueueLength].FirstValue,
+		c.perfDataObject[0].ConflictCheckQueueLength,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.discoversTotal,
 		prometheus.CounterValue,
-		data[discoversTotal].FirstValue,
+		c.perfDataObject[0].DiscoversTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.offersTotal,
 		prometheus.CounterValue,
-		data[offersTotal].FirstValue,
+		c.perfDataObject[0].OffersTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.requestsTotal,
 		prometheus.CounterValue,
-		data[requestsTotal].FirstValue,
+		c.perfDataObject[0].RequestsTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.informsTotal,
 		prometheus.CounterValue,
-		data[informsTotal].FirstValue,
+		c.perfDataObject[0].InformsTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.acksTotal,
 		prometheus.CounterValue,
-		data[acksTotal].FirstValue,
+		c.perfDataObject[0].AcksTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.nACKsTotal,
 		prometheus.CounterValue,
-		data[nacksTotal].FirstValue,
+		c.perfDataObject[0].NacksTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.declinesTotal,
 		prometheus.CounterValue,
-		data[declinesTotal].FirstValue,
+		c.perfDataObject[0].DeclinesTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.releasesTotal,
 		prometheus.CounterValue,
-		data[releasesTotal].FirstValue,
+		c.perfDataObject[0].ReleasesTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.offerQueueLength,
 		prometheus.GaugeValue,
-		data[offerQueueLength].FirstValue,
+		c.perfDataObject[0].OfferQueueLength,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.deniedDueToMatch,
 		prometheus.CounterValue,
-		data[deniedDueToMatch].FirstValue,
+		c.perfDataObject[0].DeniedDueToMatch,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.deniedDueToNonMatch,
 		prometheus.CounterValue,
-		data[deniedDueToNonMatch].FirstValue,
+		c.perfDataObject[0].DeniedDueToNonMatch,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.failoverBndUpdSentTotal,
 		prometheus.CounterValue,
-		data[failoverBndUpdSentTotal].FirstValue,
+		c.perfDataObject[0].FailoverBndUpdSentTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.failoverBndUpdReceivedTotal,
 		prometheus.CounterValue,
-		data[failoverBndUpdReceivedTotal].FirstValue,
+		c.perfDataObject[0].FailoverBndUpdReceivedTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.failoverBndAckSentTotal,
 		prometheus.CounterValue,
-		data[failoverBndAckSentTotal].FirstValue,
+		c.perfDataObject[0].FailoverBndAckSentTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.failoverBndAckReceivedTotal,
 		prometheus.CounterValue,
-		data[failoverBndAckReceivedTotal].FirstValue,
+		c.perfDataObject[0].FailoverBndAckReceivedTotal,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.failoverBndUpdPendingOutboundQueue,
 		prometheus.GaugeValue,
-		data[failoverBndUpdPendingOutboundQueue].FirstValue,
+		c.perfDataObject[0].FailoverBndUpdPendingOutboundQueue,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.failoverTransitionsCommunicationInterruptedState,
 		prometheus.CounterValue,
-		data[failoverTransitionsCommunicationInterruptedState].FirstValue,
+		c.perfDataObject[0].FailoverTransitionsCommunicationInterruptedState,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.failoverTransitionsPartnerDownState,
 		prometheus.CounterValue,
-		data[failoverTransitionsPartnerDownState].FirstValue,
+		c.perfDataObject[0].FailoverTransitionsPartnerDownState,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.failoverTransitionsRecoverState,
 		prometheus.CounterValue,
-		data[failoverTransitionsRecoverState].FirstValue,
+		c.perfDataObject[0].FailoverTransitionsRecoverState,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.failoverBndUpdDropped,
 		prometheus.CounterValue,
-		data[failoverBndUpdDropped].FirstValue,
+		c.perfDataObject[0].FailoverBndUpdDropped,
 	)
 
 	return nil
 }
+
+func (c *Collector) collectScopeMetrics(ch chan<- prometheus.Metric) error {
+	dhcpScopes, err := dhcpsapi.GetDHCPV4ScopeStatistics()
+	if err != nil {
+		return fmt.Errorf("failed to get DHCP scopes: %w", err)
+	}
+
+	for _, scope := range dhcpScopes {
+		scopeID := scope.ScopeIPAddress.String()
+
+		ch <- prometheus.MustNewConstMetric(
+			c.scopeInfo,
+			prometheus.GaugeValue,
+			1,
+			scope.Name,
+			scope.SuperScopeName,
+			strconv.Itoa(int(scope.SuperScopeNumber)),
+			scopeID,
+		)
+
+		for state, name := range dhcpsapi.DHCP_SUBNET_STATE_NAMES {
+			metric := 0.0
+			if state == scope.State {
+				metric = 1.0
+			}
+
+			ch <- prometheus.MustNewConstMetric(
+				c.scopeState,
+				prometheus.GaugeValue,
+				metric,
+				scopeID,
+				name,
+			)
+		}
+
+		if scope.AddressesFree != -1 {
+			ch <- prometheus.MustNewConstMetric(
+				c.scopeAddressesFreeTotal,
+				prometheus.GaugeValue,
+				scope.AddressesFree,
+				scopeID,
+			)
+		}
+
+		if scope.AddressesFreeOnPartnerServer != -1 {
+			ch <- prometheus.MustNewConstMetric(
+				c.scopeAddressesFreeOnPartnerServerTotal,
+				prometheus.GaugeValue,
+				scope.AddressesFreeOnPartnerServer,
+				scopeID,
+			)
+		}
+
+		if scope.AddressesFreeOnThisServer != -1 {
+			ch <- prometheus.MustNewConstMetric(
+				c.scopeAddressesFreeOnThisServerTotal,
+				prometheus.GaugeValue,
+				scope.AddressesFreeOnThisServer,
+				scopeID,
+			)
+		}
+
+		if scope.AddressesInUse != -1 {
+			ch <- prometheus.MustNewConstMetric(
+				c.scopeAddressesInUseTotal,
+				prometheus.GaugeValue,
+				scope.AddressesInUse,
+				scopeID,
+			)
+		}
+
+		if scope.AddressesInUseOnPartnerServer != -1 {
+			ch <- prometheus.MustNewConstMetric(
+				c.scopeAddressesInUseOnPartnerServerTotal,
+				prometheus.GaugeValue,
+				scope.AddressesInUseOnPartnerServer,
+				scopeID,
+			)
+		}
+
+		if scope.AddressesInUseOnThisServer != -1 {
+			ch <- prometheus.MustNewConstMetric(
+				c.scopeAddressesInUseOnThisServerTotal,
+				prometheus.GaugeValue,
+				scope.AddressesInUseOnThisServer,
+				scopeID,
+			)
+		}
+
+		if scope.PendingOffers != -1 {
+			ch <- prometheus.MustNewConstMetric(
+				c.scopePendingOffersTotal,
+				prometheus.GaugeValue,
+				scope.PendingOffers,
+				scopeID,
+			)
+		}
+
+		if scope.ReservedAddress != -1 {
+			ch <- prometheus.MustNewConstMetric(
+				c.scopeReservedAddressTotal,
+				prometheus.GaugeValue,
+				scope.ReservedAddress,
+				scopeID,
+			)
+		}
+	}
+
+	return nil
+}

internal/collector/dhcp/dhcp_test.go

@@ -25,3 +25,7 @@ import (
 func BenchmarkCollector(b *testing.B) {
 	testutils.FuncBenchmarkCollector(b, dhcp.Name, dhcp.NewWithFlags)
 }
+
+func TestCollector(t *testing.T) {
+	testutils.TestCollector(t, dhcp.New, nil)
+}

internal/collector/dhcp/types.go

@@ -0,0 +1,44 @@
+// Copyright 2024 The Prometheus Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//go:build windows
+
+package dhcp
+
+type perfDataCounterValues struct {
+	AcksTotal                                        float64 `perfdata:"Acks/sec"`
+	ActiveQueueLength                                float64 `perfdata:"Active Queue Length"`
+	ConflictCheckQueueLength                         float64 `perfdata:"Conflict Check Queue Length"`
+	DeclinesTotal                                    float64 `perfdata:"Declines/sec"`
+	DeniedDueToMatch                                 float64 `perfdata:"Denied due to match."`
+	DeniedDueToNonMatch                              float64 `perfdata:"Denied due to match."`
+	DiscoversTotal                                   float64 `perfdata:"Discovers/sec"`
+	DuplicatesDroppedTotal                           float64 `perfdata:"Duplicates Dropped/sec"`
+	FailoverBndAckReceivedTotal                      float64 `perfdata:"Failover: BndAck received/sec."`
+	FailoverBndAckSentTotal                          float64 `perfdata:"Failover: BndAck sent/sec."`
+	FailoverBndUpdDropped                            float64 `perfdata:"Failover: BndUpd Dropped."`
+	FailoverBndUpdPendingOutboundQueue               float64 `perfdata:"Failover: BndUpd pending in outbound queue."`
+	FailoverBndUpdReceivedTotal                      float64 `perfdata:"Failover: BndUpd received/sec."`
+	FailoverBndUpdSentTotal                          float64 `perfdata:"Failover: BndUpd sent/sec."`
+	FailoverTransitionsCommunicationInterruptedState float64 `perfdata:"Failover: Transitions to COMMUNICATION-INTERRUPTED state."`
+	FailoverTransitionsPartnerDownState              float64 `perfdata:"Failover: Transitions to PARTNER-DOWN state."`
+	FailoverTransitionsRecoverState                  float64 `perfdata:"Failover: Transitions to RECOVER state."`
+	InformsTotal                                     float64 `perfdata:"Informs/sec"`
+	NacksTotal                                       float64 `perfdata:"Nacks/sec"`
+	OfferQueueLength                                 float64 `perfdata:"Offer Queue Length"`
+	OffersTotal                                      float64 `perfdata:"Offers/sec"`
+	PacketsExpiredTotal                              float64 `perfdata:"Packets Expired/sec"`
+	PacketsReceivedTotal                             float64 `perfdata:"Packets Received/sec"`
+	ReleasesTotal                                    float64 `perfdata:"Releases/sec"`
+	RequestsTotal                                    float64 `perfdata:"Requests/sec"`
+}

internal/collector/diskdrive/diskdrive_test.go

@@ -25,3 +25,7 @@ import (
 func BenchmarkCollector(b *testing.B) {
 	testutils.FuncBenchmarkCollector(b, diskdrive.Name, diskdrive.NewWithFlags)
 }
+
+func TestCollector(t *testing.T) {
+	testutils.TestCollector(t, diskdrive.New, nil)
+}

internal/collector/dns/const.go

@@ -1,107 +0,0 @@
-// Copyright 2024 The Prometheus Authors
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//go:build windows
-
-package dns
-
-const (
-	_                              = "% User Time"
-	_                              = "176"
-	_                              = "Async Fast Reads/sec"
-	axfrRequestReceived            = "AXFR Request Received"
-	axfrRequestSent                = "AXFR Request Sent"
-	axfrResponseReceived           = "AXFR Response Received"
-	axfrSuccessReceived            = "AXFR Success Received"
-	axfrSuccessSent                = "AXFR Success Sent"
-	cachingMemory                  = "Caching Memory"
-	_                              = "Data Flush Pages/sec"
-	_                              = "Data Flushes/sec"
-	databaseNodeMemory             = "Database Node Memory"
-	dynamicUpdateNoOperation       = "Dynamic Update NoOperation"
-	_                              = "Dynamic Update NoOperation/sec"
-	dynamicUpdateQueued            = "Dynamic Update Queued"
-	_                              = "Dynamic Update Received"
-	_                              = "Dynamic Update Received/sec"
-	dynamicUpdateRejected          = "Dynamic Update Rejected"
-	dynamicUpdateTimeOuts          = "Dynamic Update TimeOuts"
-	dynamicUpdateWrittenToDatabase = "Dynamic Update Written to Database"
-	_                              = "Dynamic Update Written to Database/sec"
-	_                              = "Enumerations Server/sec"
-	_                              = "Fast Read Not Possibles/sec"
-	_                              = "Fast Read Resource Misses/sec"
-	ixfrRequestReceived            = "IXFR Request Received"
-	ixfrRequestSent                = "IXFR Request Sent"
-	ixfrResponseReceived           = "IXFR Response Received"
-	_                              = "IXFR Success Received"
-	ixfrSuccessSent                = "IXFR Success Sent"
-	ixfrTCPSuccessReceived         = "IXFR TCP Success Received"
-	ixfrUDPSuccessReceived         = "IXFR UDP Success Received"
-	_                              = "Lazy Write Flushes/sec"
-	_                              = "Lazy Write Pages/sec"
-	_                              = "Level 2 TLB Fills/sec"
-	nbStatMemory                   = "Nbstat Memory"
-	notifyReceived                 = "Notify Received"
-	notifySent                     = "Notify Sent"
-	_                              = "Query Dropped Bad Socket"
-	_                              = "Query Dropped Bad Socket/sec"
-	_                              = "Query Dropped By Policy"
-	_                              = "Query Dropped By Policy/sec"
-	_                              = "Query Dropped By Response Rate Limiting"
-	_                              = "Query Dropped By Response Rate Limiting/sec"
-	_                              = "Query Dropped Send"
-	_                              = "Query Dropped Send/sec"
-	_                              = "Query Dropped Total"
-	_                              = "Query Dropped Total/sec"
-	recordFlowMemory               = "Record Flow Memory"
-	recursiveQueries               = "Recursive Queries"
-	_                              = "Recursive Queries/sec"
-	recursiveQueryFailure          = "Recursive Query Failure"
-	_                              = "Recursive Query Failure/sec"
-	_                              = "Recursive Send TimeOuts"
-	recursiveSendTimeOuts          = "Recursive TimeOut/sec"
-	_                              = "Responses Suppressed"
-	_                              = "Responses Suppressed/sec"
-	secureUpdateFailure            = "Secure Update Failure"
-	secureUpdateReceived           = "Secure Update Received"
-	_                              = "Secure Update Received/sec"
-	tcpMessageMemory               = "TCP Message Memory"
-	tcpQueryReceived               = "TCP Query Received"
-	_                              = "TCP Query Received/sec"
-	tcpResponseSent                = "TCP Response Sent"
-	_                              = "TCP Response Sent/sec"
-	_                              = "Total Query Received"
-	_                              = "Total Query Received/sec"
-	_                              = "Total Remote Inflight Queries"
-	_                              = "Total Response Sent"
-	_                              = "Total Response Sent/sec"
-	udpMessageMemory               = "UDP Message Memory"
-	udpQueryReceived               = "UDP Query Received"
-	_                              = "UDP Query Received/sec"
-	udpResponseSent                = "UDP Response Sent"
-	_                              = "UDP Response Sent/sec"
-	unmatchedResponsesReceived     = "Unmatched Responses Received"
-	_                              = "Virtual Bytes"
-	winsLookupReceived             = "WINS Lookup Received"
-	_                              = "WINS Lookup Received/sec"
-	winsResponseSent               = "WINS Response Sent"
-	_                              = "WINS Response Sent/sec"
-	winsReverseLookupReceived      = "WINS Reverse Lookup Received"
-	_                              = "WINS Reverse Lookup Received/sec"
-	winsReverseResponseSent        = "WINS Reverse Response Sent"
-	_                              = "WINS Reverse Response Sent/sec"
-	zoneTransferFailure            = "Zone Transfer Failure"
-	zoneTransferSOARequestSent     = "Zone Transfer Request Received"
-	_                              = "Zone Transfer SOA Request Sent"
-	_                              = "Zone Transfer Success"
-)

internal/collector/dns/dns.go

@@ -21,7 +21,7 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/mi"
-	"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"
 )
@@ -37,7 +37,8 @@ var ConfigDefaults = Config{}
 type Collector struct {
 	config Config
 
-	perfDataCollector *perfdata.Collector
+	perfDataCollector *pdh.Collector
+	perfDataObject    []perfDataCounterValues
 
 	dynamicUpdatesFailures        *prometheus.Desc
 	dynamicUpdatesQueued          *prometheus.Desc
@@ -92,48 +93,7 @@ func (c *Collector) Close() error {
 func (c *Collector) Build(_ *slog.Logger, _ *mi.Session) error {
 	var err error
 
-	c.perfDataCollector, err = perfdata.NewCollector("DNS", perfdata.InstancesAll, []string{
-		axfrRequestReceived,
-		axfrRequestSent,
-		axfrResponseReceived,
-		axfrSuccessReceived,
-		axfrSuccessSent,
-		cachingMemory,
-		databaseNodeMemory,
-		dynamicUpdateNoOperation,
-		dynamicUpdateQueued,
-		dynamicUpdateRejected,
-		dynamicUpdateTimeOuts,
-		dynamicUpdateWrittenToDatabase,
-		ixfrRequestReceived,
-		ixfrRequestSent,
-		ixfrResponseReceived,
-		ixfrSuccessSent,
-		ixfrTCPSuccessReceived,
-		ixfrUDPSuccessReceived,
-		nbStatMemory,
-		notifyReceived,
-		notifySent,
-		recordFlowMemory,
-		recursiveQueries,
-		recursiveQueryFailure,
-		recursiveSendTimeOuts,
-		secureUpdateFailure,
-		secureUpdateReceived,
-		tcpMessageMemory,
-		tcpQueryReceived,
-		tcpResponseSent,
-		udpMessageMemory,
-		udpQueryReceived,
-		udpResponseSent,
-		unmatchedResponsesReceived,
-		winsLookupReceived,
-		winsResponseSent,
-		winsReverseLookupReceived,
-		winsReverseResponseSent,
-		zoneTransferFailure,
-		zoneTransferSOARequestSent,
-	})
+	c.perfDataCollector, err = pdh.NewCollector[perfDataCounterValues](pdh.CounterTypeRaw, "DNS", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create DNS collector: %w", err)
 	}
@@ -277,79 +237,74 @@ func (c *Collector) Build(_ *slog.Logger, _ *mi.Session) error {
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
 func (c *Collector) Collect(ch chan<- prometheus.Metric) error {
-	perfData, err := c.perfDataCollector.Collect()
+	err := c.perfDataCollector.Collect(&c.perfDataObject)
 	if err != nil {
 		return fmt.Errorf("failed to collect DNS metrics: %w", err)
 	}
 
-	data, ok := perfData[perfdata.InstanceEmpty]
-	if !ok {
-		return fmt.Errorf("failed to collect DNS metrics: %w", types.ErrNoData)
-	}
-
 	ch <- prometheus.MustNewConstMetric(
 		c.zoneTransferRequestsReceived,
 		prometheus.CounterValue,
-		data[axfrRequestReceived].FirstValue,
+		c.perfDataObject[0].AxfrRequestReceived,
 		"full",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.zoneTransferRequestsReceived,
 		prometheus.CounterValue,
-		data[ixfrRequestReceived].FirstValue,
+		c.perfDataObject[0].IxfrRequestReceived,
 		"incremental",
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.zoneTransferRequestsSent,
 		prometheus.CounterValue,
-		data[axfrRequestSent].FirstValue,
+		c.perfDataObject[0].AxfrRequestSent,
 		"full",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.zoneTransferRequestsSent,
 		prometheus.CounterValue,
-		data[ixfrRequestSent].FirstValue,
+		c.perfDataObject[0].IxfrRequestSent,
 		"incremental",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.zoneTransferRequestsSent,
 		prometheus.CounterValue,
-		data[zoneTransferSOARequestSent].FirstValue,
+		c.perfDataObject[0].ZoneTransferSOARequestSent,
 		"soa",
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.zoneTransferResponsesReceived,
 		prometheus.CounterValue,
-		data[axfrResponseReceived].FirstValue,
+		c.perfDataObject[0].AxfrResponseReceived,
 		"full",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.zoneTransferResponsesReceived,
 		prometheus.CounterValue,
-		data[ixfrResponseReceived].FirstValue,
+		c.perfDataObject[0].IxfrResponseReceived,
 		"incremental",
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.zoneTransferSuccessReceived,
 		prometheus.CounterValue,
-		data[axfrSuccessReceived].FirstValue,
+		c.perfDataObject[0].AxfrSuccessReceived,
 		"full",
 		"tcp",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.zoneTransferSuccessReceived,
 		prometheus.CounterValue,
-		data[ixfrTCPSuccessReceived].FirstValue,
+		c.perfDataObject[0].IxfrTCPSuccessReceived,
 		"incremental",
 		"tcp",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.zoneTransferSuccessReceived,
 		prometheus.CounterValue,
-		data[ixfrTCPSuccessReceived].FirstValue,
+		c.perfDataObject[0].IxfrTCPSuccessReceived,
 		"incremental",
 		"udp",
 	)
@@ -357,183 +312,183 @@ func (c *Collector) Collect(ch chan<- prometheus.Metric) error {
 	ch <- prometheus.MustNewConstMetric(
 		c.zoneTransferSuccessSent,
 		prometheus.CounterValue,
-		data[axfrSuccessSent].FirstValue,
+		c.perfDataObject[0].AxfrSuccessSent,
 		"full",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.zoneTransferSuccessSent,
 		prometheus.CounterValue,
-		data[ixfrSuccessSent].FirstValue,
+		c.perfDataObject[0].IxfrSuccessSent,
 		"incremental",
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.zoneTransferFailures,
 		prometheus.CounterValue,
-		data[zoneTransferFailure].FirstValue,
+		c.perfDataObject[0].ZoneTransferFailure,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.memoryUsedBytes,
 		prometheus.GaugeValue,
-		data[cachingMemory].FirstValue,
+		c.perfDataObject[0].CachingMemory,
 		"caching",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.memoryUsedBytes,
 		prometheus.GaugeValue,
-		data[databaseNodeMemory].FirstValue,
+		c.perfDataObject[0].DatabaseNodeMemory,
 		"database_node",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.memoryUsedBytes,
 		prometheus.GaugeValue,
-		data[nbStatMemory].FirstValue,
+		c.perfDataObject[0].NbStatMemory,
 		"nbstat",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.memoryUsedBytes,
 		prometheus.GaugeValue,
-		data[recordFlowMemory].FirstValue,
+		c.perfDataObject[0].RecordFlowMemory,
 		"record_flow",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.memoryUsedBytes,
 		prometheus.GaugeValue,
-		data[tcpMessageMemory].FirstValue,
+		c.perfDataObject[0].TcpMessageMemory,
 		"tcp_message",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.memoryUsedBytes,
 		prometheus.GaugeValue,
-		data[udpMessageMemory].FirstValue,
+		c.perfDataObject[0].UdpMessageMemory,
 		"udp_message",
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.dynamicUpdatesReceived,
 		prometheus.CounterValue,
-		data[dynamicUpdateNoOperation].FirstValue,
+		c.perfDataObject[0].DynamicUpdateNoOperation,
 		"noop",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.dynamicUpdatesReceived,
 		prometheus.CounterValue,
-		data[dynamicUpdateWrittenToDatabase].FirstValue,
+		c.perfDataObject[0].DynamicUpdateWrittenToDatabase,
 		"written",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.dynamicUpdatesQueued,
 		prometheus.GaugeValue,
-		data[dynamicUpdateQueued].FirstValue,
+		c.perfDataObject[0].DynamicUpdateQueued,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.dynamicUpdatesFailures,
 		prometheus.CounterValue,
-		data[dynamicUpdateRejected].FirstValue,
+		c.perfDataObject[0].DynamicUpdateRejected,
 		"rejected",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.dynamicUpdatesFailures,
 		prometheus.CounterValue,
-		data[dynamicUpdateTimeOuts].FirstValue,
+		c.perfDataObject[0].DynamicUpdateTimeOuts,
 		"timeout",
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.notifyReceived,
 		prometheus.CounterValue,
-		data[notifyReceived].FirstValue,
+		c.perfDataObject[0].NotifyReceived,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.notifySent,
 		prometheus.CounterValue,
-		data[notifySent].FirstValue,
+		c.perfDataObject[0].NotifySent,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.recursiveQueries,
 		prometheus.CounterValue,
-		data[recursiveQueries].FirstValue,
+		c.perfDataObject[0].RecursiveQueries,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.recursiveQueryFailures,
 		prometheus.CounterValue,
-		data[recursiveQueryFailure].FirstValue,
+		c.perfDataObject[0].RecursiveQueryFailure,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.recursiveQuerySendTimeouts,
 		prometheus.CounterValue,
-		data[recursiveSendTimeOuts].FirstValue,
+		c.perfDataObject[0].RecursiveSendTimeOuts,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.queries,
 		prometheus.CounterValue,
-		data[tcpQueryReceived].FirstValue,
+		c.perfDataObject[0].TcpQueryReceived,
 		"tcp",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.queries,
 		prometheus.CounterValue,
-		data[udpQueryReceived].FirstValue,
+		c.perfDataObject[0].UdpQueryReceived,
 		"udp",
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.responses,
 		prometheus.CounterValue,
-		data[tcpResponseSent].FirstValue,
+		c.perfDataObject[0].TcpResponseSent,
 		"tcp",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.responses,
 		prometheus.CounterValue,
-		data[udpResponseSent].FirstValue,
+		c.perfDataObject[0].UdpResponseSent,
 		"udp",
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.unmatchedResponsesReceived,
 		prometheus.CounterValue,
-		data[unmatchedResponsesReceived].FirstValue,
+		c.perfDataObject[0].UnmatchedResponsesReceived,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.winsQueries,
 		prometheus.CounterValue,
-		data[winsLookupReceived].FirstValue,
+		c.perfDataObject[0].WinsLookupReceived,
 		"forward",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.winsQueries,
 		prometheus.CounterValue,
-		data[winsReverseLookupReceived].FirstValue,
+		c.perfDataObject[0].WinsReverseLookupReceived,
 		"reverse",
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.winsResponses,
 		prometheus.CounterValue,
-		data[winsResponseSent].FirstValue,
+		c.perfDataObject[0].WinsResponseSent,
 		"forward",
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.winsResponses,
 		prometheus.CounterValue,
-		data[winsReverseResponseSent].FirstValue,
+		c.perfDataObject[0].WinsReverseResponseSent,
 		"reverse",
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.secureUpdateFailures,
 		prometheus.CounterValue,
-		data[secureUpdateFailure].FirstValue,
+		c.perfDataObject[0].SecureUpdateFailure,
 	)
 	ch <- prometheus.MustNewConstMetric(
 		c.secureUpdateReceived,
 		prometheus.CounterValue,
-		data[secureUpdateReceived].FirstValue,
+		c.perfDataObject[0].SecureUpdateReceived,
 	)
 
 	return nil

internal/collector/dns/dns_test.go

@@ -25,3 +25,7 @@ import (
 func BenchmarkCollector(b *testing.B) {
 	testutils.FuncBenchmarkCollector(b, dns.Name, dns.NewWithFlags)
 }
+
+func TestCollector(t *testing.T) {
+	testutils.TestCollector(t, dns.New, nil)
+}

internal/collector/dns/types.go

@@ -0,0 +1,107 @@
+// Copyright 2024 The Prometheus Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//go:build windows
+
+package dns
+
+type perfDataCounterValues struct {
+	_                              float64 `perfdata:"% User Time"`
+	_                              float64 `perfdata:"176"`
+	_                              float64 `perfdata:"Async Fast Reads/sec"`
+	AxfrRequestReceived            float64 `perfdata:"AXFR Request Received"`
+	AxfrRequestSent                float64 `perfdata:"AXFR Request Sent"`
+	AxfrResponseReceived           float64 `perfdata:"AXFR Response Received"`
+	AxfrSuccessReceived            float64 `perfdata:"AXFR Success Received"`
+	AxfrSuccessSent                float64 `perfdata:"AXFR Success Sent"`
+	CachingMemory                  float64 `perfdata:"Caching Memory"`
+	_                              float64 `perfdata:"Data Flush Pages/sec"`
+	_                              float64 `perfdata:"Data Flushes/sec"`
+	DatabaseNodeMemory             float64 `perfdata:"Database Node Memory"`
+	DynamicUpdateNoOperation       float64 `perfdata:"Dynamic Update NoOperation"`
+	_                              float64 `perfdata:"Dynamic Update NoOperation/sec"`
+	DynamicUpdateQueued            float64 `perfdata:"Dynamic Update Queued"`
+	_                              float64 `perfdata:"Dynamic Update Received"`
+	_                              float64 `perfdata:"Dynamic Update Received/sec"`
+	DynamicUpdateRejected          float64 `perfdata:"Dynamic Update Rejected"`
+	DynamicUpdateTimeOuts          float64 `perfdata:"Dynamic Update TimeOuts"`
+	DynamicUpdateWrittenToDatabase float64 `perfdata:"Dynamic Update Written to Database"`
+	_                              float64 `perfdata:"Dynamic Update Written to Database/sec"`
+	_                              float64 `perfdata:"Enumerations Server/sec"`
+	_                              float64 `perfdata:"Fast Read Not Possibles/sec"`
+	_                              float64 `perfdata:"Fast Read Resource Misses/sec"`
+	IxfrRequestReceived            float64 `perfdata:"IXFR Request Received"`
+	IxfrRequestSent                float64 `perfdata:"IXFR Request Sent"`
+	IxfrResponseReceived           float64 `perfdata:"IXFR Response Received"`
+	_                              float64 `perfdata:"IXFR Success Received"`
+	IxfrSuccessSent                float64 `perfdata:"IXFR Success Sent"`
+	IxfrTCPSuccessReceived         float64 `perfdata:"IXFR TCP Success Received"`
+	IxfrUDPSuccessReceived         float64 `perfdata:"IXFR UDP Success Received"`
+	_                              float64 `perfdata:"Lazy Write Flushes/sec"`
+	_                              float64 `perfdata:"Lazy Write Pages/sec"`
+	_                              float64 `perfdata:"Level 2 TLB Fills/sec"`
+	NbStatMemory                   float64 `perfdata:"Nbstat Memory"`
+	NotifyReceived                 float64 `perfdata:"Notify Received"`
+	NotifySent                     float64 `perfdata:"Notify Sent"`
+	_                              float64 `perfdata:"Query Dropped Bad Socket"`
+	_                              float64 `perfdata:"Query Dropped Bad Socket/sec"`
+	_                              float64 `perfdata:"Query Dropped By Policy"`
+	_                              float64 `perfdata:"Query Dropped By Policy/sec"`
+	_                              float64 `perfdata:"Query Dropped By Response Rate Limiting"`
+	_                              float64 `perfdata:"Query Dropped By Response Rate Limiting/sec"`
+	_                              float64 `perfdata:"Query Dropped Send"`
+	_                              float64 `perfdata:"Query Dropped Send/sec"`
+	_                              float64 `perfdata:"Query Dropped Total"`
+	_                              float64 `perfdata:"Query Dropped Total/sec"`
+	RecordFlowMemory               float64 `perfdata:"Record Flow Memory"`
+	RecursiveQueries               float64 `perfdata:"Recursive Queries"`
+	_                              float64 `perfdata:"Recursive Queries/sec"`
+	RecursiveQueryFailure          float64 `perfdata:"Recursive Query Failure"`
+	_                              float64 `perfdata:"Recursive Query Failure/sec"`
+	_                              float64 `perfdata:"Recursive Send TimeOuts"`
+	RecursiveSendTimeOuts          float64 `perfdata:"Recursive TimeOut/sec"`
+	_                              float64 `perfdata:"Responses Suppressed"`
+	_                              float64 `perfdata:"Responses Suppressed/sec"`
+	SecureUpdateFailure            float64 `perfdata:"Secure Update Failure"`
+	SecureUpdateReceived           float64 `perfdata:"Secure Update Received"`
+	_                              float64 `perfdata:"Secure Update Received/sec"`
+	TcpMessageMemory               float64 `perfdata:"TCP Message Memory"`
+	TcpQueryReceived               float64 `perfdata:"TCP Query Received"`
+	_                              float64 `perfdata:"TCP Query Received/sec"`
+	TcpResponseSent                float64 `perfdata:"TCP Response Sent"`
+	_                              float64 `perfdata:"TCP Response Sent/sec"`
+	_                              float64 `perfdata:"Total Query Received"`
+	_                              float64 `perfdata:"Total Query Received/sec"`
+	_                              float64 `perfdata:"Total Remote Inflight Queries"`
+	_                              float64 `perfdata:"Total Response Sent"`
+	_                              float64 `perfdata:"Total Response Sent/sec"`
+	UdpMessageMemory               float64 `perfdata:"UDP Message Memory"`
+	UdpQueryReceived               float64 `perfdata:"UDP Query Received"`
+	_                              float64 `perfdata:"UDP Query Received/sec"`
+	UdpResponseSent                float64 `perfdata:"UDP Response Sent"`
+	_                              float64 `perfdata:"UDP Response Sent/sec"`
+	UnmatchedResponsesReceived     float64 `perfdata:"Unmatched Responses Received"`
+	_                              float64 `perfdata:"Virtual Bytes"`
+	WinsLookupReceived             float64 `perfdata:"WINS Lookup Received"`
+	_                              float64 `perfdata:"WINS Lookup Received/sec"`
+	WinsResponseSent               float64 `perfdata:"WINS Response Sent"`
+	_                              float64 `perfdata:"WINS Response Sent/sec"`
+	WinsReverseLookupReceived      float64 `perfdata:"WINS Reverse Lookup Received"`
+	_                              float64 `perfdata:"WINS Reverse Lookup Received/sec"`
+	WinsReverseResponseSent        float64 `perfdata:"WINS Reverse Response Sent"`
+	_                              float64 `perfdata:"WINS Reverse Response Sent/sec"`
+	ZoneTransferFailure            float64 `perfdata:"Zone Transfer Failure"`
+	ZoneTransferSOARequestSent     float64 `perfdata:"Zone Transfer Request Received"`
+	_                              float64 `perfdata:"Zone Transfer SOA Request Sent"`
+	_                              float64 `perfdata:"Zone Transfer Success"`
+}

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
-}

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](pdh.CounterTypeRaw, "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,
 		)
 	}
 

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](pdh.CounterTypeRaw, "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,
 		)
 	}

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](pdh.CounterTypeRaw, "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,
 		)
 	}
 

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](pdh.CounterTypeRaw, "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,
 		)
 	}
 

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](pdh.CounterTypeRaw, "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,
 		)
 	}

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](pdh.CounterTypeRaw, "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,
 		)
 	}
 

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](pdh.CounterTypeRaw, "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,
 		)
 	}
 

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](pdh.CounterTypeRaw, "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,
 		)
 	}
 

internal/collector/exchange/exchange_test.go

@@ -25,3 +25,7 @@ import (
 func BenchmarkCollector(b *testing.B) {
 	testutils.FuncBenchmarkCollector(b, exchange.Name, exchange.NewWithFlags)
 }
+
+func TestCollector(t *testing.T) {
+	testutils.TestCollector(t, exchange.New, nil)
+}

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](pdh.CounterTypeRaw, "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,
 		)
 	}

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](pdh.CounterTypeRaw, "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,
 		)
 	}

internal/collector/fsrmquota/fsrmquota_test.go

@@ -25,3 +25,7 @@ import (
 func BenchmarkCollector(b *testing.B) {
 	testutils.FuncBenchmarkCollector(b, fsrmquota.Name, fsrmquota.NewWithFlags)
 }
+
+func TestCollector(t *testing.T) {
+	testutils.TestCollector(t, fsrmquota.New, nil)
+}

internal/collector/hyperv/hyperv.go

@@ -23,11 +23,10 @@ import (
 	"strings"
 	"sync"
 
+	"github.com/Microsoft/hcsshim/osversion"
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/mi"
-	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
-	"golang.org/x/sys/windows"
 )
 
 const (
@@ -157,19 +156,17 @@ func (c *Collector) Build(_ *slog.Logger, _ *mi.Session) error {
 		return nil
 	}
 
-	version := windows.RtlGetVersion()
-
 	subCollectors := map[string]struct {
 		build          func() error
 		collect        func(ch chan<- prometheus.Metric) error
 		close          func()
-		minBuildNumber uint32
+		minBuildNumber uint16
 	}{
 		subCollectorDataStore: {
 			build:          c.buildDataStore,
 			collect:        c.collectDataStore,
 			close:          c.perfDataCollectorDataStore.Close,
-			minBuildNumber: types.BuildNumberWindowsServer2022,
+			minBuildNumber: osversion.LTSC2022,
 		},
 		subCollectorDynamicMemoryBalancer: {
 			build:   c.buildDynamicMemoryBalancer,
@@ -243,6 +240,8 @@ func (c *Collector) Build(_ *slog.Logger, _ *mi.Session) error {
 		},
 	}
 
+	buildNumber := osversion.Build()
+
 	// Result must order, to prevent test failures.
 	sort.Strings(c.config.CollectorsEnabled)
 
@@ -253,7 +252,7 @@ func (c *Collector) Build(_ *slog.Logger, _ *mi.Session) error {
 			return fmt.Errorf("unknown collector: %s", name)
 		}
 
-		if version.BuildNumber < subCollectors[name].minBuildNumber {
+		if buildNumber < subCollectors[name].minBuildNumber {
 			errs = append(errs, fmt.Errorf("collector %s requires Windows Server 2022 or newer", name))
 
 			continue

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](pdh.CounterTypeRaw, "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](pdh.CounterTypeRaw, "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](pdh.CounterTypeRaw, "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](pdh.CounterTypeRaw, "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](pdh.CounterTypeRaw, "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,16 +19,16 @@ 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 Idle Time
 	// \Hyper-V Hypervisor Root Virtual Processor(*)\% Guest Run Time
 	// \Hyper-V Hypervisor Root Virtual Processor(*)\% Hypervisor Run Time
 	// \Hyper-V Hypervisor Root Virtual Processor(*)\% Remote Run Time
@@ -38,26 +38,20 @@ type collectorHypervisorRootVirtualProcessor struct {
 	hypervisorRootVirtualProcessorCPUWaitTimePerDispatch *prometheus.Desc // \Hyper-V Hypervisor Root Virtual Processor(*)\CPU Wait Time Per Dispatch
 }
 
-const (
-	hypervisorRootVirtualProcessorGuestIdleTimePercent     = "% Guest Idle Time"
-	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{
-		hypervisorRootVirtualProcessorGuestIdleTimePercent,
-		hypervisorRootVirtualProcessorGuestRunTimePercent,
-		hypervisorRootVirtualProcessorHypervisorRunTimePercent,
-		hypervisorRootVirtualProcessorTotalRunTimePercent,
-		hypervisorRootVirtualProcessorRemoteRunTimePercent,
-		hypervisorRootVirtualProcessorCPUWaitTimePerDispatch,
-	})
+	c.perfDataCollectorHypervisorRootVirtualProcessor, err = pdh.NewCollector[perfDataCounterValuesHypervisorRootVirtualProcessor](pdh.CounterTypeRaw, "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)
 	}
@@ -87,60 +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[hypervisorRootVirtualProcessorGuestIdleTimePercent].FirstValue,
-			coreId, "guest_idle",
-		)
-
-		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,16 +19,16 @@ 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 Idle Time
 	// \Hyper-V Hypervisor Virtual Processor(*)\% Guest Run Time
 	// \Hyper-V Hypervisor Virtual Processor(*)\% Hypervisor Run Time
 	// \Hyper-V Hypervisor Virtual Processor(*)\% Remote Run Time
@@ -37,26 +37,20 @@ type collectorHypervisorVirtualProcessor struct {
 	hypervisorVirtualProcessorContextSwitches   *prometheus.Desc // \Hyper-V Hypervisor Virtual Processor(*)\CPU Wait Time Per Dispatch
 }
 
-const (
-	hypervisorVirtualProcessorGuestRunTimePercent      = "% Guest Run Time"
-	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{
-		hypervisorVirtualProcessorGuestRunTimePercent,
-		hypervisorVirtualProcessorGuestIdleTimePercent,
-		hypervisorVirtualProcessorHypervisorRunTimePercent,
-		hypervisorVirtualProcessorTotalRunTimePercent,
-		hypervisorVirtualProcessorRemoteRunTimePercent,
-		hypervisorVirtualProcessorCPUWaitTimePerDispatch,
-	})
+	c.perfDataCollectorHypervisorVirtualProcessor, err = pdh.NewCollector[perfDataCounterValuesHypervisorVirtualProcessor](pdh.CounterTypeRaw, "Hyper-V Hypervisor Virtual Processor", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create Hyper-V Hypervisor Virtual Processor collector: %w", err)
 	}
@@ -84,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], " ")
@@ -102,48 +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[hypervisorVirtualProcessorGuestRunTimePercent].FirstValue,
-			vmName, coreId, "guest_run",
+			data.HypervisorVirtualProcessorHypervisorRunTimePercent,
+			vmName, coreID, "hypervisor",
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.hypervisorVirtualProcessorTimeTotal,
 			prometheus.CounterValue,
-			coreData[hypervisorVirtualProcessorHypervisorRunTimePercent].FirstValue,
-			vmName, coreId, "hypervisor",
+			data.HypervisorVirtualProcessorGuestIdleTimePercent,
+			vmName, coreID, "guest_idle",
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.hypervisorVirtualProcessorTimeTotal,
 			prometheus.CounterValue,
-			coreData[hypervisorVirtualProcessorGuestIdleTimePercent].FirstValue,
-			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](pdh.CounterTypeRaw, "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_test.go

@@ -25,3 +25,7 @@ import (
 func BenchmarkCollector(b *testing.B) {
 	testutils.FuncBenchmarkCollector(b, hyperv.Name, hyperv.NewWithFlags)
 }
+
+func TestCollector(t *testing.T) {
+	testutils.TestCollector(t, hyperv.New, nil)
+}

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](pdh.CounterTypeRaw, "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](pdh.CounterTypeRaw, "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](pdh.CounterTypeRaw, "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](pdh.CounterTypeRaw, "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](pdh.CounterTypeRaw, "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](pdh.CounterTypeRaw, "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](pdh.CounterTypeRaw, "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,
 		)
 	}
 

internal/collector/iis/iis.go

@@ -19,14 +19,12 @@ import (
 	"errors"
 	"fmt"
 	"log/slog"
-	"maps"
 	"regexp"
 	"slices"
 	"strings"
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/mi"
-	"github.com/prometheus-community/windows_exporter/internal/perfdata"
 	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
 	"golang.org/x/sys/windows/registry"
@@ -270,26 +268,36 @@ func (c *Collector) Collect(ch chan<- prometheus.Metric) error {
 	return errors.Join(errs...)
 }
 
+type collectorName interface {
+	GetName() string
+}
+
 // deduplicateIISNames deduplicate IIS site names from various IIS perflib objects.
 //
 // E.G. Given the following list of site names, "Site_B" would be
 // discarded, and "Site_B#2" would be kept and presented as "Site_B" in the
 // Collector metrics.
 // [ "Site_A", "Site_B", "Site_C", "Site_B#2" ].
-func deduplicateIISNames(counterValues map[string]map[string]perfdata.CounterValue) {
-	services := slices.Collect(maps.Keys(counterValues))
+func deduplicateIISNames[T collectorName](counterValues []T) {
+	indexes := make(map[string]int)
 
 	// Ensure IIS entry with the highest suffix occurs last
-	slices.Sort(services)
+	slices.SortFunc(counterValues, func(a, b T) int {
+		return strings.Compare(a.GetName(), b.GetName())
+	})
 
 	// Use map to deduplicate IIS entries
-	for _, entry := range services {
-		name := strings.Split(entry, "#")[0]
-		if name == entry {
+	for index, counterValue := range counterValues {
+		name := strings.Split(counterValue.GetName(), "#")[0]
+		if name == counterValue.GetName() {
 			continue
 		}
 
-		counterValues[name] = counterValues[entry]
-		delete(counterValues, entry)
+		if originalIndex, ok := indexes[name]; !ok {
+			counterValues[originalIndex] = counterValue
+			counterValues = slices.Delete(counterValues, index, 1)
+		} else {
+			indexes[name] = index
+		}
 	}
 }

internal/collector/iis/iis_app_pool_was.go

@@ -18,13 +18,14 @@ package iis
 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"
 )
 
 type collectorAppPoolWAS struct {
-	perfDataCollectorAppPoolWAS *perfdata.Collector
+	perfDataCollectorAppPoolWAS *pdh.Collector
+	perfDataObjectAppPoolWAS    []perfDataCounterValuesAppPoolWAS
 
 	currentApplicationPoolState        *prometheus.Desc
 	currentApplicationPoolUptime       *prometheus.Desc
@@ -40,22 +41,27 @@ type collectorAppPoolWAS struct {
 	totalWorkerProcessShutdownFailures *prometheus.Desc
 	totalWorkerProcessStartupFailures  *prometheus.Desc
 }
+type perfDataCounterValuesAppPoolWAS struct {
+	Name string
 
-const (
-	CurrentApplicationPoolState        = "Current Application Pool State"
-	CurrentApplicationPoolUptime       = "Current Application Pool Uptime"
-	CurrentWorkerProcesses             = "Current Worker Processes"
-	MaximumWorkerProcesses             = "Maximum Worker Processes"
-	RecentWorkerProcessFailures        = "Recent Worker Process Failures"
-	TimeSinceLastWorkerProcessFailure  = "Time Since Last Worker Process Failure"
-	TotalApplicationPoolRecycles       = "Total Application Pool Recycles"
-	TotalApplicationPoolUptime         = "Total Application Pool Uptime"
-	TotalWorkerProcessesCreated        = "Total Worker Processes Created"
-	TotalWorkerProcessFailures         = "Total Worker Process Failures"
-	TotalWorkerProcessPingFailures     = "Total Worker Process Ping Failures"
-	TotalWorkerProcessShutdownFailures = "Total Worker Process Shutdown Failures"
-	TotalWorkerProcessStartupFailures  = "Total Worker Process Startup Failures"
-)
+	CurrentApplicationPoolState        float64 `perfdata:"Current Application Pool State"`
+	CurrentApplicationPoolUptime       float64 `perfdata:"Current Application Pool Uptime"`
+	CurrentWorkerProcesses             float64 `perfdata:"Current Worker Processes"`
+	MaximumWorkerProcesses             float64 `perfdata:"Maximum Worker Processes"`
+	RecentWorkerProcessFailures        float64 `perfdata:"Recent Worker Process Failures"`
+	TimeSinceLastWorkerProcessFailure  float64 `perfdata:"Time Since Last Worker Process Failure"`
+	TotalApplicationPoolRecycles       float64 `perfdata:"Total Application Pool Recycles"`
+	TotalApplicationPoolUptime         float64 `perfdata:"Total Application Pool Uptime"`
+	TotalWorkerProcessesCreated        float64 `perfdata:"Total Worker Processes Created"`
+	TotalWorkerProcessFailures         float64 `perfdata:"Total Worker Process Failures"`
+	TotalWorkerProcessPingFailures     float64 `perfdata:"Total Worker Process Ping Failures"`
+	TotalWorkerProcessShutdownFailures float64 `perfdata:"Total Worker Process Shutdown Failures"`
+	TotalWorkerProcessStartupFailures  float64 `perfdata:"Total Worker Process Startup Failures"`
+}
+
+func (p perfDataCounterValuesAppPoolWAS) GetName() string {
+	return p.Name
+}
 
 //nolint:gochecknoglobals
 var applicationStates = map[uint32]string{
@@ -71,21 +77,7 @@ var applicationStates = map[uint32]string{
 func (c *Collector) buildAppPoolWAS() error {
 	var err error
 
-	c.perfDataCollectorAppPoolWAS, err = perfdata.NewCollector("APP_POOL_WAS", perfdata.InstancesAll, []string{
-		CurrentApplicationPoolState,
-		CurrentApplicationPoolUptime,
-		CurrentWorkerProcesses,
-		MaximumWorkerProcesses,
-		RecentWorkerProcessFailures,
-		TimeSinceLastWorkerProcessFailure,
-		TotalApplicationPoolRecycles,
-		TotalApplicationPoolUptime,
-		TotalWorkerProcessesCreated,
-		TotalWorkerProcessFailures,
-		TotalWorkerProcessPingFailures,
-		TotalWorkerProcessShutdownFailures,
-		TotalWorkerProcessStartupFailures,
-	})
+	c.perfDataCollectorAppPoolWAS, err = pdh.NewCollector[perfDataCounterValuesAppPoolWAS](pdh.CounterTypeRaw, "APP_POOL_WAS", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create APP_POOL_WAS collector: %w", err)
 	}
@@ -174,21 +166,21 @@ func (c *Collector) buildAppPoolWAS() error {
 }
 
 func (c *Collector) collectAppPoolWAS(ch chan<- prometheus.Metric) error {
-	perfData, err := c.perfDataCollectorWebService.Collect()
+	err := c.perfDataCollectorAppPoolWAS.Collect(&c.perfDataObjectAppPoolWAS)
 	if err != nil {
 		return fmt.Errorf("failed to collect APP_POOL_WAS metrics: %w", err)
 	}
 
-	deduplicateIISNames(perfData)
+	deduplicateIISNames(c.perfDataObjectAppPoolWAS)
 
-	for name, app := range perfData {
-		if c.config.AppExclude.MatchString(name) || !c.config.AppInclude.MatchString(name) {
+	for _, data := range c.perfDataObjectAppPoolWAS {
+		if c.config.AppExclude.MatchString(data.Name) || !c.config.AppInclude.MatchString(data.Name) {
 			continue
 		}
 
 		for key, label := range applicationStates {
 			isCurrentState := 0.0
-			if key == uint32(app[CurrentApplicationPoolState].FirstValue) {
+			if key == uint32(data.CurrentApplicationPoolState) {
 				isCurrentState = 1.0
 			}
 
@@ -196,7 +188,7 @@ func (c *Collector) collectAppPoolWAS(ch chan<- prometheus.Metric) error {
 				c.currentApplicationPoolState,
 				prometheus.GaugeValue,
 				isCurrentState,
-				name,
+				data.Name,
 				label,
 			)
 		}
@@ -204,74 +196,74 @@ func (c *Collector) collectAppPoolWAS(ch chan<- prometheus.Metric) error {
 		ch <- prometheus.MustNewConstMetric(
 			c.currentApplicationPoolUptime,
 			prometheus.GaugeValue,
-			app[CurrentApplicationPoolUptime].FirstValue,
-			name,
+			data.CurrentApplicationPoolUptime,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.currentWorkerProcesses,
 			prometheus.GaugeValue,
-			app[CurrentWorkerProcesses].FirstValue,
-			name,
+			data.CurrentWorkerProcesses,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.maximumWorkerProcesses,
 			prometheus.GaugeValue,
-			app[MaximumWorkerProcesses].FirstValue,
-			name,
+			data.MaximumWorkerProcesses,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.recentWorkerProcessFailures,
 			prometheus.GaugeValue,
-			app[RecentWorkerProcessFailures].FirstValue,
-			name,
+			data.RecentWorkerProcessFailures,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.timeSinceLastWorkerProcessFailure,
 			prometheus.GaugeValue,
-			app[TimeSinceLastWorkerProcessFailure].FirstValue,
-			name,
+			data.TimeSinceLastWorkerProcessFailure,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.totalApplicationPoolRecycles,
 			prometheus.CounterValue,
-			app[TotalApplicationPoolRecycles].FirstValue,
-			name,
+			data.TotalApplicationPoolRecycles,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.totalApplicationPoolUptime,
 			prometheus.CounterValue,
-			app[TotalApplicationPoolUptime].FirstValue,
-			name,
+			data.TotalApplicationPoolUptime,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.totalWorkerProcessesCreated,
 			prometheus.CounterValue,
-			app[TotalWorkerProcessesCreated].FirstValue,
-			name,
+			data.TotalWorkerProcessesCreated,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.totalWorkerProcessFailures,
 			prometheus.CounterValue,
-			app[TotalWorkerProcessFailures].FirstValue,
-			name,
+			data.TotalWorkerProcessFailures,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.totalWorkerProcessPingFailures,
 			prometheus.CounterValue,
-			app[TotalWorkerProcessPingFailures].FirstValue,
-			name,
+			data.TotalWorkerProcessPingFailures,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.totalWorkerProcessShutdownFailures,
 			prometheus.CounterValue,
-			app[TotalWorkerProcessShutdownFailures].FirstValue,
-			name,
+			data.TotalWorkerProcessShutdownFailures,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.totalWorkerProcessStartupFailures,
 			prometheus.CounterValue,
-			app[TotalWorkerProcessStartupFailures].FirstValue,
-			name,
+			data.TotalWorkerProcessStartupFailures,
+			data.Name,
 		)
 	}
 

internal/collector/iis/iis_bench_test.go

@@ -25,3 +25,7 @@ import (
 func BenchmarkCollector(b *testing.B) {
 	testutils.FuncBenchmarkCollector(b, iis.Name, iis.NewWithFlags)
 }
+
+func TestCollector(t *testing.T) {
+	testutils.TestCollector(t, iis.New, nil)
+}

internal/collector/iis/iis_w3svc_w3wp.go

@@ -20,13 +20,16 @@ import (
 	"regexp"
 	"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"
 )
 
 type collectorW3SVCW3WP struct {
-	w3SVCW3WPPerfDataCollector *perfdata.Collector
+	w3SVCW3WPPerfDataCollector   *pdh.Collector
+	w3SVCW3WPPerfDataCollectorV8 *pdh.Collector
+	perfDataObjectW3SVCW3WP      []perfDataCounterValuesW3SVCW3WP
+	perfDataObjectW3SVCW3WPV8    []perfDataCounterValuesW3SVCW3WPV8
 
 	// W3SVC_W3WP
 	w3SVCW3WPThreads        *prometheus.Desc
@@ -78,112 +81,85 @@ type collectorW3SVCW3WP struct {
 
 var workerProcessNameExtractor = regexp.MustCompile(`^(\d+)_(.+)$`)
 
-const (
-	w3SVCW3WPThreads        = "Active Threads Count"
-	w3SVCW3WPMaximumThreads = "Maximum Threads Count"
+type perfDataCounterValuesW3SVCW3WP struct {
+	Name string
 
-	w3SVCW3WPRequestsTotal  = "Total HTTP Requests Served"
-	w3SVCW3WPRequestsActive = "Active Requests"
+	W3SVCW3WPThreads        float64 `perfdata:"Active Threads Count"`
+	W3SVCW3WPMaximumThreads float64 `perfdata:"Maximum Threads Count"`
 
-	w3SVCW3WPActiveFlushedEntries = "Active Flushed Entries"
+	W3SVCW3WPRequestsTotal  float64 `perfdata:"Total HTTP Requests Served"`
+	W3SVCW3WPRequestsActive float64 `perfdata:"Active Requests"`
 
-	w3SVCW3WPCurrentFileCacheMemoryUsage = "Current File Cache Memory Usage"
-	w3SVCW3WPMaximumFileCacheMemoryUsage = "Maximum File Cache Memory Usage"
-	w3SVCW3WPFileCacheFlushesTotal       = "File Cache Flushes"
-	w3SVCW3WPFileCacheHitsTotal          = "File Cache Hits"
-	w3SVCW3WPFileCacheMissesTotal        = "File Cache Misses"
-	w3SVCW3WPFilesCached                 = "Current Files Cached"
-	w3SVCW3WPFilesCachedTotal            = "Total Files Cached"
-	w3SVCW3WPFilesFlushedTotal           = "Total Flushed Files"
+	W3SVCW3WPActiveFlushedEntries float64 `perfdata:"Active Flushed Entries"`
 
-	w3SVCW3WPURICacheFlushesTotal = "Total Flushed URIs"
-	w3SVCW3WPURICacheHitsTotal    = "URI Cache Hits"
-	w3SVCW3WPURICacheMissesTotal  = "URI Cache Misses"
-	w3SVCW3WPURIsCached           = "Current URIs Cached"
-	w3SVCW3WPURIsCachedTotal      = "Total URIs Cached"
-	w3SVCW3WPURIsFlushedTotal     = "Total Flushed URIs"
+	W3SVCW3WPCurrentFileCacheMemoryUsage float64 `perfdata:"Current File Cache Memory Usage"`
+	W3SVCW3WPMaximumFileCacheMemoryUsage float64 `perfdata:"Maximum File Cache Memory Usage"`
+	W3SVCW3WPFileCacheFlushesTotal       float64 `perfdata:"File Cache Flushes"`
+	W3SVCW3WPFileCacheHitsTotal          float64 `perfdata:"File Cache Hits"`
+	W3SVCW3WPFileCacheMissesTotal        float64 `perfdata:"File Cache Misses"`
+	W3SVCW3WPFilesCached                 float64 `perfdata:"Current Files Cached"`
+	W3SVCW3WPFilesCachedTotal            float64 `perfdata:"Total Files Cached"`
+	W3SVCW3WPFilesFlushedTotal           float64 `perfdata:"Total Flushed Files"`
 
-	w3SVCW3WPMetaDataCacheHits    = "Metadata Cache Hits"
-	w3SVCW3WPMetaDataCacheMisses  = "Metadata Cache Misses"
-	w3SVCW3WPMetadataCached       = "Current Metadata Cached"
-	w3SVCW3WPMetadataCacheFlushes = "Metadata Cache Flushes"
-	w3SVCW3WPMetadataCachedTotal  = "Total Metadata Cached"
-	w3SVCW3WPMetadataFlushedTotal = "Total Flushed Metadata"
+	W3SVCW3WPURICacheFlushesTotal float64 `perfdata:"Total Flushed URIs"`
+	W3SVCW3WPURICacheHitsTotal    float64 `perfdata:"URI Cache Hits"`
+	W3SVCW3WPURICacheMissesTotal  float64 `perfdata:"URI Cache Misses"`
+	W3SVCW3WPURIsCached           float64 `perfdata:"Current URIs Cached"`
+	W3SVCW3WPURIsCachedTotal      float64 `perfdata:"Total URIs Cached"`
+	W3SVCW3WPURIsFlushedTotal     float64 `perfdata:"Total Flushed URIs"`
 
-	w3SVCW3WPOutputCacheActiveFlushedItems = "Output Cache Current Flushed Items"
-	w3SVCW3WPOutputCacheItems              = "Output Cache Current Items"
-	w3SVCW3WPOutputCacheMemoryUsage        = "Output Cache Current Memory Usage"
-	w3SVCW3WPOutputCacheHitsTotal          = "Output Cache Total Hits"
-	w3SVCW3WPOutputCacheMissesTotal        = "Output Cache Total Misses"
-	w3SVCW3WPOutputCacheFlushedItemsTotal  = "Output Cache Total Flushed Items"
-	w3SVCW3WPOutputCacheFlushesTotal       = "Output Cache Total Flushes"
+	W3SVCW3WPMetaDataCacheHits    float64 `perfdata:"Metadata Cache Hits"`
+	W3SVCW3WPMetaDataCacheMisses  float64 `perfdata:"Metadata Cache Misses"`
+	W3SVCW3WPMetadataCached       float64 `perfdata:"Current Metadata Cached"`
+	W3SVCW3WPMetadataCacheFlushes float64 `perfdata:"Metadata Cache Flushes"`
+	W3SVCW3WPMetadataCachedTotal  float64 `perfdata:"Total Metadata Cached"`
+	W3SVCW3WPMetadataFlushedTotal float64 `perfdata:"Total Flushed Metadata"`
+
+	W3SVCW3WPOutputCacheActiveFlushedItems float64 `perfdata:"Output Cache Current Flushed Items"`
+	W3SVCW3WPOutputCacheItems              float64 `perfdata:"Output Cache Current Items"`
+	W3SVCW3WPOutputCacheMemoryUsage        float64 `perfdata:"Output Cache Current Memory Usage"`
+	W3SVCW3WPOutputCacheHitsTotal          float64 `perfdata:"Output Cache Total Hits"`
+	W3SVCW3WPOutputCacheMissesTotal        float64 `perfdata:"Output Cache Total Misses"`
+	W3SVCW3WPOutputCacheFlushedItemsTotal  float64 `perfdata:"Output Cache Total Flushed Items"`
+	W3SVCW3WPOutputCacheFlushesTotal       float64 `perfdata:"Output Cache Total Flushes"`
+}
+
+func (p perfDataCounterValuesW3SVCW3WP) GetName() string {
+	return p.Name
+}
+
+type perfDataCounterValuesW3SVCW3WPV8 struct {
+	Name string
 
 	// IIS8
-	w3SVCW3WPRequestErrors500 = "% 500 HTTP Response Sent"
-	w3SVCW3WPRequestErrors404 = "% 404 HTTP Response Sent"
-	w3SVCW3WPRequestErrors403 = "% 403 HTTP Response Sent"
-	w3SVCW3WPRequestErrors401 = "% 401 HTTP Response Sent"
+	W3SVCW3WPRequestErrors500 float64 `perfdata:"% 500 HTTP Response Sent"`
+	W3SVCW3WPRequestErrors404 float64 `perfdata:"% 404 HTTP Response Sent"`
+	W3SVCW3WPRequestErrors403 float64 `perfdata:"% 403 HTTP Response Sent"`
+	W3SVCW3WPRequestErrors401 float64 `perfdata:"% 401 HTTP Response Sent"`
 
-	w3SVCW3WPWebSocketRequestsActive      = "WebSocket Active Requests"
-	w3SVCW3WPWebSocketConnectionAttempts  = "WebSocket Connection Attempts / Sec"
-	w3SVCW3WPWebSocketConnectionsAccepted = "WebSocket Connections Accepted / Sec"
-	w3SVCW3WPWebSocketConnectionsRejected = "WebSocket Connections Rejected / Sec"
-)
+	W3SVCW3WPWebSocketRequestsActive      float64 `perfdata:"WebSocket Active Requests"`
+	W3SVCW3WPWebSocketConnectionAttempts  float64 `perfdata:"WebSocket Connection Attempts / Sec"`
+	W3SVCW3WPWebSocketConnectionsAccepted float64 `perfdata:"WebSocket Connections Accepted / Sec"`
+	W3SVCW3WPWebSocketConnectionsRejected float64 `perfdata:"WebSocket Connections Rejected / Sec"`
+}
+
+func (p perfDataCounterValuesW3SVCW3WPV8) GetName() string {
+	return p.Name
+}
 
 func (c *Collector) buildW3SVCW3WP() error {
-	counters := []string{
-		w3SVCW3WPThreads,
-		w3SVCW3WPMaximumThreads,
-		w3SVCW3WPRequestsTotal,
-		w3SVCW3WPRequestsActive,
-		w3SVCW3WPActiveFlushedEntries,
-		w3SVCW3WPCurrentFileCacheMemoryUsage,
-		w3SVCW3WPMaximumFileCacheMemoryUsage,
-		w3SVCW3WPFileCacheFlushesTotal,
-		w3SVCW3WPFileCacheHitsTotal,
-		w3SVCW3WPFileCacheMissesTotal,
-		w3SVCW3WPFilesCached,
-		w3SVCW3WPFilesCachedTotal,
-		w3SVCW3WPFilesFlushedTotal,
-		w3SVCW3WPURICacheFlushesTotal,
-		w3SVCW3WPURICacheHitsTotal,
-		w3SVCW3WPURICacheMissesTotal,
-		w3SVCW3WPURIsCached,
-		w3SVCW3WPURIsCachedTotal,
-		w3SVCW3WPURIsFlushedTotal,
-		w3SVCW3WPMetaDataCacheHits,
-		w3SVCW3WPMetaDataCacheMisses,
-		w3SVCW3WPMetadataCached,
-		w3SVCW3WPMetadataCacheFlushes,
-		w3SVCW3WPMetadataCachedTotal,
-		w3SVCW3WPMetadataFlushedTotal,
-		w3SVCW3WPOutputCacheActiveFlushedItems,
-		w3SVCW3WPOutputCacheItems,
-		w3SVCW3WPOutputCacheMemoryUsage,
-		w3SVCW3WPOutputCacheHitsTotal,
-		w3SVCW3WPOutputCacheMissesTotal,
-		w3SVCW3WPOutputCacheFlushedItemsTotal,
-		w3SVCW3WPOutputCacheFlushesTotal,
+	var err error
+
+	c.w3SVCW3WPPerfDataCollector, err = pdh.NewCollector[perfDataCounterValuesW3SVCW3WP](pdh.CounterTypeRaw, "W3SVC_W3WP", pdh.InstancesAll)
+	if err != nil {
+		return fmt.Errorf("failed to create W3SVC_W3WP collector: %w", err)
 	}
 
 	if c.iisVersion.major >= 8 {
-		counters = append(counters, []string{
-			w3SVCW3WPRequestErrors500,
-			w3SVCW3WPRequestErrors404,
-			w3SVCW3WPRequestErrors403,
-			w3SVCW3WPRequestErrors401,
-			w3SVCW3WPWebSocketRequestsActive,
-			w3SVCW3WPWebSocketConnectionAttempts,
-			w3SVCW3WPWebSocketConnectionsAccepted,
-			w3SVCW3WPWebSocketConnectionsRejected,
-		}...)
-	}
-
-	var err error
-
-	c.w3SVCW3WPPerfDataCollector, err = perfdata.NewCollector("W3SVC_W3WP", perfdata.InstancesAll, counters)
-	if err != nil {
-		return fmt.Errorf("failed to create W3SVC_W3WP collector: %w", err)
+		c.w3SVCW3WPPerfDataCollectorV8, err = pdh.NewCollector[perfDataCounterValuesW3SVCW3WPV8](pdh.CounterTypeRaw, "W3SVC_W3WP", pdh.InstancesAll)
+		if err != nil {
+			return fmt.Errorf("failed to create W3SVC_W3WP collector: %w", err)
+		}
 	}
 
 	// W3SVC_W3WP
@@ -415,22 +391,128 @@ func (c *Collector) buildW3SVCW3WP() error {
 }
 
 func (c *Collector) collectW3SVCW3WP(ch chan<- prometheus.Metric) error {
-	perfData, err := c.w3SVCW3WPPerfDataCollector.Collect()
+	if err := c.collectW3SVCW3WPv7(ch); err != nil {
+		return err
+	}
+
+	if c.iisVersion.major >= 8 {
+		if err := c.collectW3SVCW3WPv8(ch); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (c *Collector) collectW3SVCW3WPv8(ch chan<- prometheus.Metric) error {
+	err := c.w3SVCW3WPPerfDataCollectorV8.Collect(&c.perfDataObjectW3SVCW3WPV8)
 	if err != nil {
 		return fmt.Errorf("failed to collect APP_POOL_WAS metrics: %w", err)
 	}
 
-	deduplicateIISNames(perfData)
+	deduplicateIISNames(c.perfDataObjectW3SVCW3WPV8)
 
-	for name, app := range perfData {
-		if c.config.AppExclude.MatchString(name) || !c.config.AppInclude.MatchString(name) {
+	for _, data := range c.perfDataObjectW3SVCW3WPV8 {
+		if c.config.AppExclude.MatchString(data.Name) || !c.config.AppInclude.MatchString(data.Name) {
 			continue
 		}
 
 		// Extract the apppool name from the format <PID>_<NAME>
-		pid := workerProcessNameExtractor.ReplaceAllString(name, "$1")
+		pid := workerProcessNameExtractor.ReplaceAllString(data.Name, "$1")
 
-		name := workerProcessNameExtractor.ReplaceAllString(name, "$2")
+		name := workerProcessNameExtractor.ReplaceAllString(data.Name, "$2")
+		if name == "" || c.config.AppExclude.MatchString(name) ||
+			!c.config.AppInclude.MatchString(name) {
+			continue
+		}
+
+		// Duplicate instances are suffixed # with an index number. These should be ignored
+		if strings.Contains(name, "#") {
+			continue
+		}
+
+		ch <- prometheus.MustNewConstMetric(
+			c.w3SVCW3WPRequestErrorsTotal,
+			prometheus.CounterValue,
+			data.W3SVCW3WPRequestErrors401,
+			name,
+			pid,
+			"401",
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.w3SVCW3WPRequestErrorsTotal,
+			prometheus.CounterValue,
+			data.W3SVCW3WPRequestErrors403,
+			name,
+			pid,
+			"403",
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.w3SVCW3WPRequestErrorsTotal,
+			prometheus.CounterValue,
+			data.W3SVCW3WPRequestErrors404,
+			name,
+			pid,
+			"404",
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.w3SVCW3WPRequestErrorsTotal,
+			prometheus.CounterValue,
+			data.W3SVCW3WPRequestErrors500,
+			name,
+			pid,
+			"500",
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.w3SVCW3WPWebSocketRequestsActive,
+			prometheus.CounterValue,
+			data.W3SVCW3WPWebSocketRequestsActive,
+			name,
+			pid,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.w3SVCW3WPWebSocketConnectionAttempts,
+			prometheus.CounterValue,
+			data.W3SVCW3WPWebSocketConnectionAttempts,
+			name,
+			pid,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.w3SVCW3WPWebSocketConnectionsAccepted,
+			prometheus.CounterValue,
+			data.W3SVCW3WPWebSocketConnectionsAccepted,
+			name,
+			pid,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.w3SVCW3WPWebSocketConnectionsRejected,
+			prometheus.CounterValue,
+			data.W3SVCW3WPWebSocketConnectionsRejected,
+			name,
+			pid,
+		)
+	}
+
+	return nil
+}
+
+func (c *Collector) collectW3SVCW3WPv7(ch chan<- prometheus.Metric) error {
+	err := c.w3SVCW3WPPerfDataCollector.Collect(&c.perfDataObjectW3SVCW3WP)
+	if err != nil {
+		return fmt.Errorf("failed to collect APP_POOL_WAS metrics: %w", err)
+	}
+
+	deduplicateIISNames(c.perfDataObjectW3SVCW3WP)
+
+	for _, data := range c.perfDataObjectW3SVCW3WP {
+		if c.config.AppExclude.MatchString(data.Name) || !c.config.AppInclude.MatchString(data.Name) {
+			continue
+		}
+
+		// Extract the apppool name from the format <PID>_<NAME>
+		pid := workerProcessNameExtractor.ReplaceAllString(data.Name, "$1")
+
+		name := workerProcessNameExtractor.ReplaceAllString(data.Name, "$2")
 		if name == "" || c.config.AppExclude.MatchString(name) ||
 			!c.config.AppInclude.MatchString(name) {
 			continue
@@ -444,7 +526,7 @@ func (c *Collector) collectW3SVCW3WP(ch chan<- prometheus.Metric) error {
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPThreads,
 			prometheus.GaugeValue,
-			app[w3SVCW3WPThreads].FirstValue,
+			data.W3SVCW3WPThreads,
 			name,
 			pid,
 			"busy",
@@ -452,283 +534,220 @@ func (c *Collector) collectW3SVCW3WP(ch chan<- prometheus.Metric) error {
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPMaximumThreads,
 			prometheus.CounterValue,
-			app[w3SVCW3WPMaximumThreads].FirstValue,
+			data.W3SVCW3WPMaximumThreads,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPRequestsTotal,
 			prometheus.CounterValue,
-			app[w3SVCW3WPRequestsTotal].FirstValue,
+			data.W3SVCW3WPRequestsTotal,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPRequestsActive,
 			prometheus.CounterValue,
-			app[w3SVCW3WPRequestsActive].FirstValue,
+			data.W3SVCW3WPRequestsActive,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPActiveFlushedEntries,
 			prometheus.GaugeValue,
-			app[w3SVCW3WPActiveFlushedEntries].FirstValue,
+			data.W3SVCW3WPActiveFlushedEntries,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPCurrentFileCacheMemoryUsage,
 			prometheus.GaugeValue,
-			app[w3SVCW3WPCurrentFileCacheMemoryUsage].FirstValue,
+			data.W3SVCW3WPCurrentFileCacheMemoryUsage,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPMaximumFileCacheMemoryUsage,
 			prometheus.CounterValue,
-			app[w3SVCW3WPMaximumFileCacheMemoryUsage].FirstValue,
+			data.W3SVCW3WPMaximumFileCacheMemoryUsage,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPFileCacheFlushesTotal,
 			prometheus.CounterValue,
-			app[w3SVCW3WPFileCacheFlushesTotal].FirstValue,
+			data.W3SVCW3WPFileCacheFlushesTotal,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPFileCacheQueriesTotal,
 			prometheus.CounterValue,
-			app[w3SVCW3WPFileCacheHitsTotal].FirstValue+app[w3SVCW3WPFileCacheMissesTotal].FirstValue,
+			data.W3SVCW3WPFileCacheHitsTotal+data.W3SVCW3WPFileCacheMissesTotal,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPFileCacheHitsTotal,
 			prometheus.CounterValue,
-			app[w3SVCW3WPFileCacheHitsTotal].FirstValue,
+			data.W3SVCW3WPFileCacheHitsTotal,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPFilesCached,
 			prometheus.GaugeValue,
-			app[w3SVCW3WPFilesCached].FirstValue,
+			data.W3SVCW3WPFilesCached,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPFilesCachedTotal,
 			prometheus.CounterValue,
-			app[w3SVCW3WPFilesCachedTotal].FirstValue,
+			data.W3SVCW3WPFilesCachedTotal,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPFilesFlushedTotal,
 			prometheus.CounterValue,
-			app[w3SVCW3WPFilesFlushedTotal].FirstValue,
+			data.W3SVCW3WPFilesFlushedTotal,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPURICacheFlushesTotal,
 			prometheus.CounterValue,
-			app[w3SVCW3WPURICacheFlushesTotal].FirstValue,
+			data.W3SVCW3WPURICacheFlushesTotal,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPURICacheQueriesTotal,
 			prometheus.CounterValue,
-			app[w3SVCW3WPURICacheHitsTotal].FirstValue+app[w3SVCW3WPURICacheMissesTotal].FirstValue,
+			data.W3SVCW3WPURICacheHitsTotal+data.W3SVCW3WPURICacheMissesTotal,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPURICacheHitsTotal,
 			prometheus.CounterValue,
-			app[w3SVCW3WPURICacheHitsTotal].FirstValue,
+			data.W3SVCW3WPURICacheHitsTotal,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPURIsCached,
 			prometheus.GaugeValue,
-			app[w3SVCW3WPURIsCached].FirstValue,
+			data.W3SVCW3WPURIsCached,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPURIsCachedTotal,
 			prometheus.CounterValue,
-			app[w3SVCW3WPURIsCachedTotal].FirstValue,
+			data.W3SVCW3WPURIsCachedTotal,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPURIsFlushedTotal,
 			prometheus.CounterValue,
-			app[w3SVCW3WPURIsFlushedTotal].FirstValue,
+			data.W3SVCW3WPURIsFlushedTotal,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPMetadataCached,
 			prometheus.GaugeValue,
-			app[w3SVCW3WPMetadataCached].FirstValue,
+			data.W3SVCW3WPMetadataCached,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPMetadataCacheFlushes,
 			prometheus.CounterValue,
-			app[w3SVCW3WPMetadataCacheFlushes].FirstValue,
+			data.W3SVCW3WPMetadataCacheFlushes,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPMetadataCacheQueriesTotal,
 			prometheus.CounterValue,
-			app[w3SVCW3WPMetaDataCacheHits].FirstValue+app[w3SVCW3WPMetaDataCacheMisses].FirstValue,
+			data.W3SVCW3WPMetaDataCacheHits+data.W3SVCW3WPMetaDataCacheMisses,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPMetadataCacheHitsTotal,
 			prometheus.CounterValue,
-			app[w3SVCW3WPMetaDataCacheHits].FirstValue,
+			data.W3SVCW3WPMetaDataCacheHits,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPMetadataCachedTotal,
 			prometheus.CounterValue,
-			app[w3SVCW3WPMetadataCachedTotal].FirstValue,
+			data.W3SVCW3WPMetadataCachedTotal,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPMetadataFlushedTotal,
 			prometheus.CounterValue,
-			app[w3SVCW3WPMetadataFlushedTotal].FirstValue,
+			data.W3SVCW3WPMetadataFlushedTotal,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPOutputCacheActiveFlushedItems,
 			prometheus.CounterValue,
-			app[w3SVCW3WPOutputCacheActiveFlushedItems].FirstValue,
+			data.W3SVCW3WPOutputCacheActiveFlushedItems,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPOutputCacheItems,
 			prometheus.CounterValue,
-			app[w3SVCW3WPOutputCacheItems].FirstValue,
+			data.W3SVCW3WPOutputCacheItems,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPOutputCacheMemoryUsage,
 			prometheus.CounterValue,
-			app[w3SVCW3WPOutputCacheMemoryUsage].FirstValue,
+			data.W3SVCW3WPOutputCacheMemoryUsage,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPOutputCacheQueriesTotal,
 			prometheus.CounterValue,
-			app[w3SVCW3WPOutputCacheHitsTotal].FirstValue+app[w3SVCW3WPOutputCacheMissesTotal].FirstValue,
+			data.W3SVCW3WPOutputCacheHitsTotal+data.W3SVCW3WPOutputCacheMissesTotal,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPOutputCacheHitsTotal,
 			prometheus.CounterValue,
-			app[w3SVCW3WPOutputCacheHitsTotal].FirstValue,
+			data.W3SVCW3WPOutputCacheHitsTotal,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPOutputCacheFlushedItemsTotal,
 			prometheus.CounterValue,
-			app[w3SVCW3WPOutputCacheFlushedItemsTotal].FirstValue,
+			data.W3SVCW3WPOutputCacheFlushedItemsTotal,
 			name,
 			pid,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.w3SVCW3WPOutputCacheFlushesTotal,
 			prometheus.CounterValue,
-			app[w3SVCW3WPOutputCacheFlushesTotal].FirstValue,
+			data.W3SVCW3WPOutputCacheFlushesTotal,
 			name,
 			pid,
 		)
-
-		if c.iisVersion.major >= 8 {
-			ch <- prometheus.MustNewConstMetric(
-				c.w3SVCW3WPRequestErrorsTotal,
-				prometheus.CounterValue,
-				app[w3SVCW3WPRequestErrors401].FirstValue,
-				name,
-				pid,
-				"401",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				c.w3SVCW3WPRequestErrorsTotal,
-				prometheus.CounterValue,
-				app[w3SVCW3WPRequestErrors403].FirstValue,
-				name,
-				pid,
-				"403",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				c.w3SVCW3WPRequestErrorsTotal,
-				prometheus.CounterValue,
-				app[w3SVCW3WPRequestErrors404].FirstValue,
-				name,
-				pid,
-				"404",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				c.w3SVCW3WPRequestErrorsTotal,
-				prometheus.CounterValue,
-				app[w3SVCW3WPRequestErrors500].FirstValue,
-				name,
-				pid,
-				"500",
-			)
-			ch <- prometheus.MustNewConstMetric(
-				c.w3SVCW3WPWebSocketRequestsActive,
-				prometheus.CounterValue,
-				app[w3SVCW3WPWebSocketRequestsActive].FirstValue,
-				name,
-				pid,
-			)
-			ch <- prometheus.MustNewConstMetric(
-				c.w3SVCW3WPWebSocketConnectionAttempts,
-				prometheus.CounterValue,
-				app[w3SVCW3WPWebSocketConnectionAttempts].FirstValue,
-				name,
-				pid,
-			)
-			ch <- prometheus.MustNewConstMetric(
-				c.w3SVCW3WPWebSocketConnectionsAccepted,
-				prometheus.CounterValue,
-				app[w3SVCW3WPWebSocketConnectionsAccepted].FirstValue,
-				name,
-				pid,
-			)
-			ch <- prometheus.MustNewConstMetric(
-				c.w3SVCW3WPWebSocketConnectionsRejected,
-				prometheus.CounterValue,
-				app[w3SVCW3WPWebSocketConnectionsRejected].FirstValue,
-				name,
-				pid,
-			)
-		}
 	}
 
 	return nil

internal/collector/iis/iis_web_service.go

@@ -18,13 +18,14 @@ package iis
 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"
 )
 
 type collectorWebService struct {
-	perfDataCollectorWebService *perfdata.Collector
+	perfDataCollectorWebService *pdh.Collector
+	perfDataObjectWebService    []perfDataCounterValuesWebService
 
 	webServiceCurrentAnonymousUsers               *prometheus.Desc
 	webServiceCurrentBlockedAsyncIORequests       *prometheus.Desc
@@ -50,88 +51,56 @@ type collectorWebService struct {
 	webServiceTotalRejectedAsyncIORequests        *prometheus.Desc
 }
 
-const (
-	webServiceCurrentAnonymousUsers               = "Current Anonymous Users"
-	webServiceCurrentBlockedAsyncIORequests       = "Current Blocked Async I/O Requests"
-	webServiceCurrentCGIRequests                  = "Current CGI Requests"
-	webServiceCurrentConnections                  = "Current Connections"
-	webServiceCurrentISAPIExtensionRequests       = "Current ISAPI Extension Requests"
-	webServiceCurrentNonAnonymousUsers            = "Current NonAnonymous Users"
-	webServiceServiceUptime                       = "Service Uptime"
-	webServiceTotalBytesReceived                  = "Total Bytes Received"
-	webServiceTotalBytesSent                      = "Total Bytes Sent"
-	webServiceTotalAnonymousUsers                 = "Total Anonymous Users"
-	webServiceTotalBlockedAsyncIORequests         = "Total Blocked Async I/O Requests"
-	webServiceTotalCGIRequests                    = "Total CGI Requests"
-	webServiceTotalConnectionAttemptsAllInstances = "Total Connection Attempts (all instances)"
-	webServiceTotalFilesReceived                  = "Total Files Received"
-	webServiceTotalFilesSent                      = "Total Files Sent"
-	webServiceTotalISAPIExtensionRequests         = "Total ISAPI Extension Requests"
-	webServiceTotalLockedErrors                   = "Total Locked Errors"
-	webServiceTotalLogonAttempts                  = "Total Logon Attempts"
-	webServiceTotalNonAnonymousUsers              = "Total NonAnonymous Users"
-	webServiceTotalNotFoundErrors                 = "Total Not Found Errors"
-	webServiceTotalRejectedAsyncIORequests        = "Total Rejected Async I/O Requests"
-	webServiceTotalCopyRequests                   = "Total Copy Requests"
-	webServiceTotalDeleteRequests                 = "Total Delete Requests"
-	webServiceTotalGetRequests                    = "Total Get Requests"
-	webServiceTotalHeadRequests                   = "Total Head Requests"
-	webServiceTotalLockRequests                   = "Total Lock Requests"
-	webServiceTotalMkcolRequests                  = "Total Mkcol Requests"
-	webServiceTotalMoveRequests                   = "Total Move Requests"
-	webServiceTotalOptionsRequests                = "Total Options Requests"
-	webServiceTotalOtherRequests                  = "Total Other Request Methods"
-	webServiceTotalPostRequests                   = "Total Post Requests"
-	webServiceTotalPropfindRequests               = "Total Propfind Requests"
-	webServiceTotalProppatchRequests              = "Total Proppatch Requests"
-	webServiceTotalPutRequests                    = "Total Put Requests"
-	webServiceTotalSearchRequests                 = "Total Search Requests"
-	webServiceTotalTraceRequests                  = "Total Trace Requests"
-	webServiceTotalUnlockRequests                 = "Total Unlock Requests"
-)
+type perfDataCounterValuesWebService struct {
+	Name string
+
+	WebServiceCurrentAnonymousUsers               float64 `perfdata:"Current Anonymous Users"`
+	WebServiceCurrentBlockedAsyncIORequests       float64 `perfdata:"Current Blocked Async I/O Requests"`
+	WebServiceCurrentCGIRequests                  float64 `perfdata:"Current CGI Requests"`
+	WebServiceCurrentConnections                  float64 `perfdata:"Current Connections"`
+	WebServiceCurrentISAPIExtensionRequests       float64 `perfdata:"Current ISAPI Extension Requests"`
+	WebServiceCurrentNonAnonymousUsers            float64 `perfdata:"Current NonAnonymous Users"`
+	WebServiceServiceUptime                       float64 `perfdata:"Service Uptime"`
+	WebServiceTotalBytesReceived                  float64 `perfdata:"Total Bytes Received"`
+	WebServiceTotalBytesSent                      float64 `perfdata:"Total Bytes Sent"`
+	WebServiceTotalAnonymousUsers                 float64 `perfdata:"Total Anonymous Users"`
+	WebServiceTotalBlockedAsyncIORequests         float64 `perfdata:"Total Blocked Async I/O Requests"`
+	WebServiceTotalCGIRequests                    float64 `perfdata:"Total CGI Requests"`
+	WebServiceTotalConnectionAttemptsAllInstances float64 `perfdata:"Total Connection Attempts (all instances)"`
+	WebServiceTotalFilesReceived                  float64 `perfdata:"Total Files Received"`
+	WebServiceTotalFilesSent                      float64 `perfdata:"Total Files Sent"`
+	WebServiceTotalISAPIExtensionRequests         float64 `perfdata:"Total ISAPI Extension Requests"`
+	WebServiceTotalLockedErrors                   float64 `perfdata:"Total Locked Errors"`
+	WebServiceTotalLogonAttempts                  float64 `perfdata:"Total Logon Attempts"`
+	WebServiceTotalNonAnonymousUsers              float64 `perfdata:"Total NonAnonymous Users"`
+	WebServiceTotalNotFoundErrors                 float64 `perfdata:"Total Not Found Errors"`
+	WebServiceTotalRejectedAsyncIORequests        float64 `perfdata:"Total Rejected Async I/O Requests"`
+	WebServiceTotalCopyRequests                   float64 `perfdata:"Total Copy Requests"`
+	WebServiceTotalDeleteRequests                 float64 `perfdata:"Total Delete Requests"`
+	WebServiceTotalGetRequests                    float64 `perfdata:"Total Get Requests"`
+	WebServiceTotalHeadRequests                   float64 `perfdata:"Total Head Requests"`
+	WebServiceTotalLockRequests                   float64 `perfdata:"Total Lock Requests"`
+	WebServiceTotalMkcolRequests                  float64 `perfdata:"Total Mkcol Requests"`
+	WebServiceTotalMoveRequests                   float64 `perfdata:"Total Move Requests"`
+	WebServiceTotalOptionsRequests                float64 `perfdata:"Total Options Requests"`
+	WebServiceTotalOtherRequests                  float64 `perfdata:"Total Other Request Methods"`
+	WebServiceTotalPostRequests                   float64 `perfdata:"Total Post Requests"`
+	WebServiceTotalPropfindRequests               float64 `perfdata:"Total Propfind Requests"`
+	WebServiceTotalProppatchRequests              float64 `perfdata:"Total Proppatch Requests"`
+	WebServiceTotalPutRequests                    float64 `perfdata:"Total Put Requests"`
+	WebServiceTotalSearchRequests                 float64 `perfdata:"Total Search Requests"`
+	WebServiceTotalTraceRequests                  float64 `perfdata:"Total Trace Requests"`
+	WebServiceTotalUnlockRequests                 float64 `perfdata:"Total Unlock Requests"`
+}
+
+func (p perfDataCounterValuesWebService) GetName() string {
+	return p.Name
+}
 
 func (c *Collector) buildWebService() error {
 	var err error
 
-	c.perfDataCollectorWebService, err = perfdata.NewCollector("Web Service", perfdata.InstancesAll, []string{
-		webServiceCurrentAnonymousUsers,
-		webServiceCurrentBlockedAsyncIORequests,
-		webServiceCurrentCGIRequests,
-		webServiceCurrentConnections,
-		webServiceCurrentISAPIExtensionRequests,
-		webServiceCurrentNonAnonymousUsers,
-		webServiceServiceUptime,
-		webServiceTotalBytesReceived,
-		webServiceTotalBytesSent,
-		webServiceTotalAnonymousUsers,
-		webServiceTotalBlockedAsyncIORequests,
-		webServiceTotalCGIRequests,
-		webServiceTotalConnectionAttemptsAllInstances,
-		webServiceTotalFilesReceived,
-		webServiceTotalFilesSent,
-		webServiceTotalISAPIExtensionRequests,
-		webServiceTotalLockedErrors,
-		webServiceTotalLogonAttempts,
-		webServiceTotalNonAnonymousUsers,
-		webServiceTotalNotFoundErrors,
-		webServiceTotalRejectedAsyncIORequests,
-		webServiceTotalCopyRequests,
-		webServiceTotalDeleteRequests,
-		webServiceTotalGetRequests,
-		webServiceTotalHeadRequests,
-		webServiceTotalLockRequests,
-		webServiceTotalMkcolRequests,
-		webServiceTotalMoveRequests,
-		webServiceTotalOptionsRequests,
-		webServiceTotalOtherRequests,
-		webServiceTotalPostRequests,
-		webServiceTotalPropfindRequests,
-		webServiceTotalProppatchRequests,
-		webServiceTotalPutRequests,
-		webServiceTotalSearchRequests,
-		webServiceTotalTraceRequests,
-		webServiceTotalUnlockRequests,
-	})
+	c.perfDataCollectorWebService, err = pdh.NewCollector[perfDataCounterValuesWebService](pdh.CounterTypeRaw, "Web Service", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create Web Service collector: %w", err)
 	}
@@ -273,254 +242,254 @@ func (c *Collector) buildWebService() error {
 }
 
 func (c *Collector) collectWebService(ch chan<- prometheus.Metric) error {
-	perfData, err := c.perfDataCollectorWebService.Collect()
+	err := c.perfDataCollectorWebService.Collect(&c.perfDataObjectWebService)
 	if err != nil {
 		return fmt.Errorf("failed to collect Web Service metrics: %w", err)
 	}
 
-	deduplicateIISNames(perfData)
+	deduplicateIISNames(c.perfDataObjectWebService)
 
-	for name, app := range perfData {
-		if c.config.SiteExclude.MatchString(name) || !c.config.SiteInclude.MatchString(name) {
+	for _, data := range c.perfDataObjectWebService {
+		if c.config.SiteExclude.MatchString(data.Name) || !c.config.SiteInclude.MatchString(data.Name) {
 			continue
 		}
 
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceCurrentAnonymousUsers,
 			prometheus.GaugeValue,
-			app[webServiceCurrentAnonymousUsers].FirstValue,
-			name,
+			data.WebServiceCurrentAnonymousUsers,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceCurrentBlockedAsyncIORequests,
 			prometheus.GaugeValue,
-			app[webServiceCurrentBlockedAsyncIORequests].FirstValue,
-			name,
+			data.WebServiceCurrentBlockedAsyncIORequests,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceCurrentCGIRequests,
 			prometheus.GaugeValue,
-			app[webServiceCurrentCGIRequests].FirstValue,
-			name,
+			data.WebServiceCurrentCGIRequests,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceCurrentConnections,
 			prometheus.GaugeValue,
-			app[webServiceCurrentConnections].FirstValue,
-			name,
+			data.WebServiceCurrentConnections,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceCurrentISAPIExtensionRequests,
 			prometheus.GaugeValue,
-			app[webServiceCurrentISAPIExtensionRequests].FirstValue,
-			name,
+			data.WebServiceCurrentISAPIExtensionRequests,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceCurrentNonAnonymousUsers,
 			prometheus.GaugeValue,
-			app[webServiceCurrentNonAnonymousUsers].FirstValue,
-			name,
+			data.WebServiceCurrentNonAnonymousUsers,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceServiceUptime,
 			prometheus.GaugeValue,
-			app[webServiceServiceUptime].FirstValue,
-			name,
+			data.WebServiceServiceUptime,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalBytesReceived,
 			prometheus.CounterValue,
-			app[webServiceTotalBytesReceived].FirstValue,
-			name,
+			data.WebServiceTotalBytesReceived,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalBytesSent,
 			prometheus.CounterValue,
-			app[webServiceTotalBytesSent].FirstValue,
-			name,
+			data.WebServiceTotalBytesSent,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalAnonymousUsers,
 			prometheus.CounterValue,
-			app[webServiceTotalAnonymousUsers].FirstValue,
-			name,
+			data.WebServiceTotalAnonymousUsers,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalBlockedAsyncIORequests,
 			prometheus.CounterValue,
-			app[webServiceTotalBlockedAsyncIORequests].FirstValue,
-			name,
+			data.WebServiceTotalBlockedAsyncIORequests,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalCGIRequests,
 			prometheus.CounterValue,
-			app[webServiceTotalCGIRequests].FirstValue,
-			name,
+			data.WebServiceTotalCGIRequests,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalConnectionAttemptsAllInstances,
 			prometheus.CounterValue,
-			app[webServiceTotalConnectionAttemptsAllInstances].FirstValue,
-			name,
+			data.WebServiceTotalConnectionAttemptsAllInstances,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalFilesReceived,
 			prometheus.CounterValue,
-			app[webServiceTotalFilesReceived].FirstValue,
-			name,
+			data.WebServiceTotalFilesReceived,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalFilesSent,
 			prometheus.CounterValue,
-			app[webServiceTotalFilesSent].FirstValue,
-			name,
+			data.WebServiceTotalFilesSent,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalISAPIExtensionRequests,
 			prometheus.CounterValue,
-			app[webServiceTotalISAPIExtensionRequests].FirstValue,
-			name,
+			data.WebServiceTotalISAPIExtensionRequests,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalLockedErrors,
 			prometheus.CounterValue,
-			app[webServiceTotalLockedErrors].FirstValue,
-			name,
+			data.WebServiceTotalLockedErrors,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalLogonAttempts,
 			prometheus.CounterValue,
-			app[webServiceTotalLogonAttempts].FirstValue,
-			name,
+			data.WebServiceTotalLogonAttempts,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalNonAnonymousUsers,
 			prometheus.CounterValue,
-			app[webServiceTotalNonAnonymousUsers].FirstValue,
-			name,
+			data.WebServiceTotalNonAnonymousUsers,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalNotFoundErrors,
 			prometheus.CounterValue,
-			app[webServiceTotalNotFoundErrors].FirstValue,
-			name,
+			data.WebServiceTotalNotFoundErrors,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalRejectedAsyncIORequests,
 			prometheus.CounterValue,
-			app[webServiceTotalRejectedAsyncIORequests].FirstValue,
-			name,
+			data.WebServiceTotalRejectedAsyncIORequests,
+			data.Name,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalRequests,
 			prometheus.CounterValue,
-			app[webServiceTotalOtherRequests].FirstValue,
-			name,
+			data.WebServiceTotalOtherRequests,
+			data.Name,
 			"other",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalRequests,
 			prometheus.CounterValue,
-			app[webServiceTotalCopyRequests].FirstValue,
-			name,
+			data.WebServiceTotalCopyRequests,
+			data.Name,
 			"COPY",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalRequests,
 			prometheus.CounterValue,
-			app[webServiceTotalDeleteRequests].FirstValue,
-			name,
+			data.WebServiceTotalDeleteRequests,
+			data.Name,
 			"DELETE",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalRequests,
 			prometheus.CounterValue,
-			app[webServiceTotalGetRequests].FirstValue,
-			name,
+			data.WebServiceTotalGetRequests,
+			data.Name,
 			"GET",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalRequests,
 			prometheus.CounterValue,
-			app[webServiceTotalHeadRequests].FirstValue,
-			name,
+			data.WebServiceTotalHeadRequests,
+			data.Name,
 			"HEAD",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalRequests,
 			prometheus.CounterValue,
-			app[webServiceTotalLockRequests].FirstValue,
-			name,
+			data.WebServiceTotalLockRequests,
+			data.Name,
 			"LOCK",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalRequests,
 			prometheus.CounterValue,
-			app[webServiceTotalMkcolRequests].FirstValue,
-			name,
+			data.WebServiceTotalMkcolRequests,
+			data.Name,
 			"MKCOL",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalRequests,
 			prometheus.CounterValue,
-			app[webServiceTotalMoveRequests].FirstValue,
-			name,
+			data.WebServiceTotalMoveRequests,
+			data.Name,
 			"MOVE",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalRequests,
 			prometheus.CounterValue,
-			app[webServiceTotalOptionsRequests].FirstValue,
-			name,
+			data.WebServiceTotalOptionsRequests,
+			data.Name,
 			"OPTIONS",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalRequests,
 			prometheus.CounterValue,
-			app[webServiceTotalPostRequests].FirstValue,
-			name,
+			data.WebServiceTotalPostRequests,
+			data.Name,
 			"POST",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalRequests,
 			prometheus.CounterValue,
-			app[webServiceTotalPropfindRequests].FirstValue,
-			name,
+			data.WebServiceTotalPropfindRequests,
+			data.Name,
 			"PROPFIND",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalRequests,
 			prometheus.CounterValue,
-			app[webServiceTotalProppatchRequests].FirstValue,
-			name,
+			data.WebServiceTotalProppatchRequests,
+			data.Name,
 			"PROPPATCH",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalRequests,
 			prometheus.CounterValue,
-			app[webServiceTotalPutRequests].FirstValue,
-			name,
+			data.WebServiceTotalPutRequests,
+			data.Name,
 			"PUT",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalRequests,
 			prometheus.CounterValue,
-			app[webServiceTotalSearchRequests].FirstValue,
-			name,
+			data.WebServiceTotalSearchRequests,
+			data.Name,
 			"SEARCH",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalRequests,
 			prometheus.CounterValue,
-			app[webServiceTotalTraceRequests].FirstValue,
-			name,
+			data.WebServiceTotalTraceRequests,
+			data.Name,
 			"TRACE",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.webServiceTotalRequests,
 			prometheus.CounterValue,
-			app[webServiceTotalUnlockRequests].FirstValue,
-			name,
+			data.WebServiceTotalUnlockRequests,
+			data.Name,
 			"UNLOCK",
 		)
 	}

internal/collector/iis/iis_web_service_cache.go

@@ -18,13 +18,14 @@ package iis
 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"
 )
 
 type collectorWebServiceCache struct {
-	serviceCachePerfDataCollector *perfdata.Collector
+	serviceCachePerfDataCollector *pdh.Collector
+	perfDataObjectServiceCache    []perfDataCounterServiceCache
 
 	serviceCacheActiveFlushedEntries *prometheus.Desc
 
@@ -60,82 +61,53 @@ type collectorWebServiceCache struct {
 	serviceCacheOutputCacheFlushesTotal       *prometheus.Desc
 }
 
-const (
-	serviceCacheActiveFlushedEntries          = "Active Flushed Entries"
-	serviceCacheCurrentFileCacheMemoryUsage   = "Current File Cache Memory Usage"
-	serviceCacheMaximumFileCacheMemoryUsage   = "Maximum File Cache Memory Usage"
-	serviceCacheFileCacheFlushesTotal         = "File Cache Flushes"
-	serviceCacheFileCacheHitsTotal            = "File Cache Hits"
-	serviceCacheFileCacheMissesTotal          = "File Cache Misses"
-	serviceCacheFilesCached                   = "Current Files Cached"
-	serviceCacheFilesCachedTotal              = "Total Files Cached"
-	serviceCacheFilesFlushedTotal             = "Total Flushed Files"
-	serviceCacheURICacheFlushesTotal          = "Total Flushed URIs"
-	serviceCacheURICacheFlushesTotalKernel    = "Total Flushed URIs"
-	serviceCacheURIsFlushedTotalKernel        = "Kernel: Total Flushed URIs"
-	serviceCacheURICacheHitsTotal             = "URI Cache Hits"
-	serviceCacheURICacheHitsTotalKernel       = "Kernel: URI Cache Hits"
-	serviceCacheURICacheMissesTotal           = "URI Cache Misses"
-	serviceCacheURICacheMissesTotalKernel     = "Kernel: URI Cache Misses"
-	serviceCacheURIsCached                    = "Current URIs Cached"
-	serviceCacheURIsCachedKernel              = "Kernel: Current URIs Cached"
-	serviceCacheURIsCachedTotal               = "Total URIs Cached"
-	serviceCacheURIsCachedTotalKernel         = "Total URIs Cached"
-	serviceCacheURIsFlushedTotal              = "Total Flushed URIs"
-	serviceCacheMetaDataCacheHits             = "Metadata Cache Hits"
-	serviceCacheMetaDataCacheMisses           = "Metadata Cache Misses"
-	serviceCacheMetadataCached                = "Current Metadata Cached"
-	serviceCacheMetadataCacheFlushes          = "Metadata Cache Flushes"
-	serviceCacheMetadataCachedTotal           = "Total Metadata Cached"
-	serviceCacheMetadataFlushedTotal          = "Total Flushed Metadata"
-	serviceCacheOutputCacheActiveFlushedItems = "Output Cache Current Flushed Items"
-	serviceCacheOutputCacheItems              = "Output Cache Current Items"
-	serviceCacheOutputCacheMemoryUsage        = "Output Cache Current Memory Usage"
-	serviceCacheOutputCacheHitsTotal          = "Output Cache Total Hits"
-	serviceCacheOutputCacheMissesTotal        = "Output Cache Total Misses"
-	serviceCacheOutputCacheFlushedItemsTotal  = "Output Cache Total Flushed Items"
-	serviceCacheOutputCacheFlushesTotal       = "Output Cache Total Flushes"
-)
+type perfDataCounterServiceCache struct {
+	Name string
+
+	ServiceCacheActiveFlushedEntries          float64 `perfdata:"Active Flushed Entries"`
+	ServiceCacheCurrentFileCacheMemoryUsage   float64 `perfdata:"Current File Cache Memory Usage"`
+	ServiceCacheMaximumFileCacheMemoryUsage   float64 `perfdata:"Maximum File Cache Memory Usage"`
+	ServiceCacheFileCacheFlushesTotal         float64 `perfdata:"File Cache Flushes"`
+	ServiceCacheFileCacheHitsTotal            float64 `perfdata:"File Cache Hits"`
+	ServiceCacheFileCacheMissesTotal          float64 `perfdata:"File Cache Misses"`
+	ServiceCacheFilesCached                   float64 `perfdata:"Current Files Cached"`
+	ServiceCacheFilesCachedTotal              float64 `perfdata:"Total Files Cached"`
+	ServiceCacheFilesFlushedTotal             float64 `perfdata:"Total Flushed Files"`
+	ServiceCacheURICacheFlushesTotal          float64 `perfdata:"Total Flushed URIs"`
+	ServiceCacheURICacheFlushesTotalKernel    float64 `perfdata:"Total Flushed URIs"`
+	ServiceCacheURIsFlushedTotalKernel        float64 `perfdata:"Kernel: Total Flushed URIs"`
+	ServiceCacheURICacheHitsTotal             float64 `perfdata:"URI Cache Hits"`
+	ServiceCacheURICacheHitsTotalKernel       float64 `perfdata:"Kernel: URI Cache Hits"`
+	ServiceCacheURICacheMissesTotal           float64 `perfdata:"URI Cache Misses"`
+	ServiceCacheURICacheMissesTotalKernel     float64 `perfdata:"Kernel: URI Cache Misses"`
+	ServiceCacheURIsCached                    float64 `perfdata:"Current URIs Cached"`
+	ServiceCacheURIsCachedKernel              float64 `perfdata:"Kernel: Current URIs Cached"`
+	ServiceCacheURIsCachedTotal               float64 `perfdata:"Total URIs Cached"`
+	ServiceCacheURIsCachedTotalKernel         float64 `perfdata:"Total URIs Cached"`
+	ServiceCacheURIsFlushedTotal              float64 `perfdata:"Total Flushed URIs"`
+	ServiceCacheMetaDataCacheHits             float64 `perfdata:"Metadata Cache Hits"`
+	ServiceCacheMetaDataCacheMisses           float64 `perfdata:"Metadata Cache Misses"`
+	ServiceCacheMetadataCached                float64 `perfdata:"Current Metadata Cached"`
+	ServiceCacheMetadataCacheFlushes          float64 `perfdata:"Metadata Cache Flushes"`
+	ServiceCacheMetadataCachedTotal           float64 `perfdata:"Total Metadata Cached"`
+	ServiceCacheMetadataFlushedTotal          float64 `perfdata:"Total Flushed Metadata"`
+	ServiceCacheOutputCacheActiveFlushedItems float64 `perfdata:"Output Cache Current Flushed Items"`
+	ServiceCacheOutputCacheItems              float64 `perfdata:"Output Cache Current Items"`
+	ServiceCacheOutputCacheMemoryUsage        float64 `perfdata:"Output Cache Current Memory Usage"`
+	ServiceCacheOutputCacheHitsTotal          float64 `perfdata:"Output Cache Total Hits"`
+	ServiceCacheOutputCacheMissesTotal        float64 `perfdata:"Output Cache Total Misses"`
+	ServiceCacheOutputCacheFlushedItemsTotal  float64 `perfdata:"Output Cache Total Flushed Items"`
+	ServiceCacheOutputCacheFlushesTotal       float64 `perfdata:"Output Cache Total Flushes"`
+}
+
+func (p perfDataCounterServiceCache) GetName() string {
+	return p.Name
+}
 
 func (c *Collector) buildWebServiceCache() error {
 	var err error
 
-	c.perfDataCollectorWebService, err = perfdata.NewCollector("Web Service Cache", perfdata.InstancesAll, []string{
-		serviceCacheActiveFlushedEntries,
-		serviceCacheCurrentFileCacheMemoryUsage,
-		serviceCacheMaximumFileCacheMemoryUsage,
-		serviceCacheFileCacheFlushesTotal,
-		serviceCacheFileCacheHitsTotal,
-		serviceCacheFileCacheMissesTotal,
-		serviceCacheFilesCached,
-		serviceCacheFilesCachedTotal,
-		serviceCacheFilesFlushedTotal,
-		serviceCacheURICacheFlushesTotal,
-		serviceCacheURICacheFlushesTotalKernel,
-		serviceCacheURIsFlushedTotalKernel,
-		serviceCacheURICacheHitsTotal,
-		serviceCacheURICacheHitsTotalKernel,
-		serviceCacheURICacheMissesTotal,
-		serviceCacheURICacheMissesTotalKernel,
-		serviceCacheURIsCached,
-		serviceCacheURIsCachedKernel,
-		serviceCacheURIsCachedTotal,
-		serviceCacheURIsCachedTotalKernel,
-		serviceCacheURIsFlushedTotal,
-		serviceCacheMetaDataCacheHits,
-		serviceCacheMetaDataCacheMisses,
-		serviceCacheMetadataCached,
-		serviceCacheMetadataCacheFlushes,
-		serviceCacheMetadataCachedTotal,
-		serviceCacheMetadataFlushedTotal,
-		serviceCacheOutputCacheActiveFlushedItems,
-		serviceCacheOutputCacheItems,
-		serviceCacheOutputCacheMemoryUsage,
-		serviceCacheOutputCacheHitsTotal,
-		serviceCacheOutputCacheMissesTotal,
-		serviceCacheOutputCacheFlushedItemsTotal,
-		serviceCacheOutputCacheFlushesTotal,
-	})
+	c.serviceCachePerfDataCollector, err = pdh.NewCollector[perfDataCounterServiceCache](pdh.CounterTypeRaw, "Web Service Cache", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create Web Service Cache collector: %w", err)
 	}
@@ -314,199 +286,199 @@ func (c *Collector) buildWebServiceCache() error {
 }
 
 func (c *Collector) collectWebServiceCache(ch chan<- prometheus.Metric) error {
-	perfData, err := c.perfDataCollectorWebService.Collect()
+	err := c.serviceCachePerfDataCollector.Collect(&c.perfDataObjectServiceCache)
 	if err != nil {
 		return fmt.Errorf("failed to collect Web Service Cache metrics: %w", err)
 	}
 
-	deduplicateIISNames(perfData)
+	deduplicateIISNames(c.perfDataObjectServiceCache)
 
-	for name, app := range perfData {
-		if c.config.SiteExclude.MatchString(name) || !c.config.SiteInclude.MatchString(name) {
+	for _, data := range c.perfDataObjectServiceCache {
+		if c.config.SiteExclude.MatchString(data.Name) || !c.config.SiteInclude.MatchString(data.Name) {
 			continue
 		}
 
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheActiveFlushedEntries,
 			prometheus.GaugeValue,
-			app[serviceCacheActiveFlushedEntries].FirstValue,
+			data.ServiceCacheActiveFlushedEntries,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheCurrentFileCacheMemoryUsage,
 			prometheus.GaugeValue,
-			app[serviceCacheCurrentFileCacheMemoryUsage].FirstValue,
+			data.ServiceCacheCurrentFileCacheMemoryUsage,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheMaximumFileCacheMemoryUsage,
 			prometheus.CounterValue,
-			app[serviceCacheMaximumFileCacheMemoryUsage].FirstValue,
+			data.ServiceCacheMaximumFileCacheMemoryUsage,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheFileCacheFlushesTotal,
 			prometheus.CounterValue,
-			app[serviceCacheFileCacheFlushesTotal].FirstValue,
+			data.ServiceCacheFileCacheFlushesTotal,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheFileCacheQueriesTotal,
 			prometheus.CounterValue,
-			app[serviceCacheFileCacheHitsTotal].FirstValue+app[serviceCacheFileCacheMissesTotal].FirstValue,
+			data.ServiceCacheFileCacheHitsTotal+data.ServiceCacheFileCacheMissesTotal,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheFileCacheHitsTotal,
 			prometheus.CounterValue,
-			app[serviceCacheFileCacheHitsTotal].FirstValue,
+			data.ServiceCacheFileCacheHitsTotal,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheFilesCached,
 			prometheus.GaugeValue,
-			app[serviceCacheFilesCached].FirstValue,
+			data.ServiceCacheFilesCached,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheFilesCachedTotal,
 			prometheus.CounterValue,
-			app[serviceCacheFilesCachedTotal].FirstValue,
+			data.ServiceCacheFilesCachedTotal,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheFilesFlushedTotal,
 			prometheus.CounterValue,
-			app[serviceCacheFilesFlushedTotal].FirstValue,
+			data.ServiceCacheFilesFlushedTotal,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheURICacheFlushesTotal,
 			prometheus.CounterValue,
-			app[serviceCacheURICacheFlushesTotal].FirstValue,
+			data.ServiceCacheURICacheFlushesTotal,
 			"user",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheURICacheFlushesTotal,
 			prometheus.CounterValue,
-			app[serviceCacheURICacheFlushesTotalKernel].FirstValue,
+			data.ServiceCacheURICacheFlushesTotalKernel,
 			"kernel",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheURICacheQueriesTotal,
 			prometheus.CounterValue,
-			app[serviceCacheURICacheHitsTotal].FirstValue+app[serviceCacheURICacheMissesTotal].FirstValue,
+			data.ServiceCacheURICacheHitsTotal+data.ServiceCacheURICacheMissesTotal,
 			"user",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheURICacheQueriesTotal,
 			prometheus.CounterValue,
-			app[serviceCacheURICacheHitsTotalKernel].FirstValue+app[serviceCacheURICacheMissesTotalKernel].FirstValue,
+			data.ServiceCacheURICacheHitsTotalKernel+data.ServiceCacheURICacheMissesTotalKernel,
 			"kernel",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheURICacheHitsTotal,
 			prometheus.CounterValue,
-			app[serviceCacheURICacheHitsTotal].FirstValue,
+			data.ServiceCacheURICacheHitsTotal,
 			"user",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheURICacheHitsTotal,
 			prometheus.CounterValue,
-			app[serviceCacheURICacheHitsTotalKernel].FirstValue,
+			data.ServiceCacheURICacheHitsTotalKernel,
 			"kernel",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheURIsCached,
 			prometheus.GaugeValue,
-			app[serviceCacheURIsCached].FirstValue,
+			data.ServiceCacheURIsCached,
 			"user",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheURIsCached,
 			prometheus.GaugeValue,
-			app[serviceCacheURIsCachedKernel].FirstValue,
+			data.ServiceCacheURIsCachedKernel,
 			"kernel",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheURIsCachedTotal,
 			prometheus.CounterValue,
-			app[serviceCacheURIsCachedTotal].FirstValue,
+			data.ServiceCacheURIsCachedTotal,
 			"user",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheURIsCachedTotal,
 			prometheus.CounterValue,
-			app[serviceCacheURIsCachedTotalKernel].FirstValue,
+			data.ServiceCacheURIsCachedTotalKernel,
 			"kernel",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheURIsFlushedTotal,
 			prometheus.CounterValue,
-			app[serviceCacheURIsFlushedTotal].FirstValue,
+			data.ServiceCacheURIsFlushedTotal,
 			"user",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheURIsFlushedTotal,
 			prometheus.CounterValue,
-			app[serviceCacheURIsFlushedTotalKernel].FirstValue,
+			data.ServiceCacheURIsFlushedTotalKernel,
 			"kernel",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheMetadataCached,
 			prometheus.GaugeValue,
-			app[serviceCacheMetadataCached].FirstValue,
+			data.ServiceCacheMetadataCached,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheMetadataCacheFlushes,
 			prometheus.CounterValue,
-			app[serviceCacheMetadataCacheFlushes].FirstValue,
+			data.ServiceCacheMetadataCacheFlushes,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheMetadataCacheQueriesTotal,
 			prometheus.CounterValue,
-			app[serviceCacheMetaDataCacheHits].FirstValue+app[serviceCacheMetaDataCacheMisses].FirstValue,
+			data.ServiceCacheMetaDataCacheHits+data.ServiceCacheMetaDataCacheMisses,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheMetadataCacheHitsTotal,
 			prometheus.CounterValue,
-			0, // app[serviceCacheMetadataCacheHitsTotal].FirstValue,
+			0, // data.ServiceCacheMetadataCacheHitsTotal,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheMetadataCachedTotal,
 			prometheus.CounterValue,
-			app[serviceCacheMetadataCachedTotal].FirstValue,
+			data.ServiceCacheMetadataCachedTotal,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheMetadataFlushedTotal,
 			prometheus.CounterValue,
-			app[serviceCacheMetadataFlushedTotal].FirstValue,
+			data.ServiceCacheMetadataFlushedTotal,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheOutputCacheActiveFlushedItems,
 			prometheus.CounterValue,
-			app[serviceCacheOutputCacheActiveFlushedItems].FirstValue,
+			data.ServiceCacheOutputCacheActiveFlushedItems,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheOutputCacheItems,
 			prometheus.CounterValue,
-			app[serviceCacheOutputCacheItems].FirstValue,
+			data.ServiceCacheOutputCacheItems,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheOutputCacheMemoryUsage,
 			prometheus.CounterValue,
-			app[serviceCacheOutputCacheMemoryUsage].FirstValue,
+			data.ServiceCacheOutputCacheMemoryUsage,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheOutputCacheQueriesTotal,
 			prometheus.CounterValue,
-			app[serviceCacheOutputCacheHitsTotal].FirstValue+app[serviceCacheOutputCacheMissesTotal].FirstValue,
+			data.ServiceCacheOutputCacheHitsTotal+data.ServiceCacheOutputCacheMissesTotal,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheOutputCacheHitsTotal,
 			prometheus.CounterValue,
-			app[serviceCacheOutputCacheHitsTotal].FirstValue,
+			data.ServiceCacheOutputCacheHitsTotal,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheOutputCacheFlushedItemsTotal,
 			prometheus.CounterValue,
-			app[serviceCacheOutputCacheFlushedItemsTotal].FirstValue,
+			data.ServiceCacheOutputCacheFlushedItemsTotal,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.serviceCacheOutputCacheFlushesTotal,
 			prometheus.CounterValue,
-			app[serviceCacheOutputCacheFlushesTotal].FirstValue,
+			data.ServiceCacheOutputCacheFlushesTotal,
 		)
 	}
 

internal/collector/logical_disk/const.go

@@ -1,35 +0,0 @@
-// Copyright 2024 The Prometheus Authors
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//go:build windows
-
-package logical_disk
-
-const (
-	avgDiskReadQueueLength  = "Avg. Disk Read Queue Length"
-	avgDiskSecPerRead       = "Avg. Disk sec/Read"
-	avgDiskSecPerTransfer   = "Avg. Disk sec/Transfer"
-	avgDiskSecPerWrite      = "Avg. Disk sec/Write"
-	avgDiskWriteQueueLength = "Avg. Disk Write Queue Length"
-	currentDiskQueueLength  = "Current Disk Queue Length"
-	freeSpace               = "Free Megabytes"
-	diskReadBytesPerSec     = "Disk Read Bytes/sec"
-	diskReadsPerSec         = "Disk Reads/sec"
-	diskWriteBytesPerSec    = "Disk Write Bytes/sec"
-	diskWritesPerSec        = "Disk Writes/sec"
-	percentDiskReadTime     = "% Disk Read Time"
-	percentDiskWriteTime    = "% Disk Write Time"
-	percentFreeSpace        = "% Free Space"
-	percentIdleTime         = "% Idle Time"
-	splitIOPerSec           = "Split IO/Sec"
-)

internal/collector/logical_disk/logical_disk.go

@@ -17,6 +17,7 @@ package logical_disk
 
 import (
 	"encoding/binary"
+	"errors"
 	"fmt"
 	"log/slog"
 	"regexp"
@@ -26,7 +27,7 @@ import (
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/internal/mi"
-	"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"
 	"golang.org/x/sys/windows"
@@ -50,7 +51,8 @@ type Collector struct {
 	config Config
 	logger *slog.Logger
 
-	perfDataCollector *perfdata.Collector
+	perfDataCollector *pdh.Collector
+	perfDataObject    []perfDataCounterValues
 
 	avgReadQueue     *prometheus.Desc
 	avgWriteQueue    *prometheus.Desc
@@ -150,24 +152,7 @@ func (c *Collector) Build(logger *slog.Logger, _ *mi.Session) error {
 
 	var err error
 
-	c.perfDataCollector, err = perfdata.NewCollector("LogicalDisk", perfdata.InstancesAll, []string{
-		currentDiskQueueLength,
-		avgDiskReadQueueLength,
-		avgDiskWriteQueueLength,
-		diskReadBytesPerSec,
-		diskReadsPerSec,
-		diskWriteBytesPerSec,
-		diskWritesPerSec,
-		percentDiskReadTime,
-		percentDiskWriteTime,
-		percentFreeSpace,
-		freeSpace,
-		percentIdleTime,
-		splitIOPerSec,
-		avgDiskSecPerRead,
-		avgDiskSecPerWrite,
-		avgDiskSecPerTransfer,
-	})
+	c.perfDataCollector, err = pdh.NewCollector[perfDataCounterValues](pdh.CounterTypeRaw, "LogicalDisk", pdh.InstancesAll)
 	if err != nil {
 		return fmt.Errorf("failed to create LogicalDisk collector: %w", err)
 	}
@@ -302,24 +287,26 @@ func (c *Collector) Build(logger *slog.Logger, _ *mi.Session) error {
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
 func (c *Collector) Collect(ch chan<- prometheus.Metric) error {
-	var (
-		err  error
-		info volumeInfo
-	)
+	var info volumeInfo
 
-	perfData, err := c.perfDataCollector.Collect()
+	err := c.perfDataCollector.Collect(&c.perfDataObject)
 	if err != nil {
 		return fmt.Errorf("failed to collect LogicalDisk metrics: %w", err)
 	}
 
-	for name, volume := range perfData {
-		if c.config.VolumeExclude.MatchString(name) || !c.config.VolumeInclude.MatchString(name) {
+	volumes, err := getAllMountedVolumes()
+	if err != nil {
+		return fmt.Errorf("failed to get volumes: %w", err)
+	}
+
+	for _, data := range c.perfDataObject {
+		if c.config.VolumeExclude.MatchString(data.Name) || !c.config.VolumeInclude.MatchString(data.Name) {
 			continue
 		}
 
-		info, err = getVolumeInfo(name)
+		info, err = getVolumeInfo(volumes, data.Name)
 		if err != nil {
-			c.logger.Warn("failed to get volume information for "+name,
+			c.logger.Warn("failed to get volume information for "+data.Name,
 				slog.Any("err", err),
 			)
 		}
@@ -330,7 +317,7 @@ func (c *Collector) Collect(ch chan<- prometheus.Metric) error {
 			1,
 			info.diskIDs,
 			info.volumeType,
-			name,
+			data.Name,
 			info.label,
 			info.filesystem,
 			info.serialNumber,
@@ -339,113 +326,113 @@ func (c *Collector) Collect(ch chan<- prometheus.Metric) error {
 		ch <- prometheus.MustNewConstMetric(
 			c.requestsQueued,
 			prometheus.GaugeValue,
-			volume[currentDiskQueueLength].FirstValue,
-			name,
+			data.CurrentDiskQueueLength,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.avgReadQueue,
 			prometheus.GaugeValue,
-			volume[avgDiskReadQueueLength].FirstValue*perfdata.TicksToSecondScaleFactor,
-			name,
+			data.AvgDiskReadQueueLength*pdh.TicksToSecondScaleFactor,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.avgWriteQueue,
 			prometheus.GaugeValue,
-			volume[avgDiskWriteQueueLength].FirstValue*perfdata.TicksToSecondScaleFactor,
-			name,
+			data.AvgDiskWriteQueueLength*pdh.TicksToSecondScaleFactor,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.readBytesTotal,
 			prometheus.CounterValue,
-			volume[diskReadBytesPerSec].FirstValue,
-			name,
+			data.DiskReadBytesPerSec,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.readsTotal,
 			prometheus.CounterValue,
-			volume[diskReadsPerSec].FirstValue,
-			name,
+			data.DiskReadsPerSec,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.writeBytesTotal,
 			prometheus.CounterValue,
-			volume[diskWriteBytesPerSec].FirstValue,
-			name,
+			data.DiskWriteBytesPerSec,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.writesTotal,
 			prometheus.CounterValue,
-			volume[diskWritesPerSec].FirstValue,
-			name,
+			data.DiskWritesPerSec,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.readTime,
 			prometheus.CounterValue,
-			volume[percentDiskReadTime].FirstValue,
-			name,
+			data.PercentDiskReadTime,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.writeTime,
 			prometheus.CounterValue,
-			volume[percentDiskWriteTime].FirstValue,
-			name,
+			data.PercentDiskWriteTime,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.freeSpace,
 			prometheus.GaugeValue,
-			volume[freeSpace].FirstValue*1024*1024,
-			name,
+			data.FreeSpace*1024*1024,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.totalSpace,
 			prometheus.GaugeValue,
-			volume[percentFreeSpace].SecondValue*1024*1024,
-			name,
+			data.PercentFreeSpace*1024*1024,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.idleTime,
 			prometheus.CounterValue,
-			volume[percentIdleTime].FirstValue,
-			name,
+			data.PercentIdleTime,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.splitIOs,
 			prometheus.CounterValue,
-			volume[splitIOPerSec].FirstValue,
-			name,
+			data.SplitIOPerSec,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.readLatency,
 			prometheus.CounterValue,
-			volume[avgDiskSecPerRead].FirstValue*perfdata.TicksToSecondScaleFactor,
-			name,
+			data.AvgDiskSecPerRead*pdh.TicksToSecondScaleFactor,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.writeLatency,
 			prometheus.CounterValue,
-			volume[avgDiskSecPerWrite].FirstValue*perfdata.TicksToSecondScaleFactor,
-			name,
+			data.AvgDiskSecPerWrite*pdh.TicksToSecondScaleFactor,
+			data.Name,
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.readWriteLatency,
 			prometheus.CounterValue,
-			volume[avgDiskSecPerTransfer].FirstValue*perfdata.TicksToSecondScaleFactor,
-			name,
+			data.AvgDiskSecPerTransfer*pdh.TicksToSecondScaleFactor,
+			data.Name,
 		)
 	}
 
@@ -477,34 +464,15 @@ func getDriveType(driveType uint32) string {
 const diskExtentSize = 24
 
 // getDiskIDByVolume returns the disk ID for a given volume.
-func getVolumeInfo(rootDrive string) (volumeInfo, error) {
+func getVolumeInfo(volumes map[string]string, rootDrive string) (volumeInfo, error) {
 	volumePath := rootDrive
 
 	// If rootDrive is a NTFS directory, convert it to a volume GUID.
-	if strings.Contains(volumePath, `\`) {
-		// GetVolumeNameForVolumeMountPoint expects a trailing backslash.
-		volumePath += `\`
-
-		volumePathName, err := windows.UTF16PtrFromString(volumePath)
-		if err != nil {
-			return volumeInfo{}, fmt.Errorf("could not convert rootDrive to volume path %s: %w", volumePath, err)
-		}
-
-		volumeGUIDPtr := make([]uint16, 50)
-		if err := windows.GetVolumeNameForVolumeMountPoint(volumePathName, &volumeGUIDPtr[0], uint32(len(volumeGUIDPtr))); err != nil {
-			return volumeInfo{}, fmt.Errorf("could not get volume GUID for volume %s: %w", volumePath, err)
-		}
-
-		volumePath = windows.UTF16ToString(volumeGUIDPtr)
-
+	if volumeGUID, ok := volumes[rootDrive]; ok {
 		// GetVolumeNameForVolumeMountPoint returns the volume GUID path as \\?\Volume{GUID}\
 		// According https://learn.microsoft.com/en-us/windows/win32/api/ioapiset/nf-ioapiset-deviceiocontrol#remarks
 		// Win32 Drive Namespace is prefixed with \\.\, so we need to remove the \\?\ prefix.
-		volumePath, _ = strings.CutPrefix(volumePath, `\\?\`)
-
-		// https://stackoverflow.com/questions/55710326/how-to-get-the-physical-device-that-a-volume-guid-path-belongs-to#comment98104360_55710326
-		// DeviceIoControl expects no trailing backslash in the volume GUID path.
-		volumePath = strings.TrimRight(volumePath, `\`)
+		volumePath, _ = strings.CutPrefix(volumeGUID, `\\?\`)
 	}
 
 	volumePathPtr := windows.StringToUTF16Ptr(`\\.\` + volumePath)
@@ -519,7 +487,9 @@ func getVolumeInfo(rootDrive string) (volumeInfo, error) {
 		return volumeInfo{}, fmt.Errorf("could not open volume for %s: %w", rootDrive, err)
 	}
 
-	defer windows.Close(volumeHandle)
+	defer func(fd windows.Handle) {
+		_ = windows.Close(fd)
+	}(volumeHandle)
 
 	controlCode := uint32(5636096) // IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS
 	volumeDiskExtents := make([]byte, 16*1024)
@@ -581,3 +551,59 @@ func getVolumeInfo(rootDrive string) (volumeInfo, error) {
 		readonly:     float64(fsFlags & windows.FILE_READ_ONLY_VOLUME),
 	}, nil
 }
+
+func getAllMountedVolumes() (map[string]string, error) {
+	guidBuf := make([]uint16, windows.MAX_PATH+1)
+	guidBufLen := uint32(len(guidBuf) * 2)
+
+	hFindVolume, err := windows.FindFirstVolume(&guidBuf[0], guidBufLen)
+	if err != nil {
+		return nil, fmt.Errorf("FindFirstVolume: %w", err)
+	}
+
+	defer func() {
+		_ = windows.FindVolumeClose(hFindVolume)
+	}()
+
+	volumes := map[string]string{}
+
+	for ; ; err = windows.FindNextVolume(hFindVolume, &guidBuf[0], guidBufLen) {
+		if err != nil {
+			switch {
+			case errors.Is(err, windows.ERROR_NO_MORE_FILES):
+				return volumes, nil
+			default:
+				return nil, fmt.Errorf("FindNextVolume: %w", err)
+			}
+		}
+
+		var rootPathLen uint32
+
+		rootPathBuf := make([]uint16, windows.MAX_PATH+1)
+		rootPathBufLen := uint32(len(rootPathBuf) * 2)
+
+		for {
+			err = windows.GetVolumePathNamesForVolumeName(&guidBuf[0], &rootPathBuf[0], rootPathBufLen, &rootPathLen)
+			if err == nil {
+				break
+			}
+
+			if errors.Is(err, windows.ERROR_NO_MORE_FILES) {
+				rootPathBuf = make([]uint16, (rootPathLen+1)/2)
+
+				continue
+			}
+
+			return nil, fmt.Errorf("GetVolumePathNamesForVolumeName: %w", err)
+		}
+
+		mountPoint := windows.UTF16ToString(rootPathBuf)
+
+		// Skip unmounted volumes
+		if len(mountPoint) == 0 {
+			continue
+		}
+
+		volumes[strings.TrimSuffix(mountPoint, `\`)] = strings.TrimSuffix(windows.UTF16ToString(guidBuf), `\`)
+	}
+}

internal/collector/logical_disk/logical_disk_test.go

@@ -27,8 +27,10 @@ import (
 func BenchmarkCollector(b *testing.B) {
 	// Whitelist is not set in testing context (kingpin flags not parsed), causing the Collector to skip all disks.
 	localVolumeInclude := ".+"
-	kingpin.CommandLine.GetArg("collector.logical_disk.volume-include").StringVar(&localVolumeInclude)
-	testutils.FuncBenchmarkCollector(b, "logical_disk", logical_disk.NewWithFlags)
+
+	testutils.FuncBenchmarkCollector(b, "logical_disk", logical_disk.NewWithFlags, func(app *kingpin.Application) {
+		app.GetFlag("collector.logical_disk.volume-include").StringVar(&localVolumeInclude)
+	})
 }
 
 func TestCollector(t *testing.T) {