Merge pull request #1026 from breed808/ci

Add content write permissions to GITHUB_TOKEN

.github/workflows/ci.yml

@@ -1,8 +1,11 @@
 name: windows_exporter CI/CD
 
-# Trigger on pull requests and releases
+# Trigger on pull requests, releases and pushes to master branch.
 # Deployments will only occur for releases (see `if` clauses in the build job).
 on:
+  push:
+    branches:
+      - master
   pull_request:
     branches:
       - master
@@ -11,6 +14,13 @@ on:
       - published
       - edited
 
+permissions:
+  contents: write
+  packages: write
+  
+env:
+  PROMU_VER: 'v0.13.0'
+
 jobs:
   test:
     runs-on: windows-2019
@@ -25,16 +35,43 @@ jobs:
 
       - name: Install e2e deps
         run: |
-          go get -u github.com/prometheus/promu@v0.11.1
-          go get -u github.com/josephspurrier/goversioninfo/cmd/goversioninfo@v1.2.0
+          go install "github.com/prometheus/promu@$($Env:PROMU_VER)"
+          go install github.com/josephspurrier/goversioninfo/cmd/goversioninfo@v1.2.0
           # GOPATH\bin dir must be appended to PATH else the `promu` command won't be found
           echo "$(go env GOPATH)\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
 
       - name: e2e Test
         run: make e2e-test
 
-  lint:
+  promtool:
     runs-on: windows-2019
+    env:
+      PROMTOOL_VER: '2.32.1'
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-go@v2
+        with:
+          go-version: '^1.17.5'
+
+      - name: Install promtool
+        run: |
+          # promtool brings in a lot of dependencies, slowing down compilation via `go get` and `go install`, so
+          # download the binary directly and extract.
+          # go get github.com/prometheus/prometheus/cmd/promtool@main
+          Invoke-WebRequest -Uri https://github.com/prometheus/prometheus/releases/download/v$($Env:PROMTOOL_VER)/prometheus-$($Env:PROMTOOL_VER).windows-amd64.zip -OutFile prometheus-$($Env:PROMTOOL_VER).windows-amd64.zip
+          Expand-Archive -Path prometheus-$($Env:PROMTOOL_VER).windows-amd64.zip -DestinationPath .
+          Copy-Item -Path prometheus-$($Env:PROMTOOL_VER).windows-amd64\promtool.exe -Destination "$(go env GOPATH)\bin"
+
+          go install "github.com/prometheus/promu@$($Env:PROMU_VER)"
+          go install github.com/josephspurrier/goversioninfo/cmd/goversioninfo@v1.2.0
+          # GOPATH\bin dir must be appended to PATH else the `promu` command won't be found
+          echo "$(go env GOPATH)\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+
+      - name: Promtool
+        run: make promtool
+
+  lint:
+    runs-on: windows-2022
     steps:
       # `gofmt` linter run by golangci-lint fails on CRLF line endings (the default for Windows)
       - name: Set git to use LF
@@ -48,9 +85,9 @@ jobs:
           go-version: '^1.17.5'
 
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v2
+        uses: golangci/golangci-lint-action@v3
         with:
-          version: v1.43
+          version: v1.45.2
           args: "--timeout=5m"
 
       # golangci-lint action doesn't always provide helpful output, so re-run without the action for
@@ -60,11 +97,24 @@ jobs:
         if: ${{ failure() }}
         run: golangci-lint run --timeout=5m -c .golangci.yaml
 
+  codespell:
+    name: Check for spelling errors
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: codespell-project/actions-codespell@master
+        with:
+          check_filenames: true
+          # When using this Action in other repos, the --skip option below can be removed
+          skip: ./.git
+          ignore_words_list: calle
+
   build:
-    runs-on: windows-2019
+    runs-on: windows-2022
     needs:
       - test
       - lint
+      - codespell
     steps:
       - uses: actions/checkout@v2
         with:
@@ -77,8 +127,9 @@ jobs:
 
       - name: Install Build deps
         run: |
-          go get -u github.com/prometheus/promu@v0.11.1
-          go get -u github.com/josephspurrier/goversioninfo/cmd/goversioninfo@v1.2.0
+          dotnet tool install --global GitVersion.Tool --version 5.*
+          go install "github.com/prometheus/promu@$($Env:PROMU_VER)"
+          go install github.com/josephspurrier/goversioninfo/cmd/goversioninfo@v1.4.0
           # GOPATH\bin dir must be added to PATH else the `promu` and `goversioninfo` commands won't be found
           echo "$(go env GOPATH)\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
 
@@ -86,13 +137,16 @@ jobs:
         run: |
           $ErrorActionPreference = "Stop"
 
-          gitversion /output json /showvariable FullSemVer | Set-Content VERSION -PassThru
+          dotnet-gitversion /output json /showvariable FullSemVer | Set-Content VERSION -PassThru
           $Version = Get-Content VERSION
           # Windows versioninfo resources need the file version by parts (but product version is free text)
           $VersionParts = ($Version -replace '^v?([0-9\.]+).*$','$1').Split(".")
           goversioninfo.exe -ver-major $VersionParts[0] -ver-minor $VersionParts[1] -ver-patch $VersionParts[2] -product-version $Version -platform-specific
 
           make crossbuild
+          # '+' symbols are invalid characters in image tags
+          (Get-Content -Path VERSION) -replace '\+', '_' | Set-Content -Path VERSION
+          make build-all
           # GH requires all files to have different names, so add version/arch to differentiate
           foreach($Arch in "amd64","386") {
             Move-Item output\$Arch\windows_exporter.exe output\windows_exporter-$Version-$Arch.exe
@@ -120,6 +174,22 @@ jobs:
 
           promu checksum output\
 
+      - name: Login to GitHub container registry
+        if: ${{ github.event_name != 'pull_request' }}
+        uses: docker/login-action@v1
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Push Latest image
+        if: ${{ github.event_name != 'pull_request' }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          $Env:VERSION = 'latest'
+          make push-all
+
       - name: Release
         if: startsWith(github.ref, 'refs/tags/')
         env:
@@ -127,3 +197,4 @@ jobs:
         run: |
           $TagName = $env:GITHUB_REF -replace 'refs/tags/', ''
           Get-ChildItem -Path output\* -Include @('windows_exporter*.msi', 'windows_exporter*.exe', 'sha256sums.txt') | Foreach-Object {gh release upload $TagName $_}
+          make push-all

Dockerfile

@@ -0,0 +1,9 @@
+# Note this image doesn't really matter for hostprocess but it is good to build per OS version
+# the files in the image are copied to $env:CONTAINER_SANDBOX_MOUNT_POINT on the host
+# but the file system is the Host NOT the container
+ARG BASE="mcr.microsoft.com/windows/nanoserver:1809"
+FROM $BASE
+
+ENV PATH="C:\Windows\system32;C:\Windows;"
+COPY output/amd64/windows_exporter.exe /windows_exporter.exe
+ENTRYPOINT ["windows_exporter.exe"]

Makefile

@@ -1,4 +1,15 @@
 export GOOS=windows
+export DOCKER_IMAGE_NAME ?= windows-exporter
+export DOCKER_REPO ?= ghcr.io/prometheus-community
+
+VERSION?=$(shell cat VERSION)
+DOCKER?=docker
+
+# Image Variables for Hostprocess Container
+# Windows image build is heavily influenced by https://github.com/kubernetes/kubernetes/blob/master/cluster/images/etcd/Makefile
+OS=1809
+ALL_OS:= 1809 ltsc2022
+BASE_IMAGE=mcr.microsoft.com/windows/nanoserver
 
 .PHONY: build
 build: windows_exporter.exe
@@ -18,6 +29,10 @@ lint:
 e2e-test: windows_exporter.exe
 	pwsh -NonInteractive -ExecutionPolicy Bypass -File .\tools\end-to-end-test.ps1
 
+.PHONY: promtool
+promtool: windows_exporter.exe
+	pwsh -NonInteractive -ExecutionPolicy Bypass -File .\tools\promtool.ps1
+
 fmt:
 	gofmt -l -w -s .
 
@@ -26,3 +41,23 @@ crossbuild:
 	# on Windows, so for now, we'll just build twice
 	GOARCH=amd64 promu build --prefix=output/amd64
 	GOARCH=386   promu build --prefix=output/386
+
+build-image: crossbuild
+	$(DOCKER) build --build-arg=BASE=$(BASE_IMAGE):$(OS) -f Dockerfile -t $(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(VERSION)-$(OS) .
+
+sub-build-%:
+	$(MAKE) OS=$* build-image
+
+build-all: $(addprefix sub-build-,$(ALL_OS))
+
+push:
+	set -x; \
+	for osversion in ${ALL_OS}; do \
+		$(DOCKER) push $(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(VERSION)-$${osversion}; \
+		$(DOCKER) manifest create --amend $(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(VERSION) $(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(VERSION)-$${osversion}; \
+		full_version=`$(DOCKER) manifest inspect $(BASE_IMAGE):$${osversion} | grep "os.version" | head -n 1 | awk -F\" '{print $$4}'` || true; \
+		$(DOCKER) manifest annotate --os windows --arch amd64 --os-version $${full_version} $(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(VERSION)  $(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(VERSION)-$${osversion}; \
+	done
+	$(DOCKER) manifest push --purge $(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(VERSION)
+
+push-all: build-all push

README.md

@@ -1,6 +1,6 @@
 # windows_exporter
 
-[![Build status](https://ci.appveyor.com/api/projects/status/xoym3fftr7giasiw/branch/master?svg=true)](https://ci.appveyor.com/project/prometheus-community/windows-exporter)
+![Build Status](https://github.com/prometheus-community/windows_exporter/workflows/windows_exporter%20CI/CD/badge.svg)
 
 A Prometheus exporter for Windows machines.
 
@@ -10,6 +10,7 @@ A Prometheus exporter for Windows machines.
 Name     | Description | Enabled by default
 ---------|-------------|--------------------
 [ad](docs/collector.ad.md) | Active Directory Domain Services |
+[adcs](docs/collector.adcs.md) | Active Directory Certificate Services |
 [adfs](docs/collector.adfs.md) | Active Directory Federation Services |
 [cache](docs/collector.cache.md) | Cache metrics |
 [cpu](docs/collector.cpu.md) | CPU usage | ✓
@@ -26,6 +27,11 @@ Name     | Description | Enabled by default
 [logical_disk](docs/collector.logical_disk.md) | Logical disks, disk I/O | ✓
 [logon](docs/collector.logon.md) | User logon sessions |
 [memory](docs/collector.memory.md) | Memory usage metrics |
+[mscluster_cluster](docs/collector.mscluster_cluster.md) | MSCluster cluster metrics |
+[mscluster_network](docs/collector.mscluster_network.md) | MSCluster network metrics |
+[mscluster_node](docs/collector.mscluster_node.md) | MSCluster Node metrics |
+[mscluster_resource](docs/collector.mscluster_resource.md) | MSCluster Resource metrics |
+[mscluster_resourcegroup](docs/collector.mscluster_resourcegroup.md) | MSCluster ResourceGroup metrics |
 [msmq](docs/collector.msmq.md) | MSMQ queues |
 [mssql](docs/collector.mssql.md) | [SQL Server Performance Objects](https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/use-sql-server-objects#SQLServerPOs) metrics  |
 [netframework_clrexceptions](docs/collector.netframework_clrexceptions.md) | .NET Framework CLR Exceptions |
@@ -40,6 +46,7 @@ Name     | Description | Enabled by default
 [os](docs/collector.os.md) | OS metrics (memory, processes, users) | ✓
 [process](docs/collector.process.md) | Per-process metrics |
 [remote_fx](docs/collector.remote_fx.md) | RemoteFX protocol (RDP) metrics |
+[scheduled_task](docs/collector.scheduled_task.md) | Scheduled Tasks metrics |
 [service](docs/collector.service.md) | Service state metrics | ✓
 [smtp](docs/collector.smtp.md) | IIS SMTP Server |
 [system](docs/collector.system.md) | System calls | ✓
@@ -77,7 +84,7 @@ Flag     | Description | Default value
 `--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.print` | If true, print available collectors and exit. | 
+`--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
 
@@ -114,6 +121,11 @@ On some older versions of Windows you may need to surround parameter values with
 msiexec /i C:\Users\Administrator\Downloads\windows_exporter.msi ENABLED_COLLECTORS="ad,iis,logon,memory,process,tcp,thermalzone" TEXTFILE_DIR="C:\custom_metrics\"
 ```
 
+
+## Kubernetes Implementation
+
+See detailed steps to install on Windows Kubernetes [here](./kubernetes/kubernetes.md).
+
 ## Supported versions
 
 windows_exporter supports Windows Server versions 2008R2 and later, and desktop Windows version 7 and later.
@@ -145,7 +157,7 @@ When there are multiple processes with the same name, WMI represents those after
 Using `[defaults]`  with `--collectors.enabled` argument which gets expanded with all default collectors.
 
     .\windows_exporter.exe --collectors.enabled "[defaults],process,container"
-    
+
 This enables the additional process and container collectors on top of the defaults.
 
 ### Using a configuration file

collector/adcs.go

@@ -0,0 +1,242 @@
+//go:build windows
+// +build windows
+
+package collector
+
+import (
+	"errors"
+	"github.com/prometheus-community/windows_exporter/log"
+	"github.com/prometheus/client_golang/prometheus"
+	"strings"
+)
+
+func init() {
+	registerCollector("adcs", adcsCollectorMethod, "Certification Authority")
+}
+
+type adcsCollector struct {
+	RequestsPerSecond                            *prometheus.Desc
+	RequestProcessingTime                        *prometheus.Desc
+	RetrievalsPerSecond                          *prometheus.Desc
+	RetrievalProcessingTime                      *prometheus.Desc
+	FailedRequestsPerSecond                      *prometheus.Desc
+	IssuedRequestsPerSecond                      *prometheus.Desc
+	PendingRequestsPerSecond                     *prometheus.Desc
+	RequestCryptographicSigningTime              *prometheus.Desc
+	RequestPolicyModuleProcessingTime            *prometheus.Desc
+	ChallengeResponsesPerSecond                  *prometheus.Desc
+	ChallengeResponseProcessingTime              *prometheus.Desc
+	SignedCertificateTimestampListsPerSecond     *prometheus.Desc
+	SignedCertificateTimestampListProcessingTime *prometheus.Desc
+}
+
+// ADCSCollectorMethod ...
+func adcsCollectorMethod() (Collector, error) {
+	const subsystem = "adcs"
+	return &adcsCollector{
+		RequestsPerSecond: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "requests_total"),
+			"Total certificate requests processed",
+			[]string{"cert_template"},
+			nil,
+		),
+		RequestProcessingTime: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "request_processing_time_seconds"),
+			"Last time elapsed for certificate requests",
+			[]string{"cert_template"},
+			nil,
+		),
+		RetrievalsPerSecond: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "retrievals_total"),
+			"Total certificate retrieval requests processed",
+			[]string{"cert_template"},
+			nil,
+		),
+		RetrievalProcessingTime: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "retrievals_processing_time_seconds"),
+			"Last time elapsed for certificate retrieval request",
+			[]string{"cert_template"},
+			nil,
+		),
+		FailedRequestsPerSecond: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "failed_requests_total"),
+			"Total failed certificate requests processed",
+			[]string{"cert_template"},
+			nil,
+		),
+		IssuedRequestsPerSecond: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "issued_requests_total"),
+			"Total issued certificate requests processed",
+			[]string{"cert_template"},
+			nil,
+		),
+		PendingRequestsPerSecond: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "pending_requests_total"),
+			"Total pending certificate requests processed",
+			[]string{"cert_template"},
+			nil,
+		),
+		RequestCryptographicSigningTime: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "request_cryptographic_signing_time_seconds"),
+			"Last time elapsed for signing operation request",
+			[]string{"cert_template"},
+			nil,
+		),
+		RequestPolicyModuleProcessingTime: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "request_policy_module_processing_time_seconds"),
+			"Last time elapsed for policy module processing request",
+			[]string{"cert_template"},
+			nil,
+		),
+		ChallengeResponsesPerSecond: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "challenge_responses_total"),
+			"Total certificate challenge responses processed",
+			[]string{"cert_template"},
+			nil,
+		),
+		ChallengeResponseProcessingTime: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "challenge_response_processing_time_seconds"),
+			"Last time elapsed for challenge response",
+			[]string{"cert_template"},
+			nil,
+		),
+		SignedCertificateTimestampListsPerSecond: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "signed_certificate_timestamp_lists_total"),
+			"Total Signed Certificate Timestamp Lists processed",
+			[]string{"cert_template"},
+			nil,
+		),
+		SignedCertificateTimestampListProcessingTime: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "signed_certificate_timestamp_list_processing_time_seconds"),
+			"Last time elapsed for Signed Certificate Timestamp List",
+			[]string{"cert_template"},
+			nil,
+		),
+	}, nil
+}
+
+func (c *adcsCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
+	if desc, err := c.collectADCSCounters(ctx, ch); err != nil {
+		log.Error("Failed collecting ADCS Metrics:", desc, err)
+		return err
+	}
+	return nil
+}
+
+type perflibADCS struct {
+	Name                                         string
+	RequestsPerSecond                            float64 `perflib:"Requests/sec"`
+	RequestProcessingTime                        float64 `perflib:"Request processing time (ms)"`
+	RetrievalsPerSecond                          float64 `perflib:"Retrievals/sec"`
+	RetrievalProcessingTime                      float64 `perflib:"Retrieval processing time (ms)"`
+	FailedRequestsPerSecond                      float64 `perflib:"Failed Requests/sec"`
+	IssuedRequestsPerSecond                      float64 `perflib:"Issued Requests/sec"`
+	PendingRequestsPerSecond                     float64 `perflib:"Pending Requests/sec"`
+	RequestCryptographicSigningTime              float64 `perflib:"Request cryptographic signing time (ms)"`
+	RequestPolicyModuleProcessingTime            float64 `perflib:"Request policy module processing time (ms)"`
+	ChallengeResponsesPerSecond                  float64 `perflib:"Challenge Responses/sec"`
+	ChallengeResponseProcessingTime              float64 `perflib:"Challenge Response processing time (ms)"`
+	SignedCertificateTimestampListsPerSecond     float64 `perflib:"Signed Certificate Timestamp Lists/sec"`
+	SignedCertificateTimestampListProcessingTime float64 `perflib:"Signed Certificate Timestamp List processing time (ms)"`
+}
+
+func (c *adcsCollector) collectADCSCounters(ctx *ScrapeContext, ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
+	dst := make([]perflibADCS, 0)
+	if _, ok := ctx.perfObjects["Certification Authority"]; !ok {
+		return nil, errors.New("Perflib did not contain an entry for Certification Authority")
+	}
+	err := unmarshalObject(ctx.perfObjects["Certification Authority"], &dst)
+	if err != nil {
+		return nil, err
+	}
+	if len(dst) == 0 {
+		return nil, errors.New("Perflib query for Certification Authority (ADCS) returned empty result set")
+	}
+
+	for _, d := range dst {
+		n := strings.ToLower(d.Name)
+		if n == "" {
+			continue
+		}
+		ch <- prometheus.MustNewConstMetric(
+			c.RequestsPerSecond,
+			prometheus.CounterValue,
+			d.RequestsPerSecond,
+			d.Name,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.RequestProcessingTime,
+			prometheus.GaugeValue,
+			milliSecToSec(d.RequestProcessingTime),
+			d.Name,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.RetrievalsPerSecond,
+			prometheus.CounterValue,
+			d.RetrievalsPerSecond,
+			d.Name,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.RetrievalProcessingTime,
+			prometheus.GaugeValue,
+			milliSecToSec(d.RetrievalProcessingTime),
+			d.Name,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.FailedRequestsPerSecond,
+			prometheus.CounterValue,
+			d.FailedRequestsPerSecond,
+			d.Name,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.IssuedRequestsPerSecond,
+			prometheus.CounterValue,
+			d.IssuedRequestsPerSecond,
+			d.Name,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.PendingRequestsPerSecond,
+			prometheus.CounterValue,
+			d.PendingRequestsPerSecond,
+			d.Name,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.RequestCryptographicSigningTime,
+			prometheus.GaugeValue,
+			milliSecToSec(d.RequestCryptographicSigningTime),
+			d.Name,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.RequestPolicyModuleProcessingTime,
+			prometheus.GaugeValue,
+			milliSecToSec(d.RequestPolicyModuleProcessingTime),
+			d.Name,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.ChallengeResponsesPerSecond,
+			prometheus.CounterValue,
+			d.ChallengeResponsesPerSecond,
+			d.Name,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.ChallengeResponseProcessingTime,
+			prometheus.GaugeValue,
+			milliSecToSec(d.ChallengeResponseProcessingTime),
+			d.Name,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.SignedCertificateTimestampListsPerSecond,
+			prometheus.CounterValue,
+			d.SignedCertificateTimestampListsPerSecond,
+			d.Name,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.SignedCertificateTimestampListProcessingTime,
+			prometheus.GaugeValue,
+			milliSecToSec(d.SignedCertificateTimestampListProcessingTime),
+			d.Name,
+		)
+	}
+
+	return nil, nil
+}

collector/adcs_test.go

@@ -0,0 +1,9 @@
+package collector
+
+import (
+	"testing"
+)
+
+func BenchmarkADCSCollector(b *testing.B) {
+	benchmarkCollector(b, "adcs", adcsCollectorMethod)
+}

collector/adfs.go

@@ -5,6 +5,7 @@ package collector
 
 import (
 	"github.com/prometheus/client_golang/prometheus"
+	"math"
 )
 
 func init() {
@@ -12,17 +13,49 @@ func init() {
 }
 
 type adfsCollector struct {
-	adLoginConnectionFailures        *prometheus.Desc
-	certificateAuthentications       *prometheus.Desc
-	deviceAuthentications            *prometheus.Desc
-	extranetAccountLockouts          *prometheus.Desc
-	federatedAuthentications         *prometheus.Desc
-	passportAuthentications          *prometheus.Desc
-	passiveRequests                  *prometheus.Desc
-	passwordChangeFailed             *prometheus.Desc
-	passwordChangeSucceeded          *prometheus.Desc
-	tokenRequests                    *prometheus.Desc
-	windowsIntegratedAuthentications *prometheus.Desc
+	adLoginConnectionFailures                          *prometheus.Desc
+	certificateAuthentications                         *prometheus.Desc
+	deviceAuthentications                              *prometheus.Desc
+	extranetAccountLockouts                            *prometheus.Desc
+	federatedAuthentications                           *prometheus.Desc
+	passportAuthentications                            *prometheus.Desc
+	passiveRequests                                    *prometheus.Desc
+	passwordChangeFailed                               *prometheus.Desc
+	passwordChangeSucceeded                            *prometheus.Desc
+	tokenRequests                                      *prometheus.Desc
+	windowsIntegratedAuthentications                   *prometheus.Desc
+	oAuthAuthZRequests                                 *prometheus.Desc
+	oAuthClientAuthentications                         *prometheus.Desc
+	oAuthClientAuthenticationsFailures                 *prometheus.Desc
+	oAuthClientCredentialsRequestFailures              *prometheus.Desc
+	oAuthClientCredentialsRequests                     *prometheus.Desc
+	oAuthClientPrivateKeyJwtAuthenticationFailures     *prometheus.Desc
+	oAuthClientPrivateKeyJwtAuthentications            *prometheus.Desc
+	oAuthClientSecretBasicAuthenticationFailures       *prometheus.Desc
+	oAuthClientSecretBasicAuthentications              *prometheus.Desc
+	oAuthClientSecretPostAuthenticationFailures        *prometheus.Desc
+	oAuthClientSecretPostAuthentications               *prometheus.Desc
+	oAuthClientWindowsIntegratedAuthenticationFailures *prometheus.Desc
+	oAuthClientWindowsIntegratedAuthentications        *prometheus.Desc
+	oAuthLogonCertificateRequestFailures               *prometheus.Desc
+	oAuthLogonCertificateTokenRequests                 *prometheus.Desc
+	oAuthPasswordGrantRequestFailures                  *prometheus.Desc
+	oAuthPasswordGrantRequests                         *prometheus.Desc
+	oAuthTokenRequests                                 *prometheus.Desc
+	samlPTokenRequests                                 *prometheus.Desc
+	ssoAuthenticationFailures                          *prometheus.Desc
+	ssoAuthentications                                 *prometheus.Desc
+	wsfedTokenRequests                                 *prometheus.Desc
+	wstrustTokenRequests                               *prometheus.Desc
+	upAuthenticationFailures                           *prometheus.Desc
+	upAuthentications                                  *prometheus.Desc
+	externalAuthenticationFailures                     *prometheus.Desc
+	externalAuthentications                            *prometheus.Desc
+	artifactDBFailures                                 *prometheus.Desc
+	avgArtifactDBQueryTime                             *prometheus.Desc
+	configDBFailures                                   *prometheus.Desc
+	avgConfigDBQueryTime                               *prometheus.Desc
+	federationMetadataRequests                         *prometheus.Desc
 }
 
 // newADFSCollector constructs a new adfsCollector
@@ -96,21 +129,245 @@ func newADFSCollector() (Collector, error) {
 			nil,
 			nil,
 		),
+		oAuthAuthZRequests: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "oauth_authorization_requests_total"),
+			"Total number of incoming requests to the OAuth Authorization endpoint",
+			nil,
+			nil,
+		),
+		oAuthClientAuthentications: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "oauth_client_authentication_success_total"),
+			"Total number of successful OAuth client Authentications",
+			nil,
+			nil,
+		),
+		oAuthClientAuthenticationsFailures: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "oauth_client_authentication_failure_total"),
+			"Total number of failed OAuth client Authentications",
+			nil,
+			nil,
+		),
+		oAuthClientCredentialsRequestFailures: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "oauth_client_credentials_failure_total"),
+			"Total number of failed OAuth Client Credentials Requests",
+			nil,
+			nil,
+		),
+		oAuthClientCredentialsRequests: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "oauth_client_credentials_success_total"),
+			"Total number of successful RP tokens issued for OAuth Client Credentials Requests",
+			nil,
+			nil,
+		),
+		oAuthClientPrivateKeyJwtAuthenticationFailures: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "oauth_client_privkey_jtw_authentication_failure_total"),
+			"Total number of failed OAuth Client Private Key Jwt Authentications",
+			nil,
+			nil,
+		),
+		oAuthClientPrivateKeyJwtAuthentications: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "oauth_client_privkey_jwt_authentications_success_total"),
+			"Total number of successful OAuth Client Private Key Jwt Authentications",
+			nil,
+			nil,
+		),
+		oAuthClientSecretBasicAuthenticationFailures: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "oauth_client_secret_basic_authentications_failure_total"),
+			"Total number of failed OAuth Client Secret Basic Authentications",
+			nil,
+			nil,
+		),
+		oAuthClientSecretBasicAuthentications: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "oauth_client_secret_basic_authentications_success_total"),
+			"Total number of successful OAuth Client Secret Basic Authentications",
+			nil,
+			nil,
+		),
+		oAuthClientSecretPostAuthenticationFailures: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "oauth_client_secret_post_authentications_failure_total"),
+			"Total number of failed OAuth Client Secret Post Authentications",
+			nil,
+			nil,
+		),
+		oAuthClientSecretPostAuthentications: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "oauth_client_secret_post_authentications_success_total"),
+			"Total number of successful OAuth Client Secret Post Authentications",
+			nil,
+			nil,
+		),
+		oAuthClientWindowsIntegratedAuthenticationFailures: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "oauth_client_windows_authentications_failure_total"),
+			"Total number of failed OAuth Client Windows Integrated Authentications",
+			nil,
+			nil,
+		),
+		oAuthClientWindowsIntegratedAuthentications: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "oauth_client_windows_authentications_success_total"),
+			"Total number of successful OAuth Client Windows Integrated Authentications",
+			nil,
+			nil,
+		),
+		oAuthLogonCertificateRequestFailures: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "oauth_logon_certificate_requests_failure_total"),
+			"Total number of failed OAuth Logon Certificate Requests",
+			nil,
+			nil,
+		),
+		oAuthLogonCertificateTokenRequests: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "oauth_logon_certificate_token_requests_success_total"),
+			"Total number of successful RP tokens issued for OAuth Logon Certificate Requests",
+			nil,
+			nil,
+		),
+		oAuthPasswordGrantRequestFailures: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "oauth_password_grant_requests_failure_total"),
+			"Total number of failed OAuth Password Grant Requests",
+			nil,
+			nil,
+		),
+		oAuthPasswordGrantRequests: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "oauth_password_grant_requests_success_total"),
+			"Total number of successful OAuth Password Grant Requests",
+			nil,
+			nil,
+		),
+		oAuthTokenRequests: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "oauth_token_requests_success_total"),
+			"Total number of successful RP tokens issued over OAuth protocol",
+			nil,
+			nil,
+		),
+		samlPTokenRequests: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "samlp_token_requests_success_total"),
+			"Total number of successful RP tokens issued over SAML-P protocol",
+			nil,
+			nil,
+		),
+		ssoAuthenticationFailures: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "sso_authentications_failure_total"),
+			"Total number of failed SSO authentications",
+			nil,
+			nil,
+		),
+		ssoAuthentications: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "sso_authentications_success_total"),
+			"Total number of successful SSO authentications",
+			nil,
+			nil,
+		),
+		wsfedTokenRequests: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "wsfed_token_requests_success_total"),
+			"Total number of successful RP tokens issued over WS-Fed protocol",
+			nil,
+			nil,
+		),
+		wstrustTokenRequests: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "wstrust_token_requests_success_total"),
+			"Total number of successful RP tokens issued over WS-Trust protocol",
+			nil,
+			nil,
+		),
+		upAuthenticationFailures: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "userpassword_authentications_failure_total"),
+			"Total number of failed AD U/P authentications",
+			nil,
+			nil,
+		),
+		upAuthentications: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "userpassword_authentications_success_total"),
+			"Total number of successful AD U/P authentications",
+			nil,
+			nil,
+		),
+		externalAuthenticationFailures: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "external_authentications_failure_total"),
+			"Total number of failed authentications from external MFA providers",
+			nil,
+			nil,
+		),
+		externalAuthentications: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "external_authentications_success_total"),
+			"Total number of successful authentications from external MFA providers",
+			nil,
+			nil,
+		),
+		artifactDBFailures: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "db_artifact_failure_total"),
+			"Total number of failures connecting to the artifact database",
+			nil,
+			nil,
+		),
+		avgArtifactDBQueryTime: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "db_artifact_query_time_seconds_total"),
+			"Accumulator of time taken for an artifact database query",
+			nil,
+			nil,
+		),
+		configDBFailures: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "db_config_failure_total"),
+			"Total number of failures connecting to the configuration database",
+			nil,
+			nil,
+		),
+		avgConfigDBQueryTime: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "db_config_query_time_seconds_total"),
+			"Accumulator of time taken for a configuration database query",
+			nil,
+			nil,
+		),
+		federationMetadataRequests: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "federation_metadata_requests_total"),
+			"Total number of Federation Metadata requests",
+			nil,
+			nil,
+		),
 	}, nil
 }
 
 type perflibADFS struct {
-	AdLoginConnectionFailures        float64 `perflib:"AD login Connection Failures"`
-	CertificateAuthentications       float64 `perflib:"Certificate Authentications"`
-	DeviceAuthentications            float64 `perflib:"Device Authentications"`
-	ExtranetAccountLockouts          float64 `perflib:"Extranet Account Lockouts"`
-	FederatedAuthentications         float64 `perflib:"Federated Authentications"`
-	PassportAuthentications          float64 `perflib:"Microsoft Passport Authentications"`
-	PassiveRequests                  float64 `perflib:"Passive Requests"`
-	PasswordChangeFailed             float64 `perflib:"Password Change Failed Requests"`
-	PasswordChangeSucceeded          float64 `perflib:"Password Change Successful Requests"`
-	TokenRequests                    float64 `perflib:"Token Requests"`
-	WindowsIntegratedAuthentications float64 `perflib:"Windows Integrated Authentications"`
+	AdLoginConnectionFailures            float64 `perflib:"AD Login Connection Failures"`
+	CertificateAuthentications           float64 `perflib:"Certificate Authentications"`
+	DeviceAuthentications                float64 `perflib:"Device Authentications"`
+	ExtranetAccountLockouts              float64 `perflib:"Extranet Account Lockouts"`
+	FederatedAuthentications             float64 `perflib:"Federated Authentications"`
+	PassportAuthentications              float64 `perflib:"Microsoft Passport Authentications"`
+	PassiveRequests                      float64 `perflib:"Passive Requests"`
+	PasswordChangeFailed                 float64 `perflib:"Password Change Failed Requests"`
+	PasswordChangeSucceeded              float64 `perflib:"Password Change Successful Requests"`
+	TokenRequests                        float64 `perflib:"Token Requests"`
+	WindowsIntegratedAuthentications     float64 `perflib:"Windows Integrated Authentications"`
+	OAuthAuthZRequests                   float64 `perflib:"OAuth AuthZ Requests"`
+	OAuthClientAuthentications           float64 `perflib:"OAuth Client Authentications"`
+	OAuthClientAuthenticationFailures    float64 `perflib:"OAuth Client Authentications Failures"`
+	OAuthClientCredentialRequestFailures float64 `perflib:"OAuth Client Credentials Request Failures"`
+	OAuthClientCredentialRequests        float64 `perflib:"OAuth Client Credentials Requests"`
+	OAuthClientPrivKeyJWTAuthnFailures   float64 `perflib:"OAuth Client Private Key Jwt Authentication Failures"`
+	OAuthClientPrivKeyJWTAuthentications float64 `perflib:"OAuth Client Private Key Jwt Authentications"`
+	OAuthClientBasicAuthnFailures        float64 `perflib:"OAuth Client Secret Basic Authentication Failures"`
+	OAuthClientBasicAuthentications      float64 `perflib:"OAuth Client Secret Basic Authentication Requests"`
+	OAuthClientSecretPostAuthnFailures   float64 `perflib:"OAuth Client Secret Post Authentication Failures"`
+	OAuthClientSecretPostAuthentications float64 `perflib:"OAuth Client Secret Post Authentications"`
+	OAuthClientWindowsAuthnFailures      float64 `perflib:"OAuth Client Windows Integrated Authentication Failures"`
+	OAuthClientWindowsAuthentications    float64 `perflib:"OAuth Client Windows Integrated Authentications"`
+	OAuthLogonCertRequestFailures        float64 `perflib:"OAuth Logon Certificate Request Failures"`
+	OAuthLogonCertTokenRequests          float64 `perflib:"OAuth Logon Certificate Token Requests"`
+	OAuthPasswordGrantRequestFailures    float64 `perflib:"OAuth Password Grant Request Failures"`
+	OAuthPasswordGrantRequests           float64 `perflib:"OAuth Password Grant Requests"`
+	OAuthTokenRequests                   float64 `perflib:"OAuth Token Requests"`
+	SAMLPTokenRequests                   float64 `perflib:"SAML-P Token Requests"`
+	SSOAuthenticationFailures            float64 `perflib:"SSO Authentication Failures"`
+	SSOAuthentications                   float64 `perflib:"SSO Authentications"`
+	WSFedTokenRequests                   float64 `perflib:"WS-Fed Token Requests"`
+	WSTrustTokenRequests                 float64 `perflib:"WS-Trust Token Requests"`
+	UsernamePasswordAuthnFailures        float64 `perflib:"U/P Authentication Failures"`
+	UsernamePasswordAuthentications      float64 `perflib:"U/P Authentications"`
+	ExternalAuthentications              float64 `perflib:"External Authentications"`
+	ExternalAuthNFailures                float64 `perflib:"External Authentication Failures"`
+	ArtifactDBFailures                   float64 `perflib:"Artifact Database Connection Failures"`
+	AvgArtifactDBQueryTime               float64 `perflib:"Average Artifact Database Query Time"`
+	ConfigDBFailures                     float64 `perflib:"Configuration Database Connection Failures"`
+	AvgConfigDBQueryTime                 float64 `perflib:"Average Config Database Query Time"`
+	FederationMetadataRequests           float64 `perflib:"Federation Metadata Requests"`
 }
 
 func (c *adfsCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
@@ -185,5 +442,197 @@ func (c *adfsCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric)
 		prometheus.CounterValue,
 		adfsData[0].WindowsIntegratedAuthentications,
 	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.oAuthAuthZRequests,
+		prometheus.CounterValue,
+		adfsData[0].OAuthAuthZRequests,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.oAuthClientAuthentications,
+		prometheus.CounterValue,
+		adfsData[0].OAuthClientAuthentications,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.oAuthClientAuthenticationsFailures,
+		prometheus.CounterValue,
+		adfsData[0].OAuthClientAuthenticationFailures,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.oAuthClientCredentialsRequestFailures,
+		prometheus.CounterValue,
+		adfsData[0].OAuthClientCredentialRequestFailures,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.oAuthClientCredentialsRequests,
+		prometheus.CounterValue,
+		adfsData[0].OAuthClientCredentialRequests,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.oAuthClientPrivateKeyJwtAuthenticationFailures,
+		prometheus.CounterValue,
+		adfsData[0].OAuthClientPrivKeyJWTAuthnFailures,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.oAuthClientPrivateKeyJwtAuthentications,
+		prometheus.CounterValue,
+		adfsData[0].OAuthClientPrivKeyJWTAuthentications,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.oAuthClientSecretBasicAuthenticationFailures,
+		prometheus.CounterValue,
+		adfsData[0].OAuthClientBasicAuthnFailures,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.oAuthClientSecretBasicAuthentications,
+		prometheus.CounterValue,
+		adfsData[0].OAuthClientBasicAuthentications,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.oAuthClientSecretPostAuthenticationFailures,
+		prometheus.CounterValue,
+		adfsData[0].OAuthClientSecretPostAuthnFailures,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.oAuthClientSecretPostAuthentications,
+		prometheus.CounterValue,
+		adfsData[0].OAuthClientSecretPostAuthentications,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.oAuthClientWindowsIntegratedAuthenticationFailures,
+		prometheus.CounterValue,
+		adfsData[0].OAuthClientWindowsAuthnFailures,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.oAuthClientWindowsIntegratedAuthentications,
+		prometheus.CounterValue,
+		adfsData[0].OAuthClientWindowsAuthentications,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.oAuthLogonCertificateRequestFailures,
+		prometheus.CounterValue,
+		adfsData[0].OAuthLogonCertRequestFailures,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.oAuthLogonCertificateTokenRequests,
+		prometheus.CounterValue,
+		adfsData[0].OAuthLogonCertTokenRequests,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.oAuthPasswordGrantRequestFailures,
+		prometheus.CounterValue,
+		adfsData[0].OAuthPasswordGrantRequestFailures,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.oAuthPasswordGrantRequests,
+		prometheus.CounterValue,
+		adfsData[0].OAuthPasswordGrantRequests,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.oAuthTokenRequests,
+		prometheus.CounterValue,
+		adfsData[0].OAuthTokenRequests,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.samlPTokenRequests,
+		prometheus.CounterValue,
+		adfsData[0].SAMLPTokenRequests,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.ssoAuthenticationFailures,
+		prometheus.CounterValue,
+		adfsData[0].SSOAuthenticationFailures,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.ssoAuthentications,
+		prometheus.CounterValue,
+		adfsData[0].SSOAuthentications,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.wsfedTokenRequests,
+		prometheus.CounterValue,
+		adfsData[0].WSFedTokenRequests,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.wstrustTokenRequests,
+		prometheus.CounterValue,
+		adfsData[0].WSTrustTokenRequests,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.upAuthenticationFailures,
+		prometheus.CounterValue,
+		adfsData[0].UsernamePasswordAuthnFailures,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.upAuthentications,
+		prometheus.CounterValue,
+		adfsData[0].UsernamePasswordAuthentications,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.externalAuthenticationFailures,
+		prometheus.CounterValue,
+		adfsData[0].ExternalAuthNFailures,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.externalAuthentications,
+		prometheus.CounterValue,
+		adfsData[0].ExternalAuthentications,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.artifactDBFailures,
+		prometheus.CounterValue,
+		adfsData[0].ArtifactDBFailures,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.avgArtifactDBQueryTime,
+		prometheus.CounterValue,
+		adfsData[0].AvgArtifactDBQueryTime*math.Pow(10, -8),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.configDBFailures,
+		prometheus.CounterValue,
+		adfsData[0].ConfigDBFailures,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.avgConfigDBQueryTime,
+		prometheus.CounterValue,
+		adfsData[0].AvgConfigDBQueryTime*math.Pow(10, -8),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.federationMetadataRequests,
+		prometheus.CounterValue,
+		adfsData[0].FederationMetadataRequests,
+	)
 	return nil
 }

collector/collector.go

@@ -148,3 +148,7 @@ func expandEnabledChildCollectors(enabled string) []string {
 	sort.Strings(result)
 	return result
 }
+
+func milliSecToSec(t float64) float64 {
+	return t / 1000
+}

collector/container.go

@@ -37,6 +37,12 @@ type ContainerMetricsCollector struct {
 	PacketsSent            *prometheus.Desc
 	DroppedPacketsIncoming *prometheus.Desc
 	DroppedPacketsOutgoing *prometheus.Desc
+
+	// Storage
+	ReadCountNormalized  *prometheus.Desc
+	ReadSizeBytes        *prometheus.Desc
+	WriteCountNormalized *prometheus.Desc
+	WriteSizeBytes       *prometheus.Desc
 }
 
 // NewContainerMetricsCollector constructs a new ContainerMetricsCollector
@@ -127,6 +133,30 @@ func NewContainerMetricsCollector() (Collector, error) {
 			[]string{"container_id", "interface"},
 			nil,
 		),
+		ReadCountNormalized: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "storage_read_count_normalized_total"),
+			"Read Count Normalized",
+			[]string{"container_id"},
+			nil,
+		),
+		ReadSizeBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "storage_read_size_bytes_total"),
+			"Read Size Bytes",
+			[]string{"container_id"},
+			nil,
+		),
+		WriteCountNormalized: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "storage_write_count_normalized_total"),
+			"Write Count Normalized",
+			[]string{"container_id"},
+			nil,
+		),
+		WriteSizeBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "storage_write_size_bytes_total"),
+			"Write Size Bytes",
+			[]string{"container_id"},
+			nil,
+		),
 	}, nil
 }
 
@@ -274,6 +304,31 @@ func (c *ContainerMetricsCollector) collect(ch chan<- prometheus.Metric) (*prome
 			)
 			break
 		}
+
+		ch <- prometheus.MustNewConstMetric(
+			c.ReadCountNormalized,
+			prometheus.CounterValue,
+			float64(cstats.Storage.ReadCountNormalized),
+			containerIdWithPrefix,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.ReadSizeBytes,
+			prometheus.CounterValue,
+			float64(cstats.Storage.ReadSizeBytes),
+			containerIdWithPrefix,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.WriteCountNormalized,
+			prometheus.CounterValue,
+			float64(cstats.Storage.WriteCountNormalized),
+			containerIdWithPrefix,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.WriteSizeBytes,
+			prometheus.CounterValue,
+			float64(cstats.Storage.WriteSizeBytes),
+			containerIdWithPrefix,
+		)
 	}
 
 	return nil, nil

collector/cpu.go

@@ -60,7 +60,7 @@ func newCPUCollector() (Collector, error) {
 			),
 			TimeTotal: prometheus.NewDesc(
 				prometheus.BuildFQName(Namespace, subsystem, "time_total"),
-				"Time that processor spent in different modes (idle, user, system, ...)",
+				"Time that processor spent in different modes (dpc, idle, interrupt, privileged, user)",
 				[]string{"core", "mode"},
 				nil,
 			),
@@ -88,7 +88,7 @@ func newCPUCollector() (Collector, error) {
 		),
 		TimeTotal: prometheus.NewDesc(
 			prometheus.BuildFQName(Namespace, subsystem, "time_total"),
-			"Time that processor spent in different modes (idle, user, system, ...)",
+			"Time that processor spent in different modes (dpc, idle, interrupt, privileged, user)",
 			[]string{"core", "mode"},
 			nil,
 		),

collector/hyperv.go

@@ -111,6 +111,18 @@ type HyperVCollector struct {
 	VMNetworkDroppedPacketsOutgoing *prometheus.Desc
 	VMNetworkPacketsReceived        *prometheus.Desc
 	VMNetworkPacketsSent            *prometheus.Desc
+
+	// Win32_PerfRawData_BalancerStats_HyperVDynamicMemoryVM
+	VMMemoryAddedMemory                *prometheus.Desc
+	VMMemoryAveragePressure            *prometheus.Desc
+	VMMemoryCurrentPressure            *prometheus.Desc
+	VMMemoryGuestVisiblePhysicalMemory *prometheus.Desc
+	VMMemoryMaximumPressure            *prometheus.Desc
+	VMMemoryMemoryAddOperations        *prometheus.Desc
+	VMMemoryMemoryRemoveOperations     *prometheus.Desc
+	VMMemoryMinimumPressure            *prometheus.Desc
+	VMMemoryPhysicalMemory             *prometheus.Desc
+	VMMemoryRemovedMemory              *prometheus.Desc
 }
 
 // NewHyperVCollector ...
@@ -593,6 +605,69 @@ func NewHyperVCollector() (Collector, error) {
 			[]string{"vm_interface"},
 			nil,
 		),
+
+		//
+
+		VMMemoryAddedMemory: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, buildSubsystemName("vm_memory"), "added_total"),
+			"This counter represents memory in MB added to the VM",
+			[]string{"vm"},
+			nil,
+		),
+		VMMemoryAveragePressure: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, buildSubsystemName("vm_memory"), "pressure_average"),
+			"This gauge represents the average pressure in the VM.",
+			[]string{"vm"},
+			nil,
+		),
+		VMMemoryCurrentPressure: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, buildSubsystemName("vm_memory"), "pressure_current"),
+			"This gauge represents the current pressure in the VM.",
+			[]string{"vm"},
+			nil,
+		),
+		VMMemoryGuestVisiblePhysicalMemory: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, buildSubsystemName("vm_memory"), "physical_guest_visible"),
+			"'This gauge represents the amount of memory in MB visible to the VM guest.'",
+			[]string{"vm"},
+			nil,
+		),
+		VMMemoryMaximumPressure: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, buildSubsystemName("vm_memory"), "pressure_maximum"),
+			"This gauge represents the maximum pressure band in the VM.",
+			[]string{"vm"},
+			nil,
+		),
+		VMMemoryMemoryAddOperations: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, buildSubsystemName("vm_memory"), "add_operations_total"),
+			"This counter represents the number of operations adding memory to the VM.",
+			[]string{"vm"},
+			nil,
+		),
+		VMMemoryMemoryRemoveOperations: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, buildSubsystemName("vm_memory"), "remove_operations_total"),
+			"This counter represents the number of operations removing memory from the VM.",
+			[]string{"vm"},
+			nil,
+		),
+		VMMemoryMinimumPressure: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, buildSubsystemName("vm_memory"), "pressure_minimum"),
+			"This gauge represents the minimum pressure band in the VM.",
+			[]string{"vm"},
+			nil,
+		),
+		VMMemoryPhysicalMemory: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, buildSubsystemName("vm_memory"), "physical"),
+			"This gauge represents the current amount of memory in MB assigned to the VM.",
+			[]string{"vm"},
+			nil,
+		),
+		VMMemoryRemovedMemory: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, buildSubsystemName("vm_memory"), "removed_total"),
+			"This counter represents memory in MB removed from the VM",
+			[]string{"vm"},
+			nil,
+		),
 	}, nil
 }
 
@@ -649,6 +724,11 @@ func (c *HyperVCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metri
 		return err
 	}
 
+	if desc, err := c.collectVmMemory(ch); err != nil {
+		log.Error("failed collecting hyperV virtual memory metrics:", desc, err)
+		return err
+	}
+
 	return nil
 }
 
@@ -1431,3 +1511,104 @@ func (c *HyperVCollector) collectVmNetwork(ch chan<- prometheus.Metric) (*promet
 
 	return nil, nil
 }
+
+// Win32_PerfRawData_BalancerStats_HyperVDynamicMemoryVM ...
+type Win32_PerfRawData_BalancerStats_HyperVDynamicMemoryVM struct {
+	Name                       string
+	AddedMemory                uint64
+	AveragePressure            uint64
+	CurrentPressure            uint64
+	GuestVisiblePhysicalMemory uint64
+	MaximumPressure            uint64
+	MemoryAddOperations        uint64
+	MemoryRemoveOperations     uint64
+	MinimumPressure            uint64
+	PhysicalMemory             uint64
+	RemovedMemory              uint64
+}
+
+func (c *HyperVCollector) collectVmMemory(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
+	var dst []Win32_PerfRawData_BalancerStats_HyperVDynamicMemoryVM
+	q := queryAll(&dst)
+	if err := wmi.Query(q, &dst); err != nil {
+		return nil, err
+	}
+
+	for _, obj := range dst {
+		if strings.Contains(obj.Name, "_Total") {
+			continue
+		}
+
+		ch <- prometheus.MustNewConstMetric(
+			c.VMMemoryAddedMemory,
+			prometheus.CounterValue,
+			float64(obj.AddedMemory),
+			obj.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.VMMemoryAveragePressure,
+			prometheus.GaugeValue,
+			float64(obj.AveragePressure),
+			obj.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.VMMemoryCurrentPressure,
+			prometheus.GaugeValue,
+			float64(obj.CurrentPressure),
+			obj.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.VMMemoryGuestVisiblePhysicalMemory,
+			prometheus.GaugeValue,
+			float64(obj.GuestVisiblePhysicalMemory),
+			obj.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.VMMemoryMaximumPressure,
+			prometheus.GaugeValue,
+			float64(obj.MaximumPressure),
+			obj.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.VMMemoryMemoryAddOperations,
+			prometheus.CounterValue,
+			float64(obj.MemoryAddOperations),
+			obj.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.VMMemoryMemoryRemoveOperations,
+			prometheus.CounterValue,
+			float64(obj.MemoryRemoveOperations),
+			obj.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.VMMemoryMinimumPressure,
+			prometheus.GaugeValue,
+			float64(obj.MinimumPressure),
+			obj.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.VMMemoryPhysicalMemory,
+			prometheus.GaugeValue,
+			float64(obj.PhysicalMemory),
+			obj.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.VMMemoryRemovedMemory,
+			prometheus.CounterValue,
+			float64(obj.RemovedMemory),
+			obj.Name,
+		)
+	}
+
+	return nil, nil
+}

collector/iis.go

@@ -885,6 +885,10 @@ func (c *IISCollector) collectWebService(ctx *ScrapeContext, ch chan<- prometheu
 	}
 
 	for _, app := range WebService {
+		if app.Name == "_Total" || c.siteBlacklistPattern.MatchString(app.Name) || !c.siteWhitelistPattern.MatchString(app.Name) {
+			continue
+		}
+
 		ch <- prometheus.MustNewConstMetric(
 			c.CurrentAnonymousUsers,
 			prometheus.GaugeValue,
@@ -1159,6 +1163,12 @@ func (c *IISCollector) collectAPP_POOL_WAS(ctx *ScrapeContext, ch chan<- prometh
 	}
 
 	for _, app := range APP_POOL_WAS {
+		if app.Name == "_Total" ||
+			c.appBlacklistPattern.MatchString(app.Name) ||
+			!c.appWhitelistPattern.MatchString(app.Name) {
+			continue
+		}
+
 		for key, label := range applicationStates {
 			isCurrentState := 0.0
 			if key == uint32(app.CurrentApplicationPoolState) {
@@ -1330,11 +1340,7 @@ func (c *IISCollector) collectW3SVC_W3WP(ctx *ScrapeContext, ch chan<- prometheu
 		// Extract the apppool name from the format <PID>_<NAME>
 		pid := workerProcessNameExtractor.ReplaceAllString(app.Name, "$1")
 		name := workerProcessNameExtractor.ReplaceAllString(app.Name, "$2")
-		if name == "" {
-			log.Error("no instances found in W3SVC_W3WP - skipping collection")
-			break
-		}
-		if name == "_Total" ||
+		if name == "" || name == "_Total" ||
 			c.appBlacklistPattern.MatchString(name) ||
 			!c.appWhitelistPattern.MatchString(name) {
 			continue
@@ -1574,87 +1580,84 @@ func (c *IISCollector) collectW3SVC_W3WP(ctx *ScrapeContext, ch chan<- prometheu
 			pid,
 		)
 
-		if c.iis_version.major >= 8 {
-			var W3SVC_W3WP_IIS8 []perflibW3SVC_W3WP_IIS8
-			if err := unmarshalObject(ctx.perfObjects["W3SVC_W3WP"], &W3SVC_W3WP_IIS8); err != nil {
-				return nil, err
+	}
+
+	if c.iis_version.major >= 8 {
+		var W3SVC_W3WP_IIS8 []perflibW3SVC_W3WP_IIS8
+		if err := unmarshalObject(ctx.perfObjects["W3SVC_W3WP"], &W3SVC_W3WP_IIS8); err != nil {
+			return nil, err
+		}
+
+		for _, app := range W3SVC_W3WP_IIS8 {
+			// Extract the apppool name from the format <PID>_<NAME>
+			pid := workerProcessNameExtractor.ReplaceAllString(app.Name, "$1")
+			name := workerProcessNameExtractor.ReplaceAllString(app.Name, "$2")
+			if name == "" || name == "_Total" ||
+				c.appBlacklistPattern.MatchString(name) ||
+				!c.appWhitelistPattern.MatchString(name) {
+				continue
 			}
 
-			for _, app := range W3SVC_W3WP_IIS8 {
-				// Extract the apppool name from the format <PID>_<NAME>
-				pid := workerProcessNameExtractor.ReplaceAllString(app.Name, "$1")
-				name := workerProcessNameExtractor.ReplaceAllString(app.Name, "$2")
-				if name == "" {
-					log.Error("no instances found in W3SVC_W3WP_IIS8 - skipping collection")
-					break
-				}
-				if name == "_Total" ||
-					c.appBlacklistPattern.MatchString(name) ||
-					!c.appWhitelistPattern.MatchString(name) {
-					continue
-				}
-
-				ch <- prometheus.MustNewConstMetric(
-					c.RequestErrorsTotal,
-					prometheus.CounterValue,
-					app.RequestErrors401,
-					name,
-					pid,
-					"401",
-				)
-				ch <- prometheus.MustNewConstMetric(
-					c.RequestErrorsTotal,
-					prometheus.CounterValue,
-					app.RequestErrors403,
-					name,
-					pid,
-					"403",
-				)
-				ch <- prometheus.MustNewConstMetric(
-					c.RequestErrorsTotal,
-					prometheus.CounterValue,
-					app.RequestErrors404,
-					name,
-					pid,
-					"404",
-				)
-				ch <- prometheus.MustNewConstMetric(
-					c.RequestErrorsTotal,
-					prometheus.CounterValue,
-					app.RequestErrors500,
-					name,
-					pid,
-					"500",
-				)
-				ch <- prometheus.MustNewConstMetric(
-					c.WebSocketRequestsActive,
-					prometheus.CounterValue,
-					app.WebSocketRequestsActive,
-					name,
-					pid,
-				)
-				ch <- prometheus.MustNewConstMetric(
-					c.WebSocketConnectionAttempts,
-					prometheus.CounterValue,
-					app.WebSocketConnectionAttempts,
-					name,
-					pid,
-				)
-				ch <- prometheus.MustNewConstMetric(
-					c.WebSocketConnectionsAccepted,
-					prometheus.CounterValue,
-					app.WebSocketConnectionsAccepted,
-					name,
-					pid,
-				)
-				ch <- prometheus.MustNewConstMetric(
-					c.WebSocketConnectionsRejected,
-					prometheus.CounterValue,
-					app.WebSocketConnectionsRejected,
-					name,
-					pid,
-				)
-			}
+			ch <- prometheus.MustNewConstMetric(
+				c.RequestErrorsTotal,
+				prometheus.CounterValue,
+				app.RequestErrors401,
+				name,
+				pid,
+				"401",
+			)
+			ch <- prometheus.MustNewConstMetric(
+				c.RequestErrorsTotal,
+				prometheus.CounterValue,
+				app.RequestErrors403,
+				name,
+				pid,
+				"403",
+			)
+			ch <- prometheus.MustNewConstMetric(
+				c.RequestErrorsTotal,
+				prometheus.CounterValue,
+				app.RequestErrors404,
+				name,
+				pid,
+				"404",
+			)
+			ch <- prometheus.MustNewConstMetric(
+				c.RequestErrorsTotal,
+				prometheus.CounterValue,
+				app.RequestErrors500,
+				name,
+				pid,
+				"500",
+			)
+			ch <- prometheus.MustNewConstMetric(
+				c.WebSocketRequestsActive,
+				prometheus.CounterValue,
+				app.WebSocketRequestsActive,
+				name,
+				pid,
+			)
+			ch <- prometheus.MustNewConstMetric(
+				c.WebSocketConnectionAttempts,
+				prometheus.CounterValue,
+				app.WebSocketConnectionAttempts,
+				name,
+				pid,
+			)
+			ch <- prometheus.MustNewConstMetric(
+				c.WebSocketConnectionsAccepted,
+				prometheus.CounterValue,
+				app.WebSocketConnectionsAccepted,
+				name,
+				pid,
+			)
+			ch <- prometheus.MustNewConstMetric(
+				c.WebSocketConnectionsRejected,
+				prometheus.CounterValue,
+				app.WebSocketConnectionsRejected,
+				name,
+				pid,
+			)
 		}
 	}
 

collector/memory.go

@@ -77,7 +77,8 @@ func NewMemoryCollector() (Collector, error) {
 		),
 		CacheFaultsTotal: prometheus.NewDesc(
 			prometheus.BuildFQName(Namespace, subsystem, "cache_faults_total"),
-			"(CacheFaultsPersec)",
+			"Number of faults which occur when a page sought in the file system cache is not found there and must be retrieved from elsewhere in memory (soft fault) "+
+				"or from disk (hard fault) (Cache Faults/sec)",
 			nil,
 			nil,
 		),
@@ -96,13 +97,14 @@ func NewMemoryCollector() (Collector, error) {
 		DemandZeroFaultsTotal: prometheus.NewDesc(
 			prometheus.BuildFQName(Namespace, subsystem, "demand_zero_faults_total"),
 			"The number of zeroed pages required to satisfy faults. Zeroed pages, pages emptied of previously stored data and filled with zeros, are a security"+
-				" feature of Windows that prevent processes from seeing data stored by earlier processes that used the memory space (DemandZeroFaults)",
+				" feature of Windows that prevent processes from seeing data stored by earlier processes that used the memory space (Demand Zero Faults/sec)",
 			nil,
 			nil,
 		),
 		FreeAndZeroPageListBytes: prometheus.NewDesc(
 			prometheus.BuildFQName(Namespace, subsystem, "free_and_zero_page_list_bytes"),
-			"(FreeAndZeroPageListBytes)",
+			"The amount of physical memory, in bytes, that is assigned to the free and zero page lists. This memory does not contain cached data. It is immediately"+
+				" available for allocation to a process or for system use (FreeAndZeroPageListBytes)",
 			nil,
 			nil,
 		),
@@ -114,13 +116,14 @@ func NewMemoryCollector() (Collector, error) {
 		),
 		ModifiedPageListBytes: prometheus.NewDesc(
 			prometheus.BuildFQName(Namespace, subsystem, "modified_page_list_bytes"),
-			"(ModifiedPageListBytes)",
+			"The amount of physical memory, in bytes, that is assigned to the modified page list. This memory contains cached data and code that is not actively in "+
+				"use by processes, the system and the system cache (ModifiedPageListBytes)",
 			nil,
 			nil,
 		),
 		PageFaultsTotal: prometheus.NewDesc(
 			prometheus.BuildFQName(Namespace, subsystem, "page_faults_total"),
-			"(PageFaultsPersec)",
+			"Overall rate at which faulted pages are handled by the processor (Page Faults/sec)",
 			nil,
 			nil,
 		),
@@ -162,14 +165,15 @@ func NewMemoryCollector() (Collector, error) {
 			nil,
 		),
 		PoolNonpagedBytes: prometheus.NewDesc(
-			prometheus.BuildFQName(Namespace, subsystem, "pool_nonpaged_bytes_total"),
-			"(PoolNonpagedBytes)",
+			prometheus.BuildFQName(Namespace, subsystem, "pool_nonpaged_bytes"),
+			"Number of bytes in the non-paged pool, an area of the system virtual memory that is used for objects that cannot be written to disk, but must "+
+				"remain in physical memory as long as they are allocated (PoolNonpagedBytes)",
 			nil,
 			nil,
 		),
 		PoolPagedAllocsTotal: prometheus.NewDesc(
 			prometheus.BuildFQName(Namespace, subsystem, "pool_paged_allocs_total"),
-			"(PoolPagedAllocs)",
+			"Number of calls to allocate space in the paged pool, regardless of the amount of space allocated in each call (PoolPagedAllocs)",
 			nil,
 			nil,
 		),
@@ -181,67 +185,72 @@ func NewMemoryCollector() (Collector, error) {
 		),
 		PoolPagedResidentBytes: prometheus.NewDesc(
 			prometheus.BuildFQName(Namespace, subsystem, "pool_paged_resident_bytes"),
-			"(PoolPagedResidentBytes)",
+			"The size, in bytes, of the portion of the paged pool that is currently resident and active in physical memory. The paged pool is an area of the "+
+				"system virtual memory that is used for objects that can be written to disk when they are not being used (PoolPagedResidentBytes)",
 			nil,
 			nil,
 		),
 		StandbyCacheCoreBytes: prometheus.NewDesc(
 			prometheus.BuildFQName(Namespace, subsystem, "standby_cache_core_bytes"),
-			"(StandbyCacheCoreBytes)",
+			"The amount of physical memory, in bytes, that is assigned to the core standby cache page lists. This memory contains cached data and code that is "+
+				"not actively in use by processes, the system and the system cache (StandbyCacheCoreBytes)",
 			nil,
 			nil,
 		),
 		StandbyCacheNormalPriorityBytes: prometheus.NewDesc(
 			prometheus.BuildFQName(Namespace, subsystem, "standby_cache_normal_priority_bytes"),
-			"(StandbyCacheNormalPriorityBytes)",
+			"The amount of physical memory, in bytes, that is assigned to the normal priority standby cache page lists. This memory contains cached data and "+
+				"code that is not actively in use by processes, the system and the system cache (StandbyCacheNormalPriorityBytes)",
 			nil,
 			nil,
 		),
 		StandbyCacheReserveBytes: prometheus.NewDesc(
 			prometheus.BuildFQName(Namespace, subsystem, "standby_cache_reserve_bytes"),
-			"(StandbyCacheReserveBytes)",
+			"The amount of physical memory, in bytes, that is assigned to the reserve standby cache page lists. This memory contains cached data and code "+
+				"that is not actively in use by processes, the system and the system cache (StandbyCacheReserveBytes)",
 			nil,
 			nil,
 		),
 		SystemCacheResidentBytes: prometheus.NewDesc(
 			prometheus.BuildFQName(Namespace, subsystem, "system_cache_resident_bytes"),
-			"(SystemCacheResidentBytes)",
+			"The size, in bytes, of the portion of the system file cache which is currently resident and active in physical memory (SystemCacheResidentBytes)",
 			nil,
 			nil,
 		),
 		SystemCodeResidentBytes: prometheus.NewDesc(
 			prometheus.BuildFQName(Namespace, subsystem, "system_code_resident_bytes"),
-			"(SystemCodeResidentBytes)",
+			"The size, in bytes, of the pageable operating system code that is currently resident and active in physical memory (SystemCodeResidentBytes)",
 			nil,
 			nil,
 		),
 		SystemCodeTotalBytes: prometheus.NewDesc(
 			prometheus.BuildFQName(Namespace, subsystem, "system_code_total_bytes"),
-			"(SystemCodeTotalBytes)",
+			"The size, in bytes, of the pageable operating system code currently mapped into the system virtual address space (SystemCodeTotalBytes)",
 			nil,
 			nil,
 		),
 		SystemDriverResidentBytes: prometheus.NewDesc(
 			prometheus.BuildFQName(Namespace, subsystem, "system_driver_resident_bytes"),
-			"(SystemDriverResidentBytes)",
+			"The size, in bytes, of the pageable physical memory being used by device drivers. It is the working set (physical memory area) of the drivers (SystemDriverResidentBytes)",
 			nil,
 			nil,
 		),
 		SystemDriverTotalBytes: prometheus.NewDesc(
 			prometheus.BuildFQName(Namespace, subsystem, "system_driver_total_bytes"),
-			"(SystemDriverTotalBytes)",
+			"The size, in bytes, of the pageable virtual memory currently being used by device drivers. Pageable memory can be written to disk when it is not being used (SystemDriverTotalBytes)",
 			nil,
 			nil,
 		),
 		TransitionFaultsTotal: prometheus.NewDesc(
 			prometheus.BuildFQName(Namespace, subsystem, "transition_faults_total"),
-			"(TransitionFaultsPersec)",
+			"Number of faults rate at which page faults are resolved by recovering pages that were being used by another process sharing the page, or were on the "+
+				"modified page list or the standby list, or were being written to disk at the time of the page fault (TransitionFaultsPersec)",
 			nil,
 			nil,
 		),
 		TransitionPagesRepurposedTotal: prometheus.NewDesc(
 			prometheus.BuildFQName(Namespace, subsystem, "transition_pages_repurposed_total"),
-			"(TransitionPagesRePurposedPersec)",
+			"Transition Pages RePurposed is the rate at which the number of transition cache pages were reused for a different purpose (TransitionPagesRePurposedPersec)",
 			nil,
 			nil,
 		),
@@ -327,7 +336,7 @@ func (c *MemoryCollector) collect(ctx *ScrapeContext, ch chan<- prometheus.Metri
 
 	ch <- prometheus.MustNewConstMetric(
 		c.CacheFaultsTotal,
-		prometheus.GaugeValue,
+		prometheus.CounterValue,
 		dst[0].CacheFaultsPersec,
 	)
 
@@ -345,7 +354,7 @@ func (c *MemoryCollector) collect(ctx *ScrapeContext, ch chan<- prometheus.Metri
 
 	ch <- prometheus.MustNewConstMetric(
 		c.DemandZeroFaultsTotal,
-		prometheus.GaugeValue,
+		prometheus.CounterValue,
 		dst[0].DemandZeroFaultsPersec,
 	)
 
@@ -369,37 +378,37 @@ func (c *MemoryCollector) collect(ctx *ScrapeContext, ch chan<- prometheus.Metri
 
 	ch <- prometheus.MustNewConstMetric(
 		c.PageFaultsTotal,
-		prometheus.GaugeValue,
+		prometheus.CounterValue,
 		dst[0].PageFaultsPersec,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.SwapPageReadsTotal,
-		prometheus.GaugeValue,
+		prometheus.CounterValue,
 		dst[0].PageReadsPersec,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.SwapPagesReadTotal,
-		prometheus.GaugeValue,
+		prometheus.CounterValue,
 		dst[0].PagesInputPersec,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.SwapPagesWrittenTotal,
-		prometheus.GaugeValue,
+		prometheus.CounterValue,
 		dst[0].PagesOutputPersec,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.SwapPageOperationsTotal,
-		prometheus.GaugeValue,
+		prometheus.CounterValue,
 		dst[0].PagesPersec,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.SwapPageWritesTotal,
-		prometheus.GaugeValue,
+		prometheus.CounterValue,
 		dst[0].PageWritesPersec,
 	)
 
@@ -417,7 +426,7 @@ func (c *MemoryCollector) collect(ctx *ScrapeContext, ch chan<- prometheus.Metri
 
 	ch <- prometheus.MustNewConstMetric(
 		c.PoolPagedAllocsTotal,
-		prometheus.GaugeValue,
+		prometheus.CounterValue,
 		dst[0].PoolPagedAllocs,
 	)
 
@@ -483,19 +492,19 @@ func (c *MemoryCollector) collect(ctx *ScrapeContext, ch chan<- prometheus.Metri
 
 	ch <- prometheus.MustNewConstMetric(
 		c.TransitionFaultsTotal,
-		prometheus.GaugeValue,
+		prometheus.CounterValue,
 		dst[0].TransitionFaultsPersec,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.TransitionPagesRepurposedTotal,
-		prometheus.GaugeValue,
+		prometheus.CounterValue,
 		dst[0].TransitionPagesRePurposedPersec,
 	)
 
 	ch <- prometheus.MustNewConstMetric(
 		c.WriteCopiesTotal,
-		prometheus.GaugeValue,
+		prometheus.CounterValue,
 		dst[0].WriteCopiesPersec,
 	)
 

collector/mscluster_network.go

@@ -0,0 +1,117 @@
+package collector
+
+import (
+	"github.com/StackExchange/wmi"
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+func init() {
+	registerCollector("mscluster_network", newMSCluster_NetworkCollector)
+}
+
+// A MSCluster_NetworkCollector is a Prometheus collector for WMI MSCluster_Network metrics
+type MSCluster_NetworkCollector struct {
+	Characteristics *prometheus.Desc
+	Flags           *prometheus.Desc
+	Metric          *prometheus.Desc
+	Role            *prometheus.Desc
+	State           *prometheus.Desc
+}
+
+func newMSCluster_NetworkCollector() (Collector, error) {
+	const subsystem = "mscluster_network"
+	return &MSCluster_NetworkCollector{
+		Characteristics: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "characteristics"),
+			"Provides the characteristics of the network.",
+			[]string{"name"},
+			nil,
+		),
+		Flags: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "flags"),
+			"Provides access to the flags set for the node. ",
+			[]string{"name"},
+			nil,
+		),
+		Metric: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "metric"),
+			"The metric of a cluster network (networks with lower values are used first). If this value is set, then the AutoMetric property is set to false.",
+			[]string{"name"},
+			nil,
+		),
+		Role: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "role"),
+			"Provides access to the network's Role property. The Role property describes the role of the network in the cluster. 0: None; 1: Cluster; 2: Client; 3: Both ",
+			[]string{"name"},
+			nil,
+		),
+		State: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "state"),
+			"Provides the current state of the network. 1-1: Unknown; 0: Unavailable; 1: Down; 2: Partitioned; 3: Up",
+			[]string{"name"},
+			nil,
+		),
+	}, nil
+}
+
+// MSCluster_Network docs:
+// - https://docs.microsoft.com/en-us/previous-versions/windows/desktop/cluswmi/mscluster-network
+//
+type MSCluster_Network struct {
+	Name string
+
+	Characteristics uint
+	Flags           uint
+	Metric          uint
+	Role            uint
+	State           uint
+}
+
+// Collect sends the metric values for each metric
+// to the provided prometheus Metric channel.
+func (c *MSCluster_NetworkCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
+	var dst []MSCluster_Network
+	q := queryAll(&dst)
+	if err := wmi.QueryNamespace(q, &dst, "root/MSCluster"); err != nil {
+		return err
+	}
+
+	for _, v := range dst {
+		ch <- prometheus.MustNewConstMetric(
+			c.Characteristics,
+			prometheus.GaugeValue,
+			float64(v.Characteristics),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.Flags,
+			prometheus.GaugeValue,
+			float64(v.Flags),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.Metric,
+			prometheus.GaugeValue,
+			float64(v.Metric),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.Role,
+			prometheus.GaugeValue,
+			float64(v.Role),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.State,
+			prometheus.GaugeValue,
+			float64(v.State),
+			v.Name,
+		)
+	}
+
+	return nil
+}

collector/mscluster_node.go

@@ -0,0 +1,253 @@
+package collector
+
+import (
+	"github.com/StackExchange/wmi"
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+func init() {
+	registerCollector("mscluster_node", newMSCluster_NodeCollector)
+}
+
+// A MSCluster_NodeCollector is a Prometheus collector for WMI MSCluster_Node metrics
+type MSCluster_NodeCollector struct {
+	BuildNumber           *prometheus.Desc
+	Characteristics       *prometheus.Desc
+	DetectedCloudPlatform *prometheus.Desc
+	DynamicWeight         *prometheus.Desc
+	Flags                 *prometheus.Desc
+	MajorVersion          *prometheus.Desc
+	MinorVersion          *prometheus.Desc
+	NeedsPreventQuorum    *prometheus.Desc
+	NodeDrainStatus       *prometheus.Desc
+	NodeHighestVersion    *prometheus.Desc
+	NodeLowestVersion     *prometheus.Desc
+	NodeWeight            *prometheus.Desc
+	State                 *prometheus.Desc
+	StatusInformation     *prometheus.Desc
+}
+
+func newMSCluster_NodeCollector() (Collector, error) {
+	const subsystem = "mscluster_node"
+	return &MSCluster_NodeCollector{
+		BuildNumber: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "build_number"),
+			"Provides access to the node's BuildNumber property.",
+			[]string{"name"},
+			nil,
+		),
+		Characteristics: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "characteristics"),
+			"Provides access to the characteristics set for the node.",
+			[]string{"name"},
+			nil,
+		),
+		DetectedCloudPlatform: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "detected_cloud_platform"),
+			"(DetectedCloudPlatform)",
+			[]string{"name"},
+			nil,
+		),
+		DynamicWeight: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "dynamic_weight"),
+			"The dynamic vote weight of the node adjusted by dynamic quorum feature.",
+			[]string{"name"},
+			nil,
+		),
+		Flags: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "flags"),
+			"Provides access to the flags set for the node.",
+			[]string{"name"},
+			nil,
+		),
+		MajorVersion: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "major_version"),
+			"Provides access to the node's MajorVersion property, which specifies the major portion of the Windows version installed.",
+			[]string{"name"},
+			nil,
+		),
+		MinorVersion: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "minor_version"),
+			"Provides access to the node's MinorVersion property, which specifies the minor portion of the Windows version installed.",
+			[]string{"name"},
+			nil,
+		),
+		NeedsPreventQuorum: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "needs_prevent_quorum"),
+			"Whether the cluster service on that node should be started with prevent quorum flag.",
+			[]string{"name"},
+			nil,
+		),
+		NodeDrainStatus: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "node_drain_status"),
+			"The current node drain status of a node. 0: Not Initiated; 1: In Progress; 2: Completed; 3: Failed",
+			[]string{"name"},
+			nil,
+		),
+		NodeHighestVersion: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "node_highest_version"),
+			"Provides access to the node's NodeHighestVersion property, which specifies the highest possible version of the cluster service with which the node can join or communicate.",
+			[]string{"name"},
+			nil,
+		),
+		NodeLowestVersion: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "node_lowest_version"),
+			"Provides access to the node's NodeLowestVersion property, which specifies the lowest possible version of the cluster service with which the node can join or communicate.",
+			[]string{"name"},
+			nil,
+		),
+		NodeWeight: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "node_weight"),
+			"The vote weight of the node.",
+			[]string{"name"},
+			nil,
+		),
+		State: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "state"),
+			"Returns the current state of a node. -1: Unknown; 0: Up; 1: Down; 2: Paused; 3: Joining",
+			[]string{"name"},
+			nil,
+		),
+		StatusInformation: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "status_information"),
+			"The isolation or quarantine status of the node.",
+			[]string{"name"},
+			nil,
+		),
+	}, nil
+}
+
+// MSCluster_Node docs:
+// - https://docs.microsoft.com/en-us/previous-versions/windows/desktop/cluswmi/mscluster-node
+//
+type MSCluster_Node struct {
+	Name string
+
+	BuildNumber           uint
+	Characteristics       uint
+	DetectedCloudPlatform uint
+	DynamicWeight         uint
+	Flags                 uint
+	MajorVersion          uint
+	MinorVersion          uint
+	NeedsPreventQuorum    uint
+	NodeDrainStatus       uint
+	NodeHighestVersion    uint
+	NodeLowestVersion     uint
+	NodeWeight            uint
+	State                 uint
+	StatusInformation     uint
+}
+
+// Collect sends the metric values for each metric
+// to the provided prometheus Metric channel.
+func (c *MSCluster_NodeCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
+	var dst []MSCluster_Node
+	q := queryAll(&dst)
+	if err := wmi.QueryNamespace(q, &dst, "root/MSCluster"); err != nil {
+		return err
+	}
+
+	for _, v := range dst {
+
+		ch <- prometheus.MustNewConstMetric(
+			c.BuildNumber,
+			prometheus.GaugeValue,
+			float64(v.BuildNumber),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.Characteristics,
+			prometheus.GaugeValue,
+			float64(v.Characteristics),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.DetectedCloudPlatform,
+			prometheus.GaugeValue,
+			float64(v.DetectedCloudPlatform),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.DynamicWeight,
+			prometheus.GaugeValue,
+			float64(v.DynamicWeight),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.Flags,
+			prometheus.GaugeValue,
+			float64(v.Flags),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.MajorVersion,
+			prometheus.GaugeValue,
+			float64(v.MajorVersion),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.MinorVersion,
+			prometheus.GaugeValue,
+			float64(v.MinorVersion),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.NeedsPreventQuorum,
+			prometheus.GaugeValue,
+			float64(v.NeedsPreventQuorum),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.NodeDrainStatus,
+			prometheus.GaugeValue,
+			float64(v.NodeDrainStatus),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.NodeHighestVersion,
+			prometheus.GaugeValue,
+			float64(v.NodeHighestVersion),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.NodeLowestVersion,
+			prometheus.GaugeValue,
+			float64(v.NodeLowestVersion),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.NodeWeight,
+			prometheus.GaugeValue,
+			float64(v.NodeWeight),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.State,
+			prometheus.GaugeValue,
+			float64(v.State),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.StatusInformation,
+			prometheus.GaugeValue,
+			float64(v.StatusInformation),
+			v.Name,
+		)
+	}
+
+	return nil
+}

collector/mscluster_resource.go

@@ -0,0 +1,285 @@
+package collector
+
+import (
+	"github.com/StackExchange/wmi"
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+func init() {
+	registerCollector("mscluster_resource", newMSCluster_ResourceCollector)
+}
+
+// A MSCluster_ResourceCollector is a Prometheus collector for WMI MSCluster_Resource metrics
+type MSCluster_ResourceCollector struct {
+	Characteristics        *prometheus.Desc
+	DeadlockTimeout        *prometheus.Desc
+	EmbeddedFailureAction  *prometheus.Desc
+	Flags                  *prometheus.Desc
+	IsAlivePollInterval    *prometheus.Desc
+	LooksAlivePollInterval *prometheus.Desc
+	MonitorProcessId       *prometheus.Desc
+	PendingTimeout         *prometheus.Desc
+	ResourceClass          *prometheus.Desc
+	RestartAction          *prometheus.Desc
+	RestartDelay           *prometheus.Desc
+	RestartPeriod          *prometheus.Desc
+	RestartThreshold       *prometheus.Desc
+	RetryPeriodOnFailure   *prometheus.Desc
+	State                  *prometheus.Desc
+	Subclass               *prometheus.Desc
+}
+
+func newMSCluster_ResourceCollector() (Collector, error) {
+	const subsystem = "mscluster_resource"
+	return &MSCluster_ResourceCollector{
+		Characteristics: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "characteristics"),
+			"Provides the characteristics of the object.",
+			[]string{"type", "owner_group", "name"},
+			nil,
+		),
+		DeadlockTimeout: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "deadlock_timeout"),
+			"Indicates the length of time to wait, in milliseconds, before declaring a deadlock in any call into a resource.",
+			[]string{"type", "owner_group", "name"},
+			nil,
+		),
+		EmbeddedFailureAction: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "embedded_failure_action"),
+			"The time, in milliseconds, that a resource should remain in a failed state before the Cluster service attempts to restart it.",
+			[]string{"type", "owner_group", "name"},
+			nil,
+		),
+		Flags: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "flags"),
+			"Provides access to the flags set for the object.",
+			[]string{"type", "owner_group", "name"},
+			nil,
+		),
+		IsAlivePollInterval: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "is_alive_poll_interval"),
+			"Provides access to the resource's IsAlivePollInterval property, which is the recommended interval in milliseconds at which the Cluster Service should poll the resource to determine whether it is operational. If the property is set to 0xFFFFFFFF, the Cluster Service uses the IsAlivePollInterval property for the resource type associated with the resource.",
+			[]string{"type", "owner_group", "name"},
+			nil,
+		),
+		LooksAlivePollInterval: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "looks_alive_poll_interval"),
+			"Provides access to the resource's LooksAlivePollInterval property, which is the recommended interval in milliseconds at which the Cluster Service should poll the resource to determine whether it appears operational. If the property is set to 0xFFFFFFFF, the Cluster Service uses the LooksAlivePollInterval property for the resource type associated with the resource.",
+			[]string{"type", "owner_group", "name"},
+			nil,
+		),
+		MonitorProcessId: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "monitor_process_id"),
+			"Provides the process ID of the resource host service that is currently hosting the resource.",
+			[]string{"type", "owner_group", "name"},
+			nil,
+		),
+		PendingTimeout: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "pending_timeout"),
+			"Provides access to the resource's PendingTimeout property. If a resource cannot be brought online or taken offline in the number of milliseconds specified by the PendingTimeout property, the resource is forcibly terminated.",
+			[]string{"type", "owner_group", "name"},
+			nil,
+		),
+		ResourceClass: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "resource_class"),
+			"Gets or sets the resource class of a resource. 0: Unknown; 1: Storage; 2: Network; 32768: Unknown ",
+			[]string{"type", "owner_group", "name"},
+			nil,
+		),
+		RestartAction: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "restart_action"),
+			"Provides access to the resource's RestartAction property, which is the action to be taken by the Cluster Service if the resource fails.",
+			[]string{"type", "owner_group", "name"},
+			nil,
+		),
+		RestartDelay: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "restart_delay"),
+			"Indicates the time delay before a failed resource is restarted.",
+			[]string{"type", "owner_group", "name"},
+			nil,
+		),
+		RestartPeriod: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "restart_period"),
+			"Provides access to the resource's RestartPeriod property, which is interval of time, in milliseconds, during which a specified number of restart attempts can be made on a nonresponsive resource.",
+			[]string{"type", "owner_group", "name"},
+			nil,
+		),
+		RestartThreshold: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "restart_threshold"),
+			"Provides access to the resource's RestartThreshold property which is the maximum number of restart attempts that can be made on a resource within an interval defined by the RestartPeriod property before the Cluster Service initiates the action specified by the RestartAction property.",
+			[]string{"type", "owner_group", "name"},
+			nil,
+		),
+		RetryPeriodOnFailure: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "retry_period_on_failure"),
+			"Provides access to the resource's RetryPeriodOnFailure property, which is the interval of time (in milliseconds) that a resource should remain in a failed state before the Cluster service attempts to restart it.",
+			[]string{"type", "owner_group", "name"},
+			nil,
+		),
+		State: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "state"),
+			"The current state of the resource. -1: Unknown; 0: Inherited; 1: Initializing; 2: Online; 3: Offline; 4: Failed; 128: Pending; 129: Online Pending; 130: Offline Pending ",
+			[]string{"type", "owner_group", "name"},
+			nil,
+		),
+		Subclass: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "subclass"),
+			"Provides the list of references to nodes that can be the owner of this resource.",
+			[]string{"type", "owner_group", "name"},
+			nil,
+		),
+	}, nil
+}
+
+// MSCluster_Resource docs:
+// - https://docs.microsoft.com/en-us/previous-versions/windows/desktop/cluswmi/mscluster-resource
+//
+type MSCluster_Resource struct {
+	Name       string
+	Type       string
+	OwnerGroup string
+
+	Characteristics        uint
+	DeadlockTimeout        uint
+	EmbeddedFailureAction  uint
+	Flags                  uint
+	IsAlivePollInterval    uint
+	LooksAlivePollInterval uint
+	MonitorProcessId       uint
+	PendingTimeout         uint
+	ResourceClass          uint
+	RestartAction          uint
+	RestartDelay           uint
+	RestartPeriod          uint
+	RestartThreshold       uint
+	RetryPeriodOnFailure   uint
+	State                  uint
+	Subclass               uint
+}
+
+// Collect sends the metric values for each metric
+// to the provided prometheus Metric channel.
+func (c *MSCluster_ResourceCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
+	var dst []MSCluster_Resource
+	q := queryAll(&dst)
+	if err := wmi.QueryNamespace(q, &dst, "root/MSCluster"); err != nil {
+		return err
+	}
+
+	for _, v := range dst {
+
+		ch <- prometheus.MustNewConstMetric(
+			c.Characteristics,
+			prometheus.GaugeValue,
+			float64(v.Characteristics),
+			v.Type, v.OwnerGroup, v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.DeadlockTimeout,
+			prometheus.GaugeValue,
+			float64(v.DeadlockTimeout),
+			v.Type, v.OwnerGroup, v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.EmbeddedFailureAction,
+			prometheus.GaugeValue,
+			float64(v.EmbeddedFailureAction),
+			v.Type, v.OwnerGroup, v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.Flags,
+			prometheus.GaugeValue,
+			float64(v.Flags),
+			v.Type, v.OwnerGroup, v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.IsAlivePollInterval,
+			prometheus.GaugeValue,
+			float64(v.IsAlivePollInterval),
+			v.Type, v.OwnerGroup, v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.LooksAlivePollInterval,
+			prometheus.GaugeValue,
+			float64(v.LooksAlivePollInterval),
+			v.Type, v.OwnerGroup, v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.MonitorProcessId,
+			prometheus.GaugeValue,
+			float64(v.MonitorProcessId),
+			v.Type, v.OwnerGroup, v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.PendingTimeout,
+			prometheus.GaugeValue,
+			float64(v.PendingTimeout),
+			v.Type, v.OwnerGroup, v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.ResourceClass,
+			prometheus.GaugeValue,
+			float64(v.ResourceClass),
+			v.Type, v.OwnerGroup, v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.RestartAction,
+			prometheus.GaugeValue,
+			float64(v.RestartAction),
+			v.Type, v.OwnerGroup, v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.RestartDelay,
+			prometheus.GaugeValue,
+			float64(v.RestartDelay),
+			v.Type, v.OwnerGroup, v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.RestartPeriod,
+			prometheus.GaugeValue,
+			float64(v.RestartPeriod),
+			v.Type, v.OwnerGroup, v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.RestartThreshold,
+			prometheus.GaugeValue,
+			float64(v.RestartThreshold),
+			v.Type, v.OwnerGroup, v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.RetryPeriodOnFailure,
+			prometheus.GaugeValue,
+			float64(v.RetryPeriodOnFailure),
+			v.Type, v.OwnerGroup, v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.State,
+			prometheus.GaugeValue,
+			float64(v.State),
+			v.Type, v.OwnerGroup, v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.Subclass,
+			prometheus.GaugeValue,
+			float64(v.Subclass),
+			v.Type, v.OwnerGroup, v.Name,
+		)
+	}
+
+	return nil
+}

collector/mscluster_resourcegroup.go

@@ -0,0 +1,241 @@
+package collector
+
+import (
+	"github.com/StackExchange/wmi"
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+func init() {
+	registerCollector("mscluster_resourcegroup", newMSCluster_ResourceGroupCollector)
+}
+
+// A MSCluster_ResourceGroupCollector is a Prometheus collector for WMI MSCluster_ResourceGroup metrics
+type MSCluster_ResourceGroupCollector struct {
+	AutoFailbackType    *prometheus.Desc
+	Characteristics     *prometheus.Desc
+	ColdStartSetting    *prometheus.Desc
+	DefaultOwner        *prometheus.Desc
+	FailbackWindowEnd   *prometheus.Desc
+	FailbackWindowStart *prometheus.Desc
+	FailoverPeriod      *prometheus.Desc
+	FailoverThreshold   *prometheus.Desc
+	FaultDomain         *prometheus.Desc
+	Flags               *prometheus.Desc
+	GroupType           *prometheus.Desc
+	PlacementOptions    *prometheus.Desc
+	Priority            *prometheus.Desc
+	ResiliencyPeriod    *prometheus.Desc
+	State               *prometheus.Desc
+}
+
+func newMSCluster_ResourceGroupCollector() (Collector, error) {
+	const subsystem = "mscluster_resourcegroup"
+	return &MSCluster_ResourceGroupCollector{
+		AutoFailbackType: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "auto_failback_type"),
+			"Provides access to the group's AutoFailbackType property.",
+			[]string{"name"},
+			nil,
+		),
+		Characteristics: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "characteristics"),
+			"Provides the characteristics of the group.",
+			[]string{"name"},
+			nil,
+		),
+		ColdStartSetting: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "cold_start_setting"),
+			"Indicates whether a group can start after a cluster cold start.",
+			[]string{"name"},
+			nil,
+		),
+		DefaultOwner: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "default_owner"),
+			"Number of the last node the resource group was activated on or explicitly moved to.",
+			[]string{"name"},
+			nil,
+		),
+		FailbackWindowEnd: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "failback_window_end"),
+			"The FailbackWindowEnd property provides the latest time that the group can be moved back to the node identified as its preferred node.",
+			[]string{"name"},
+			nil,
+		),
+		FailbackWindowStart: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "failback_window_start"),
+			"The FailbackWindowStart property provides the earliest time (that is, local time as kept by the cluster) that the group can be moved back to the node identified as its preferred node.",
+			[]string{"name"},
+			nil,
+		),
+		FailoverPeriod: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "failover_period"),
+			"The FailoverPeriod property specifies a number of hours during which a maximum number of failover attempts, specified by the FailoverThreshold property, can occur.",
+			[]string{"name"},
+			nil,
+		),
+		FailoverThreshold: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "failover_threshold"),
+			"The FailoverThreshold property specifies the maximum number of failover attempts.",
+			[]string{"name"},
+			nil,
+		),
+		Flags: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "flags"),
+			"Provides access to the flags set for the group. ",
+			[]string{"name"},
+			nil,
+		),
+		GroupType: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "group_type"),
+			"The Type of the resource group.",
+			[]string{"name"},
+			nil,
+		),
+		Priority: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "priority"),
+			"Priority value of the resource group",
+			[]string{"name"},
+			nil,
+		),
+		ResiliencyPeriod: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "resiliency_period"),
+			"The resiliency period for this group, in seconds.",
+			[]string{"name"},
+			nil,
+		),
+		State: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "state"),
+			"The current state of the resource group. -1: Unknown; 0: Online; 1: Offline; 2: Failed; 3: Partial Online; 4: Pending",
+			[]string{"name"},
+			nil,
+		),
+	}, nil
+}
+
+// MSCluster_ResourceGroup docs:
+// - https://docs.microsoft.com/en-us/previous-versions/windows/desktop/cluswmi/mscluster-resourcegroup
+//
+type MSCluster_ResourceGroup struct {
+	Name string
+
+	AutoFailbackType    uint
+	Characteristics     uint
+	ColdStartSetting    uint
+	DefaultOwner        uint
+	FailbackWindowEnd   int
+	FailbackWindowStart int
+	FailoverPeriod      uint
+	FailoverThreshold   uint
+	Flags               uint
+	GroupType           uint
+	Priority            uint
+	ResiliencyPeriod    uint
+	State               uint
+}
+
+// Collect sends the metric values for each metric
+// to the provided prometheus Metric channel.
+func (c *MSCluster_ResourceGroupCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
+	var dst []MSCluster_ResourceGroup
+	q := queryAll(&dst)
+	if err := wmi.QueryNamespace(q, &dst, "root/MSCluster"); err != nil {
+		return err
+	}
+
+	for _, v := range dst {
+
+		ch <- prometheus.MustNewConstMetric(
+			c.AutoFailbackType,
+			prometheus.GaugeValue,
+			float64(v.AutoFailbackType),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.Characteristics,
+			prometheus.GaugeValue,
+			float64(v.Characteristics),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.ColdStartSetting,
+			prometheus.GaugeValue,
+			float64(v.ColdStartSetting),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.DefaultOwner,
+			prometheus.GaugeValue,
+			float64(v.DefaultOwner),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.FailbackWindowEnd,
+			prometheus.GaugeValue,
+			float64(v.FailbackWindowEnd),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.FailbackWindowStart,
+			prometheus.GaugeValue,
+			float64(v.FailbackWindowStart),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.FailoverPeriod,
+			prometheus.GaugeValue,
+			float64(v.FailoverPeriod),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.FailoverThreshold,
+			prometheus.GaugeValue,
+			float64(v.FailoverThreshold),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.Flags,
+			prometheus.GaugeValue,
+			float64(v.Flags),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.GroupType,
+			prometheus.GaugeValue,
+			float64(v.GroupType),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.Priority,
+			prometheus.GaugeValue,
+			float64(v.Priority),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.ResiliencyPeriod,
+			prometheus.GaugeValue,
+			float64(v.ResiliencyPeriod),
+			v.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.State,
+			prometheus.GaugeValue,
+			float64(v.State),
+			v.Name,
+		)
+
+	}
+
+	return nil
+}

collector/os.go

@@ -179,11 +179,7 @@ func (c *OSCollector) collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) (
 	if err != nil {
 		return nil, err
 	}
-	pagingFiles, _, err := memManKey.GetStringsValue("ExistingPageFiles")
-	if err != nil {
-		return nil, err
-	}
-
+	pagingFiles, _, pagingErr := memManKey.GetStringsValue("ExistingPageFiles")
 	// Get build number and product name from registry
 	ntKey, err := registry.OpenKey(registry.LOCAL_MACHINE, `SOFTWARE\Microsoft\Windows NT\CurrentVersion`, registry.QUERY_VALUE)
 	defer ntKey.Close()
@@ -261,12 +257,21 @@ func (c *OSCollector) collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) (
 		timezoneName,
 	)
 
-	ch <- prometheus.MustNewConstMetric(
-		c.PagingFreeBytes,
-		prometheus.GaugeValue,
-		pfb,
-	)
+	if pagingErr == nil {
+		ch <- prometheus.MustNewConstMetric(
+			c.PagingFreeBytes,
+			prometheus.GaugeValue,
+			pfb,
+		)
 
+		ch <- prometheus.MustNewConstMetric(
+			c.PagingLimitBytes,
+			prometheus.GaugeValue,
+			fsipf,
+		)
+	} else {
+		log.Debugln("Could not find HKLM:\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Memory Management key. windows_os_paging_free_bytes and windows_os_paging_limit_bytes will be omitted.")
+	}
 	ch <- prometheus.MustNewConstMetric(
 		c.VirtualMemoryFreeBytes,
 		prometheus.GaugeValue,
@@ -300,12 +305,6 @@ func (c *OSCollector) collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) (
 		float64(nwgi.LoggedOnUsers),
 	)
 
-	ch <- prometheus.MustNewConstMetric(
-		c.PagingLimitBytes,
-		prometheus.GaugeValue,
-		fsipf,
-	)
-
 	ch <- prometheus.MustNewConstMetric(
 		c.VirtualMemoryBytes,
 		prometheus.GaugeValue,

collector/process.go

@@ -73,7 +73,7 @@ func newProcessCollector() (Collector, error) {
 			nil,
 		),
 		HandleCount: prometheus.NewDesc(
-			prometheus.BuildFQName(Namespace, subsystem, "handle_count"),
+			prometheus.BuildFQName(Namespace, subsystem, "handles"),
 			"Total number of handles the process has open. This number is the sum of the handles currently open by each thread in the process.",
 			[]string{"process", "process_id", "creating_process_id"},
 			nil,
@@ -121,7 +121,7 @@ func newProcessCollector() (Collector, error) {
 			nil,
 		),
 		ThreadCount: prometheus.NewDesc(
-			prometheus.BuildFQName(Namespace, subsystem, "thread_count"),
+			prometheus.BuildFQName(Namespace, subsystem, "threads"),
 			"Number of threads currently active in this process.",
 			[]string{"process", "process_id", "creating_process_id"},
 			nil,

collector/remote_fx.go

@@ -346,7 +346,3 @@ func (c *RemoteFxCollector) collectRemoteFXGraphicsCounters(ctx *ScrapeContext,
 
 	return nil, nil
 }
-
-func milliSecToSec(t float64) float64 {
-	return t / 1000
-}

collector/scheduled_task.go

@@ -0,0 +1,314 @@
+//go:build windows
+// +build windows
+
+package collector
+
+import (
+	"fmt"
+	"regexp"
+	"runtime"
+	"strings"
+
+	ole "github.com/go-ole/go-ole"
+	"github.com/go-ole/go-ole/oleutil"
+	"github.com/prometheus-community/windows_exporter/log"
+	"github.com/prometheus/client_golang/prometheus"
+	"gopkg.in/alecthomas/kingpin.v2"
+)
+
+var (
+	taskWhitelist = kingpin.Flag(
+		"collector.scheduled_task.whitelist",
+		"Regexp of tasks to whitelist. Task path must both match whitelist and not match blacklist to be included.",
+	).Default(".+").String()
+	taskBlacklist = kingpin.Flag(
+		"collector.scheduled_task.blacklist",
+		"Regexp of tasks to blacklist. Task path must both match whitelist and not match blacklist to be included.",
+	).String()
+)
+
+type ScheduledTaskCollector struct {
+	LastResult *prometheus.Desc
+	MissedRuns *prometheus.Desc
+	State      *prometheus.Desc
+
+	taskWhitelistPattern *regexp.Regexp
+	taskBlacklistPattern *regexp.Regexp
+}
+
+// TaskState ...
+// https://docs.microsoft.com/en-us/windows/desktop/api/taskschd/ne-taskschd-task_state
+type TaskState uint
+
+type TaskResult uint
+
+const (
+	TASK_STATE_UNKNOWN TaskState = iota
+	TASK_STATE_DISABLED
+	TASK_STATE_QUEUED
+	TASK_STATE_READY
+	TASK_STATE_RUNNING
+	TASK_RESULT_SUCCESS TaskResult = 0x0
+)
+
+// RegisteredTask ...
+type ScheduledTask struct {
+	Name            string
+	Path            string
+	Enabled         bool
+	State           TaskState
+	MissedRunsCount float64
+	LastTaskResult  TaskResult
+}
+
+type ScheduledTasks []ScheduledTask
+
+func init() {
+	registerCollector("scheduled_task", NewScheduledTask)
+}
+
+// NewScheduledTask ...
+func NewScheduledTask() (Collector, error) {
+	const subsystem = "scheduled_task"
+
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	err := ole.CoInitializeEx(0, ole.COINIT_MULTITHREADED)
+	if err != nil {
+		code := err.(*ole.OleError).Code()
+		if code != ole.S_OK && code != S_FALSE {
+			return nil, err
+		}
+	}
+	defer ole.CoUninitialize()
+
+	return &ScheduledTaskCollector{
+		LastResult: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "last_result"),
+			"The result that was returned the last time the registered task was run",
+			[]string{"task"},
+			nil,
+		),
+
+		MissedRuns: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "missed_runs"),
+			"The number of times the registered task missed a scheduled run",
+			[]string{"task"},
+			nil,
+		),
+
+		State: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "state"),
+			"The current state of a scheduled task",
+			[]string{"task", "state"},
+			nil,
+		),
+
+		taskWhitelistPattern: regexp.MustCompile(fmt.Sprintf("^(?:%s)$", *taskWhitelist)),
+		taskBlacklistPattern: regexp.MustCompile(fmt.Sprintf("^(?:%s)$", *taskBlacklist)),
+	}, nil
+}
+
+func (c *ScheduledTaskCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
+	if desc, err := c.collect(ch); err != nil {
+		log.Error("failed collecting user metrics:", desc, err)
+		return err
+	}
+
+	return nil
+}
+
+var TASK_STATES = []string{"disabled", "queued", "ready", "running", "unknown"}
+
+func (c *ScheduledTaskCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
+	scheduledTasks, err := getScheduledTasks()
+	if err != nil {
+		return nil, err
+	}
+
+	for _, task := range scheduledTasks {
+		if c.taskBlacklistPattern.MatchString(task.Path) ||
+			!c.taskWhitelistPattern.MatchString(task.Path) {
+			continue
+		}
+
+		lastResult := 0.0
+		if task.LastTaskResult == TASK_RESULT_SUCCESS {
+			lastResult = 1.0
+		}
+
+		ch <- prometheus.MustNewConstMetric(
+			c.LastResult,
+			prometheus.GaugeValue,
+			lastResult,
+			task.Path,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.MissedRuns,
+			prometheus.GaugeValue,
+			task.MissedRunsCount,
+			task.Path,
+		)
+
+		for _, state := range TASK_STATES {
+			var stateValue float64
+
+			if strings.ToLower(task.State.String()) == state {
+				stateValue = 1.0
+			}
+
+			ch <- prometheus.MustNewConstMetric(
+				c.State,
+				prometheus.GaugeValue,
+				stateValue,
+				task.Path,
+				state,
+			)
+		}
+	}
+
+	return nil, nil
+}
+
+const SCHEDULED_TASK_PROGRAM_ID = "Schedule.Service.1"
+
+// S_FALSE is returned by CoInitialize if it was already called on this thread.
+const S_FALSE = 0x00000001
+
+func getScheduledTasks() (scheduledTasks ScheduledTasks, err error) {
+	schedClassID, err := ole.ClassIDFrom(SCHEDULED_TASK_PROGRAM_ID)
+	if err != nil {
+		return scheduledTasks, err
+	}
+
+	taskSchedulerObj, err := ole.CreateInstance(schedClassID, nil)
+	if err != nil || taskSchedulerObj == nil {
+		return scheduledTasks, err
+	}
+	defer taskSchedulerObj.Release()
+
+	taskServiceObj := taskSchedulerObj.MustQueryInterface(ole.IID_IDispatch)
+	_, err = oleutil.CallMethod(taskServiceObj, "Connect")
+	if err != nil {
+		return scheduledTasks, err
+	}
+	defer taskServiceObj.Release()
+
+	res, err := oleutil.CallMethod(taskServiceObj, "GetFolder", `\`)
+	if err != nil {
+		return scheduledTasks, err
+	}
+
+	rootFolderObj := res.ToIDispatch()
+	defer rootFolderObj.Release()
+
+	err = fetchTasksRecursively(rootFolderObj, &scheduledTasks)
+
+	return scheduledTasks, err
+}
+
+func fetchTasksInFolder(folder *ole.IDispatch, scheduledTasks *ScheduledTasks) error {
+	res, err := oleutil.CallMethod(folder, "GetTasks", 1)
+	if err != nil {
+		return err
+	}
+
+	tasks := res.ToIDispatch()
+	defer tasks.Release()
+
+	err = oleutil.ForEach(tasks, func(v *ole.VARIANT) error {
+		task := v.ToIDispatch()
+
+		parsedTask, err := parseTask(task)
+		if err != nil {
+			return err
+		}
+
+		*scheduledTasks = append(*scheduledTasks, parsedTask)
+
+		return nil
+	})
+
+	return err
+}
+
+func fetchTasksRecursively(folder *ole.IDispatch, scheduledTasks *ScheduledTasks) error {
+	if err := fetchTasksInFolder(folder, scheduledTasks); err != nil {
+		return err
+	}
+
+	res, err := oleutil.CallMethod(folder, "GetFolders", 1)
+	if err != nil {
+		return err
+	}
+
+	subFolders := res.ToIDispatch()
+	defer subFolders.Release()
+
+	err = oleutil.ForEach(subFolders, func(v *ole.VARIANT) error {
+		subFolder := v.ToIDispatch()
+		return fetchTasksRecursively(subFolder, scheduledTasks)
+	})
+
+	return err
+}
+
+func parseTask(task *ole.IDispatch) (scheduledTask ScheduledTask, err error) {
+	taskNameVar, err := oleutil.GetProperty(task, "Name")
+	if err != nil {
+		return scheduledTask, err
+	}
+
+	taskPathVar, err := oleutil.GetProperty(task, "Path")
+	if err != nil {
+		return scheduledTask, err
+	}
+
+	taskEnabledVar, err := oleutil.GetProperty(task, "Enabled")
+	if err != nil {
+		return scheduledTask, err
+	}
+
+	taskStateVar, err := oleutil.GetProperty(task, "State")
+	if err != nil {
+		return scheduledTask, err
+	}
+
+	taskNumberOfMissedRunsVar, err := oleutil.GetProperty(task, "NumberOfMissedRuns")
+	if err != nil {
+		return scheduledTask, err
+	}
+
+	taskLastTaskResultVar, err := oleutil.GetProperty(task, "LastTaskResult")
+	if err != nil {
+		return scheduledTask, err
+	}
+
+	scheduledTask.Name = taskNameVar.ToString()
+	scheduledTask.Path = strings.ReplaceAll(taskPathVar.ToString(), "\\", "/")
+	scheduledTask.Enabled = taskEnabledVar.Value().(bool)
+	scheduledTask.State = TaskState(taskStateVar.Val)
+	scheduledTask.MissedRunsCount = float64(taskNumberOfMissedRunsVar.Val)
+	scheduledTask.LastTaskResult = TaskResult(taskLastTaskResultVar.Val)
+
+	return scheduledTask, err
+}
+
+func (t TaskState) String() string {
+	switch t {
+	case TASK_STATE_UNKNOWN:
+		return "Unknown"
+	case TASK_STATE_DISABLED:
+		return "Disabled"
+	case TASK_STATE_QUEUED:
+		return "Queued"
+	case TASK_STATE_READY:
+		return "Ready"
+	case TASK_STATE_RUNNING:
+		return "Running"
+	default:
+		return ""
+	}
+}

collector/scheduled_task_test.go

@@ -0,0 +1,9 @@
+package collector
+
+import (
+	"testing"
+)
+
+func BenchmarkScheduledTaskCollector(b *testing.B) {
+	benchmarkCollector(b, "scheduled_task", NewScheduledTask)
+}

collector/tcp.go

@@ -31,13 +31,13 @@ func NewTCPCollector() (Collector, error) {
 
 	return &TCPCollector{
 		ConnectionFailures: prometheus.NewDesc(
-			prometheus.BuildFQName(Namespace, subsystem, "connection_failures"),
+			prometheus.BuildFQName(Namespace, subsystem, "connection_failures_total"),
 			"(TCP.ConnectionFailures)",
 			[]string{"af"},
 			nil,
 		),
 		ConnectionsActive: prometheus.NewDesc(
-			prometheus.BuildFQName(Namespace, subsystem, "connections_active"),
+			prometheus.BuildFQName(Namespace, subsystem, "connections_active_total"),
 			"(TCP.ConnectionsActive)",
 			[]string{"af"},
 			nil,
@@ -49,13 +49,13 @@ func NewTCPCollector() (Collector, error) {
 			nil,
 		),
 		ConnectionsPassive: prometheus.NewDesc(
-			prometheus.BuildFQName(Namespace, subsystem, "connections_passive"),
+			prometheus.BuildFQName(Namespace, subsystem, "connections_passive_total"),
 			"(TCP.ConnectionsPassive)",
 			[]string{"af"},
 			nil,
 		),
 		ConnectionsReset: prometheus.NewDesc(
-			prometheus.BuildFQName(Namespace, subsystem, "connections_reset"),
+			prometheus.BuildFQName(Namespace, subsystem, "connections_reset_total"),
 			"(TCP.ConnectionsReset)",
 			[]string{"af"},
 			nil,

collector/terminal_services.go

@@ -82,7 +82,7 @@ func NewTerminalServicesCollector() (Collector, error) {
 			nil,
 		),
 		HandleCount: prometheus.NewDesc(
-			prometheus.BuildFQName(Namespace, subsystem, "handle_count"),
+			prometheus.BuildFQName(Namespace, subsystem, "handles"),
 			"Total number of handles currently opened by this process. This number is the sum of the handles currently opened by each thread in this process.",
 			[]string{"session_name"},
 			nil,
@@ -142,7 +142,7 @@ func NewTerminalServicesCollector() (Collector, error) {
 			nil,
 		),
 		ThreadCount: prometheus.NewDesc(
-			prometheus.BuildFQName(Namespace, subsystem, "thread_count"),
+			prometheus.BuildFQName(Namespace, subsystem, "threads"),
 			"Number of threads currently active in this process. An instruction is the basic unit of execution in a processor, and a thread is the object that executes instructions. Every running process has at least one thread.",
 			[]string{"session_name"},
 			nil,

collector/textfile.go

@@ -284,7 +284,12 @@ fileLoop:
 			error = 1.0
 			continue
 		}
+
+		// Use temporary array to check for duplicates
+		var families_array []*dto.MetricFamily
+
 		for _, mf := range parsedFamilies {
+			families_array = append(families_array, mf)
 			for _, m := range mf.Metric {
 				if m.TimestampMs != nil {
 					log.Errorf("Textfile %q contains unsupported client-side timestamps, skipping entire file", path)
@@ -298,6 +303,13 @@ fileLoop:
 			}
 		}
 
+		// If duplicate metrics are detected in a *single* file, skip processing of file metrics
+		if duplicateMetricEntry(families_array) {
+			log.Errorf("Duplicate metrics detected in file %s. Skipping file processing.", f.Name())
+			error = 1.0
+			continue
+		}
+
 		// Only set this once it has been parsed and validated, so that
 		// a failure does not appear fresh.
 		mtimes[f.Name()] = f.ModTime()
@@ -307,8 +319,9 @@ fileLoop:
 		}
 	}
 
+	// If duplicates are detected across *multiple* files, return error.
 	if duplicateMetricEntry(metricFamilies) {
-		log.Errorf("Duplicate metrics detected in files")
+		log.Errorf("Duplicate metrics detected across multiple files")
 		error = 1.0
 	} else {
 		for _, mf := range metricFamilies {

collector/time.go

@@ -45,7 +45,7 @@ func newTimeCollector() (Collector, error) {
 			nil,
 		),
 		NTPClientTimeSourceCount: prometheus.NewDesc(
-			prometheus.BuildFQName(Namespace, subsystem, "ntp_client_time_source_count"),
+			prometheus.BuildFQName(Namespace, subsystem, "ntp_client_time_sources"),
 			"Active number of NTP Time sources being used by the client",
 			nil,
 			nil,

docs/README.md

@@ -28,6 +28,7 @@ This directory contains documentation of the collectors in the windows_exporter,
 - [`os`](collector.os.md)
 - [`process`](collector.process.md)
 - [`remote_fx`](collector.remote_fx.md)
+- [`scheduled_task`](collector.scheduled_task.md)
 - [`service`](collector.service.md)
 - [`smtp`](collector.smtp.md)
 - [`system`](collector.system.md)

docs/collector.adcs.md

@@ -0,0 +1,55 @@
+# adcs collector
+
+The adcs collector exposes metrics about Active Directory Certificate Services, Note that this collector has only been tested against Windows Server 2019.
+Other Windows Server versions may work but are not tested.
+
+|||
+-|-
+Metric name prefix  | `adcs`
+Data source         | Perflib
+Counters            | `Certification Authority`
+Enabled by default? | No
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+|requests_total|Total certificate requests processed|counter|`cert_template`|
+|request_processing_time_seconds|Last time elapsed for certificate requests|gauge|`cert_template`|
+|retrievals_total|Last time elapsed for certificate requests|counter|`cert_template`|
+|retrievals_processing_time_seconds|Last time elapsed for certificate retrieval request|gauge|`cert_template`|
+|failed_requests_total|Total failed certificate requests processed|counter|`cert_template`|
+|issued_requests_total|Total issued certificate requests processed|counter|`cert_template`|
+|pending_requests_total|Total pending certificate requests processed|counter|`cert_template`|
+|request_cryptographic_signing_time_seconds|Last time elapsed for signing operation request|gauge|`cert_template`|
+|request_policy_module_processing_time_seconds|Last time elapsed for policy module processing request|gauge|`cert_template`|
+|challenge_responses_total|Total certificate challenge responses processed|counter|`cert_template`|
+|challenge_response_processing_time_seconds|Last time elapsed for challenge response|gauge|`cert_template`|
+|signed_certificate_timestamp_lists_total|Total Signed Certificate Timestamp Lists processed|counter|`cert_template`|
+|signed_certificate_timestamp_list_processing_time_seconds|Last time elapsed for Signed Certificate Timestamp List|gauge|`cert_template`|
+
+### Example metric
+```
+windows_adcs_issued_requests_total{cert_template="Administrator"} 0
+windows_adcs_issued_requests_total{cert_template="DirectoryEmailReplication"} 0
+windows_adcs_issued_requests_total{cert_template="DomainController"} 1
+windows_adcs_issued_requests_total{cert_template="DomainControllerAuthentication"} 0
+windows_adcs_issued_requests_total{cert_template="EFS"} 0
+windows_adcs_issued_requests_total{cert_template="EFSRecovery"} 0
+windows_adcs_issued_requests_total{cert_template="KerberosAuthentication"} 0
+windows_adcs_issued_requests_total{cert_template="Machine"} 0
+windows_adcs_issued_requests_total{cert_template="SubCA"} 0
+windows_adcs_issued_requests_total{cert_template="User"} 0
+windows_adcs_issued_requests_total{cert_template="WebServer"} 0
+windows_adcs_issued_requests_total{cert_template="_Total"} 1
+```
+
+## Useful queries
+_This collector does not yet have any useful queries added, we would appreciate your help adding them!_
+
+## Alerting examples
+_This collector does not yet have alerting examples, we would appreciate your help adding them!_

docs/collector.adfs.md

@@ -1,6 +1,6 @@
 # adfs collector
 
-The adfs collector exposes metrics about Active Directory Federation Services. Note that this collector has only been tested against ADFS 4.0 (2016).
+The ADFS collector exposes metrics about Active Directory Federation Services. Note that this collector has only been tested against ADFS 4.0/ [Farm Behavior (FLB) 3](https://docs.microsoft.com/en-us/windows-server/identity/ad-fs/deployment/upgrading-to-ad-fs-in-windows-server#ad-fs-farm-behavior-levels-fbl) (Server 2016).
 Other ADFS versions may work but are not tested.
 
 |||
@@ -28,6 +28,49 @@ Name | Description | Type | Labels
 `windows_adfs_password_change_succeeded_total` | Total number of succeeded password changes. The Password Change Portal must be enabled in the AD FS Management tool in order to allow user password changes | counter | None
 `windows_adfs_token_requests_total` | Total number of requested access tokens | counter | None
 `windows_adfs_windows_integrated_authentications_total` | Total number of Windows integrated authentications using Kerberos or NTLM | counter | None
+`ad_login_connection_failures_total` | Total number of connection failures to an Active Directory domain controller | counter | None
+`certificate_authentications_total` | Total number of User Certificate authentications | counter | None
+`device_authentications_total` | Total number of Device authentications | counter | None
+`extranet_account_lockouts_total` | Total number of Extranet Account Lockouts | counter | None
+`federated_authentications_total` | Total number of authentications from a federated source | counter | None
+`passport_authentications_total` | Total number of Microsoft Passport SSO authentications | counter | None
+`passive_requests_total` | Total number of passive (browser-based) requests | counter | None
+`password_change_failed_total` | Total number of failed password changes | counter | None
+`password_change_succeeded_total` | Total number of successful password changes | counter | None
+`token_requests_total` | Total number of token requests | counter | None
+`windows_integrated_authentications_total` | Total number of Windows integrated authentications (Kerberos/NTLM) | counter | None
+`oauth_authorization_requests_total` | Total number of incoming requests to the OAuth Authorization endpoint | counter | None
+`oauth_client_authentication_success_total` | Total number of successful OAuth client Authentications | counter | None
+`oauth_client_authentication_failure_total` | Total number of failed OAuth client Authentications | counter | None
+`oauth_client_credentials_failure_total` | Total number of failed OAuth Client Credentials Requests | counter | None
+`oauth_client_credentials_success_total` | Total number of successful RP tokens issued for OAuth Client Credentials Requests | counter | None
+`oauth_client_privkey_jtw_authentication_failure_total` | Total number of failed OAuth Client Private Key Jwt Authentications | counter | None
+`oauth_client_privkey_jwt_authentications_success_total` | Total number of successful OAuth Client Private Key Jwt Authentications | counter | None
+`oauth_client_secret_basic_authentications_failure_total` | Total number of failed OAuth Client Secret Basic Authentications | counter | None
+`oauth_client_secret_basic_authentications_success_total` | Total number of successful OAuth Client Secret Basic Authentications | counter | None
+`oauth_client_secret_post_authentications_failure_total` | Total number of failed OAuth Client Secret Post Authentications | counter | None
+`oauth_client_secret_post_authentications_success_total` | Total number of successful OAuth Client Secret Post Authentications | counter | None
+`oauth_client_windows_authentications_failure_total` | Total number of failed OAuth Client Windows Integrated Authentications | counter | None
+`oauth_client_windows_authentications_success_total` | Total number of successful OAuth Client Windows Integrated Authentications | counter | None
+`oauth_logon_certificate_requests_failure_total` | Total number of failed OAuth Logon Certificate Requests | counter | None
+`oauth_logon_certificate_token_requests_success_total` | Total number of successful RP tokens issued for OAuth Logon Certificate Requests | counter | None
+`oauth_password_grant_requests_failure_total` | Total number of failed OAuth Password Grant Requests | counter | None
+`oauth_password_grant_requests_success_total` | Total number of successful OAuth Password Grant Requests | counter | None
+`oauth_token_requests_success_total` | Total number of successful RP tokens issued over OAuth protocol | counter | None
+`samlp_token_requests_success_total` | Total number of successful RP tokens issued over SAML-P protocol | counter | None
+`sso_authentications_failure_total` | Total number of failed SSO authentications | counter | None
+`sso_authentications_success_total` | Total number of successful SSO authentications | counter | None
+`wsfed_token_requests_success_total` | Total number of successful RP tokens issued over WS-Fed protocol | counter | None
+`wstrust_token_requests_success_total` | Total number of successful RP tokens issued over WS-Trust protocol | counter | None
+`userpassword_authentications_failure_total` | Total number of failed AD U/P authentications | counter | None
+`userpassword_authentications_success_total` | Total number of successful AD U/P authentications | counter | None
+`external_authentications_failure_total` | Total number of failed authentications from external MFA providers | counter | None
+`external_authentications_success_total` | Total number of successful authentications from external MFA providers | counter | None
+`db_artifact_failure_total` | Total number of failures connecting to the artifact database | counter | None
+`db_artifact_query_time_seconds_total` | Accumulator of time taken for an artifact database query | counter | None
+`db_config_failure_total` | Total number of failures connecting to the configuration database | counter | None
+`db_config_query_time_seconds_total` | Accumulator of time taken for a configuration database query | counter | None
+`federation_metadata_requests_total` | Total number of Federation Metadata requests | counter | None
 
 ### Example metric
 Show rate of device authentications in AD FS:
@@ -37,6 +80,11 @@ rate(windows_adfs_device_authentications)[2m]
 
 ## Useful queries
 
+|Query|Description|
+|---|----|
+|`rate(windows_adfs_oauth_password_grant_requests_failure_total[5m])`| Rate of OAuth requests failing due to bad client/resource values|
+|`rate(windows_adfs_userpassword_authentications_failures_total[5m])`| Rate of `/adfs/oauth2/token/` requests failing due to bad username/password values (possible credential spraying)|
+
 ## Alerting examples
 **prometheus.rules**
 ```yaml

docs/collector.container.md

@@ -30,6 +30,10 @@ Name | Description | Type | Labels
 `windows_container_network_transmit_bytes_total` | Bytes Sent on Interface | counter | `container_id`, `interface`
 `windows_container_network_transmit_packets_total` | Packets Sent on Interface | counter | `container_id`, `interface`
 `windows_container_network_transmit_packets_dropped_total` | Dropped Outgoing Packets on Interface | counter | `container_id`, `interface`
+`windows_container_storage_read_count_normalized_total` | Read Count Normalized | counter | `container_id`
+`windows_container_storage_read_size_bytes_total` | Read Size Bytes | counter | `container_id`
+`windows_container_storage_write_count_normalized_total` | Write Count Normalized | counter | `container_id`
+`windows_container_storage_write_size_bytes_total` | Write Size Bytes | counter | `container_id`
 
 ### Example metric
 _windows_container_network_receive_bytes_total{container_id="docker://1bd30e8b8ac28cbd76a9b697b4d7bb9d760267b0733d1bc55c60024e98d1e43e",interface="822179E7-002C-4280-ABBA-28BCFE401826"} 9.3305343e+07_
@@ -37,7 +41,11 @@ _windows_container_network_receive_bytes_total{container_id="docker://1bd30e8b8a
 This metric means that total _9.3305343e+07_ bytes received on interface _822179E7-002C-4280-ABBA-28BCFE401826_ for container _docker://1bd30e8b8ac28cbd76a9b697b4d7bb9d760267b0733d1bc55c60024e98d1e43e_
 
 ## Useful queries
-_This collector does not yet have any useful queries added, we would appreciate your help adding them!_
-
+Attach labels namespace/pod/container fow windows container metrics.
+```
+# kube_pod_container_info(a metric of kube-state-metrics) has labels namespace/pod/container/container_id for a container, while windows container metrics only have container_id.
+# Attaching labels namespace/pod/container for windows container metrics, is useful to query for windows pods.
+windows_container_network_receive_bytes_total * on(container_id) group_left(namespace, pod, container) kube_pod_container_info{container_id!=""}
+```
 ## Alerting examples
 _This collector does not yet have alerting examples, we would appreciate your help adding them!_

docs/collector.cpu.md

@@ -19,7 +19,7 @@ These metrics are available on all versions of Windows:
 Name | Description | Type | Labels
 -----|-------------|------|-------
 `windows_cpu_cstate_seconds_total` | Time spent in low-power idle states | counter | `core`, `state`
-`windows_cpu_time_total` | Time that processor spent in different modes (idle, user, system, ...) | counter | `core`, `mode`
+`windows_cpu_time_total` | Time that processor spent in different modes (dpc, idle, interrupt, privileged, user) | counter | `core`, `mode`
 `windows_cpu_interrupts_total` | Total number of received and serviced hardware interrupts | counter | `core`
 `windows_cpu_dpcs_total` | Total number of received and serviced deferred procedure calls (DPCs) | counter | `core`
 

docs/collector.fsrmquota.md

@@ -18,7 +18,6 @@ None
 
 Name | Description | Type | Labels
 -----|-------------|------|-------
-
 `windows_fsrmquota_count` | Number of Quotas | counter |None
 `windows_fsrmquota_description` | A string up to 1KB in size. Optional. The default value is an empty string. (Description) | counter |`path`, `template`,`description`
 `windows_fsrmquota_disabled` | If 1, the quota is disabled. The default value is 0. (Disabled) | counter |`path`, `template`

docs/collector.hyperv.md

@@ -51,6 +51,16 @@ Name | Description | Type | Labels
 `windows_hyperv_vm_cpu_guest_run_time` | _Not yet documented_ | counter | `vm`, `core`
 `windows_hyperv_vm_cpu_hypervisor_run_time` | _Not yet documented_ | counter | `vm`, `core`
 `windows_hyperv_vm_cpu_remote_run_time` | _Not yet documented_ | counter | `vm`, `core`
+`windows_hyperv_vm_memory_added_total` | _Not yet documented_ | counter | `vm`
+`windows_hyperv_vm_memory_pressure_average` | _Not yet documented_ | gauge | `vm`
+`windows_hyperv_vm_memory_pressure_current` | _Not yet documented_ | counter | `vm`
+`windows_hyperv_vm_memory_physical_guest_visible` | _Not yet documented_ | gauge | `vm`
+`windows_hyperv_vm_memory_pressure_maximum` | _Not yet documented_ | gauge | `vm`
+`windows_hyperv_vm_memory_add_operations_total` | _Not yet documented_ | counter | `vm`
+`windows_hyperv_vm_memory_remove_operations_total` | _Not yet documented_ | counter | `vm`
+`windows_hyperv_vm_memory_pressure_minumim` | _Not yet documented_ | gauge | `vm`
+`windows_hyperv_vm_memory_physical` | _Not yet documented_ | gauge | `vm`
+`windows_hyperv_vm_memory_removed_total` | _Not yet documented_ | counter | `vm`
 `windows_hyperv_vm_cpu_total_run_time` | _Not yet documented_ | counter | `vm`, `core`
 `windows_hyperv_vswitch_broadcast_packets_received_total` | _Not yet documented_ | counter | `vswitch`
 `windows_hyperv_vswitch_broadcast_packets_sent_total` | _Not yet documented_ | counter | `vswitch`

docs/collector.memory.md

@@ -20,35 +20,35 @@ Name | Description | Type | Labels
 `windows_memory_available_bytes` | The amount of physical memory immediately available for allocation to a process or for system use. It is equal to the sum of memory assigned to the standby (cached), free and zero page lists | gauge | None
 `windows_memory_cache_bytes` | Number of bytes currently being used by the file system cache | gauge | None
 `windows_memory_cache_bytes_peak` | Maximum number of CacheBytes after the system was last restarted | gauge | None
-`windows_memory_cache_faults_total` | Number of faults which occur when a page sought in the file system cache is not found there and must be retrieved from elsewhere in memory (soft fault) or from disk (hard fault) | gauge | None
+`windows_memory_cache_faults_total` | Number of faults which occur when a page sought in the file system cache is not found there and must be retrieved from elsewhere in memory (soft fault) or from disk (hard fault) | counter | None
 `windows_memory_commit_limit` | Amount of virtual memory, in bytes, that can be committed without having to extend the paging file(s) | gauge | None
 `windows_memory_committed_bytes` | Amount of committed virtual memory, in bytes | gauge | None
-`windows_memory_demand_zero_faults_total` | The number of zeroed pages required to satisfy faults. Zeroed pages, pages emptied of previously stored data and filled with zeros, are a security feature of Windows that prevent processes from seeing data stored by earlier processes that used the memory space | gauge | None
-`windows_memory_free_and_zero_page_list_bytes` | _Not yet documented_ | gauge | None
+`windows_memory_demand_zero_faults_total` | The number of zeroed pages required to satisfy faults. Zeroed pages, pages emptied of previously stored data and filled with zeros, are a security feature of Windows that prevent processes from seeing data stored by earlier processes that used the memory space | counter | None
+`windows_memory_free_and_zero_page_list_bytes` | The amount of physical memory, in bytes, that is assigned to the free and zero page lists. This memory does not contain cached data. It is immediately available for allocation to a process or for system use | gauge | None
 `windows_memory_free_system_page_table_entries` | Number of page table entries not being used by the system | gauge | None
-`windows_memory_modified_page_list_bytes` | _Not yet documented_ | gauge | None
-`windows_memory_page_faults_total` | Overall rate at which faulted pages are handled by the processor | gauge | None
-`windows_memory_swap_page_reads_total` | Number of disk page reads (a single read operation reading several pages is still only counted once) | gauge | None
-`windows_memory_swap_pages_read_total` | Number of pages read across all page reads (ie counting all pages read even if they are read in a single operation) | gauge | None
-`windows_memory_swap_pages_written_total` | Number of pages written across all page writes (ie counting all pages written even if they are written in a single operation) | gauge | None
-`windows_memory_swap_page_operations_total` | Total number of swap page read and writes (PagesPersec) | gauge | None
-`windows_memory_swap_page_writes_total` | Number of disk page writes (a single write operation writing several pages is still only counted once) | gauge | None
-`windows_memory_pool_nonpaged_allocs_total` | The number of calls to allocate space in the nonpaged pool. The nonpaged pool is an area of system memory area for objects that cannot be written to disk, and must remain in physical memory as long as they are allocated | gauge | None
-`windows_memory_pool_nonpaged_bytes_total` | Number of bytes in the non-paged pool | gauge | None
-`windows_memory_pool_paged_allocs_total` | Number of calls to allocate space in the paged pool, regardless of the amount of space allocated in each call | gauge | None
+`windows_memory_modified_page_list_bytes` | The amount of physical memory, in bytes, that is assigned to the modified page list. This memory contains cached data and code that is not actively in use by processes, the system and the system cache. This memory needs to be written out before it will be available for allocation to a process or for system use | gauge | None
+`windows_memory_page_faults_total` | Overall rate at which faulted pages are handled by the processor | counter | None
+`windows_memory_swap_page_reads_total` | Number of disk page reads (a single read operation reading several pages is still only counted once) | counter | None
+`windows_memory_swap_pages_read_total` | Number of pages read across all page reads (ie counting all pages read even if they are read in a single operation) | counter | None
+`windows_memory_swap_pages_written_total` | Number of pages written across all page writes (ie counting all pages written even if they are written in a single operation) | counter | None
+`windows_memory_swap_page_operations_total` | Total number of swap page read and writes (PagesPersec) | counter | None
+`windows_memory_swap_page_writes_total` | Number of disk page writes (a single write operation writing several pages is still only counted once) | counter | None
+`windows_memory_pool_nonpaged_allocs_total` | The number of calls to allocate space in the nonpaged pool. The nonpaged pool is an area of system memory area for objects that cannot be written to disk, and must remain in physical memory as long as they are allocated | counter | None
+`windows_memory_pool_nonpaged_bytes` | Number of bytes in the non-paged pool, an area of the system virtual memory that is used for objects that cannot be written to disk, but must remain in physical memory as long as they are allocated | gauge | None
+`windows_memory_pool_paged_allocs_total` | Number of calls to allocate space in the paged pool, regardless of the amount of space allocated in each call | counter | None
 `windows_memory_pool_paged_bytes` | Number of bytes in the paged pool | gauge | None
-`windows_memory_pool_paged_resident_bytes` | _Not yet documented_ | gauge | None
-`windows_memory_standby_cache_core_bytes` | _Not yet documented_ | gauge | None
-`windows_memory_standby_cache_normal_priority_bytes` | _Not yet documented_ | gauge | None
-`windows_memory_standby_cache_reserve_bytes` | _Not yet documented_ | gauge | None
-`windows_memory_system_cache_resident_bytes` | _Not yet documented_ | gauge | None
-`windows_memory_system_code_resident_bytes` | _Not yet documented_ | gauge | None
-`windows_memory_system_code_total_bytes` | _Not yet documented_ | gauge | None
-`windows_memory_system_driver_resident_bytes` | _Not yet documented_ | gauge | None
-`windows_memory_system_driver_total_bytes` | _Not yet documented_ | gauge | None
-`windows_memory_transition_faults_total` | _Not yet documented_ | gauge | None
-`windows_memory_transition_pages_repurposed_total` | _Not yet documented_ | gauge | None
-`windows_memory_write_copies_total` | The number of page faults caused by attempting to write that were satisfied by copying the page from elsewhere in physical memory | gauge | None
+`windows_memory_pool_paged_resident_bytes` | The size, in bytes, of the portion of the paged pool that is currently resident and active in physical memory. The paged pool is an area of the system virtual memory that is used for objects that can be written to disk when they are not being used | gauge | None
+`windows_memory_standby_cache_core_bytes` | The amount of physical memory, in bytes, that is assigned to the core standby cache page lists. This memory contains cached data and code that is not actively in use by processes, the system and the system cache. It is immediately available for allocation to a process or for system use. If the system runs out of available free and zero memory, memory on lower priority standby cache page lists will be repurposed before memory on higher priority standby cache page lists | gauge | None
+`windows_memory_standby_cache_normal_priority_bytes` | The amount of physical memory, in bytes, that is assigned to the normal priority standby cache page lists. This memory contains cached data and code that is not actively in use by processes, the system and the system cache. It is immediately available for allocation to a process or for system use. If the system runs out of available free and zero memory, memory on lower priority standby cache page lists will be repurposed before memory on higher priority standby cache page lists | gauge | None
+`windows_memory_standby_cache_reserve_bytes` | The amount of physical memory, in bytes, that is assigned to the reserve standby cache page lists. This memory contains cached data and code that is not actively in use by processes, the system and the system cache. It is immediately available for allocation to a process or for system use. If the system runs out of available free and zero memory, memory on lower priority standby cache page lists will be repurposed before memory on higher priority standby cache page lists | gauge | None
+`windows_memory_system_cache_resident_bytes` | The size, in bytes, of the portion of the system file cache which is currently resident and active in physical memory | gauge | None
+`windows_memory_system_code_resident_bytes` | The size, in bytes, of the pageable operating system code that is currently resident and active in physical memory. This value is a component of Memory\\System Code Total Bytes. Memory\\System Code Resident Bytes (and Memory\\System Code Total Bytes) does not include code that must remain in physical memory and cannot be written to disk | gauge | None
+`windows_memory_system_code_total_bytes` | The size, in bytes, of the pageable operating system code currently mapped into the system virtual address space. This value is calculated by summing the bytes in Ntoskrnl.exe, Hal.dll, the boot drivers, and file systems loaded by Ntldr/osloader. This counter does not include code that must remain in physical memory and cannot be written to disk | gauge | None
+`windows_memory_system_driver_resident_bytes` | The size, in bytes, of the pageable physical memory being used by device drivers. It is the working set (physical memory area) of the drivers. This value is a component of Memory\\System Driver Total Bytes, which also includes driver memory that has been written to disk. Neither Memory\\System Driver Resident Bytes nor Memory\\System Driver Total Bytes includes memory that cannot be written to disk | gauge | None
+`windows_memory_system_driver_total_bytes` | The size, in bytes, of the pageable virtual memory currently being used by device drivers. Pageable memory can be written to disk when it is not being used. It includes both physical memory (Memory\\System Driver Resident Bytes) and code and data paged to disk. It is a component of Memory\\System Code Total Bytes | gauge | None
+`windows_memory_transition_faults_total` | Number of faults rate at which page faults are resolved by recovering pages that were being used by another process sharing the page, or were on the modified page list or the standby list, or were being written to disk at the time of the page fault. The pages were recovered without additional disk activity. Transition faults are counted in numbers of faults; because only one page is faulted in each operation, it is also equal to the number of pages faulted | counter | None
+`windows_memory_transition_pages_repurposed_total` | Transition Pages RePurposed is the rate at which the number of transition cache pages were reused for a different purpose. These pages would have otherwise remained in the page cache to provide a (fast) soft fault (instead of retrieving it from backing store) in the event the page was accessed in the future | counter | None
+`windows_memory_write_copies_total` | The number of page faults caused by attempting to write that were satisfied by copying the page from elsewhere in physical memory | counter | None
 
 ### Example metric
 _This collector does not yet have explained examples, we would appreciate your help adding them!_

docs/collector.mscluster_cluster.md

@@ -0,0 +1,104 @@
+# mscluster_cluster collector
+
+The MSCluster_Cluster class is a dynamic WMI class that represents a cluster.
+
+|||
+-|-
+Metric name prefix  | `mscluster_cluster`
+Classes             | `MSCluster_Cluster`
+Enabled by default? | No
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`AddEvictDelay` | Provides access to the cluster's AddEvictDelay property, which is the number a seconds that a new node is delayed after an eviction of another node. | gauge | `name`
+`AdminAccessPoint` | The type of the cluster administrative access point. | gauge | `name`
+`AutoAssignNodeSite` | Determines whether or not the cluster will attempt to automatically assign nodes to sites based on networks and Active Directory Site information. | gauge | `name`
+`AutoBalancerLevel` | Determines the level of aggressiveness of AutoBalancer. | gauge | `name`
+`AutoBalancerMode` | Determines whether or not the auto balancer is enabled. | gauge | `name`
+`BackupInProgress` | Indicates whether a backup is in progress. | gauge | `name`
+`BlockCacheSize` | CSV BlockCache Size in MB. | gauge | `name`
+`ClusSvcHangTimeout` | Controls how long the cluster network driver waits between Failover Cluster Service heartbeats before it determines that the Failover Cluster Service has stopped responding. | gauge | `name`
+`ClusSvcRegroupOpeningTimeout` | Controls how long a node will wait on other nodes in the opening stage before deciding that they failed. | gauge | `name`
+`ClusSvcRegroupPruningTimeout` | Controls how long the membership leader will wait to reach full connectivity between cluster nodes. | gauge | `name`
+`ClusSvcRegroupStageTimeout` | Controls how long a node will wait on other nodes in a membership stage before deciding that they failed. | gauge | `name`
+`ClusSvcRegroupTickInMilliseconds` | Controls how frequently the membership algorithm is sending periodic membership messages. | gauge | `name`
+`ClusterEnforcedAntiAffinity` | Enables or disables hard enforcement of group anti-affinity classes. | gauge | `name`
+`ClusterFunctionalLevel` | The functional level the cluster is currently running in. | gauge | `name`
+`ClusterGroupWaitDelay` | Maximum time in seconds that a group waits for its preferred node to come online during cluster startup before coming online on a different node. | gauge | `name`
+`ClusterLogLevel` | Controls the level of cluster logging. | gauge | `name`
+`ClusterLogSize` | Controls the maximum size of the cluster log files on each of the nodes. | gauge | `name`
+`ClusterUpgradeVersion` | Specifies the upgrade version the cluster is currently running in. | gauge | `name`
+`CrossSiteDelay` | Controls how long the cluster network driver waits in milliseconds between sending Cluster Service heartbeats across sites. | gauge | `name`
+`CrossSiteThreshold` | Controls how many Cluster Service heartbeats can be missed across sites before it determines that Cluster Service has stopped responding. | gauge | `name`
+`CrossSubnetDelay` | Controls how long the cluster network driver waits in milliseconds between sending Cluster Service heartbeats across subnets. | gauge | `name`
+`CrossSubnetThreshold` | Controls how many Cluster Service heartbeats can be missed across subnets before it determines that Cluster Service has stopped responding. | gauge | `name`
+`CsvBalancer` | Whether automatic balancing for CSV is enabled. | gauge | `name`
+`DatabaseReadWriteMode` | Sets the database read and write mode. | gauge | `name`
+`DefaultNetworkRole` | Provides access to the cluster's DefaultNetworkRole property. | gauge | `name`
+`DetectedCloudPlatform` | | gauge | `name`
+`DetectManagedEvents` | | gauge | `name`
+`DetectManagedEventsThreshold` | | gauge | `name`
+`DisableGroupPreferredOwnerRandomization` | | gauge | `name`
+`DrainOnShutdown` | Whether to drain the node when cluster service is being stopped. | gauge | `name`
+`DynamicQuorumEnabled` | Allows cluster service to adjust node weights as needed to increase availability. | gauge | `name`
+`EnableSharedVolumes` | Enables or disables cluster shared volumes on this cluster. | gauge | `name`
+`FixQuorum` | Provides access to the cluster's FixQuorum property, which specifies if the cluster is in a fix quorum state. | gauge | `name`
+`GracePeriodEnabled` | Whether the node grace period feature of this cluster is enabled. | gauge | `name`
+`GracePeriodTimeout` | The grace period timeout in milliseconds. | gauge | `name`
+`GroupDependencyTimeout` | The timeout after which a group will be brought online despite unsatisfied dependencies | gauge | `name`
+`HangRecoveryAction` | Controls the action to take if the user-mode processes have stopped responding. | gauge | `name`
+`IgnorePersistentStateOnStartup` | Provides access to the cluster's IgnorePersistentStateOnStartup property, which specifies whether the cluster will bring online groups that were online when the cluster was shut down. | gauge | `name`
+`LogResourceControls` | Controls the logging of resource controls. | gauge | `name`
+`LowerQuorumPriorityNodeId` | Specifies the Node ID that has a lower priority when voting for quorum is performed. If the quorum vote is split 50/50%, the specified node's vote would be ignored to break the tie. If this is not set then the cluster will pick a node at random to break the tie. | gauge | `name`
+`MaxNumberOfNodes` | Indicates the maximum number of nodes that may participate in the Cluster. | gauge | `name`
+`MessageBufferLength` | The maximum unacknowledged message count for GEM. | gauge | `name`
+`MinimumNeverPreemptPriority` | Groups with this priority or higher cannot be preempted. | gauge | `name`
+`MinimumPreemptorPriority` | Minimum priority a cluster group must have to be able to preempt another group. | gauge | `name`
+`NetftIPSecEnabled` | Whether IPSec is enabled for cluster internal traffic. | gauge | `name`
+`PlacementOptions` | Various option flags to modify default placement behavior. | gauge | `name`
+`PlumbAllCrossSubnetRoutes` | Plumbs all possible cross subnet routes to all nodes. | gauge | `name`
+`PreventQuorum` | Whether the cluster will ignore group persistent state on startup. | gauge | `name`
+`QuarantineDuration` | The quarantine period timeout in milliseconds. | gauge | `name`
+`QuarantineThreshold` | Number of node failures before it will be quarantined. | gauge | `name`
+`QuorumArbitrationTimeMax` | Controls the maximum time necessary to decide the Quorum owner node. | gauge | `name`
+`QuorumArbitrationTimeMin` | Controls the minimum time necessary to decide the Quorum owner node. | gauge | `name`
+`QuorumLogFileSize` | This property is obsolete. | gauge | `name`
+`QuorumTypeValue` | Get the current quorum type value. -1: Unknown; 1: Node; 2: FileShareWitness; 3: Storage; 4: None | gauge | `name`
+`RequestReplyTimeout` | Controls the request reply time-out period. | gauge | `name`
+`ResiliencyDefaultPeriod` | The default resiliency period, in seconds, for the cluster. | gauge | `name`
+`ResiliencyLevel` | The resiliency level for the cluster. | gauge | `name`
+`ResourceDllDeadlockPeriod` | This property is obsolete. | gauge | `name`
+`RootMemoryReserved` | Controls the amount of memory reserved for the parent partition on all cluster nodes. | gauge | `name`
+`RouteHistoryLength` | The history length for routes to help finding network issues. | gauge | `name`
+`S2DBusTypes` | Bus types for storage spaces direct. | gauge | `name`
+`S2DCacheDesiredState` | Desired state of the storage spaces direct cache. | gauge | `name`
+`S2DCacheFlashReservePercent` | Percentage of allocated flash space to utilize when caching. | gauge | `name`
+`S2DCachePageSizeKBytes` | Page size in KB used by S2D cache. | gauge | `name`
+`S2DEnabled` | Whether direct attached storage (DAS) is enabled. | gauge | `name`
+`S2DIOLatencyThreshold` | The I/O latency threshold for storage spaces direct. | gauge | `name`
+`S2DOptimizations` | Optimization flags for storage spaces direct. | gauge | `name`
+`SameSubnetDelay` | Controls how long the cluster network driver waits in milliseconds between sending Cluster Service heartbeats on the same subnet. | gauge | `name`
+`SameSubnetThreshold` | Controls how many Cluster Service heartbeats can be missed on the same subnet before it determines that Cluster Service has stopped responding. | gauge | `name`
+`SecurityLevel` | Controls the level of security that should apply to intracluster messages. 0: Clear Text; 1: Sign; 2: Encrypt | gauge | `name`
+`SecurityLevelForStorage` | | gauge | `name`
+`SharedVolumeVssWriterOperationTimeout` | CSV VSS Writer operation timeout in seconds. | gauge | `name`
+`ShutdownTimeoutInMinutes` | The maximum time in minutes allowed for cluster resources to come offline during cluster service shutdown. | gauge | `name`
+`UseClientAccessNetworksForSharedVolumes` | Whether the use of client access networks for cluster shared volumes feature of this cluster is enabled. 0: Disabled; 1: Enabled; 2: Auto | gauge | `name`
+`WitnessDatabaseWriteTimeout` | Controls the maximum time in seconds that a cluster database write to a witness can take before the write is abandoned. | gauge | `name`
+`WitnessDynamicWeight` | The weight of the configured witness. | gauge | `name`
+`WitnessRestartInterval` | Controls the witness restart interval. | gauge | `name`
+
+### Example metric
+_This collector does not yet have explained examples, we would appreciate your help adding them!_
+
+## Useful queries
+_This collector does not yet have any useful queries added, we would appreciate your help adding them!_
+
+## Alerting examples
+_This collector does not yet have alerting examples, we would appreciate your help adding them!_

docs/collector.mscluster_network.md

@@ -0,0 +1,32 @@
+# mscluster_network collector
+
+The MSCluster_Network class is a dynamic WMI class that represents cluster networks.
+
+|||
+-|-
+Metric name prefix  | `mscluster_network`
+Classes             | `MSCluster_Network`
+Enabled by default? | No
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`Characteristics` | Provides the characteristics of the network. The cluster defines characteristics only for resources. For a description of these characteristics, see [CLUSCTL_RESOURCE_GET_CHARACTERISTICS](https://msdn.microsoft.com/library/aa367466).  | gauge | `name`
+`Flags` | Provides access to the flags set for the network. The cluster defines flags only for resources. For a description of these flags, see [CLUSCTL_RESOURCE_GET_FLAGS](https://docs.microsoft.com/en-us/previous-versions/windows/desktop/mscs/clusctl-resource-get-flags). | gauge | `name`
+`Metric` | The metric of a cluster network (networks with lower values are used first). If this value is set, then the AutoMetric property is set to false. | gauge | `name`
+`Role` | Provides access to the network's Role property. The Role property describes the role of the network in the cluster. 0: None; 1: Cluster; 2: Client; 3: Both  | gauge | `name`
+`State` | Provides the current state of the network. 1-1: Unknown; 0: Unavailable; 1: Down; 2: Partitioned; 3: Up | gauge | `name`
+
+### Example metric
+_This collector does not yet have explained examples, we would appreciate your help adding them!_
+
+## Useful queries
+_This collector does not yet have any useful queries added, we would appreciate your help adding them!_
+
+## Alerting examples
+_This collector does not yet have alerting examples, we would appreciate your help adding them!_

docs/collector.mscluster_node.md

@@ -0,0 +1,41 @@
+# mscluster_node collector
+
+The MSCluster_Node class is a dynamic WMI class that represents a cluster node.
+
+|||
+-|-
+Metric name prefix  | `mscluster_node`
+Classes             | `MSCluster_Node`
+Enabled by default? | No
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`BuildNumber` | Provides access to the node's BuildNumber property. | gauge | `name`
+`Characteristics` | Provides access to the characteristics set for the node. For a list of possible characteristics, see [CLUSCTL_NODE_GET_CHARACTERISTICS](https://docs.microsoft.com/en-us/previous-versions/windows/desktop/mscs/clusctl-node-get-characteristics). | gauge | `name`
+`DetectedCloudPlatform` | The dynamic vote weight of the node adjusted by dynamic quorum feature. | gauge | `name`
+`DynamicWeight` | The dynamic vote weight of the node adjusted by dynamic quorum feature. | gauge | `name`
+`Flags` | Provides access to the flags set for the node. For a list of possible characteristics, see [CLUSCTL_NODE_GET_FLAGS](https://docs.microsoft.com/en-us/previous-versions/windows/desktop/mscs/clusctl-node-get-flags). | gauge | `name`
+`MajorVersion` | Provides access to the node's MajorVersion property, which specifies the major portion of the Windows version installed. | gauge | `name`
+`MinorVersion` | Provides access to the node's MinorVersion property, which specifies the minor portion of the Windows version installed. | gauge | `name`
+`NeedsPreventQuorum` | Whether the cluster service on that node should be started with prevent quorum flag. | gauge | `name`
+`NodeDrainStatus` | The current node drain status of a node. 0: Not Initiated; 1: In Progress; 2: Completed; 3: Failed | gauge | `name`
+`NodeHighestVersion` | Provides access to the node's NodeHighestVersion property, which specifies the highest possible version of the cluster service with which the node can join or communicate. | gauge | `name`
+`NodeLowestVersion` | Provides access to the node's NodeLowestVersion property, which specifies the lowest possible version of the cluster service with which the node can join or communicate. | gauge | `name`
+`NodeWeight` | The vote weight of the node. | gauge | `name`
+`State` | Returns the current state of a node. -1: Unknown; 0: Up; 1: Down; 2: Paused; 3: Joining | gauge | `name`
+`StatusInformation` | The isolation or quarantine status of the node. | gauge | `name`
+
+### Example metric
+_This collector does not yet have explained examples, we would appreciate your help adding them!_
+
+## Useful queries
+_This collector does not yet have any useful queries added, we would appreciate your help adding them!_
+
+## Alerting examples
+_This collector does not yet have alerting examples, we would appreciate your help adding them!_

docs/collector.mscluster_resource.md

@@ -0,0 +1,43 @@
+# mscluster_resource collector
+
+The MSCluster_resource class is a dynamic WMI class that represents a cluster resource.
+
+|||
+-|-
+Metric name prefix  | `mscluster_resource`
+Classes             | `MSCluster_Resource`
+Enabled by default? | No
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`Characteristics` | Provides the characteristics of the object. The cluster defines characteristics only for resources. For a description of these characteristics, see [CLUSCTL_RESOURCE_GET_CHARACTERISTICS](https://docs.microsoft.com/en-us/previous-versions/windows/desktop/mscs/clusctl-resource-get-characteristics). | gauge | `type`, `owner_group`, `name`
+`DeadlockTimeout` | Indicates the length of time to wait, in milliseconds, before declaring a deadlock in any call into a resource. | gauge | `type`, `owner_group`, `name`
+`EmbeddedFailureAction` | The time, in milliseconds, that a resource should remain in a failed state before the Cluster service attempts to restart it. | gauge | `type`, `owner_group`, `name`
+`Flags` | Provides access to the flags set for the object. The cluster defines flags only for resources. For a description of these flags, see [CLUSCTL_RESOURCE_GET_FLAGS](https://docs.microsoft.com/en-us/previous-versions/windows/desktop/mscs/clusctl-resource-get-flags). | gauge | `type`, `owner_group`, `name`
+`IsAlivePollInterval` | Provides access to the resource's IsAlivePollInterval property, which is the recommended interval in milliseconds at which the Cluster Service should poll the resource to determine whether it is operational. If the property is set to 0xFFFFFFFF, the Cluster Service uses the IsAlivePollInterval property for the resource type associated with the resource. | gauge | `type`, `owner_group`, `name`
+`LooksAlivePollInterval` | Provides access to the resource's LooksAlivePollInterval property, which is the recommended interval in milliseconds at which the Cluster Service should poll the resource to determine whether it appears operational. If the property is set to 0xFFFFFFFF, the Cluster Service uses the LooksAlivePollInterval property for the resource type associated with the resource. | gauge | `type`, `owner_group`, `name`
+`MonitorProcessId` | Provides the process ID of the resource host service that is currently hosting the resource. | gauge | `type`, `owner_group`, `name`
+`PendingTimeout` | Provides access to the resource's PendingTimeout property. If a resource cannot be brought online or taken offline in the number of milliseconds specified by the PendingTimeout property, the resource is forcibly terminated. | gauge | `type`, `owner_group`, `name`
+`ResourceClass` | Gets or sets the resource class of a resource. 0: Unknown; 1: Storage; 2: Network; 32768: Unknown | gauge | `type`, `owner_group`, `name`
+`RestartAction` | Provides access to the resource's RestartAction property, which is the action to be taken by the Cluster Service if the resource fails. | gauge | `type`, `owner_group`, `name`
+`RestartDelay` | Indicates the time delay before a failed resource is restarted. | gauge | `type`, `owner_group`, `name`
+`RestartPeriod` | Provides access to the resource's RestartPeriod property, which is interval of time, in milliseconds, during which a specified number of restart attempts can be made on a nonresponsive resource. | gauge | `type`, `owner_group`, `name`
+`RestartThreshold` | Provides access to the resource's RestartThreshold property which is the maximum number of restart attempts that can be made on a resource within an interval defined by the RestartPeriod property before the Cluster Service initiates the action specified by the RestartAction property. | gauge | `type`, `owner_group`, `name`
+`RetryPeriodOnFailure` | Provides access to the resource's RetryPeriodOnFailure property, which is the interval of time (in milliseconds) that a resource should remain in a failed state before the Cluster service attempts to restart it. | gauge | `type`, `owner_group`, `name`
+`State` | The current state of the resource. -1: Unknown; 0: Inherited; 1: Initializing; 2: Online; 3: Offline; 4: Failed; 128: Pending; 129: Online Pending; 130: Offline Pending | gauge | `type`, `owner_group`, `name`
+`Subclass` | Provides the list of references to nodes that can be the owner of this resource. | gauge | `type`, `owner_group`, `name`
+
+### Example metric
+_This collector does not yet have explained examples, we would appreciate your help adding them!_
+
+## Useful queries
+_This collector does not yet have any useful queries added, we would appreciate your help adding them!_
+
+## Alerting examples
+_This collector does not yet have alerting examples, we would appreciate your help adding them!_

docs/collector.mscluster_resourcegroup.md

@@ -0,0 +1,41 @@
+# mscluster_resourcegroup collector
+
+The MSCluster_ResourceGroup class is a dynamic WMI class that represents a cluster group.
+
+|||
+-|-
+Metric name prefix  | `mscluster_resourcegroup`
+Classes             | `MSCluster_ResourceGroup`
+Enabled by default? | No
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`AutoFailbackType` | Provides access to the group's AutoFailbackType property. | gauge | `name`
+`Characteristics` | Provides the characteristics of the group. The cluster defines characteristics only for resources. For a description of these characteristics, see [CLUSCTL_RESOURCE_GET_CHARACTERISTICS](https://docs.microsoft.com/en-us/previous-versions/windows/desktop/mscs/clusctl-resource-get-characteristics). | gauge | `name`
+`ColdStartSetting` | Indicates whether a group can start after a cluster cold start. | gauge | `name`
+`DefaultOwner` | Number of the last node the resource group was activated on or explicitly moved to. | gauge | `name`
+`FailbackWindowEnd` | The FailbackWindowEnd property provides the latest time that the group can be moved back to the node identified as its preferred node. | gauge | `name`
+`FailbackWindowStart` | The FailbackWindowStart property provides the earliest time (that is, local time as kept by the cluster) that the group can be moved back to the node identified as its preferred node. | gauge | `name`
+`FailoverPeriod` | The FailoverPeriod property specifies a number of hours during which a maximum number of failover attempts, specified by the FailoverThreshold property, can occur. | gauge | `name`
+`FailoverThreshold` | The FailoverThreshold property specifies the maximum number of failover attempts. | gauge | `name`
+`Flags` | Provides access to the flags set for the group. The cluster defines flags only for resources. For a description of these flags, see [CLUSCTL_RESOURCE_GET_FLAGS](https://docs.microsoft.com/en-us/previous-versions/windows/desktop/mscs/clusctl-resource-get-flags). | gauge | `name`
+`GroupType` | The Type of the resource group. | gauge | `name`
+`Priority` | Priority value of the resource group | gauge | `name`
+`ResiliencyPeriod` | The resiliency period for this group, in seconds. | gauge | `name`
+`State` | The current state of the resource group. -1: Unknown; 0: Online; 1: Offline; 2: Failed; 3: Partial Online; 4: Pending | gauge | `name`
+`UpdateDomain` | | gauge | `name`
+
+### Example metric
+_This collector does not yet have explained examples, we would appreciate your help adding them!_
+
+## Useful queries
+_This collector does not yet have any useful queries added, we would appreciate your help adding them!_
+
+## Alerting examples
+_This collector does not yet have alerting examples, we would appreciate your help adding them!_

docs/collector.process.md

@@ -43,7 +43,7 @@ Name | Description | Type | Labels
 -----|-------------|------|-------
 `windows_process_start_time` | Time of process start | gauge | `process`, `process_id`, `creating_process_id`
 `windows_process_cpu_time_total` | Returns elapsed time that all of the threads of this process used the processor to execute instructions by mode (privileged, user). An instruction is the basic unit of execution in a computer, a thread is the object that executes instructions, and a process is the object created when a program is run. Code executed to handle some hardware interrupts and trap conditions is included in this count. | counter | `process`, `process_id`, `creating_process_id`
-`windows_process_handle_count` | Total number of handles the process has open. This number is the sum of the handles currently open by each thread in the process. | gauge | `process`, `process_id`, `creating_process_id`
+`windows_process_handles` | Total number of handles the process has open. This number is the sum of the handles currently open by each thread in the process. | gauge | `process`, `process_id`, `creating_process_id`
 `windows_process_io_bytes_total` | Bytes issued to I/O operations in different modes (read, write, other). This property counts all I/O activity generated by the process to include file, network, and device I/Os. Read and write mode includes data operations; other mode includes those that do not involve data, such as control operations. | counter | `process`, `process_id`, `creating_process_id`
 `windows_process_io_operations_total` | I/O operations issued in different modes (read, write, other). This property counts all I/O activity generated by the process to include file, network, and device I/Os. Read and write mode includes data operations; other mode includes those that do not involve data, such as control operations. | counter | `process`, `process_id`, `creating_process_id`
 `windows_process_page_faults_total` | Page faults by the threads executing in this process. A page fault occurs when a thread refers to a virtual memory page that is not in its working set in main memory. This can cause the page not to be fetched from disk if it is on the standby list and hence already in main memory, or if it is in use by another process with which the page is shared. | counter | `process`, `process_id`, `creating_process_id`
@@ -51,7 +51,7 @@ Name | Description | Type | Labels
 `windows_process_pool_bytes` | Pool Bytes is the last observed number of bytes in the paged or nonpaged pool. The nonpaged pool is an area of system memory (physical memory used by the operating system) for objects that cannot be written to disk, but must remain in physical memory as long as they are allocated. The paged pool is an area of system memory (physical memory used by the operating system) for objects that can be written to disk when they are not being used. Nonpaged pool bytes is calculated differently than paged pool bytes, so it might not equal the total of paged pool bytes. | gauge | `process`, `process_id`, `creating_process_id`
 `windows_process_priority_base` | Current base priority of this process. Threads within a process can raise and lower their own base priority relative to the process base priority of the process. | gauge | `process`, `process_id`, `creating_process_id`
 `windows_process_private_bytes` | Current number of bytes this process has allocated that cannot be shared with other processes. | gauge | `process`, `process_id`, `creating_process_id`
-`windows_process_thread_count` | Number of threads currently active in this process. An instruction is the basic unit of execution in a processor, and a thread is the object that executes instructions. Every running process has at least one thread. | gauge | `process`, `process_id`, `creating_process_id`
+`windows_process_threads` | Number of threads currently active in this process. An instruction is the basic unit of execution in a processor, and a thread is the object that executes instructions. Every running process has at least one thread. | gauge | `process`, `process_id`, `creating_process_id`
 `windows_process_virtual_bytes` | Current size, in bytes, of the virtual address space that the process is using. Use of virtual address space does not necessarily imply corresponding use of either disk or main memory pages. Virtual space is finite and, by using too much, the process can limit its ability to load libraries. | gauge | `process`, `process_id`, `creating_process_id`
 `windows_process_working_set_private_bytes` | Size of the working set, in bytes, that is use for this process only and not shared nor shareable by other processes. | gauge | `process`, `process_id`, `creating_process_id`
 `windows_process_working_set_peak_bytes` | Maximum size, in bytes, of the Working Set of this process at any point in time. The Working Set is the set of memory pages touched recently by the threads in the process. If free memory in the computer is above a threshold, pages are left in the Working Set of a process even if they are not in use. When free memory falls below a threshold, pages are trimmed from Working Sets. If they are needed they will then be soft-faulted back into the Working Set before they leave main memory. | gauge | `process`, `process_id`, `creating_process_id`

docs/collector.scheduled_task.md

@@ -0,0 +1,67 @@
+# scheduled_task collector
+
+The scheduled_task collector exposes metrics about Windows Task Scheduler
+
+|||
+-|-
+Metric name prefix  | `scheduled_task`
+Data source         | OLE
+Enabled by default? | No
+
+## Flags
+
+### `--collector.scheduled_task.whitelist`
+
+If given, the path of the task needs to match the whitelist regexp in order for the corresponding metrics to be reported.
+
+### `--collector.scheduled_task.blacklist`
+
+If given, the path of the task needs to *not* match the blacklist regexp in order for the corresponding metrics to be reported.
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`windows_scheduled_task_last_result` | The result that was returned the last time the registered task was run | gauge | task
+`windows_scheduled_task_missed_runs` | The number of times the registered task missed a scheduled run | gauge | task
+`windows_scheduled_task_state` | The current state of a scheduled task | gauge | task, state
+
+For the values of the `state` label, see below.
+
+### State
+
+A task can be in the following states:
+- `disabled`
+- `queued`
+- `ready`
+- `running`
+- `unknown`
+
+
+### Example metric
+
+```
+windows_scheduled_task_last_result{task="/Microsoft/Windows/Chkdsk/SyspartRepair"} 1
+windows_scheduled_task_missed_runs{task="/Microsoft/Windows/Chkdsk/SyspartRepair"} 0
+windows_scheduled_task_state{state="disabled",task="/Microsoft/Windows/Chkdsk/SyspartRepair"} 1
+windows_scheduled_task_state{state="queued",task="/Microsoft/Windows/Chkdsk/SyspartRepair"} 0
+windows_scheduled_task_state{state="ready",task="/Microsoft/Windows/Chkdsk/SyspartRepair"} 0
+windows_scheduled_task_state{state="running",task="/Microsoft/Windows/Chkdsk/SyspartRepair"} 0
+windows_scheduled_task_state{state="unknown",task="/Microsoft/Windows/Chkdsk/SyspartRepair"} 0
+```
+
+## Useful queries
+_This collector does not yet have any useful queries added, we would appreciate your help adding them!_
+
+## Alerting examples
+**prometheus.rules**
+```yaml
+  - alert: "WindowsScheduledTaskFailure"
+    expr: "windows_scheduled_task_last_result == 0"
+    for: "1d"
+    labels:
+      severity: "high"
+    annotations:
+      summary: "Scheduled Task Failed"
+      description: "Scheduled task '{{ $labels.task }}' failed for 1 day"
+```

docs/collector.tcp.md

@@ -17,11 +17,11 @@ None
 
 Name | Description | Type | Labels
 -----|-------------|------|-------
-`windows_tcp_connection_failures` | Number of times TCP connections have made a direct transition to the CLOSED state from the SYN-SENT state or the SYN-RCVD state, plus the number of times TCP connections have made a direct transition from the SYN-RCVD state to the LISTEN state | counter | af
-`windows_tcp_connections_active` |  Number of times TCP connections have made a direct transition from the CLOSED state to the SYN-SENT state.| counter | af
+`windows_tcp_connection_failures_total` | Number of times TCP connections have made a direct transition to the CLOSED state from the SYN-SENT state or the SYN-RCVD state, plus the number of times TCP connections have made a direct transition from the SYN-RCVD state to the LISTEN state | counter | af
+`windows_tcp_connections_active_total` |  Number of times TCP connections have made a direct transition from the CLOSED state to the SYN-SENT state.| counter | af
 `windows_tcp_connections_established` | Number of TCP connections for which the current state is either ESTABLISHED or CLOSE-WAIT. | gauge | af
-`windows_tcp_connections_passive` | Number of times TCP connections have made a direct transition from the LISTEN state to the SYN-RCVD state. | counter | af
-`windows_tcp_connections_reset` | Number of times TCP connections have made a direct transition from the LISTEN state to the SYN-RCVD state. | counter | af
+`windows_tcp_connections_passive_total` | Number of times TCP connections have made a direct transition from the LISTEN state to the SYN-RCVD state. | counter | af
+`windows_tcp_connections_reset_total` | Number of times TCP connections have made a direct transition from the LISTEN state to the SYN-RCVD state. | counter | af
 `windows_tcp_segments_total` | Total segments sent or received using the TCP protocol | counter | af
 `windows_tcp_segments_received_total` | Total segments received, including those received in error. This count includes segments received on currently established connections | counter | af
 `windows_tcp_segments_retransmitted_total` | Total segments retransmitted. That is, segments transmitted that contain one or more previously transmitted bytes | counter | af

docs/collector.terminal_services.md

@@ -19,7 +19,7 @@ Name | Description | Type | Labels
 -----|-------------|------|-------
 `windows_terminal_services_local_session_count` | Number of local Terminal Services sessions. | gauge | `session`
 `windows_terminal_services_connection_broker_performance_total`* | The total number of connections handled by the Connection Brokers since the service started. | counter | `connection`
-`windows_terminal_services_handle_count` | Total number of handles currently opened by this process. This number is the sum of the handles currently opened by each thread in this process. | gauge | `session_name`
+`windows_terminal_services_handles` | Total number of handles currently opened by this process. This number is the sum of the handles currently opened by each thread in this process. | gauge | `session_name`
 `windows_terminal_services_page_fault_total` | Rate at which page faults occur in the threads executing in this process. A page fault occurs when a thread refers to a virtual memory page that is not in its working set in main memory. The page may not be retrieved from disk if it is on the standby list and therefore already in main memory. The page also may not be retrieved if it is in use by another process which shares the page. | counter | `session_name`
 `windows_terminal_services_page_file_bytes` | Current number of bytes this process has used in the paging file(s). Paging files are used to store pages of memory used by the process that are not contained in other files. Paging files are shared by all processes, and lack of space in paging files can prevent other processes from allocating memory. | gauge | `session_name`
 `windows_terminal_services_page_file_bytes_peak` | Maximum number of bytes this process has used in the paging file(s). Paging files are used to store pages of memory used by the process that are not contained in other files. Paging files are shared by all processes, and lack of space in paging files can prevent other processes from allocating memory. | gauge | `session_name`
@@ -29,7 +29,7 @@ Name | Description | Type | Labels
 `windows_terminal_services_pool_non_paged_bytes` | Number of bytes in the non-paged pool, an area of system memory (physical memory used by the operating system) for objects that cannot be written to disk, but must remain in physical memory as long as they are allocated. This property displays the last observed value only; it is not an average. | gauge | `session_name`
 `windows_terminal_services_pool_paged_bytes` | Number of bytes in the paged pool, an area of system memory (physical memory used by the operating system) for objects that can be written to disk when they are not being used. This property displays the last observed value only; it is not an average. | gauge | `session_name`
 `windows_terminal_services_private_bytes` | Current number of bytes this process has allocated that cannot be shared with other processes. | gauge | `session_name`
-`windows_terminal_services_thread_count` | Number of threads currently active in this process. An instruction is the basic unit of execution in a processor, and a thread is the object that executes instructions. Every running process has at least one thread. | gauge | `session_name`
+`windows_terminal_services_threads` | Number of threads currently active in this process. An instruction is the basic unit of execution in a processor, and a thread is the object that executes instructions. Every running process has at least one thread. | gauge | `session_name`
 `windows_terminal_services_virtual_bytes` | Current size, in bytes, of the virtual address space the process is using. Use of virtual address space does not necessarily imply corresponding use of either disk or main memory pages. Virtual space is finite and, by using too much, the process can limit its ability to load libraries. | gauge | `session_name`
 `windows_terminal_services_virtual_bytes_peak` | Maximum number of bytes of virtual address space the process has used at any one time. Use of virtual address space does not necessarily imply corresponding use of either disk or main memory pages. Virtual space is finite and, by using too much, the process might limit its ability to load libraries. | gauge | `session_name`
 `windows_terminal_services_working_set_bytes` | Current number of bytes in the working set of this process. The working set is the set of memory pages touched recently by the threads in the process. If free memory in the computer is above a threshold, pages are left in the working set of a process even if they are not in use. When free memory falls below a threshold, pages are trimmed from working sets. If they are needed, they are then soft-faulted back into the working set before they leave main memory. | gauge | `session_name`

docs/collector.time.md

@@ -21,7 +21,7 @@ Name | Description | Type | Labels
 -----|-------------|------|-------
 `windows_time_clock_frequency_Adjustment_ppb_total` | Total adjustment made to the local system clock frequency by W32Time in parts per billion (PPB) units. 1 PPB adjustment implies the system clock was adjusted at a rate of 1 nanosecond per second (1 ns/s). The smallest possible adjustment can vary and is expected to be in the order of 100's of PPB. | counter | None
 `windows_time_computed_time_offset_seconds` | Absolute time offset between the system clock and the chosen time source, in seconds. | counter | None
-`windows_time_ntp_client_time_source_count` | Active number of NTP Time sources being used by the client. This is a count of active, distinct IP addresses of time servers that are responding to this client's requests. | gauge | None
+`windows_time_ntp_client_time_sources` | Active number of NTP Time sources being used by the client. This is a count of active, distinct IP addresses of time servers that are responding to this client's requests. | gauge | None
 `windows_time_ntp_round_trip_delay_seconds` | Total roundtrip delay experienced by the NTP client in receiving a response from the server for the most recent request, in seconds. This is the time elapsed on the NTP client between transmitting a request to the NTP server and receiving a valid response from the server. | gauge | None
 `windows_time_ntp_server_outgoing_responses_total` | Total number of requests responded to by the NTP server. | counter | None
 `windows_time_ntp_server_incoming_requests_total` | Total number of requests received by the NTP server. | counter | None

docs/example_config.yml

@@ -5,6 +5,8 @@ collectors:
 collector:
   service:
     services-where: Name='windows_exporter'
+  scheduled_task:
+    blacklist: /Microsoft/.+
 log:
   level: debug
 scrape:

exporter.go

@@ -9,6 +9,7 @@ import (
 	"net/http"
 	_ "net/http/pprof"
 	"os"
+	"os/user"
 	"sort"
 	"strconv"
 	"strings"
@@ -22,6 +23,7 @@ import (
 	"github.com/prometheus-community/windows_exporter/config"
 	"github.com/prometheus-community/windows_exporter/log"
 	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/collectors"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 	"github.com/prometheus/common/version"
 	"github.com/prometheus/exporter-toolkit/web"
@@ -345,6 +347,16 @@ func main() {
 		log.Fatalf("Couldn't load collectors: %s", err)
 	}
 
+	u, err := user.Current()
+	if err != nil {
+		log.Fatalf(err.Error())
+	}
+
+	log.Infof("Running as %v", u.Username)
+	if strings.Contains(u.Username, "ContainerAdministrator") || strings.Contains(u.Username, "ContainerUser") {
+		log.Warnf("Running as a preconfigured Windows Container user. This may mean you do not have Windows HostProcess containers configured correctly and some functionality will not work as expected.")
+	}
+
 	log.Infof("Enabled collectors: %v", strings.Join(keys(collectors), ", "))
 
 	h := &metricsHandler{
@@ -509,8 +521,8 @@ func (mh *metricsHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	}
 	reg.MustRegister(wc)
 	reg.MustRegister(
-		prometheus.NewProcessCollector(prometheus.ProcessCollectorOpts{}),
-		prometheus.NewGoCollector(),
+		collectors.NewProcessCollector(collectors.ProcessCollectorOpts{}),
+		collectors.NewGoCollector(),
 		version.NewCollector("windows_exporter"),
 	)
 

go.mod

@@ -3,18 +3,18 @@ module github.com/prometheus-community/windows_exporter
 go 1.13
 
 require (
-	github.com/Microsoft/hcsshim v0.9.1
+	github.com/Microsoft/hcsshim v0.9.3
 	github.com/StackExchange/wmi v0.0.0-20180725035823-b12b22c5341f
 	github.com/dimchansky/utfbom v1.1.1
-	github.com/go-kit/log v0.2.0
-	github.com/go-ole/go-ole v1.2.1 // indirect
+	github.com/go-kit/log v0.2.1
+	github.com/go-ole/go-ole v1.2.6
 	github.com/leoluk/perflib_exporter v0.1.1-0.20211204221052-9e3696429c20
-	github.com/prometheus/client_golang v1.11.0
+	github.com/prometheus/client_golang v1.12.2
 	github.com/prometheus/client_model v0.2.0
-	github.com/prometheus/common v0.32.1
+	github.com/prometheus/common v0.37.0
 	github.com/prometheus/exporter-toolkit v0.7.1
 	github.com/sirupsen/logrus v1.8.1
-	golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1
+	golang.org/x/sys v0.0.0-20220114195835-da31bd327af9
 	gopkg.in/alecthomas/kingpin.v2 v2.2.6
 	gopkg.in/yaml.v2 v2.4.0
 )

go.sum

@@ -63,8 +63,8 @@ github.com/Microsoft/hcsshim v0.8.14/go.mod h1:NtVKoYxQuTLx6gEq0L96c9Ju4JbRJ4nY2
 github.com/Microsoft/hcsshim v0.8.15/go.mod h1:x38A4YbHbdxJtc0sF6oIz+RG0npwSCAvn69iY6URG00=
 github.com/Microsoft/hcsshim v0.8.16/go.mod h1:o5/SZqmR7x9JNKsW3pu+nqHm0MF8vbA+VxGOoXdC600=
 github.com/Microsoft/hcsshim v0.8.21/go.mod h1:+w2gRZ5ReXQhFOrvSQeNfhrYB/dg3oDwTOcER2fw4I4=
-github.com/Microsoft/hcsshim v0.9.1 h1:VfDCj+QnY19ktX5TsH22JHcjaZ05RWQiwDbOyEg5ziM=
-github.com/Microsoft/hcsshim v0.9.1/go.mod h1:Y/0uV2jUab5kBI7SQgl62at0AVX7uaruzADAVmxm3eM=
+github.com/Microsoft/hcsshim v0.9.3 h1:k371PzBuRrz2b+ebGuI2nVgVhgsVX60jMfSw80NECxo=
+github.com/Microsoft/hcsshim v0.9.3/go.mod h1:7pLA8lDk46WKDWlVsENo92gC0XFa8rbKfyFRBqxEbCc=
 github.com/Microsoft/hcsshim/test v0.0.0-20201218223536-d3e5debf77da/go.mod h1:5hlzMzRKMLyo42nCZ9oml8AdTlq/0cvIaBv6tK1RehU=
 github.com/Microsoft/hcsshim/test v0.0.0-20210227013316-43a75bb4edd3/go.mod h1:mw7qgWloBUl75W/gVH3cQszUg1+gUITj7D6NY7ywVnY=
 github.com/NYTimes/gziphandler v0.0.0-20170623195520-56545f4a5d46/go.mod h1:3wb06e3pkSAbeQ52E9H9iFoQsEEwGN64994WTCIhntQ=
@@ -108,8 +108,9 @@ github.com/cenkalti/backoff/v4 v4.1.1/go.mod h1:scbssz8iZGpm3xbr14ovlUdkxfGXNInq
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
 github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko=
 github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
-github.com/cespare/xxhash/v2 v2.1.1 h1:6MnRN8NT7+YBpUIWxHtefFZOKTAPgGjpQSxqLNn0+qY=
 github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cespare/xxhash/v2 v2.1.2 h1:YRXhKfTDauu4ajMg1TPgFO5jnlC2HCbmLXMcTG5cbYE=
+github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/checkpoint-restore/go-criu/v4 v4.1.0/go.mod h1:xUQBLp4RLc5zJtWY++yjOoMoB5lihDt7fai+75m+rGw=
 github.com/checkpoint-restore/go-criu/v5 v5.0.0/go.mod h1:cfwC0EG7HMUenopBsUf9d89JlCLQIfgVcNsNN0t6T2M=
 github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
@@ -287,8 +288,9 @@ github.com/go-ini/ini v1.25.4/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3I
 github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
-github.com/go-kit/log v0.2.0 h1:7i2K3eKTos3Vc0enKCfnVcgHh2olr/MyfboYq7cAcFw=
 github.com/go-kit/log v0.2.0/go.mod h1:NwTd00d/i8cPZ3xOwwiv2PO5MOcx78fFErGNcVmBjv0=
+github.com/go-kit/log v0.2.1 h1:MRVx0/zhvdseW+Gza6N9rVzU/IVzaeE1SFI4raAhmBU=
+github.com/go-kit/log v0.2.1/go.mod h1:NwTd00d/i8cPZ3xOwwiv2PO5MOcx78fFErGNcVmBjv0=
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
 github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
@@ -296,8 +298,8 @@ github.com/go-logfmt/logfmt v0.5.1 h1:otpy5pqBCBZ1ng9RQ0dPu4PN7ba75Y/aA+UpowDyNV
 github.com/go-logfmt/logfmt v0.5.1/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs=
 github.com/go-logr/logr v0.1.0/go.mod h1:ixOQHD9gLJUVQQ2ZOR7zLEifBX6tGkNJF4QyIY7sIas=
 github.com/go-logr/logr v0.2.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTgseGU=
-github.com/go-ole/go-ole v1.2.1 h1:2lOsA72HgjxAuMlKpFiCbHTvu44PIVkZ5hqm3RSdI/E=
-github.com/go-ole/go-ole v1.2.1/go.mod h1:7FAglXiTm7HKlQRDeOQ6ZNUHidzCWXuZWq/1dTyBNF8=
+github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY=
+github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
 github.com/go-openapi/jsonpointer v0.0.0-20160704185906-46af16f9f7b1/go.mod h1:+35s3my2LFTysnkMfxsJBAMHj/DoqoB9knIWoYG/Vk0=
 github.com/go-openapi/jsonpointer v0.19.2/go.mod h1:3akKfEdA7DF1sugOqz1dVQHBcuDBPKZGEoHC/NkiQRg=
 github.com/go-openapi/jsonpointer v0.19.3/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg=
@@ -353,8 +355,9 @@ github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvq
 github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
 github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
-github.com/golang/protobuf v1.5.0 h1:LUVKkCeviFUMKqHa4tXIIij/lbhnMbP7Fn5wKdKkRh4=
 github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
+github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
@@ -429,6 +432,7 @@ github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCV
 github.com/json-iterator/go v1.1.7/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
 github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
 github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
@@ -484,6 +488,7 @@ github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJ
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
 github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc=
 github.com/mrunalp/fileutils v0.5.0/go.mod h1:M1WthSahJixYnrXQl/DFQuteStB1weuxD2QJNHXfbSQ=
 github.com/munnerz/goautoneg v0.0.0-20120707110453-a547fc61f48d/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
@@ -554,8 +559,10 @@ github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDf
 github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
 github.com/prometheus/client_golang v1.1.0/go.mod h1:I1FGZT9+L76gKKOs5djB6ezCbFQP1xR9D75/vuwEF3g=
 github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
-github.com/prometheus/client_golang v1.11.0 h1:HNkLOAEQMIDv/K+04rukrLx6ch7msSRwf3/SASFAGtQ=
 github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0=
+github.com/prometheus/client_golang v1.12.1/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY=
+github.com/prometheus/client_golang v1.12.2 h1:51L9cDoUHVrXx4zWYlcLQIZ+d+VXHgqnYKkIuq4g/34=
+github.com/prometheus/client_golang v1.12.2/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY=
 github.com/prometheus/client_model v0.0.0-20171117100541-99fa1f4be8e5/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
@@ -571,8 +578,9 @@ github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB8
 github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc=
 github.com/prometheus/common v0.29.0/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls=
 github.com/prometheus/common v0.31.1/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls=
-github.com/prometheus/common v0.32.1 h1:hWIdL3N2HoUx3B8j3YN9mWor0qhY/NlEKZEaXxuIRh4=
 github.com/prometheus/common v0.32.1/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls=
+github.com/prometheus/common v0.37.0 h1:ccBbHCgIiT9uSoFY0vX8H3zsNR5eLt17/RQLUvn8pXE=
+github.com/prometheus/common v0.37.0/go.mod h1:phzohg0JFMnBEFGxTDbfu3QyL5GI8gTQJFhYO5B3mfA=
 github.com/prometheus/exporter-toolkit v0.7.1 h1:c6RXaK8xBVercEeUQ4tRNL8UGWzDHfvj9dseo1FcK1Y=
 github.com/prometheus/exporter-toolkit v0.7.1/go.mod h1:ZUBIj498ePooX9t/2xtDjeQYwvRpiPP2lh5u4iblj2g=
 github.com/prometheus/procfs v0.0.0-20180125133057-cb4147076ac7/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
@@ -585,8 +593,9 @@ github.com/prometheus/procfs v0.0.5/go.mod h1:4A/X28fw3Fc593LaREMrKMqOKvUAntwMDa
 github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
 github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
 github.com/prometheus/procfs v0.2.0/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
-github.com/prometheus/procfs v0.6.0 h1:mxy4L2jP6qMonqmq+aTtOx1ifVWUgG/TAmntgbh3xv4=
 github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
+github.com/prometheus/procfs v0.7.3 h1:4jVXhlkAyzOScmCkXBTOLRLTz8EeU+eyjrwB/EPq0VU=
+github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
 github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
 github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
 github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
@@ -773,15 +782,18 @@ golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
 golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20210825183410-e898025ed96a h1:bRuuGXV8wwSdGTB+CtJf+FjgO1APK1CoO39T4BN/XBw=
 golang.org/x/net v0.0.0-20210825183410-e898025ed96a/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
+golang.org/x/net v0.0.0-20220225172249-27dd8689420f h1:oA4XRj0qtSt8Yo1Zms0CUlsT3KG69V2UGQWPBxujDmc=
+golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c h1:pkQiBZBvdos9qq4wBAHqlzuZHEXo07pqV06ef90u1WI=
 golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/oauth2 v0.0.0-20220223155221-ee480838109b h1:clP8eMhB30EHdc0bd2Twtq6kgU7yl5ub2cQLSdrv1Dg=
+golang.org/x/oauth2 v0.0.0-20220223155221-ee480838109b/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc=
 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-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -866,17 +878,21 @@ golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210426230700-d19ff857e887/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1 h1:SrN+KX8Art/Sf4HNj6Zcz06G7VEz+7w9tdXTPOZ7+l4=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220114195835-da31bd327af9 h1:XfKQ4OlFl8okEOr5UvAqFRVj8pY/4yfcXrddB8qAbU0=
+golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.6 h1:aRYxNxv6iGQlyVaZmk6ZgYEDa+Jg18DxebPSrd6bg1M=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=

installer/windows_exporter.wxs

@@ -25,7 +25,7 @@
     <Property Id="LISTEN_ADDR" Secure="yes" />
     <Property Id="LISTEN_PORT" Secure="yes" />
     <SetProperty Id="ListenFlagBoth" After="InstallFiles" Sequence="execute" Value="--telemetry.addr [LISTEN_ADDR]:[LISTEN_PORT]">LISTEN_ADDR AND LISTEN_PORT</SetProperty>
-    <SetProperty Id="ListenFlagAddr" After="InstallFiles" Sequence="execute" Value="--telemetry.addr [LISTEN_ADDR]:">LISTEN_ADDR AND (NOT LISTEN_PORT)</SetProperty>
+    <SetProperty Id="ListenFlagAddr" After="InstallFiles" Sequence="execute" Value="--telemetry.addr [LISTEN_ADDR]:9182">LISTEN_ADDR AND (NOT LISTEN_PORT)</SetProperty>
     <SetProperty Id="ListenFlagPort" After="InstallFiles" Sequence="execute" Value="--telemetry.addr 0.0.0.0:[LISTEN_PORT]">LISTEN_PORT AND (NOT LISTEN_ADDR)</SetProperty>
 
     <Property Id="METRICS_PATH" Secure="yes"/>

kubernetes/kubernetes.md

@@ -0,0 +1,92 @@
+# windows_exporter on Kubernetes
+
+With Kubernetes supporting HostProcess containers on Windows nodes (as of [v1.22](https://kubernetes.io/blog/2021/08/16/windows-hostprocess-containers/), it is useful to run the `windows_exporter` as a container on Windows to export metrics for your Prometheus implementation.  Read the [Kubernetes HostProcess documentation](https://kubernetes.io/docs/tasks/configure-pod-container/create-hostprocess-pod/) for more information.
+
+Requirements:
+
+- Kubernetes 1.22+
+- containerd 1.6 Beta+
+- WindowsHostProcessContainers feature-gate turned on for `kube-apiserver` and `kubelet`
+
+> IMPORTANT: This does not work unless you are specifically targeting Host Process Containers with Containerd (Docker doesn't have support).  The image will build but will **not** be able to access the host.
+
+## Container Image
+
+The image is multi arch image (WS 2019, WS 2022) built on Windows. To build the images:
+
+```
+DOCKER_REPO=<your repo> make push-all
+```
+
+If you don't have a version of `make` on your Windows machine, You can use WSL to build the image with Windows Containers by creating a symbolic link to the docker cli and then override the docker command in the `Makefile`: 
+
+On Windows Powershell prompt:
+```
+New-Item -ItemType SymbolicLink -Path "c:\docker" -Target "C:\Program Files\Docker\Docker\resources\bin\docker.exe"
+```
+
+In WSL:
+```
+DOCKER_REPO=<your repo> DOCKER=/mnt/c/docker make push-all 
+```
+
+## Kubernetes Quick Start
+
+Before beginning you need to deploy the [prometheus operator](https://github.com/prometheus-operator/prometheus-operator) to your cluster. As a quick start, you can use a project like https://github.com/prometheus-operator/kube-prometheus. The export itself doesn't have any dependency on prometheus operator and the exporter image can be used in manual configurations.
+
+### Windows Exporter DaemonSet
+
+This create a deployment on every node. A config map is created for to handle the configuration of the Windows exporter with [configuration file](../README.md#using-a-configuration-file).  Adjust the configuration file for the collectors you are interested in.
+
+```bash
+kubectl apply -f kubernetes/windows-exporter-daemonset.yaml
+```
+
+> Note: This example manifest deploys the latest bleeding edge image `ghcr.io/prometheus-community/windows-exporter:latest` built from the main branch.  You should update this to use a released version which you can find at https://github.com/prometheus-community/windows_exporter/releases
+
+#### Configuring the firewall
+The firewall on the node needs to be configured  to allow connections on the node: `New-NetFirewallRule -DisplayName 'windows-exporter' -Direction inbound -Profile Any -Action Allow -LocalPort 9182 -Protocol TCP` 
+
+You could do this by adding an init container but if you remove the deployment at a later date you will need to remove the firewall rule manually. The following could be added to the `windows-exporter-daemonset.yaml`:
+
+```
+apiVersion: apps/v1
+kind: DaemonSet
+spec:
+  template:
+    spec:
+      initContainers:
+        - name: configure-firewall
+          image: mcr.microsoft.com/windows/powershell:lts-nanoserver-1809
+          command: ["powershell"]
+          args: ["New-NetFirewallRule", "-DisplayName", "'windows-exporter'", "-Direction", "inbound", "-Profile", "Any", "-Action", "Allow", "-LocalPort", "9182", "-Protocol", "TCP"]
+```
+
+### Prometheus PodMonitor
+
+Create the [Pod Monitor](https://prometheus-operator.dev/docs/operator/design/#podmonitor) to configure the scraping:
+
+```bash
+kubectl apply -f windows-exporter-podmonitor.yaml
+```
+
+### View Metrics
+
+Open Prometheus with 
+
+```
+kubectl --namespace monitoring port-forward svc/prometheus-k8s 9091:9090
+```
+
+Navigate to prometheus UI and add a query to see node cpu (replacing with your ip address)
+
+```
+sum by (mode) (irate(windows_cpu_time_total{instance="10.1.0.5:9182"}[5m]))
+```
+
+![windows cpu total time graph in prometheus ui](https://user-images.githubusercontent.com/648372/140547130-b535c766-6479-47d3-b2d3-cd8a551647df.png)
+
+
+## Configuring TLS
+
+It is possible to configure TLS of the solution using `--web.config.file`.  Read more at https://github.com/prometheus/exporter-toolkit/blob/master/docs/web-configuration.md

kubernetes/windows-exporter-daemonset.yaml

@@ -0,0 +1,61 @@
+apiVersion: apps/v1
+kind: DaemonSet
+metadata:
+  labels:
+    app: windows-exporter
+  name: windows-exporter
+  namespace: monitoring
+spec:
+  selector:
+    matchLabels:
+      app: windows-exporter
+  template:
+    metadata:
+      labels:
+        app: windows-exporter
+    spec:
+      securityContext:
+        windowsOptions:
+          hostProcess: true
+          runAsUserName: "NT AUTHORITY\\system"
+      hostNetwork: true
+      initContainers:
+        - name: configure-firewall
+          image: mcr.microsoft.com/windows/nanoserver:1809
+          command: ["powershell"]
+          args: ["New-NetFirewallRule", "-DisplayName", "'windows-exporter'", "-Direction", "inbound", "-Profile", "Any", "-Action", "Allow", "-LocalPort", "9182", "-Protocol", "TCP"]
+      containers:
+      - args: 
+        - --config.file=%CONTAINER_SANDBOX_MOUNT_POINT%/config.yml
+        name: windows-exporter
+        image: ghcr.io/prometheus-community/windows-exporter:latest
+        imagePullPolicy: Always
+        ports:
+        - containerPort: 9182
+          hostPort: 9182
+          name: http
+        volumeMounts:
+        - name:  windows-exporter-config
+          mountPath: /config.yml
+          subPath: config.yml
+      nodeSelector:
+        kubernetes.io/os: windows
+      volumes:
+      - name: windows-exporter-config
+        configMap:
+          name: windows-exporter-config
+---
+kind: ConfigMap
+apiVersion: v1
+metadata:
+  name: windows-exporter-config
+  namespace: monitoring
+  labels:
+    app: windows-exporter
+data:
+  config.yml: |
+    collectors:
+      enabled: '[defaults],container'
+    collector:
+      service:
+        services-where: "Name='containerd' or Name='kubelet'"

kubernetes/windows-exporter-podmonitor.yaml

@@ -0,0 +1,15 @@
+apiVersion: monitoring.coreos.com/v1
+kind: PodMonitor
+metadata:
+  labels:
+    app: windows-exporter
+  name: windows-exporter
+  namespace: monitoring
+spec:
+  jobLabel: windows-exporter
+  selector:
+    matchLabels:
+      app: windows-exporter
+  podMetricsEndpoints:
+  - port: http
+    scheme: http

tools/collector-generator/New-Collector.ps1

@@ -2,19 +2,21 @@ Param(
     [Parameter(Mandatory=$true)]
     $Class,
     [Parameter(Mandatory=$false)]
+    $Namespace = "root/cimv2",   
+    [Parameter(Mandatory=$false)]
     $CollectorName = ($Class -replace 'Win32_PerfRawData_Perf',''),
     [Parameter(Mandatory=$false)]
     $ComputerName = "localhost",
     [Parameter(Mandatory=$false)]
-    $Credential
+    [CimSession] $Session
 )
 $ErrorActionPreference = "Stop"
 
-if($Credential -ne $null) {
-    $wmiObject = Get-CimInstance -ComputerName $ComputerName -Credential $Credential -Class $Class
+if($null -ne $Session) {
+    $wmiObject = Get-CimInstance -CimSession $Session -Namespace $Namespace -Class $Class
 }
 else {
-    $wmiObject = Get-CimInstance -ComputerName $ComputerName -Class $Class
+    $wmiObject = Get-CimInstance -ComputerName $ComputerName -Namespace $Namespace -Class $Class
 }
 
 $members = $wmiObject `
@@ -22,6 +24,7 @@ $members = $wmiObject `
     | Where-Object { $_.Definition -Match '^u?int' -and $_.Name -NotMatch '_' } `
     | Select-Object Name, @{Name="Type";Expression={$_.Definition.Split(" ")[0]}}
 $input = @{
+    "Namespace"=$Namespace;
     "Class"=$Class;
     "CollectorName"=$CollectorName;
     "Members"=$members

tools/e2e-output.txt

@@ -12,8 +12,6 @@
 # TYPE go_memstats_buck_hash_sys_bytes gauge
 # HELP go_memstats_frees_total Total number of frees.
 # TYPE go_memstats_frees_total counter
-# HELP go_memstats_gc_cpu_fraction The fraction of this program's available CPU time used by the GC since the program started.
-# TYPE go_memstats_gc_cpu_fraction gauge
 # HELP go_memstats_gc_sys_bytes Number of bytes used for garbage collection system metadata.
 # TYPE go_memstats_gc_sys_bytes gauge
 # HELP go_memstats_heap_alloc_bytes Number of heap bytes allocated and still in use.
@@ -85,7 +83,7 @@ test_alpha_total 42
 # TYPE windows_cpu_parking_status gauge
 # HELP windows_cpu_processor_performance Processor Performance is the average performance of the processor while it is executing instructions, as a percentage of the nominal performance of the processor. On some processors, Processor Performance may exceed 100%
 # TYPE windows_cpu_processor_performance gauge
-# HELP windows_cpu_time_total Time that processor spent in different modes (idle, user, system, ...)
+# HELP windows_cpu_time_total Time that processor spent in different modes (dpc, idle, interrupt, privileged, user)
 # TYPE windows_cpu_time_total counter
 # HELP windows_cs_hostname Labeled system hostname information as provided by ComputerSystem.DNSHostName and ComputerSystem.Domain
 # TYPE windows_cs_hostname gauge

tools/end-to-end-test.ps1

@@ -24,19 +24,27 @@ $skip_re = "^(go_|windows_exporter_build_info|windows_exporter_collector_duratio
 # Use default collectors, port and address: http://localhost:9182/metrics
 $exporter_proc = Start-Process `
     -PassThru `
-    -FilePath .\windows_exporter.exe `
+    -FilePath ..\windows_exporter.exe `
     -ArgumentList "--log.level=debug --collector.textfile.directory=$($textfile_dir)" `
     -WindowStyle Hidden `
     -RedirectStandardOutput "$($temp_dir)/windows_exporter.log" `
     -RedirectStandardError "$($temp_dir)/windows_exporter_error.log"
 
-# Give exporter some time to start
-Start-Sleep 3
+# Exporter can take some time to start
+for ($i=1; $i -le 5; $i++) {
+    Start-Sleep 10
+
+    $netstat_output = netstat -anp tcp | Select-String 'listening'
+    if ($netstat_output -like '*:9182*') {
+            break
+    }
+    Write-Host "Waiting for exporter to start"
+}
 
 $response = Invoke-WebRequest -UseBasicParsing -URI http://127.0.0.1:9182/metrics
 # Response output must be split and saved as UTF-8.
 $response.content -split "[`r`n]"| Select-String -NotMatch $skip_re | Set-Content -Encoding utf8 "$($temp_dir)/e2e-output.txt"
-Stop-Process $exporter_proc
+Stop-Process -Id $exporter_proc.Id
 $output_diff = Compare-Object (Get-Content 'e2e-output.txt') (Get-Content "$($temp_dir)/e2e-output.txt")
 
 # Fail if differences in output are detected

tools/promtool.ps1

@@ -0,0 +1,124 @@
+$ErrorActionPreference = 'Stop'
+Set-StrictMode -Version 3
+
+if (-not (Test-Path -Path '.\windows_exporter.exe')) {
+    Write-Output ".\windows_exporter.exe not found. Consider running \`go build\` first"
+}
+
+# Powershell pipes & Get-Content command rather unhelpfully add a carriage return at the end of the string, so
+# passing the string as bytes is a messy but necessary workaround for processes that are sensitive to
+# line endings, like promtool.
+function Start-RawProcess {
+    param(
+        # String to pass to $CommandName via STDIN
+        [Parameter(Mandatory=$true)][String]$InputVar,
+        # Command to run
+        [Parameter(Mandatory=$true)][String]$CommandName,
+        # Arguments provided to $CommandName
+        [Parameter(Mandatory=$false)][String[]]$CommandArgs
+    )
+    # Buffer & initial size of MemoryStream
+    $BufferSize = 4096
+
+    # Convert text to bytes and write to MemoryStream
+    [byte[]]$InputBytes = [Text.Encoding]::UTF8.GetBytes($InputVar)
+    $MemStream = New-Object -TypeName System.IO.MemoryStream -ArgumentList $BufferSize
+    $MemStream.Write($InputBytes, 0, $InputBytes.Length)
+    [Void]$MemStream.Seek(0, 'Begin')
+
+    # Setup stdin\stdout redirection for our process
+    if ($CommandArgs) {
+        $StartInfo = New-Object -TypeName System.Diagnostics.ProcessStartInfo -Property @{
+            FileName = $CommandName
+            UseShellExecute = $false
+            RedirectStandardInput = $true
+            RedirectStandardError = $true
+            Arguments = $CommandArgs
+        }
+    } else {
+        $StartInfo = New-Object -TypeName System.Diagnostics.ProcessStartInfo -Property @{
+            FileName = $CommandName
+            UseShellExecute = $false
+            RedirectStandardInput = $true
+            RedirectStandardError = $true
+        }
+    }
+
+    # Create new process
+    $Process = New-Object -TypeName System.Diagnostics.Process
+
+    # Assign previously created StartInfo properties
+    $Process.StartInfo = $StartInfo
+    # Start process
+    [void]$Process.Start()
+
+    # Pipe data
+    $Buffer = New-Object -TypeName byte[] -ArgumentList $BufferSize
+    $StdinStream = $Process.StandardInput.BaseStream
+
+    try {
+        do {
+            $ReadCount = $MemStream.Read($Buffer, 0, $Buffer.Length)
+            $StdinStream.Write($Buffer, 0, $ReadCount)
+            $StdinStream.Flush()
+        }
+        while($ReadCount -gt 0)
+    }
+    catch
+    {
+       throw 'Error streaming buffer to STDIN'
+    } finally {
+        # Close streams
+        $StdinStream.Close()
+        $MemStream.Close()
+    }
+    $Process.WaitForExit()
+    if ($Process.ExitCode -ne 0) {
+        Write-Host $Process.StandardError.ReadToEnd()
+    }
+
+    return $Process.ExitCode
+}
+
+# cd to location of script
+$script_path = $MyInvocation.MyCommand.Path
+$working_dir = Split-Path $script_path
+Push-Location $working_dir
+
+$temp_dir = Join-Path $env:TEMP $(New-Guid) | ForEach-Object { mkdir $_ }
+
+# Start process in background, awaiting HTTP requests.
+# Listen on 9183/TCP, preventing conflicts with 9182/TCP used by end-to-end-test.ps1
+# Not an issue when run individually, but will cause failures when run concurrently in CI.
+$exporter_proc = Start-Process `
+    -PassThru `
+    -FilePath ..\windows_exporter.exe `
+    -ArgumentList '--telemetry.addr="127.0.0.1:9183" --log.level=debug' `
+    -WindowStyle Hidden `
+    -RedirectStandardOutput "$($temp_dir)/windows_exporter.log" `
+    -RedirectStandardError "$($temp_dir)/windows_exporter_error.log"
+
+# Exporter can take some time to start
+for ($i=1; $i -le 5; $i++) {
+    Start-Sleep 10
+
+    $netstat_output = netstat -anp tcp | Select-String 'listening'
+    if ($netstat_output -like '*:9183*') {
+            break
+    }
+    Write-Host "Waiting for exporter to start"
+}
+
+# Omit metrics from client_golang library; we're not responsible for these
+$skip_re = "^[#]?\s*(HELP|TYPE)?\s*go_"
+
+# Need to remove carriage returns, as promtool expects LF line endings
+$output = ((Invoke-WebRequest -UseBasicParsing -URI http://127.0.0.1:9183/metrics).Content) -Split "`r?`n" | Select-String -NotMatch $skip_re | Join-String -Separator "`n"
+# Join the split lines back to a single String (with LF line endings!)
+$output = $output -Join "`n"
+Stop-Process -Id $exporter_proc.Id
+$ExitCode = Start-RawProcess -InputVar $output -CommandName promtool.exe -CommandArgs @("check metrics")
+if ($ExitCode -ne 0) {
+    Write-Host "Promtool command returned exit code $($ExitCode). See output for details."
+    EXIT 1
+}