Merge pull request #394 from martinlindhe/fix-cgo-build-tag

Remove cgo build tag from container collector

.gitignore

@@ -2,3 +2,6 @@
 VERSION
 *.swp
 *.un~
+output/
+.vscode
+.idea

.promu.yml

@@ -12,3 +12,7 @@ build:
 tarball:
     files:
         - LICENSE
+crossbuild:
+    platforms:
+        - windows/amd64
+        - windows/386

Gopkg.lock

@@ -2,124 +2,174 @@
 
 
 [[projects]]
+  digest = "1:3ccf8ba7afe02fd470c4f07d6eea4d0e6875da3d129f95b925f2003ce5dd2024"
   name = "github.com/StackExchange/wmi"
   packages = ["."]
+  pruneopts = "NUT"
   revision = "5d049714c4a64225c3c79a7cf7d02f7fb5b96338"
   version = "1.0.0"
 
 [[projects]]
   branch = "master"
+  digest = "1:f3793f8a708522400cef1dba23385e901aede5519f68971fd69938ef330b07a1"
   name = "github.com/alecthomas/template"
   packages = [
     ".",
-    "parse"
+    "parse",
   ]
+  pruneopts = "NUT"
   revision = "a0175ee3bccc567396460bf5acd36800cb10c49c"
 
 [[projects]]
   branch = "master"
+  digest = "1:fdd419e104ec26bb5bd63cc62637c640453ed2929a7453f3afadbd9a0223da66"
   name = "github.com/alecthomas/units"
   packages = ["."]
+  pruneopts = "NUT"
   revision = "2efee857e7cfd4f3d0138cc3cbb1b4966962b93a"
 
 [[projects]]
   branch = "master"
+  digest = "1:cb0535f5823b47df7dcb9768ebb6c000b79ad115472910c70efe93c9ed9b2315"
   name = "github.com/beorn7/perks"
   packages = ["quantile"]
+  pruneopts = "NUT"
   revision = "4c0e84591b9aa9e6dcfdf3e020114cd81f89d5f9"
 
 [[projects]]
+  digest = "1:f9adc21a937e5da643ea14a3488cb7506788876737a5e205394e508627a6eec8"
+  name = "github.com/dimchansky/utfbom"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "d2133a1ce379ef6fa992b0514a77146c60db9d1c"
+  version = "v1.1.0"
+
+[[projects]]
+  digest = "1:cb4e216bd9f58866f42dc65893455b24f879b026fdaa1ecc3aafff625fdb5a66"
   name = "github.com/go-ole/go-ole"
   packages = [
     ".",
-    "oleutil"
+    "oleutil",
   ]
+  pruneopts = "NUT"
   revision = "a41e3c4b706f6ae8dfbff342b06e40fa4d2d0506"
   version = "v1.2.1"
 
 [[projects]]
+  digest = "1:9f35c1344b56e5868d511d231f215edd0650aa572664f856444affdd256e43e4"
   name = "github.com/golang/protobuf"
   packages = ["proto"]
+  pruneopts = "NUT"
   revision = "925541529c1fa6821df4e44ce2723319eb2be768"
   version = "v1.0.0"
 
 [[projects]]
+  digest = "1:5985ef4caf91ece5d54817c11ea25f182697534f8ae6521eadcd628c142ac4b6"
   name = "github.com/matttproud/golang_protobuf_extensions"
   packages = ["pbutil"]
+  pruneopts = "NUT"
   revision = "3247c84500bff8d9fb6d579d800f20b3e091582c"
   version = "v1.0.0"
 
 [[projects]]
+  digest = "1:03bca087b180bf24c4f9060775f137775550a0834e18f0bca0520a868679dbd7"
   name = "github.com/prometheus/client_golang"
   packages = [
     "prometheus",
-    "prometheus/promhttp"
+    "prometheus/promhttp",
   ]
+  pruneopts = "NUT"
   revision = "c5b7fccd204277076155f10851dad72b76a49317"
   version = "v0.8.0"
 
 [[projects]]
   branch = "master"
+  digest = "1:32d10bdfa8f09ecf13598324dba86ab891f11db3c538b6a34d1c3b5b99d7c36b"
   name = "github.com/prometheus/client_model"
   packages = ["go"]
+  pruneopts = "NUT"
   revision = "99fa1f4be8e564e8a6b613da7fa6f46c9edafc6c"
 
 [[projects]]
   branch = "master"
+  digest = "1:ce98e83b2b9486b6a9ce5e44fd4097c64e8f2f0eaa6c5041a8f12d3aaa5c17b3"
   name = "github.com/prometheus/common"
   packages = [
     "expfmt",
     "internal/bitbucket.org/ww/goautoneg",
     "log",
     "model",
-    "version"
+    "version",
   ]
+  pruneopts = "NUT"
   revision = "e4aa40a9169a88835b849a6efb71e05dc04b88f0"
 
 [[projects]]
   branch = "master"
+  digest = "1:61a95e8d3e39e94207fba1b56d3c2182a356a1e41017aa647f523ae964b6bb0c"
   name = "github.com/prometheus/procfs"
   packages = [
     ".",
     "internal/util",
     "nfs",
-    "xfs"
+    "xfs",
   ]
+  pruneopts = "NUT"
   revision = "54d17b57dd7d4a3aa092476596b3f8a933bde349"
 
 [[projects]]
+  digest = "1:6989062eb7ccf25cf38bf4fe3dba097ee209f896cda42cefdca3927047bef7b6"
   name = "github.com/sirupsen/logrus"
   packages = ["."]
+  pruneopts = "NUT"
   revision = "c155da19408a8799da419ed3eeb0cb5db0ad5dbc"
   version = "v1.0.5"
 
 [[projects]]
   branch = "master"
+  digest = "1:3f3a05ae0b95893d90b9b3b5afdb79a9b3d96e4e36e099d841ae602e4aca0da8"
   name = "golang.org/x/crypto"
   packages = ["ssh/terminal"]
+  pruneopts = "NUT"
   revision = "182114d582623c1caa54f73de9c7224e23a48487"
 
 [[projects]]
   branch = "master"
+  digest = "1:ea69008276e11262595a1f9a279ffd51d93e21c32c13b0f81856e962c6f607dd"
   name = "golang.org/x/sys"
   packages = [
     "unix",
     "windows",
     "windows/registry",
     "windows/svc",
-    "windows/svc/eventlog"
+    "windows/svc/eventlog",
   ]
+  pruneopts = "NUT"
   revision = "8c0ece68c28377f4c326d85b94f8df0dace46f80"
 
 [[projects]]
+  digest = "1:22b2dee6f30bc8601f087449a2a819df8388e54e9547349c658f14d8f8c590f2"
   name = "gopkg.in/alecthomas/kingpin.v2"
   packages = ["."]
+  pruneopts = "NUT"
   revision = "947dcec5ba9c011838740e680966fd7087a71d0d"
   version = "v2.2.6"
 
 [solve-meta]
   analyzer-name = "dep"
   analyzer-version = 1
-  inputs-digest = "01d9c528210a99a08cc65af3a40d23a31df0c00193639751917ea1adb7d1ee1c"
+  input-imports = [
+    "github.com/StackExchange/wmi",
+    "github.com/dimchansky/utfbom",
+    "github.com/prometheus/client_golang/prometheus",
+    "github.com/prometheus/client_golang/prometheus/promhttp",
+    "github.com/prometheus/client_model/go",
+    "github.com/prometheus/common/expfmt",
+    "github.com/prometheus/common/log",
+    "github.com/prometheus/common/version",
+    "golang.org/x/sys/windows/registry",
+    "golang.org/x/sys/windows/svc",
+    "gopkg.in/alecthomas/kingpin.v2",
+  ]
   solver-name = "gps-cdcl"
   solver-version = 1

Makefile

@@ -1,5 +1,19 @@
-fmt:
-	gofmt -l -w -s .
+export GOOS=windows
 
 build:
 	promu build -v
+
+test:
+	go test -v ./...
+
+lint:
+	gometalinter --vendor --config gometalinter.config ./...
+
+fmt:
+	gofmt -l -w -s .
+
+crossbuild:
+	# The prometheus/golang-builder image for promu crossbuild doesn't exist
+	# on Windows, so for now, we'll just build twice
+	GOARCH=amd64 promu build --prefix=output/amd64
+	GOARCH=386   promu build --prefix=output/386

README.md

@@ -9,25 +9,37 @@ Prometheus exporter for Windows machines, using the WMI (Windows Management Inst
 
 Name     | Description | Enabled by default
 ---------|-------------|--------------------
-ad | [Win32_PerfRawData_DirectoryServices_DirectoryServices](https://msdn.microsoft.com/en-us/library/ms803980.aspx) Active Directory |
-cpu | [Win32_PerfRawData_PerfOS_Processor](https://msdn.microsoft.com/en-us/library/aa394317(v=vs.90).aspx) metrics (cpu usage) | ✓
-cs | [Win32_ComputerSystem](https://msdn.microsoft.com/en-us/library/aa394102) metrics (system properties, num cpus/total memory) | ✓
-dns | [Win32_PerfRawData_DNS_DNS](https://technet.microsoft.com/en-us/library/cc977686.aspx) metrics (DNS Server) |
-hyperv | Performance counters for Hyper-V hosts |
-iis | [Win32_PerfRawData_W3SVC_WebService](https://msdn.microsoft.com/en-us/library/aa394345) IIS metrics |
-logical_disk | [Win32_PerfRawData_PerfDisk_LogicalDisk](https://msdn.microsoft.com/en-us/windows/hardware/aa394307(v=vs.71)) metrics (disk I/O) | ✓
-net | [Win32_PerfRawData_Tcpip_NetworkInterface](https://technet.microsoft.com/en-us/security/aa394340(v=vs.80)) metrics (network interface I/O) | ✓
-msmq | [Win32_PerfRawData_MSMQ_MSMQQueue](http://wutils.com/wmi/root/cimv2/win32_perfrawdata_msmq_msmqqueue/) metrics (MSMQ/journal count) |
-mssql | various [SQL Server Performance Objects](https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/use-sql-server-objects#SQLServerPOs) metrics  |
-os | [Win32_OperatingSystem](https://msdn.microsoft.com/en-us/library/aa394239) metrics (memory, processes, users) | ✓
-process | [Win32_PerfRawData_PerfProc_Process](https://msdn.microsoft.com/en-us/library/aa394323(v=vs.85).aspx) metrics (per-process stats) |
-service | [Win32_Service](https://msdn.microsoft.com/en-us/library/aa394418(v=vs.85).aspx) metrics (service states) | ✓
-system | Win32_PerfRawData_PerfOS_System metrics (system calls) | ✓
-tcp | [Win32_PerfRawData_Tcpip_TCPv4](https://msdn.microsoft.com/en-us/library/aa394341(v=vs.85).aspx) metrics (tcp connections) |
-textfile | Read prometheus metrics from a text file | ✓
-vmware | Performance counters installed by the Vmware Guest agent |
+[ad](docs/collector.ad.md) | Active Directory Domain Services |
+[cpu](docs/collector.cpu.md) | CPU usage | ✓
+[cs](docs/collector.cs.md) | "Computer System" metrics (system properties, num cpus/total memory) | ✓
+[container](docs/collector.container.md) | Container metrics |
+[dns](docs/collector.dns.md) | DNS Server |
+[hyperv](docs/collector.hyperv.md) | Hyper-V hosts |
+[iis](docs/collector.iis.md) | IIS sites and applications |
+[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 |
+[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 |
+[netframework_clrinterop](docs/collector.netframework_clrinterop.md) | .NET Framework Interop Metrics |
+[netframework_clrjit](docs/collector.netframework_clrjit.md) | .NET Framework JIT metrics |
+[netframework_clrloading](docs/collector.netframework_clrloading.md) | .NET Framework CLR Loading metrics |
+[netframework_clrlocksandthreads](docs/collector.netframework_clrlocksandthreads.md) | .NET Framework locks and metrics threads |
+[netframework_clrmemory](docs/collector.netframework_clrmemory.md) |  .NET Framework Memory metrics |
+[netframework_clrremoting](docs/collector.netframework_clrremoting.md) | .NET Framework Remoting metrics |
+[netframework_clrsecurity](docs/collector.netframework_clrsecurity.md) | .NET Framework Security Check metrics |
+[net](docs/collector.net.md) | Network interface I/O | ✓
+[os](docs/collector.os.md) | OS metrics (memory, processes, users) | ✓
+[process](docs/collector.process.md) | Per-process metrics |
+[service](docs/collector.service.md) | Service state metrics | ✓
+[system](docs/collector.system.md) | System calls | ✓
+[tcp](docs/collector.tcp.md) | TCP connections |
+[thermalzone](docs/collector.thermalzone.md) | Thermal information
+[textfile](docs/collector.textfile.md) | Read prometheus metrics from a text file | ✓
+[vmware](docs/collector.vmware.md) | Performance counters installed by the Vmware Guest agent |
 
-The HELP texts shows the WMI data source, please see MSDN documentation for details.
+See the linked documentation on each collector for more information on reported metrics, configuration settings and usage examples.
 
 ## Installation
 The latest release can be downloaded from the [releases page](https://github.com/martinlindhe/wmi_exporter/releases).
@@ -43,13 +55,19 @@ Name | Description
 `LISTEN_PORT` | The port to bind to. Defaults to 9182.
 `METRICS_PATH` | The path at which to serve metrics. Defaults to `/metrics`
 `TEXTFILE_DIR` | As the `--collector.textfile.directory` flag, provide a directory to read text files with metrics from
+`EXTRA_FLAGS` | Allows passing full CLI flags. Defaults to an empty string.
 
-Parameters are sent to the installer via `msiexec`. Example invocation:
+Parameters are sent to the installer via `msiexec`. Example invocations:
 
 ```powershell
 msiexec /i <path-to-msi-file> ENABLED_COLLECTORS=os,iis LISTEN_PORT=5000
 ```
 
+Example service collector with a custom query.
+```powershell
+msiexec /i <path-to-msi-file> ENABLED_COLLECTORS=os,service --% EXTRA_FLAGS="--collector.service.services-where ""Name LIKE 'sql%'"""
+```
+
 ## Roadmap
 
 See [open issues](https://github.com/martinlindhe/wmi_exporter/issues)
@@ -76,7 +94,10 @@ The prometheus metrics will be exposed on [localhost:9182](http://localhost:9182
 
     .\wmi_exporter.exe --collectors.enabled "process" --collector.process.processes-where "Name LIKE 'firefox%'"
 
-When there are multiple processes with the same name, WMI represents those after the first instance as `process-name#index`. So to get them all, rather than just the first one, the query needs to be a wildcard search.
+When there are multiple processes with the same name, WMI represents those after the first instance as `process-name#index`. So to get them all, rather than just the first one, the query needs to be a wildcard search using a `%` character.
+
+Please note that in Windows batch scripts (and when using the `cmd` command prompt), the `%` character is reserved, so it has to be escaped with another `%`. For example, the wildcard syntax for searching for all firefox processes is `firefox%%`.
+
 
 ## License
 

appveyor.yml

@@ -1,51 +1,66 @@
-version: "{build}"
-
-os: Windows Server 2012 R2
-
-environment:
-  GOPATH: c:\gopath
-  matrix:
-    - MSI_ARCH: amd64
-      GOARCH: amd64
-    - MSI_ARCH: 386
-      GOARCH: 386
-
-clone_folder: c:\gopath\src\github.com\martinlindhe\wmi_exporter
-
-install:
-  - go version
-  - set PATH=%GOPATH%\bin;c:\go\bin;%GOPATH%\bin\windows_%GOARCH%;%PATH%
-  - go get -u github.com/prometheus/promu
-  - choco install gitversion.portable -y
-
-build_script:
-  - ps: gitversion /output json /showvariable FullSemVer | Set-Content VERSION -PassThru
-  - go test -v ./...
-  - promu build -v
-  - ps: |
-      $ErrorActionPreference = "Stop"
-      if($env:APPVEYOR_REPO_TAG -eq "True") {
-        # The MSI version is not semver compliant, so just take the numerical parts
-        $Version = $env:APPVEYOR_REPO_TAG_NAME -replace '^v?([0-9\.]+).*$','$1'
-        Write-Verbose "Setting msi version to $Version"
-        .\installer\build.ps1 -PathToExecutable .\wmi_exporter.exe -Version $Version -Arch "$env:MSI_ARCH"
-        Push-AppveyorArtifact installer\Output\wmi_exporter-$Version-$env:MSI_ARCH.msi -DeploymentName Installer
-      }
-
-after_build:
-  - 7z a wmi_exporter-%MSI_ARCH%.zip wmi_exporter.exe
-
-artifacts:
-  - name: Executable
-    path: 'wmi_exporter-*.zip'
-
-deploy:
-  - provider: GitHub
-    description: WMI Exporter version $(appveyor_build_version)
-    artifact: Executable,Installer
-    auth_token:
-      secure: 'CrXWeTf7qONUOEki5olFfGEUPMLDeHj61koDXV3OVEaLgtACmnVHsKUub9POflda'
-    draft: false
-    prerelease: false
-    on:
-      appveyor_repo_tag: true
+version: "{build}"
+
+os: Visual Studio 2017
+build: off
+stack: go 1.10
+
+environment:
+  GOPATH: c:\gopath
+
+clone_folder: c:\gopath\src\github.com\martinlindhe\wmi_exporter
+
+install:
+  - set PATH=%GOPATH%\bin;%PATH%
+  - set PATH=%PATH%;C:\mingw-w64\x86_64-7.2.0-posix-seh-rt_v5-rev1\mingw64\bin
+  - go get -u github.com/prometheus/promu
+  - go get -u github.com/alecthomas/gometalinter && gometalinter --install
+  - choco install gitversion.portable make -y
+
+test_script:
+  - make test
+
+after_test:
+  - make lint
+
+build_script:
+  - ps: |
+      $ErrorActionPreference = "Stop"
+      gitversion /output json /showvariable FullSemVer | Set-Content VERSION -PassThru
+      $Version = Get-Content VERSION
+      make crossbuild
+      # GH requires all files to have different names, so add version/arch to differentiate
+      foreach($Arch in "amd64","386") {
+        Rename-Item output\$Arch\wmi_exporter.exe -NewName wmi_exporter-$Version-$Arch.exe
+      }
+
+after_build:
+  - ps: |
+      # Build installer packages only on tagged releases
+      if($env:APPVEYOR_REPO_TAG -ne "True") {
+        return
+      }
+      $ErrorActionPreference = "Stop"
+      $BuildVersion = Get-Content VERSION
+      # The MSI version is not semver compliant, so just take the numerical parts
+      $MSIVersion = $env:APPVEYOR_REPO_TAG_NAME -replace '^v?([0-9\.]+).*$','$1'
+      foreach($Arch in "amd64","386") {
+        Write-Verbose "Building wmi_exporter $MSIVersion msi for $Arch"
+        .\installer\build.ps1 -PathToExecutable .\output\$Arch\wmi_exporter-$BuildVersion-$Arch.exe -Version $MSIVersion -Arch "$Arch"
+        Move-Item installer\Output\wmi_exporter-$MSIVersion-$Arch.msi output\$Arch\
+      }
+  - promu checksum output\
+
+artifacts:
+  - name: Artifacts
+    path: output\**\*
+
+deploy:
+  - provider: GitHub
+    description: WMI Exporter version $(appveyor_build_version)
+    artifact: Artifacts
+    auth_token:
+      secure: 'CrXWeTf7qONUOEki5olFfGEUPMLDeHj61koDXV3OVEaLgtACmnVHsKUub9POflda'
+    draft: false
+    prerelease: false
+    on:
+      appveyor_repo_tag: true

collector/ad.go

@@ -1,5 +1,5 @@
-// returns data points from Win32_PerfRawData_DirectoryServices_DirectoryServices
-// Partial docs: https://msdn.microsoft.com/en-us/library/ms803980.aspx
+// +build windows
+
 package collector
 
 import (
@@ -454,7 +454,7 @@ func NewADCollector() (Collector, error) {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *ADCollector) Collect(ch chan<- prometheus.Metric) error {
+func (c *ADCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
 	if desc, err := c.collect(ch); err != nil {
 		log.Error("failed collecting ad metrics:", desc, err)
 		return err
@@ -462,6 +462,8 @@ func (c *ADCollector) Collect(ch chan<- prometheus.Metric) error {
 	return nil
 }
 
+// Win32_PerfRawData_DirectoryServices_DirectoryServices docs:
+// - https://msdn.microsoft.com/en-us/library/ms803980.aspx
 type Win32_PerfRawData_DirectoryServices_DirectoryServices struct {
 	Name string
 
@@ -485,8 +487,8 @@ type Win32_PerfRawData_DirectoryServices_DirectoryServices struct {
 	DatabasemodifysPersec                                            uint32
 	DatabaserecyclesPersec                                           uint32
 	DigestBindsPersec                                                uint32
-	DRAHighestUSNCommittedHighpart                                   uint32
-	DRAHighestUSNCommittedLowpart                                    uint32
+	DRAHighestUSNCommittedHighpart                                   uint64
+	DRAHighestUSNCommittedLowpart                                    uint64
 	DRAHighestUSNIssuedHighpart                                      uint64
 	DRAHighestUSNIssuedLowpart                                       uint64
 	DRAInboundBytesCompressedBetweenSitesAfterCompressionPersec      uint32

collector/collector.go

@@ -0,0 +1,71 @@
+package collector
+
+import (
+	"strconv"
+
+	"github.com/leoluk/perflib_exporter/perflib"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/common/log"
+	"golang.org/x/sys/windows/registry"
+)
+
+// ...
+const (
+	// TODO: Make package-local
+	Namespace = "wmi"
+
+	// Conversion factors
+	ticksToSecondsScaleFactor = 1 / 1e7
+	windowsEpoch              = 116444736000000000
+)
+
+// getWindowsVersion reads the version number of the OS from the Registry
+// See https://docs.microsoft.com/en-us/windows/desktop/sysinfo/operating-system-version
+func getWindowsVersion() float64 {
+	k, err := registry.OpenKey(registry.LOCAL_MACHINE, `SOFTWARE\Microsoft\Windows NT\CurrentVersion`, registry.QUERY_VALUE)
+	if err != nil {
+		log.Warn("Couldn't open registry", err)
+		return 0
+	}
+	defer func() {
+		err = k.Close()
+		if err != nil {
+			log.Warnf("Failed to close registry key: %v", err)
+		}
+	}()
+
+	currentv, _, err := k.GetStringValue("CurrentVersion")
+	if err != nil {
+		log.Warn("Couldn't open registry to determine current Windows version:", err)
+		return 0
+	}
+
+	currentv_flt, err := strconv.ParseFloat(currentv, 64)
+
+	log.Debugf("Detected Windows version %f\n", currentv_flt)
+
+	return currentv_flt
+}
+
+// Factories ...
+var Factories = make(map[string]func() (Collector, error))
+
+// Collector is the interface a collector has to implement.
+type Collector interface {
+	// Get new metrics and expose them via prometheus registry.
+	Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) (err error)
+}
+
+type ScrapeContext struct {
+	perfObjects map[string]*perflib.PerfObject
+}
+
+// PrepareScrapeContext creates a ScrapeContext to be used during a single scrape
+func PrepareScrapeContext() (*ScrapeContext, error) {
+	objs, err := getPerflibSnapshot()
+	if err != nil {
+		return nil, err
+	}
+
+	return &ScrapeContext{objs}, nil
+}

collector/container.go

@@ -0,0 +1,282 @@
+// +build windows
+
+package collector
+
+import (
+	"github.com/Microsoft/hcsshim"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/common/log"
+)
+
+func init() {
+	Factories["container"] = NewContainerMetricsCollector
+}
+
+// A ContainerMetricsCollector is a Prometheus collector for containers metrics
+type ContainerMetricsCollector struct {
+	// Presence
+	ContainerAvailable *prometheus.Desc
+
+	// Number of containers
+	ContainersCount *prometheus.Desc
+	// memory
+	UsageCommitBytes            *prometheus.Desc
+	UsageCommitPeakBytes        *prometheus.Desc
+	UsagePrivateWorkingSetBytes *prometheus.Desc
+
+	// CPU
+	RuntimeTotal  *prometheus.Desc
+	RuntimeUser   *prometheus.Desc
+	RuntimeKernel *prometheus.Desc
+
+	// Network
+	BytesReceived          *prometheus.Desc
+	BytesSent              *prometheus.Desc
+	PacketsReceived        *prometheus.Desc
+	PacketsSent            *prometheus.Desc
+	DroppedPacketsIncoming *prometheus.Desc
+	DroppedPacketsOutgoing *prometheus.Desc
+}
+
+// NewContainerMetricsCollector constructs a new ContainerMetricsCollector
+func NewContainerMetricsCollector() (Collector, error) {
+	const subsystem = "container"
+	return &ContainerMetricsCollector{
+		ContainerAvailable: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "available"),
+			"Available",
+			[]string{"container_id"},
+			nil,
+		),
+		ContainersCount: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "count"),
+			"Number of containers",
+			nil,
+			nil,
+		),
+		UsageCommitBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "memory_usage_commit_bytes"),
+			"Memory Usage Commit Bytes",
+			[]string{"container_id"},
+			nil,
+		),
+		UsageCommitPeakBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "memory_usage_commit_peak_bytes"),
+			"Memory Usage Commit Peak Bytes",
+			[]string{"container_id"},
+			nil,
+		),
+		UsagePrivateWorkingSetBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "memory_usage_private_working_set_bytes"),
+			"Memory Usage Private Working Set Bytes",
+			[]string{"container_id"},
+			nil,
+		),
+		RuntimeTotal: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "cpu_usage_seconds_total"),
+			"Total Run time in Seconds",
+			[]string{"container_id"},
+			nil,
+		),
+		RuntimeUser: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "cpu_usage_seconds_usermode"),
+			"Run Time in User mode in Seconds",
+			[]string{"container_id"},
+			nil,
+		),
+		RuntimeKernel: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "cpu_usage_seconds_kernelmode"),
+			"Run time in Kernel mode in Seconds",
+			[]string{"container_id"},
+			nil,
+		),
+		BytesReceived: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "network_receive_bytes_total"),
+			"Bytes Received on Interface",
+			[]string{"container_id", "interface"},
+			nil,
+		),
+		BytesSent: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "network_transmit_bytes_total"),
+			"Bytes Sent on Interface",
+			[]string{"container_id", "interface"},
+			nil,
+		),
+		PacketsReceived: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "network_receive_packets_total"),
+			"Packets Received on Interface",
+			[]string{"container_id", "interface"},
+			nil,
+		),
+		PacketsSent: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "network_transmit_packets_total"),
+			"Packets Sent on Interface",
+			[]string{"container_id", "interface"},
+			nil,
+		),
+		DroppedPacketsIncoming: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "network_receive_packets_dropped_total"),
+			"Dropped Incoming Packets on Interface",
+			[]string{"container_id", "interface"},
+			nil,
+		),
+		DroppedPacketsOutgoing: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "network_transmit_packets_dropped_total"),
+			"Dropped Outgoing Packets on Interface",
+			[]string{"container_id", "interface"},
+			nil,
+		),
+	}, nil
+}
+
+// Collect sends the metric values for each metric
+// to the provided prometheus Metric channel.
+func (c *ContainerMetricsCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
+	if desc, err := c.collect(ch); err != nil {
+		log.Error("failed collecting ContainerMetricsCollector metrics:", desc, err)
+		return err
+	}
+	return nil
+}
+
+// containerClose closes the container resource
+func containerClose(c hcsshim.Container) {
+	err := c.Close()
+	if err != nil {
+		log.Error(err)
+	}
+}
+
+func (c *ContainerMetricsCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
+
+	// Types Container is passed to get the containers compute systems only
+	containers, err := hcsshim.GetContainers(hcsshim.ComputeSystemQuery{Types: []string{"Container"}})
+	if err != nil {
+		log.Error("Err in Getting containers:", err)
+		return nil, err
+	}
+
+	count := len(containers)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.ContainersCount,
+		prometheus.GaugeValue,
+		float64(count),
+	)
+	if count == 0 {
+		return nil, nil
+	}
+
+	for _, containerDetails := range containers {
+		containerId := containerDetails.ID
+
+		container, err := hcsshim.OpenContainer(containerId)
+		if container != nil {
+			defer containerClose(container)
+		}
+		if err != nil {
+			log.Error("err in opening container: ", containerId, err)
+			continue
+		}
+
+		cstats, err := container.Statistics()
+		if err != nil {
+			log.Error("err in fetching container Statistics: ", containerId, err)
+			continue
+		}
+		// HCS V1 is for docker runtime. Add the docker:// prefix on container_id
+		containerId = "docker://" + containerId
+
+		ch <- prometheus.MustNewConstMetric(
+			c.ContainerAvailable,
+			prometheus.CounterValue,
+			1,
+			containerId,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.UsageCommitBytes,
+			prometheus.GaugeValue,
+			float64(cstats.Memory.UsageCommitBytes),
+			containerId,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.UsageCommitPeakBytes,
+			prometheus.GaugeValue,
+			float64(cstats.Memory.UsageCommitPeakBytes),
+			containerId,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.UsagePrivateWorkingSetBytes,
+			prometheus.GaugeValue,
+			float64(cstats.Memory.UsagePrivateWorkingSetBytes),
+			containerId,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.RuntimeTotal,
+			prometheus.CounterValue,
+			float64(cstats.Processor.TotalRuntime100ns)*ticksToSecondsScaleFactor,
+			containerId,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.RuntimeUser,
+			prometheus.CounterValue,
+			float64(cstats.Processor.RuntimeUser100ns)*ticksToSecondsScaleFactor,
+			containerId,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.RuntimeKernel,
+			prometheus.CounterValue,
+			float64(cstats.Processor.RuntimeKernel100ns)*ticksToSecondsScaleFactor,
+			containerId,
+		)
+
+		if len(cstats.Network) == 0 {
+			log.Info("No Network Stats for container: ", containerId)
+			continue
+		}
+
+		networkStats := cstats.Network
+
+		for _, networkInterface := range networkStats {
+			ch <- prometheus.MustNewConstMetric(
+				c.BytesReceived,
+				prometheus.CounterValue,
+				float64(networkInterface.BytesReceived),
+				containerId, networkInterface.EndpointId,
+			)
+			ch <- prometheus.MustNewConstMetric(
+				c.BytesSent,
+				prometheus.CounterValue,
+				float64(networkInterface.BytesSent),
+				containerId, networkInterface.EndpointId,
+			)
+			ch <- prometheus.MustNewConstMetric(
+				c.PacketsReceived,
+				prometheus.CounterValue,
+				float64(networkInterface.PacketsReceived),
+				containerId, networkInterface.EndpointId,
+			)
+			ch <- prometheus.MustNewConstMetric(
+				c.PacketsSent,
+				prometheus.CounterValue,
+				float64(networkInterface.PacketsSent),
+				containerId, networkInterface.EndpointId,
+			)
+			ch <- prometheus.MustNewConstMetric(
+				c.DroppedPacketsIncoming,
+				prometheus.CounterValue,
+				float64(networkInterface.DroppedPacketsIncoming),
+				containerId, networkInterface.EndpointId,
+			)
+			ch <- prometheus.MustNewConstMetric(
+				c.DroppedPacketsOutgoing,
+				prometheus.CounterValue,
+				float64(networkInterface.DroppedPacketsOutgoing),
+				containerId, networkInterface.EndpointId,
+			)
+			break
+		}
+	}
+
+	return nil, nil
+}

collector/cpu.go

@@ -1,30 +1,77 @@
-// returns data points from Win32_PerfRawData_PerfOS_Processor
-// https://msdn.microsoft.com/en-us/library/aa394317(v=vs.90).aspx - Win32_PerfRawData_PerfOS_Processor class
+// +build windows
+
 package collector
 
 import (
 	"strings"
 
-	"github.com/StackExchange/wmi"
 	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/common/log"
 )
 
 func init() {
-	Factories["cpu"] = NewCPUCollector
+	Factories["cpu"] = newCPUCollector
 }
 
-// A CPUCollector is a Prometheus collector for WMI Win32_PerfRawData_PerfOS_Processor metrics
-type CPUCollector struct {
+type cpuCollectorBasic struct {
 	CStateSecondsTotal *prometheus.Desc
 	TimeTotal          *prometheus.Desc
 	InterruptsTotal    *prometheus.Desc
 	DPCsTotal          *prometheus.Desc
 }
+type cpuCollectorFull struct {
+	CStateSecondsTotal       *prometheus.Desc
+	TimeTotal                *prometheus.Desc
+	InterruptsTotal          *prometheus.Desc
+	DPCsTotal                *prometheus.Desc
+	ClockInterruptsTotal     *prometheus.Desc
+	IdleBreakEventsTotal     *prometheus.Desc
+	ParkingStatus            *prometheus.Desc
+	ProcessorFrequencyMHz    *prometheus.Desc
+	ProcessorMaxFrequencyMHz *prometheus.Desc
+	ProcessorPerformance     *prometheus.Desc
+}
 
-func NewCPUCollector() (Collector, error) {
+// newCPUCollector constructs a new cpuCollector, appropriate for the running OS
+func newCPUCollector() (Collector, error) {
 	const subsystem = "cpu"
-	return &CPUCollector{
+
+	version := getWindowsVersion()
+	// For Windows 2008 (version 6.0) or earlier we only have the "Processor"
+	// class. As of Windows 2008 R2 (version 6.1) the more detailed
+	// "ProcessorInformation" set is available (although some of the counters
+	// are added in later versions, so we aren't guaranteed to get all of
+	// them).
+	// Value 6.05 was selected to split between Windows versions.
+	if version < 6.05 {
+		return &cpuCollectorBasic{
+			CStateSecondsTotal: prometheus.NewDesc(
+				prometheus.BuildFQName(Namespace, subsystem, "cstate_seconds_total"),
+				"Time spent in low-power idle state",
+				[]string{"core", "state"},
+				nil,
+			),
+			TimeTotal: prometheus.NewDesc(
+				prometheus.BuildFQName(Namespace, subsystem, "time_total"),
+				"Time that processor spent in different modes (idle, user, system, ...)",
+				[]string{"core", "mode"},
+				nil,
+			),
+			InterruptsTotal: prometheus.NewDesc(
+				prometheus.BuildFQName(Namespace, subsystem, "interrupts_total"),
+				"Total number of received and serviced hardware interrupts",
+				[]string{"core"},
+				nil,
+			),
+			DPCsTotal: prometheus.NewDesc(
+				prometheus.BuildFQName(Namespace, subsystem, "dpcs_total"),
+				"Total number of received and serviced deferred procedure calls (DPCs)",
+				[]string{"core"},
+				nil,
+			),
+		}, nil
+	}
+
+	return &cpuCollectorFull{
 		CStateSecondsTotal: prometheus.NewDesc(
 			prometheus.BuildFQName(Namespace, subsystem, "cstate_seconds_total"),
 			"Time spent in low-power idle state",
@@ -37,7 +84,6 @@ func NewCPUCollector() (Collector, error) {
 			[]string{"core", "mode"},
 			nil,
 		),
-
 		InterruptsTotal: prometheus.NewDesc(
 			prometheus.BuildFQName(Namespace, subsystem, "interrupts_total"),
 			"Total number of received and serviced hardware interrupts",
@@ -50,162 +96,273 @@ func NewCPUCollector() (Collector, error) {
 			[]string{"core"},
 			nil,
 		),
+		ClockInterruptsTotal: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "clock_interrupts_total"),
+			"Total number of received and serviced clock tick interrupts",
+			[]string{"core"},
+			nil,
+		),
+		IdleBreakEventsTotal: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "idle_break_events_total"),
+			"Total number of time processor was woken from idle",
+			[]string{"core"},
+			nil,
+		),
+		ParkingStatus: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "parking_status"),
+			"Parking Status represents whether a processor is parked or not",
+			[]string{"core"},
+			nil,
+		),
+		ProcessorFrequencyMHz: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "core_frequency_mhz"),
+			"Core frequency in megahertz",
+			[]string{"core"},
+			nil,
+		),
+		ProcessorPerformance: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "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%",
+			[]string{"core"},
+			nil,
+		),
 	}, nil
 }
 
-// Collect sends the metric values for each metric
-// to the provided prometheus Metric channel.
-func (c *CPUCollector) Collect(ch chan<- prometheus.Metric) error {
-	if desc, err := c.collect(ch); err != nil {
-		log.Error("failed collecting cpu metrics:", desc, err)
+type perflibProcessor struct {
+	Name                  string
+	C1Transitions         float64 `perflib:"C1 Transitions/sec"`
+	C2Transitions         float64 `perflib:"C2 Transitions/sec"`
+	C3Transitions         float64 `perflib:"C3 Transitions/sec"`
+	DPCRate               float64 `perflib:"DPC Rate"`
+	DPCsQueued            float64 `perflib:"DPCs Queued/sec"`
+	Interrupts            float64 `perflib:"Interrupts/sec"`
+	PercentC2Time         float64 `perflib:"% C1 Time"`
+	PercentC3Time         float64 `perflib:"% C2 Time"`
+	PercentC1Time         float64 `perflib:"% C3 Time"`
+	PercentDPCTime        float64 `perflib:"% DPC Time"`
+	PercentIdleTime       float64 `perflib:"% Idle Time"`
+	PercentInterruptTime  float64 `perflib:"% Interrupt Time"`
+	PercentPrivilegedTime float64 `perflib:"% Privileged Time"`
+	PercentProcessorTime  float64 `perflib:"% Processor Time"`
+	PercentUserTime       float64 `perflib:"% User Time"`
+}
+
+func (c *cpuCollectorBasic) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
+	data := make([]perflibProcessor, 0)
+	err := unmarshalObject(ctx.perfObjects["Processor"], &data)
+	if err != nil {
 		return err
 	}
-	return nil
-}
 
-type Win32_PerfRawData_PerfOS_Processor struct {
-	Name                  string
-	C1TransitionsPersec   uint64
-	C2TransitionsPersec   uint64
-	C3TransitionsPersec   uint64
-	DPCRate               uint32
-	DPCsQueuedPersec      uint32
-	InterruptsPersec      uint32
-	PercentC1Time         uint64
-	PercentC2Time         uint64
-	PercentC3Time         uint64
-	PercentDPCTime        uint64
-	PercentIdleTime       uint64
-	PercentInterruptTime  uint64
-	PercentPrivilegedTime uint64
-	PercentProcessorTime  uint64
-	PercentUserTime       uint64
-}
-
-/* NOTE: This is an alternative class, but it is not as widely available. Decide which to use
-type Win32_PerfRawData_Counters_ProcessorInformation struct {
-	Name                        string
-	AverageIdleTime             uint64
-	C1TransitionsPersec         uint64
-	C2TransitionsPersec         uint64
-	C3TransitionsPersec         uint64
-	ClockInterruptsPersec       uint64
-	DPCRate                     uint64
-	DPCsQueuedPersec            uint64
-	IdleBreakEventsPersec       uint64
-	InterruptsPersec            uint64
-	ParkingStatus               uint64
-	PercentC1Time               uint64
-	PercentC2Time               uint64
-	PercentC3Time               uint64
-	PercentDPCTime              uint64
-	PercentIdleTime             uint64
-	PercentInterruptTime        uint64
-	PercentofMaximumFrequency   uint64
-	PercentPerformanceLimit     uint64
-	PercentPriorityTime         uint64
-	PercentPrivilegedTime       uint64
-	PercentPrivilegedUtility    uint64
-	PercentProcessorPerformance uint64
-	PercentProcessorTime        uint64
-	PercentProcessorUtility     uint64
-	PercentUserTime             uint64
-	PerformanceLimitFlags       uint64
-	ProcessorFrequency          uint64
-	ProcessorStateFlags         uint64
-}*/
-
-func (c *CPUCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
-	var dst []Win32_PerfRawData_PerfOS_Processor
-	q := queryAll(&dst)
-	if err := wmi.Query(q, &dst); err != nil {
-		return nil, err
-	}
-
-	for _, data := range dst {
-		if strings.Contains(data.Name, "_Total") {
+	for _, cpu := range data {
+		if strings.Contains(strings.ToLower(cpu.Name), "_total") {
 			continue
 		}
-
-		core := data.Name
-
-		// These are only available from Win32_PerfRawData_Counters_ProcessorInformation, which is only available from Win2008R2+
-		/*ch <- prometheus.MustNewConstMetric(
-			c.ProcessorFrequency,
-			prometheus.GaugeValue,
-			float64(data.ProcessorFrequency),
-			socket, core,
-		)
-		ch <- prometheus.MustNewConstMetric(
-			c.MaximumFrequency,
-			prometheus.GaugeValue,
-			float64(data.PercentofMaximumFrequency)/100*float64(data.ProcessorFrequency),
-			socket, core,
-		)*/
+		core := cpu.Name
 
 		ch <- prometheus.MustNewConstMetric(
 			c.CStateSecondsTotal,
-			prometheus.GaugeValue,
-			float64(data.PercentC1Time)*ticksToSecondsScaleFactor,
+			prometheus.CounterValue,
+			cpu.PercentC1Time,
 			core, "c1",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.CStateSecondsTotal,
-			prometheus.GaugeValue,
-			float64(data.PercentC2Time)*ticksToSecondsScaleFactor,
+			prometheus.CounterValue,
+			cpu.PercentC2Time,
 			core, "c2",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.CStateSecondsTotal,
-			prometheus.GaugeValue,
-			float64(data.PercentC3Time)*ticksToSecondsScaleFactor,
+			prometheus.CounterValue,
+			cpu.PercentC3Time,
 			core, "c3",
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.TimeTotal,
-			prometheus.GaugeValue,
-			float64(data.PercentIdleTime)*ticksToSecondsScaleFactor,
+			prometheus.CounterValue,
+			cpu.PercentIdleTime,
 			core, "idle",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.TimeTotal,
-			prometheus.GaugeValue,
-			float64(data.PercentInterruptTime)*ticksToSecondsScaleFactor,
+			prometheus.CounterValue,
+			cpu.PercentInterruptTime,
 			core, "interrupt",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.TimeTotal,
-			prometheus.GaugeValue,
-			float64(data.PercentDPCTime)*ticksToSecondsScaleFactor,
+			prometheus.CounterValue,
+			cpu.PercentDPCTime,
 			core, "dpc",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.TimeTotal,
-			prometheus.GaugeValue,
-			float64(data.PercentPrivilegedTime)*ticksToSecondsScaleFactor,
+			prometheus.CounterValue,
+			cpu.PercentPrivilegedTime,
 			core, "privileged",
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.TimeTotal,
-			prometheus.GaugeValue,
-			float64(data.PercentUserTime)*ticksToSecondsScaleFactor,
+			prometheus.CounterValue,
+			cpu.PercentUserTime,
 			core, "user",
 		)
 
 		ch <- prometheus.MustNewConstMetric(
 			c.InterruptsTotal,
 			prometheus.CounterValue,
-			float64(data.InterruptsPersec),
+			cpu.Interrupts,
 			core,
 		)
 		ch <- prometheus.MustNewConstMetric(
 			c.DPCsTotal,
 			prometheus.CounterValue,
-			float64(data.DPCsQueuedPersec),
+			cpu.DPCsQueued,
 			core,
 		)
 	}
 
-	return nil, nil
+	return nil
+}
+
+type perflibProcessorInformation struct {
+	Name                     string
+	C1TimeSeconds            float64 `perflib:"% C1 Time"`
+	C2TimeSeconds            float64 `perflib:"% C2 Time"`
+	C3TimeSeconds            float64 `perflib:"% C3 Time"`
+	C1TransitionsTotal       float64 `perflib:"C1 Transitions/sec"`
+	C2TransitionsTotal       float64 `perflib:"C2 Transitions/sec"`
+	C3TransitionsTotal       float64 `perflib:"C3 Transitions/sec"`
+	ClockInterruptsTotal     float64 `perflib:"Clock Interrupts/sec"`
+	DPCsQueuedTotal          float64 `perflib:"DPCs Queued/sec"`
+	DPCTimeSeconds           float64 `perflib:"% DPC Time"`
+	IdleBreakEventsTotal     float64 `perflib:"Idle Break Events/sec"`
+	IdleTimeSeconds          float64 `perflib:"% Idle Time"`
+	InterruptsTotal          float64 `perflib:"Interrupts/sec"`
+	InterruptTimeSeconds     float64 `perflib:"% Interrupt Time"`
+	ParkingStatus            float64 `perflib:"Parking Status"`
+	PerformanceLimitPercent  float64 `perflib:"% Performance Limit"`
+	PriorityTimeSeconds      float64 `perflib:"% Priority Time"`
+	PrivilegedTimeSeconds    float64 `perflib:"% Privileged Time"`
+	PrivilegedUtilitySeconds float64 `perflib:"% Privileged Utility"`
+	ProcessorFrequencyMHz    float64 `perflib:"Processor Frequency"`
+	ProcessorPerformance     float64 `perflib:"% Processor Performance"`
+	ProcessorTimeSeconds     float64 `perflib:"% Processor Time"`
+	ProcessorUtilityRate     float64 `perflib:"% Processor Utility"`
+	UserTimeSeconds          float64 `perflib:"% User Time"`
+}
+
+func (c *cpuCollectorFull) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
+	data := make([]perflibProcessorInformation, 0)
+	err := unmarshalObject(ctx.perfObjects["Processor Information"], &data)
+	if err != nil {
+		return err
+	}
+
+	for _, cpu := range data {
+		if strings.Contains(strings.ToLower(cpu.Name), "_total") {
+			continue
+		}
+		core := cpu.Name
+
+		ch <- prometheus.MustNewConstMetric(
+			c.CStateSecondsTotal,
+			prometheus.CounterValue,
+			cpu.C1TimeSeconds,
+			core, "c1",
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.CStateSecondsTotal,
+			prometheus.CounterValue,
+			cpu.C2TimeSeconds,
+			core, "c2",
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.CStateSecondsTotal,
+			prometheus.CounterValue,
+			cpu.C3TimeSeconds,
+			core, "c3",
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.TimeTotal,
+			prometheus.CounterValue,
+			cpu.IdleTimeSeconds,
+			core, "idle",
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.TimeTotal,
+			prometheus.CounterValue,
+			cpu.InterruptTimeSeconds,
+			core, "interrupt",
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.TimeTotal,
+			prometheus.CounterValue,
+			cpu.DPCTimeSeconds,
+			core, "dpc",
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.TimeTotal,
+			prometheus.CounterValue,
+			cpu.PrivilegedTimeSeconds,
+			core, "privileged",
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.TimeTotal,
+			prometheus.CounterValue,
+			cpu.UserTimeSeconds,
+			core, "user",
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.InterruptsTotal,
+			prometheus.CounterValue,
+			cpu.InterruptsTotal,
+			core,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.DPCsTotal,
+			prometheus.CounterValue,
+			cpu.DPCsQueuedTotal,
+			core,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.ClockInterruptsTotal,
+			prometheus.CounterValue,
+			cpu.ClockInterruptsTotal,
+			core,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.IdleBreakEventsTotal,
+			prometheus.CounterValue,
+			cpu.IdleBreakEventsTotal,
+			core,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.ParkingStatus,
+			prometheus.GaugeValue,
+			cpu.ParkingStatus,
+			core,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.ProcessorFrequencyMHz,
+			prometheus.GaugeValue,
+			cpu.ProcessorFrequencyMHz,
+			core,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			c.ProcessorPerformance,
+			prometheus.GaugeValue,
+			cpu.ProcessorPerformance,
+			core,
+		)
+	}
+
+	return nil
 }

collector/cs.go

@@ -1,5 +1,4 @@
-// returns data points from Win32_ComputerSystem
-// https://msdn.microsoft.com/en-us/library/aa394102 - Win32_ComputerSystem class
+// +build windows
 
 package collector
 
@@ -43,7 +42,7 @@ func NewCSCollector() (Collector, error) {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *CSCollector) Collect(ch chan<- prometheus.Metric) error {
+func (c *CSCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
 	if desc, err := c.collect(ch); err != nil {
 		log.Error("failed collecting cs metrics:", desc, err)
 		return err
@@ -51,6 +50,8 @@ func (c *CSCollector) Collect(ch chan<- prometheus.Metric) error {
 	return nil
 }
 
+// Win32_ComputerSystem docs:
+// - https://msdn.microsoft.com/en-us/library/aa394102
 type Win32_ComputerSystem struct {
 	NumberOfLogicalProcessors uint32
 	TotalPhysicalMemory       uint64

collector/dns.go

@@ -1,6 +1,5 @@
-// returns data points from Win32_PerfRawData_DNS_DNS
-// https://msdn.microsoft.com/en-us/library/ms803992.aspx?f=255&MSPPError=-2147217396
-// https://technet.microsoft.com/en-us/library/cc977686.aspx
+// +build windows
+
 package collector
 
 import (
@@ -182,7 +181,7 @@ func NewDNSCollector() (Collector, error) {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *DNSCollector) Collect(ch chan<- prometheus.Metric) error {
+func (c *DNSCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
 	if desc, err := c.collect(ch); err != nil {
 		log.Error("failed collecting dns metrics:", desc, err)
 		return err
@@ -190,6 +189,9 @@ func (c *DNSCollector) Collect(ch chan<- prometheus.Metric) error {
 	return nil
 }
 
+// Win32_PerfRawData_DNS_DNS docs:
+// - https://msdn.microsoft.com/en-us/library/ms803992.aspx?f=255&MSPPError=-2147217396
+// - https://technet.microsoft.com/en-us/library/cc977686.aspx
 type Win32_PerfRawData_DNS_DNS struct {
 	AXFRRequestReceived            uint32
 	AXFRRequestSent                uint32

collector/hyperv.go

@@ -1,3 +1,5 @@
+// +build windows
+
 package collector
 
 import (
@@ -595,7 +597,7 @@ func NewHyperVCollector() (Collector, error) {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *HyperVCollector) Collect(ch chan<- prometheus.Metric) error {
+func (c *HyperVCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
 	if desc, err := c.collectVmHealth(ch); err != nil {
 		log.Error("failed collecting hyperV health status metrics:", desc, err)
 		return err

collector/iis.go

@@ -1,8 +1,4 @@
-// returns data points from the following classes:
-// - Win32_PerfRawData_W3SVC_WebService
-// - Win32_PerfRawData_APPPOOLCountersProvider_APPPOOLWAS
-// - Win32_PerfRawData_W3SVCW3WPCounterProvider_W3SVCW3WP
-// - Win32_PerfRawData_W3SVC_WebServiceCache
+// +build windows
 
 package collector
 
@@ -34,7 +30,12 @@ func getIISVersion() simple_version {
 		log.Warn("Couldn't open registry to determine IIS version:", err)
 		return simple_version{}
 	}
-	defer k.Close()
+	defer func() {
+		err = k.Close()
+		if err != nil {
+			log.Warnf("Failed to close registry key: %v", err)
+		}
+	}()
 
 	major, _, err := k.GetIntegerValue("MajorVersion")
 	if err != nil {
@@ -806,8 +807,8 @@ func NewIISCollector() (Collector, error) {
 			nil,
 		),
 
-		appWhitelistPattern: regexp.MustCompile(fmt.Sprintf("^(?:%s)$", *siteWhitelist)),
-		appBlacklistPattern: regexp.MustCompile(fmt.Sprintf("^(?:%s)$", *siteBlacklist)),
+		appWhitelistPattern: regexp.MustCompile(fmt.Sprintf("^(?:%s)$", *appWhitelist)),
+		appBlacklistPattern: regexp.MustCompile(fmt.Sprintf("^(?:%s)$", *appBlacklist)),
 	}
 
 	buildIIS.iis_version = getIISVersion()
@@ -817,7 +818,7 @@ func NewIISCollector() (Collector, error) {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *IISCollector) Collect(ch chan<- prometheus.Metric) error {
+func (c *IISCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
 	if desc, err := c.collect(ch); err != nil {
 		log.Error("failed collecting iis metrics:", desc, err)
 		return err
@@ -984,7 +985,7 @@ type Win32_PerfRawData_W3SVC_WebServiceCache struct {
 	URICacheMisses                 uint32
 }
 
-var ApplicationStates = map[uint32]string{
+var applicationStates = map[uint32]string{
 	1: "Uninitialized",
 	2: "Initialized",
 	3: "Running",
@@ -1265,7 +1266,7 @@ func (c *IISCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, e
 		}
 
 		// Guages
-		for key, label := range ApplicationStates {
+		for key, label := range applicationStates {
 			isCurrentState := 0.0
 			if key == app.CurrentApplicationPoolState {
 				isCurrentState = 1.0

collector/logical_disk.go

@@ -1,6 +1,4 @@
-// returns data points from Win32_PerfRawData_PerfDisk_LogicalDisk
-// https://msdn.microsoft.com/en-us/windows/hardware/aa394307(v=vs.71) - Win32_PerfRawData_PerfDisk_LogicalDisk class
-// https://msdn.microsoft.com/en-us/library/ms803973.aspx - LogicalDisk object reference
+// +build windows
 
 package collector
 
@@ -31,17 +29,20 @@ var (
 
 // A LogicalDiskCollector is a Prometheus collector for WMI Win32_PerfRawData_PerfDisk_LogicalDisk metrics
 type LogicalDiskCollector struct {
-	RequestsQueued  *prometheus.Desc
-	ReadBytesTotal  *prometheus.Desc
-	ReadsTotal      *prometheus.Desc
-	WriteBytesTotal *prometheus.Desc
-	WritesTotal     *prometheus.Desc
-	ReadTime        *prometheus.Desc
-	WriteTime       *prometheus.Desc
-	TotalSpace      *prometheus.Desc
-	FreeSpace       *prometheus.Desc
-	IdleTime        *prometheus.Desc
-	SplitIOs        *prometheus.Desc
+	RequestsQueued   *prometheus.Desc
+	ReadBytesTotal   *prometheus.Desc
+	ReadsTotal       *prometheus.Desc
+	WriteBytesTotal  *prometheus.Desc
+	WritesTotal      *prometheus.Desc
+	ReadTime         *prometheus.Desc
+	WriteTime        *prometheus.Desc
+	TotalSpace       *prometheus.Desc
+	FreeSpace        *prometheus.Desc
+	IdleTime         *prometheus.Desc
+	SplitIOs         *prometheus.Desc
+	ReadLatency      *prometheus.Desc
+	WriteLatency     *prometheus.Desc
+	ReadWriteLatency *prometheus.Desc
 
 	volumeWhitelistPattern *regexp.Regexp
 	volumeBlacklistPattern *regexp.Regexp
@@ -129,6 +130,27 @@ func NewLogicalDiskCollector() (Collector, error) {
 			nil,
 		),
 
+		ReadLatency: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "read_latency_seconds_total"),
+			"Shows the average time, in seconds, of a read operation from the disk (LogicalDisk.AvgDiskSecPerRead)",
+			[]string{"volume"},
+			nil,
+		),
+
+		WriteLatency: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "write_latency_seconds_total"),
+			"Shows the average time, in seconds, of a write operation to the disk (LogicalDisk.AvgDiskSecPerWrite)",
+			[]string{"volume"},
+			nil,
+		),
+
+		ReadWriteLatency: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "read_write_latency_seconds_total"),
+			"Shows the time, in seconds, of the average disk transfer (LogicalDisk.AvgDiskSecPerTransfer)",
+			[]string{"volume"},
+			nil,
+		),
+
 		volumeWhitelistPattern: regexp.MustCompile(fmt.Sprintf("^(?:%s)$", *volumeWhitelist)),
 		volumeBlacklistPattern: regexp.MustCompile(fmt.Sprintf("^(?:%s)$", *volumeBlacklist)),
 	}, nil
@@ -136,7 +158,7 @@ func NewLogicalDiskCollector() (Collector, error) {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *LogicalDiskCollector) Collect(ch chan<- prometheus.Metric) error {
+func (c *LogicalDiskCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
 	if desc, err := c.collect(ch); err != nil {
 		log.Error("failed collecting logical_disk metrics:", desc, err)
 		return err
@@ -144,6 +166,9 @@ func (c *LogicalDiskCollector) Collect(ch chan<- prometheus.Metric) error {
 	return nil
 }
 
+// Win32_PerfRawData_PerfDisk_LogicalDisk docs:
+// - https://msdn.microsoft.com/en-us/windows/hardware/aa394307(v=vs.71) - Win32_PerfRawData_PerfDisk_LogicalDisk class
+// - https://msdn.microsoft.com/en-us/library/ms803973.aspx - LogicalDisk object reference
 type Win32_PerfRawData_PerfDisk_LogicalDisk struct {
 	Name                   string
 	CurrentDiskQueueLength uint32
@@ -157,6 +182,9 @@ type Win32_PerfRawData_PerfDisk_LogicalDisk struct {
 	PercentFreeSpace_Base  uint32
 	PercentIdleTime        uint64
 	SplitIOPerSec          uint32
+	AvgDiskSecPerRead      uint64
+	AvgDiskSecPerWrite     uint64
+	AvgDiskSecPerTransfer  uint64
 }
 
 func (c *LogicalDiskCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
@@ -249,6 +277,27 @@ func (c *LogicalDiskCollector) collect(ch chan<- prometheus.Metric) (*prometheus
 			float64(volume.SplitIOPerSec),
 			volume.Name,
 		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.ReadLatency,
+			prometheus.CounterValue,
+			float64(volume.AvgDiskSecPerRead),
+			volume.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.WriteLatency,
+			prometheus.CounterValue,
+			float64(volume.AvgDiskSecPerWrite),
+			volume.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.ReadWriteLatency,
+			prometheus.CounterValue,
+			float64(volume.AvgDiskSecPerTransfer),
+			volume.Name,
+		)
 	}
 
 	return nil, nil

collector/logon.go

@@ -0,0 +1,199 @@
+// +build windows
+
+package collector
+
+import (
+	"errors"
+
+	"github.com/StackExchange/wmi"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/common/log"
+)
+
+func init() {
+	Factories["logon"] = NewLogonCollector
+}
+
+// A LogonCollector is a Prometheus collector for WMI metrics
+type LogonCollector struct {
+	LogonType *prometheus.Desc
+}
+
+// NewLogonCollector ...
+func NewLogonCollector() (Collector, error) {
+	const subsystem = "logon"
+
+	return &LogonCollector{
+		LogonType: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "logon_type"),
+			"Number of active logon sessions (LogonSession.LogonType)",
+			[]string{"status"},
+			nil,
+		),
+	}, nil
+}
+
+// Collect sends the metric values for each metric
+// to the provided prometheus Metric channel.
+func (c *LogonCollector) 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
+}
+
+// Win32_LogonSession docs:
+// - https://docs.microsoft.com/en-us/windows/win32/cimwin32prov/win32-logonsession
+type Win32_LogonSession struct {
+	LogonType uint32
+}
+
+func (c *LogonCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
+	var dst []Win32_LogonSession
+	q := queryAll(&dst)
+	if err := wmi.Query(q, &dst); err != nil {
+		return nil, err
+	}
+	if len(dst) == 0 {
+		return nil, errors.New("WMI query returned empty result set")
+	}
+
+	// Init counters
+	system := 0
+	interactive := 0
+	network := 0
+	batch := 0
+	service := 0
+	proxy := 0
+	unlock := 0
+	networkcleartext := 0
+	newcredentials := 0
+	remoteinteractive := 0
+	cachedinteractive := 0
+	cachedremoteinteractive := 0
+	cachedunlock := 0
+
+	for _, entry := range dst {
+		switch entry.LogonType {
+		case 0:
+			system++
+		case 2:
+			interactive++
+		case 3:
+			network++
+		case 4:
+			batch++
+		case 5:
+			service++
+		case 6:
+			proxy++
+		case 7:
+			unlock++
+		case 8:
+			networkcleartext++
+		case 9:
+			newcredentials++
+		case 10:
+			remoteinteractive++
+		case 11:
+			cachedinteractive++
+		case 12:
+			cachedremoteinteractive++
+		case 13:
+			cachedunlock++
+		}
+	}
+
+	ch <- prometheus.MustNewConstMetric(
+		c.LogonType,
+		prometheus.GaugeValue,
+		float64(system),
+		"system",
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.LogonType,
+		prometheus.GaugeValue,
+		float64(interactive),
+		"interactive",
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.LogonType,
+		prometheus.GaugeValue,
+		float64(network),
+		"network",
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.LogonType,
+		prometheus.GaugeValue,
+		float64(batch),
+		"batch",
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.LogonType,
+		prometheus.GaugeValue,
+		float64(service),
+		"service",
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.LogonType,
+		prometheus.GaugeValue,
+		float64(proxy),
+		"proxy",
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.LogonType,
+		prometheus.GaugeValue,
+		float64(unlock),
+		"unlock",
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.LogonType,
+		prometheus.GaugeValue,
+		float64(networkcleartext),
+		"network_clear_text",
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.LogonType,
+		prometheus.GaugeValue,
+		float64(newcredentials),
+		"new_credentials",
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.LogonType,
+		prometheus.GaugeValue,
+		float64(remoteinteractive),
+		"remote_interactive",
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.LogonType,
+		prometheus.GaugeValue,
+		float64(cachedinteractive),
+		"cached_interactive",
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.LogonType,
+		prometheus.GaugeValue,
+		float64(remoteinteractive),
+		"cached_remote_interactive",
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.LogonType,
+		prometheus.GaugeValue,
+		float64(cachedunlock),
+		"cached_unlock",
+	)
+	return nil, nil
+}

collector/memory.go

@@ -0,0 +1,504 @@
+// returns data points from Win32_PerfRawData_PerfOS_Memory
+// <add link to documentation here> - Win32_PerfRawData_PerfOS_Memory class
+
+// +build windows
+
+package collector
+
+import (
+	"github.com/StackExchange/wmi"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/common/log"
+)
+
+func init() {
+	Factories["memory"] = NewMemoryCollector
+}
+
+// A MemoryCollector is a Prometheus collector for WMI Win32_PerfRawData_PerfOS_Memory metrics
+type MemoryCollector struct {
+	AvailableBytes                  *prometheus.Desc
+	CacheBytes                      *prometheus.Desc
+	CacheBytesPeak                  *prometheus.Desc
+	CacheFaultsTotal                *prometheus.Desc
+	CommitLimit                     *prometheus.Desc
+	CommittedBytes                  *prometheus.Desc
+	DemandZeroFaultsTotal           *prometheus.Desc
+	FreeAndZeroPageListBytes        *prometheus.Desc
+	FreeSystemPageTableEntries      *prometheus.Desc
+	ModifiedPageListBytes           *prometheus.Desc
+	PageFaultsTotal                 *prometheus.Desc
+	SwapPageReadsTotal              *prometheus.Desc
+	SwapPagesReadTotal              *prometheus.Desc
+	SwapPagesWrittenTotal           *prometheus.Desc
+	SwapPageOperationsTotal         *prometheus.Desc
+	SwapPageWritesTotal             *prometheus.Desc
+	PoolNonpagedAllocsTotal         *prometheus.Desc
+	PoolNonpagedBytes               *prometheus.Desc
+	PoolPagedAllocsTotal            *prometheus.Desc
+	PoolPagedBytes                  *prometheus.Desc
+	PoolPagedResidentBytes          *prometheus.Desc
+	StandbyCacheCoreBytes           *prometheus.Desc
+	StandbyCacheNormalPriorityBytes *prometheus.Desc
+	StandbyCacheReserveBytes        *prometheus.Desc
+	SystemCacheResidentBytes        *prometheus.Desc
+	SystemCodeResidentBytes         *prometheus.Desc
+	SystemCodeTotalBytes            *prometheus.Desc
+	SystemDriverResidentBytes       *prometheus.Desc
+	SystemDriverTotalBytes          *prometheus.Desc
+	TransitionFaultsTotal           *prometheus.Desc
+	TransitionPagesRepurposedTotal  *prometheus.Desc
+	WriteCopiesTotal                *prometheus.Desc
+}
+
+// NewMemoryCollector ...
+func NewMemoryCollector() (Collector, error) {
+	const subsystem = "memory"
+
+	return &MemoryCollector{
+		AvailableBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "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 (AvailableBytes)",
+			nil,
+			nil,
+		),
+		CacheBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "cache_bytes"),
+			"(CacheBytes)",
+			nil,
+			nil,
+		),
+		CacheBytesPeak: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "cache_bytes_peak"),
+			"(CacheBytesPeak)",
+			nil,
+			nil,
+		),
+		CacheFaultsTotal: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "cache_faults_total"),
+			"(CacheFaultsPersec)",
+			nil,
+			nil,
+		),
+		CommitLimit: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "commit_limit"),
+			"(CommitLimit)",
+			nil,
+			nil,
+		),
+		CommittedBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "committed_bytes"),
+			"(CommittedBytes)",
+			nil,
+			nil,
+		),
+		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)",
+			nil,
+			nil,
+		),
+		FreeAndZeroPageListBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "free_and_zero_page_list_bytes"),
+			"(FreeAndZeroPageListBytes)",
+			nil,
+			nil,
+		),
+		FreeSystemPageTableEntries: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "free_system_page_table_entries"),
+			"(FreeSystemPageTableEntries)",
+			nil,
+			nil,
+		),
+		ModifiedPageListBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "modified_page_list_bytes"),
+			"(ModifiedPageListBytes)",
+			nil,
+			nil,
+		),
+		PageFaultsTotal: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "page_faults_total"),
+			"(PageFaultsPersec)",
+			nil,
+			nil,
+		),
+		SwapPageReadsTotal: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "swap_page_reads_total"),
+			"Number of disk page reads (a single read operation reading several pages is still only counted once) (PageReadsPersec)",
+			nil,
+			nil,
+		),
+		SwapPagesReadTotal: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "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) (PagesInputPersec)",
+			nil,
+			nil,
+		),
+		SwapPagesWrittenTotal: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "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) (PagesOutputPersec)",
+			nil,
+			nil,
+		),
+		SwapPageOperationsTotal: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "swap_page_operations_total"),
+			"Total number of swap page read and writes (PagesPersec)",
+			nil,
+			nil,
+		),
+		SwapPageWritesTotal: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "swap_page_writes_total"),
+			"Number of disk page writes (a single write operation writing several pages is still only counted once) (PageWritesPersec)",
+			nil,
+			nil,
+		),
+		PoolNonpagedAllocsTotal: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "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 (PoolNonpagedAllocs)",
+			nil,
+			nil,
+		),
+		PoolNonpagedBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "pool_nonpaged_bytes_total"),
+			"(PoolNonpagedBytes)",
+			nil,
+			nil,
+		),
+		PoolPagedAllocsTotal: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "pool_paged_allocs_total"),
+			"(PoolPagedAllocs)",
+			nil,
+			nil,
+		),
+		PoolPagedBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "pool_paged_bytes"),
+			"(PoolPagedBytes)",
+			nil,
+			nil,
+		),
+		PoolPagedResidentBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "pool_paged_resident_bytes"),
+			"(PoolPagedResidentBytes)",
+			nil,
+			nil,
+		),
+		StandbyCacheCoreBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "standby_cache_core_bytes"),
+			"(StandbyCacheCoreBytes)",
+			nil,
+			nil,
+		),
+		StandbyCacheNormalPriorityBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "standby_cache_normal_priority_bytes"),
+			"(StandbyCacheNormalPriorityBytes)",
+			nil,
+			nil,
+		),
+		StandbyCacheReserveBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "standby_cache_reserve_bytes"),
+			"(StandbyCacheReserveBytes)",
+			nil,
+			nil,
+		),
+		SystemCacheResidentBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "system_cache_resident_bytes"),
+			"(SystemCacheResidentBytes)",
+			nil,
+			nil,
+		),
+		SystemCodeResidentBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "system_code_resident_bytes"),
+			"(SystemCodeResidentBytes)",
+			nil,
+			nil,
+		),
+		SystemCodeTotalBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "system_code_total_bytes"),
+			"(SystemCodeTotalBytes)",
+			nil,
+			nil,
+		),
+		SystemDriverResidentBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "system_driver_resident_bytes"),
+			"(SystemDriverResidentBytes)",
+			nil,
+			nil,
+		),
+		SystemDriverTotalBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "system_driver_total_bytes"),
+			"(SystemDriverTotalBytes)",
+			nil,
+			nil,
+		),
+		TransitionFaultsTotal: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "transition_faults_total"),
+			"(TransitionFaultsPersec)",
+			nil,
+			nil,
+		),
+		TransitionPagesRepurposedTotal: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "transition_pages_repurposed_total"),
+			"(TransitionPagesRePurposedPersec)",
+			nil,
+			nil,
+		),
+		WriteCopiesTotal: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "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 (WriteCopiesPersec)",
+			nil,
+			nil,
+		),
+	}, nil
+}
+
+// Collect sends the metric values for each metric
+// to the provided prometheus Metric channel.
+func (c *MemoryCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
+	if desc, err := c.collect(ch); err != nil {
+		log.Error("failed collecting memory metrics:", desc, err)
+		return err
+	}
+	return nil
+}
+
+type Win32_PerfRawData_PerfOS_Memory struct {
+	AvailableBytes                  uint64
+	AvailableKBytes                 uint64
+	AvailableMBytes                 uint64
+	CacheBytes                      uint64
+	CacheBytesPeak                  uint64
+	CacheFaultsPersec               uint32
+	CommitLimit                     uint64
+	CommittedBytes                  uint64
+	DemandZeroFaultsPersec          uint32
+	FreeAndZeroPageListBytes        uint64
+	FreeSystemPageTableEntries      uint32
+	ModifiedPageListBytes           uint64
+	PageFaultsPersec                uint32
+	PageReadsPersec                 uint32
+	PagesInputPersec                uint32
+	PagesOutputPersec               uint32
+	PagesPersec                     uint32
+	PageWritesPersec                uint32
+	PoolNonpagedAllocs              uint32
+	PoolNonpagedBytes               uint64
+	PoolPagedAllocs                 uint32
+	PoolPagedBytes                  uint64
+	PoolPagedResidentBytes          uint64
+	StandbyCacheCoreBytes           uint64
+	StandbyCacheNormalPriorityBytes uint64
+	StandbyCacheReserveBytes        uint64
+	SystemCacheResidentBytes        uint64
+	SystemCodeResidentBytes         uint64
+	SystemCodeTotalBytes            uint64
+	SystemDriverResidentBytes       uint64
+	SystemDriverTotalBytes          uint64
+	TransitionFaultsPersec          uint32
+	TransitionPagesRePurposedPersec uint32
+	WriteCopiesPersec               uint32
+}
+
+func (c *MemoryCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
+	var dst []Win32_PerfRawData_PerfOS_Memory
+	q := queryAll(&dst)
+	if err := wmi.Query(q, &dst); err != nil {
+		return nil, err
+	}
+
+	ch <- prometheus.MustNewConstMetric(
+		c.AvailableBytes,
+		prometheus.GaugeValue,
+		float64(dst[0].AvailableBytes),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.CacheBytes,
+		prometheus.GaugeValue,
+		float64(dst[0].CacheBytes),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.CacheBytesPeak,
+		prometheus.GaugeValue,
+		float64(dst[0].CacheBytesPeak),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.CacheFaultsTotal,
+		prometheus.GaugeValue,
+		float64(dst[0].CacheFaultsPersec),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.CommitLimit,
+		prometheus.GaugeValue,
+		float64(dst[0].CommitLimit),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.CommittedBytes,
+		prometheus.GaugeValue,
+		float64(dst[0].CommittedBytes),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.DemandZeroFaultsTotal,
+		prometheus.GaugeValue,
+		float64(dst[0].DemandZeroFaultsPersec),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.FreeAndZeroPageListBytes,
+		prometheus.GaugeValue,
+		float64(dst[0].FreeAndZeroPageListBytes),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.FreeSystemPageTableEntries,
+		prometheus.GaugeValue,
+		float64(dst[0].FreeSystemPageTableEntries),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.ModifiedPageListBytes,
+		prometheus.GaugeValue,
+		float64(dst[0].ModifiedPageListBytes),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.PageFaultsTotal,
+		prometheus.GaugeValue,
+		float64(dst[0].PageFaultsPersec),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.SwapPageReadsTotal,
+		prometheus.GaugeValue,
+		float64(dst[0].PageReadsPersec),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.SwapPagesReadTotal,
+		prometheus.GaugeValue,
+		float64(dst[0].PagesInputPersec),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.SwapPagesWrittenTotal,
+		prometheus.GaugeValue,
+		float64(dst[0].PagesOutputPersec),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.SwapPageOperationsTotal,
+		prometheus.GaugeValue,
+		float64(dst[0].PagesPersec),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.SwapPageWritesTotal,
+		prometheus.GaugeValue,
+		float64(dst[0].PageWritesPersec),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.PoolNonpagedAllocsTotal,
+		prometheus.GaugeValue,
+		float64(dst[0].PoolNonpagedAllocs),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.PoolNonpagedBytes,
+		prometheus.GaugeValue,
+		float64(dst[0].PoolNonpagedBytes),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.PoolPagedAllocsTotal,
+		prometheus.GaugeValue,
+		float64(dst[0].PoolPagedAllocs),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.PoolPagedBytes,
+		prometheus.GaugeValue,
+		float64(dst[0].PoolPagedBytes),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.PoolPagedResidentBytes,
+		prometheus.GaugeValue,
+		float64(dst[0].PoolPagedResidentBytes),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.StandbyCacheCoreBytes,
+		prometheus.GaugeValue,
+		float64(dst[0].StandbyCacheCoreBytes),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.StandbyCacheNormalPriorityBytes,
+		prometheus.GaugeValue,
+		float64(dst[0].StandbyCacheNormalPriorityBytes),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.StandbyCacheReserveBytes,
+		prometheus.GaugeValue,
+		float64(dst[0].StandbyCacheReserveBytes),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.SystemCacheResidentBytes,
+		prometheus.GaugeValue,
+		float64(dst[0].SystemCacheResidentBytes),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.SystemCodeResidentBytes,
+		prometheus.GaugeValue,
+		float64(dst[0].SystemCodeResidentBytes),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.SystemCodeTotalBytes,
+		prometheus.GaugeValue,
+		float64(dst[0].SystemCodeTotalBytes),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.SystemDriverResidentBytes,
+		prometheus.GaugeValue,
+		float64(dst[0].SystemDriverResidentBytes),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.SystemDriverTotalBytes,
+		prometheus.GaugeValue,
+		float64(dst[0].SystemDriverTotalBytes),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.TransitionFaultsTotal,
+		prometheus.GaugeValue,
+		float64(dst[0].TransitionFaultsPersec),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.TransitionPagesRepurposedTotal,
+		prometheus.GaugeValue,
+		float64(dst[0].TransitionPagesRePurposedPersec),
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.WriteCopiesTotal,
+		prometheus.GaugeValue,
+		float64(dst[0].WriteCopiesPersec),
+	)
+
+	return nil, nil
+}

collector/msmq.go

@@ -1,5 +1,5 @@
-// returns data points from Win32_PerfRawData_MSMQ_MSMQQueue
-// <add link to documentation here> - Win32_PerfRawData_MSMQ_MSMQQueue class
+// +build windows
+
 package collector
 
 import (
@@ -33,7 +33,7 @@ type Win32_PerfRawData_MSMQ_MSMQQueueCollector struct {
 func NewMSMQCollector() (Collector, error) {
 	const subsystem = "msmq"
 
-	if *msmqWhereClause != "" {
+	if *msmqWhereClause == "" {
 		log.Warn("No where-clause specified for msmq collector. This will generate a very large number of metrics!")
 	}
 
@@ -68,7 +68,7 @@ func NewMSMQCollector() (Collector, error) {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Win32_PerfRawData_MSMQ_MSMQQueueCollector) Collect(ch chan<- prometheus.Metric) error {
+func (c *Win32_PerfRawData_MSMQ_MSMQQueueCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
 	if desc, err := c.collect(ch); err != nil {
 		log.Error("failed collecting msmq metrics:", desc, err)
 		return err

collector/mssql.go

@@ -1,22 +1,4 @@
-// returns data points from the following classes:
-// - Win32_PerfRawData_MSSQLSERVER_SQLServerAccessMethods
-//   https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-access-methods-object
-// - Win32_PerfRawData_MSSQLSERVER_SQLServerAvailabilityReplica
-//   https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-availability-replica
-// - Win32_PerfRawData_MSSQLSERVER_SQLServerBufferManager
-//   https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-buffer-manager-object
-// - Win32_PerfRawData_MSSQLSERVER_SQLServerDatabaseReplica
-//   https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-database-replica
-// - Win32_PerfRawData_MSSQLSERVER_SQLServerDatabases
-//   https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-databases-object?view=sql-server-2017
-// - Win32_PerfRawData_MSSQLSERVER_SQLServerGeneralStatistics
-//   https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-general-statistics-object
-// - Win32_PerfRawData_MSSQLSERVER_SQLServerLocks
-//   https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-locks-object
-// - Win32_PerfRawData_MSSQLSERVER_SQLServerMemoryManager
-//   https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-memory-manager-object
-// - Win32_PerfRawData_MSSQLSERVER_SQLServerSQLStatistics
-//   https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-sql-statistics-object
+// +build windows
 
 package collector
 
@@ -62,11 +44,16 @@ func getMSSQLInstances() mssqlInstancesType {
 		log.Warn("Couldn't open registry to determine SQL instances:", err)
 		return sqlDefaultInstance
 	}
-	defer k.Close()
+	defer func() {
+		err = k.Close()
+		if err != nil {
+			log.Warnf("Failed to close registry key: %v", err)
+		}
+	}()
 
 	instanceNames, err := k.ReadValueNames(0)
 	if err != nil {
-		log.Warn("Can't ReadSubKeyNames %#v", err)
+		log.Warnf("Can't ReadSubKeyNames %#v", err)
 		return sqlDefaultInstance
 	}
 
@@ -87,7 +74,15 @@ func getMSSQLInstances() mssqlInstancesType {
 func mssqlBuildWMIInstanceClass(suffix string, instance string) string {
 	instancePart := "MSSQLSERVER_SQLServer"
 	if instance != "MSSQLSERVER" {
-		instancePart = fmt.Sprintf("MSSQL%s_MSSQL%s", instance, instance)
+		// Instance names can contain some special characters, which are not supported in the WMI class name.
+		// We strip those out.
+		cleanedName := strings.Map(func(r rune) rune {
+			if r == '_' || r == '$' || r == '#' {
+				return -1
+			}
+			return r
+		}, instance)
+		instancePart = fmt.Sprintf("MSSQL%s_MSSQL%s", cleanedName, cleanedName)
 	}
 
 	return fmt.Sprintf("Win32_PerfRawData_%s%s", instancePart, suffix)
@@ -96,7 +91,7 @@ func mssqlBuildWMIInstanceClass(suffix string, instance string) string {
 type mssqlCollectorsMap map[string]mssqlCollectorFunc
 
 func mssqlAvailableClassCollectors() string {
-	return "accessmethods,availreplica,bufman,databases,dbreplica,genstats,locks,memmgr,sqlstats"
+	return "accessmethods,availreplica,bufman,databases,dbreplica,genstats,locks,memmgr,sqlstats,sqlerrors,transactions"
 }
 
 func (c *MSSQLCollector) getMSSQLCollectors() mssqlCollectorsMap {
@@ -110,6 +105,8 @@ func (c *MSSQLCollector) getMSSQLCollectors() mssqlCollectorsMap {
 	mssqlCollectors["locks"] = c.collectLocks
 	mssqlCollectors["memmgr"] = c.collectMemoryManager
 	mssqlCollectors["sqlstats"] = c.collectSQLStats
+	mssqlCollectors["sqlerrors"] = c.collectSQLErrors
+	mssqlCollectors["transactions"] = c.collectTransactions
 
 	return mssqlCollectors
 }
@@ -363,6 +360,24 @@ type MSSQLCollector struct {
 	SQLStatsSQLReCompilations       *prometheus.Desc
 	SQLStatsUnsafeAutoParams        *prometheus.Desc
 
+	// Win32_PerfRawData_{instance}_SQLServerSQLErrors
+	SQLErrorsTotal *prometheus.Desc
+
+	// Win32_PerfRawData_{instance}_SQLServerTransactions
+	TransactionsTempDbFreeSpaceBytes             *prometheus.Desc
+	TransactionsLongestTransactionRunningSeconds *prometheus.Desc
+	TransactionsNonSnapshotVersionActiveTotal    *prometheus.Desc
+	TransactionsSnapshotActiveTotal              *prometheus.Desc
+	TransactionsActiveTotal                      *prometheus.Desc
+	TransactionsUpdateConflictsTotal             *prometheus.Desc
+	TransactionsUpdateSnapshotActiveTotal        *prometheus.Desc
+	TransactionsVersionCleanupRateBytes          *prometheus.Desc
+	TransactionsVersionGenerationRateBytes       *prometheus.Desc
+	TransactionsVersionStoreSizeBytes            *prometheus.Desc
+	TransactionsVersionStoreUnits                *prometheus.Desc
+	TransactionsVersionStoreCreationUnits        *prometheus.Desc
+	TransactionsVersionStoreTruncationUnits      *prometheus.Desc
+
 	mssqlInstances             mssqlInstancesType
 	mssqlCollectors            mssqlCollectorsMap
 	mssqlChildCollectorFailure int
@@ -373,7 +388,7 @@ func NewMSSQLCollector() (Collector, error) {
 
 	const subsystem = "mssql"
 
-	MSSQLCollector := MSSQLCollector{
+	mssqlCollector := MSSQLCollector{
 		// meta
 		mssqlScrapeDurationDesc: prometheus.NewDesc(
 			prometheus.BuildFQName(Namespace, subsystem, "collector_duration_seconds"),
@@ -1642,20 +1657,108 @@ func NewMSSQLCollector() (Collector, error) {
 			nil,
 		),
 
+		// Win32_PerfRawData_{instance}_SQLServerSQLErrors
+		SQLErrorsTotal: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "sql_errors_total"),
+			"(SQLErrors.Total)",
+			[]string{"instance", "resource"},
+			nil,
+		),
+
+		// Win32_PerfRawData_{instance}_SQLServerTransactions
+		TransactionsTempDbFreeSpaceBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "transactions_tempdb_free_space_bytes"),
+			"(Transactions.FreeSpaceInTempDbKB)",
+			[]string{"instance"},
+			nil,
+		),
+		TransactionsLongestTransactionRunningSeconds: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "transactions_longest_transaction_running_seconds"),
+			"(Transactions.LongestTransactionRunningTime)",
+			[]string{"instance"},
+			nil,
+		),
+		TransactionsNonSnapshotVersionActiveTotal: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "transactions_nonsnapshot_version_active_total"),
+			"(Transactions.NonSnapshotVersionTransactions)",
+			[]string{"instance"},
+			nil,
+		),
+		TransactionsSnapshotActiveTotal: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "transactions_snapshot_active_total"),
+			"(Transactions.SnapshotTransactions)",
+			[]string{"instance"},
+			nil,
+		),
+		TransactionsActiveTotal: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "transactions_active_total"),
+			"(Transactions.Transactions)",
+			[]string{"instance"},
+			nil,
+		),
+		TransactionsUpdateConflictsTotal: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "transactions_update_conflicts_total"),
+			"(Transactions.UpdateConflictRatio)",
+			[]string{"instance"},
+			nil,
+		),
+		TransactionsUpdateSnapshotActiveTotal: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "transactions_update_snapshot_active_total"),
+			"(Transactions.UpdateSnapshotTransactions)",
+			[]string{"instance"},
+			nil,
+		),
+		TransactionsVersionCleanupRateBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "transactions_version_cleanup_rate_bytes"),
+			"(Transactions.VersionCleanupRateKBs)",
+			[]string{"instance"},
+			nil,
+		),
+		TransactionsVersionGenerationRateBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "transactions_version_generation_rate_bytes"),
+			"(Transactions.VersionGenerationRateKBs)",
+			[]string{"instance"},
+			nil,
+		),
+		TransactionsVersionStoreSizeBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "transactions_version_store_size_bytes"),
+			"(Transactions.VersionStoreSizeKB)",
+			[]string{"instance"},
+			nil,
+		),
+		TransactionsVersionStoreUnits: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "transactions_version_store_units"),
+			"(Transactions.VersionStoreUnitCount)",
+			[]string{"instance"},
+			nil,
+		),
+		TransactionsVersionStoreCreationUnits: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "transactions_version_store_creation_units"),
+			"(Transactions.VersionStoreUnitCreation)",
+			[]string{"instance"},
+			nil,
+		),
+		TransactionsVersionStoreTruncationUnits: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "transactions_version_store_truncation_units"),
+			"(Transactions.VersionStoreUnitTruncation)",
+			[]string{"instance"},
+			nil,
+		),
+
 		mssqlInstances: getMSSQLInstances(),
 	}
 
-	MSSQLCollector.mssqlCollectors = MSSQLCollector.getMSSQLCollectors()
+	mssqlCollector.mssqlCollectors = mssqlCollector.getMSSQLCollectors()
 
 	if *mssqlPrintCollectors {
 		fmt.Printf("Available SQLServer Classes:\n")
-		for name := range MSSQLCollector.mssqlCollectors {
+		for name := range mssqlCollector.mssqlCollectors {
 			fmt.Printf(" - %s\n", name)
 		}
 		os.Exit(0)
 	}
 
-	return &MSSQLCollector, nil
+	return &mssqlCollector, nil
 }
 
 type mssqlCollectorFunc func(ch chan<- prometheus.Metric, sqlInstance string) (*prometheus.Desc, error)
@@ -1692,7 +1795,7 @@ func (c *MSSQLCollector) execute(name string, fn mssqlCollectorFunc, ch chan<- p
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *MSSQLCollector) Collect(ch chan<- prometheus.Metric) error {
+func (c *MSSQLCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
 	wg := sync.WaitGroup{}
 
 	enabled := mssqlExpandEnabledCollectors(*mssqlEnabledCollectors)
@@ -1713,6 +1816,9 @@ func (c *MSSQLCollector) Collect(ch chan<- prometheus.Metric) error {
 	return nil
 }
 
+// win32PerfRawDataSQLServerAccessMethods docs:
+// - Win32_PerfRawData_MSSQLSERVER_SQLServerAccessMethods
+//   https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-access-methods-object
 type win32PerfRawDataSQLServerAccessMethods struct {
 	AUcleanupbatchesPersec        uint64
 	AUcleanupsPersec              uint64
@@ -2077,6 +2183,8 @@ func (c *MSSQLCollector) collectAccessMethods(ch chan<- prometheus.Metric, sqlIn
 	return nil, nil
 }
 
+// Win32_PerfRawData_MSSQLSERVER_SQLServerAvailabilityReplica docs:
+//   https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-availability-replica
 type win32PerfRawDataSQLServerAvailabilityReplica struct {
 	Name                           string
 	BytesReceivedfromReplicaPersec uint64
@@ -2169,6 +2277,8 @@ func (c *MSSQLCollector) collectAvailabilityReplica(ch chan<- prometheus.Metric,
 	return nil, nil
 }
 
+// Win32_PerfRawData_MSSQLSERVER_SQLServerBufferManager docs:
+//   https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-buffer-manager-object
 type win32PerfRawDataSQLServerBufferManager struct {
 	BackgroundwriterpagesPersec   uint64
 	Buffercachehitratio           uint64
@@ -2366,6 +2476,8 @@ func (c *MSSQLCollector) collectBufferManager(ch chan<- prometheus.Metric, sqlIn
 	return nil, nil
 }
 
+// Win32_PerfRawData_MSSQLSERVER_SQLServerDatabaseReplica docs:
+// - https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-database-replica
 type win32PerfRawDataSQLServerDatabaseReplica struct {
 	Name                            string
 	DatabaseFlowControlDelay        uint64
@@ -2571,13 +2683,15 @@ func (c *MSSQLCollector) collectDatabaseReplica(ch chan<- prometheus.Metric, sql
 		ch <- prometheus.MustNewConstMetric(
 			c.DBReplicaTransactionDelay,
 			prometheus.GaugeValue,
-			float64(v.TransactionDelay)*1000.0,
+			float64(v.TransactionDelay)/1000.0,
 			sqlInstance, replicaName,
 		)
 	}
 	return nil, nil
 }
 
+// Win32_PerfRawData_MSSQLSERVER_SQLServerDatabases docs:
+// - https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-databases-object?view=sql-server-2017
 type win32PerfRawDataSQLServerDatabases struct {
 	Name                             string
 	ActiveTransactions               uint64
@@ -2966,6 +3080,8 @@ func (c *MSSQLCollector) collectDatabases(ch chan<- prometheus.Metric, sqlInstan
 	return nil, nil
 }
 
+// Win32_PerfRawData_MSSQLSERVER_SQLServerGeneralStatistics docs:
+// - https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-general-statistics-object
 type win32PerfRawDataSQLServerGeneralStatistics struct {
 	ActiveTempTables              uint64
 	ConnectionResetPersec         uint64
@@ -3178,6 +3294,8 @@ func (c *MSSQLCollector) collectGeneralStatistics(ch chan<- prometheus.Metric, s
 	return nil, nil
 }
 
+// Win32_PerfRawData_MSSQLSERVER_SQLServerLocks docs:
+// - https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-locks-object
 type win32PerfRawDataSQLServerLocks struct {
 	Name                       string
 	AverageWaitTimems          uint64
@@ -3254,6 +3372,8 @@ func (c *MSSQLCollector) collectLocks(ch chan<- prometheus.Metric, sqlInstance s
 	return nil, nil
 }
 
+// Win32_PerfRawData_MSSQLSERVER_SQLServerMemoryManager docs:
+// - https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-memory-manager-object
 type win32PerfRawDataSQLServerMemoryManager struct {
 	ConnectionMemoryKB       uint64
 	DatabaseCacheMemoryKB    uint64
@@ -3435,6 +3555,8 @@ func (c *MSSQLCollector) collectMemoryManager(ch chan<- prometheus.Metric, sqlIn
 	return nil, nil
 }
 
+// Win32_PerfRawData_MSSQLSERVER_SQLServerSQLStatistics docs:
+// - https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-sql-statistics-object
 type win32PerfRawDataSQLServerSQLStatistics struct {
 	AutoParamAttemptsPersec       uint64
 	BatchRequestsPersec           uint64
@@ -3544,3 +3666,162 @@ func (c *MSSQLCollector) collectSQLStats(ch chan<- prometheus.Metric, sqlInstanc
 
 	return nil, nil
 }
+
+type win32PerfRawDataSQLServerSQLErrors struct {
+	Name         string
+	ErrorsPersec uint64
+}
+
+// Win32_PerfRawData_MSSQLSERVER_SQLServerErrors docs:
+// - https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-sql-errors-object
+func (c *MSSQLCollector) collectSQLErrors(ch chan<- prometheus.Metric, sqlInstance string) (*prometheus.Desc, error) {
+	var dst []win32PerfRawDataSQLServerSQLErrors
+	log.Debugf("mssql_sqlerrors collector iterating sql instance %s.", sqlInstance)
+
+	class := mssqlBuildWMIInstanceClass("SQLErrors", sqlInstance)
+	q := queryAllForClassWhere(&dst, class, `Name <> '_Total'`)
+	if err := wmi.Query(q, &dst); err != nil {
+		return nil, err
+	}
+
+	for _, v := range dst {
+		resource := v.Name
+
+		ch <- prometheus.MustNewConstMetric(
+			c.SQLErrorsTotal,
+			prometheus.CounterValue,
+			float64(v.ErrorsPersec),
+			sqlInstance, resource,
+		)
+	}
+
+	return nil, nil
+}
+
+type win32PerfRawDataSqlServerTransactions struct {
+	FreeSpaceintempdbKB            uint64
+	LongestTransactionRunningTime  uint64
+	NonSnapshotVersionTransactions uint64
+	SnapshotTransactions           uint64
+	Transactions                   uint64
+	Updateconflictratio            uint64
+	UpdateSnapshotTransactions     uint64
+	VersionCleanuprateKBPers       uint64
+	VersionGenerationrateKBPers    uint64
+	VersionStoreSizeKB             uint64
+	VersionStoreunitcount          uint64
+	VersionStoreunitcreation       uint64
+	VersionStoreunittruncation     uint64
+}
+
+// Win32_PerfRawData_MSSQLSERVER_Transactions docs:
+// - https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-transactions-object
+func (c *MSSQLCollector) collectTransactions(ch chan<- prometheus.Metric, sqlInstance string) (*prometheus.Desc, error) {
+	var dst []win32PerfRawDataSqlServerTransactions
+	log.Debugf("mssql_transactions collector iterating sql instance %s.", sqlInstance)
+
+	class := mssqlBuildWMIInstanceClass("Transactions", sqlInstance)
+	q := queryAllForClass(&dst, class)
+	if err := wmi.Query(q, &dst); err != nil {
+		return nil, err
+	}
+
+	if len(dst) == 0 {
+		return nil, errors.New("WMI query returned empty result set")
+	}
+
+	v := dst[0]
+
+	ch <- prometheus.MustNewConstMetric(
+		c.TransactionsTempDbFreeSpaceBytes,
+		prometheus.GaugeValue,
+		float64(v.FreeSpaceintempdbKB*1024),
+		sqlInstance,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.TransactionsLongestTransactionRunningSeconds,
+		prometheus.GaugeValue,
+		float64(v.LongestTransactionRunningTime),
+		sqlInstance,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.TransactionsNonSnapshotVersionActiveTotal,
+		prometheus.CounterValue,
+		float64(v.NonSnapshotVersionTransactions),
+		sqlInstance,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.TransactionsSnapshotActiveTotal,
+		prometheus.CounterValue,
+		float64(v.SnapshotTransactions),
+		sqlInstance,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.TransactionsActiveTotal,
+		prometheus.CounterValue,
+		float64(v.Transactions),
+		sqlInstance,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.TransactionsUpdateConflictsTotal,
+		prometheus.CounterValue,
+		float64(v.Updateconflictratio),
+		sqlInstance,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.TransactionsUpdateSnapshotActiveTotal,
+		prometheus.CounterValue,
+		float64(v.UpdateSnapshotTransactions),
+		sqlInstance,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.TransactionsVersionCleanupRateBytes,
+		prometheus.GaugeValue,
+		float64(v.VersionCleanuprateKBPers*1024),
+		sqlInstance,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.TransactionsVersionGenerationRateBytes,
+		prometheus.GaugeValue,
+		float64(v.VersionGenerationrateKBPers*1024),
+		sqlInstance,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.TransactionsVersionStoreSizeBytes,
+		prometheus.GaugeValue,
+		float64(v.VersionStoreSizeKB*1024),
+		sqlInstance,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.TransactionsVersionStoreUnits,
+		prometheus.CounterValue,
+		float64(v.VersionStoreunitcount),
+		sqlInstance,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.TransactionsVersionStoreCreationUnits,
+		prometheus.CounterValue,
+		float64(v.VersionStoreunitcreation),
+		sqlInstance,
+	)
+
+	ch <- prometheus.MustNewConstMetric(
+		c.TransactionsVersionStoreTruncationUnits,
+		prometheus.CounterValue,
+		float64(v.VersionStoreunittruncation),
+		sqlInstance,
+	)
+
+	return nil, nil
+}

collector/net.go

@@ -1,8 +1,4 @@
-// returns data points from Win32_PerfRawData_Tcpip_NetworkInterface
-
-// https://technet.microsoft.com/en-us/security/aa394340(v=vs.80) (Win32_PerfRawData_Tcpip_NetworkInterface class)
-// https://msdn.microsoft.com/en-us/library/aa394216 (Win32_NetworkAdapter class)
-// https://msdn.microsoft.com/en-us/library/aa394353 (Win32_PnPEntity class)
+// +build windows
 
 package collector
 
@@ -136,7 +132,7 @@ func NewNetworkCollector() (Collector, error) {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *NetworkCollector) Collect(ch chan<- prometheus.Metric) error {
+func (c *NetworkCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
 	if desc, err := c.collect(ch); err != nil {
 		log.Error("failed collecting net metrics:", desc, err)
 		return err
@@ -150,6 +146,8 @@ func mangleNetworkName(name string) string {
 	return nicNameToUnderscore.ReplaceAllString(name, "_")
 }
 
+// Win32_PerfRawData_Tcpip_NetworkInterface docs:
+// - https://technet.microsoft.com/en-us/security/aa394340(v=vs.80)
 type Win32_PerfRawData_Tcpip_NetworkInterface struct {
 	BytesReceivedPerSec      uint64
 	BytesSentPerSec          uint64

collector/net_test.go

@@ -1,3 +1,5 @@
+// +build windows
+
 package collector
 
 import "testing"

collector/netframework_clrexceptions.go

@@ -1,5 +1,5 @@
-// returns data points from Win32_PerfRawData_NETFramework_NETCLRExceptions
-// <add link to documentation here> - Win32_PerfRawData_NETFramework_NETCLRExceptions class
+// +build windows
+
 package collector
 
 import (
@@ -53,7 +53,7 @@ func NewNETFramework_NETCLRExceptionsCollector() (Collector, error) {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *NETFramework_NETCLRExceptionsCollector) Collect(ch chan<- prometheus.Metric) error {
+func (c *NETFramework_NETCLRExceptionsCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
 	if desc, err := c.collect(ch); err != nil {
 		log.Error("failed collecting win32_perfrawdata_netframework_netclrexceptions metrics:", desc, err)
 		return err

collector/netframework_clrinterop.go

@@ -1,5 +1,5 @@
-// returns data points from Win32_PerfRawData_NETFramework_NETCLRInterop
-// <add link to documentation here> - Win32_PerfRawData_NETFramework_NETCLRInterop class
+// +build windows
+
 package collector
 
 import (
@@ -46,7 +46,7 @@ func NewNETFramework_NETCLRInteropCollector() (Collector, error) {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *NETFramework_NETCLRInteropCollector) Collect(ch chan<- prometheus.Metric) error {
+func (c *NETFramework_NETCLRInteropCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
 	if desc, err := c.collect(ch); err != nil {
 		log.Error("failed collecting win32_perfrawdata_netframework_netclrinterop metrics:", desc, err)
 		return err

collector/netframework_clrjit.go

@@ -1,5 +1,5 @@
-// returns data points from Win32_PerfRawData_NETFramework_NETCLRJit
-// <add link to documentation here> - Win32_PerfRawData_NETFramework_NETCLRJit class
+// +build windows
+
 package collector
 
 import (
@@ -53,7 +53,7 @@ func NewNETFramework_NETCLRJitCollector() (Collector, error) {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *NETFramework_NETCLRJitCollector) Collect(ch chan<- prometheus.Metric) error {
+func (c *NETFramework_NETCLRJitCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
 	if desc, err := c.collect(ch); err != nil {
 		log.Error("failed collecting win32_perfrawdata_netframework_netclrjit metrics:", desc, err)
 		return err

collector/netframework_clrloading.go

@@ -1,5 +1,5 @@
-// returns data points from Win32_PerfRawData_NETFramework_NETCLRLoading
-// <add link to documentation here> - Win32_PerfRawData_NETFramework_NETCLRLoading class
+// +build windows
+
 package collector
 
 import (
@@ -88,7 +88,7 @@ func NewNETFramework_NETCLRLoadingCollector() (Collector, error) {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *NETFramework_NETCLRLoadingCollector) Collect(ch chan<- prometheus.Metric) error {
+func (c *NETFramework_NETCLRLoadingCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
 	if desc, err := c.collect(ch); err != nil {
 		log.Error("failed collecting win32_perfrawdata_netframework_netclrloading metrics:", desc, err)
 		return err

collector/netframework_clrlocksandthreads.go

@@ -1,5 +1,5 @@
-// returns data points from Win32_PerfRawData_NETFramework_NETCLRLocksAndThreads
-// <add link to documentation here> - Win32_PerfRawData_NETFramework_NETCLRLocksAndThreads class
+// +build windows
+
 package collector
 
 import (
@@ -74,7 +74,7 @@ func NewNETFramework_NETCLRLocksAndThreadsCollector() (Collector, error) {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *NETFramework_NETCLRLocksAndThreadsCollector) Collect(ch chan<- prometheus.Metric) error {
+func (c *NETFramework_NETCLRLocksAndThreadsCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
 	if desc, err := c.collect(ch); err != nil {
 		log.Error("failed collecting win32_perfrawdata_netframework_netclrlocksandthreads metrics:", desc, err)
 		return err

collector/netframework_clrmemory.go

@@ -1,5 +1,5 @@
-// returns data points from Win32_PerfRawData_NETFramework_NETCLRMemory
-// <add link to documentation here> - Win32_PerfRawData_NETFramework_NETCLRMemory class
+// +build windows
+
 package collector
 
 import (
@@ -112,7 +112,7 @@ func NewNETFramework_NETCLRMemoryCollector() (Collector, error) {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *NETFramework_NETCLRMemoryCollector) Collect(ch chan<- prometheus.Metric) error {
+func (c *NETFramework_NETCLRMemoryCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
 	if desc, err := c.collect(ch); err != nil {
 		log.Error("failed collecting win32_perfrawdata_netframework_netclrmemory metrics:", desc, err)
 		return err

collector/netframework_clrremoting.go

@@ -1,5 +1,5 @@
-// returns data points from Win32_PerfRawData_NETFramework_NETCLRRemoting
-// <add link to documentation here> - Win32_PerfRawData_NETFramework_NETCLRRemoting class
+// +build windows
+
 package collector
 
 import (
@@ -67,7 +67,7 @@ func NewNETFramework_NETCLRRemotingCollector() (Collector, error) {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *NETFramework_NETCLRRemotingCollector) Collect(ch chan<- prometheus.Metric) error {
+func (c *NETFramework_NETCLRRemotingCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
 	if desc, err := c.collect(ch); err != nil {
 		log.Error("failed collecting win32_perfrawdata_netframework_netclrremoting metrics:", desc, err)
 		return err

collector/netframework_clrsecurity.go

@@ -1,5 +1,5 @@
-// returns data points from Win32_PerfRawData_NETFramework_NETCLRSecurity
-// <add link to documentation here> - Win32_PerfRawData_NETFramework_NETCLRSecurity class
+// +build windows
+
 package collector
 
 import (
@@ -53,7 +53,7 @@ func NewNETFramework_NETCLRSecurityCollector() (Collector, error) {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *NETFramework_NETCLRSecurityCollector) Collect(ch chan<- prometheus.Metric) error {
+func (c *NETFramework_NETCLRSecurityCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
 	if desc, err := c.collect(ch); err != nil {
 		log.Error("failed collecting win32_perfrawdata_netframework_netclrsecurity metrics:", desc, err)
 		return err

collector/os.go

@@ -1,5 +1,4 @@
-// returns data points from Win32_OperatingSystem
-// https://msdn.microsoft.com/en-us/library/aa394239 - Win32_OperatingSystem class
+// +build windows
 
 package collector
 
@@ -114,7 +113,7 @@ func NewOSCollector() (Collector, error) {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *OSCollector) Collect(ch chan<- prometheus.Metric) error {
+func (c *OSCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
 	if desc, err := c.collect(ch); err != nil {
 		log.Error("failed collecting os metrics:", desc, err)
 		return err
@@ -122,6 +121,8 @@ func (c *OSCollector) Collect(ch chan<- prometheus.Metric) error {
 	return nil
 }
 
+// Win32_OperatingSystem docs:
+// - https://msdn.microsoft.com/en-us/library/aa394239 - Win32_OperatingSystem class
 type Win32_OperatingSystem struct {
 	FreePhysicalMemory      uint64
 	FreeSpaceInPagingFiles  uint64

collector/perflib.go

@@ -0,0 +1,100 @@
+package collector
+
+import (
+	"fmt"
+	"reflect"
+
+	perflibCollector "github.com/leoluk/perflib_exporter/collector"
+	"github.com/leoluk/perflib_exporter/perflib"
+	"github.com/prometheus/common/log"
+)
+
+func getPerflibSnapshot() (map[string]*perflib.PerfObject, error) {
+	objects, err := perflib.QueryPerformanceData("Global")
+	if err != nil {
+		return nil, err
+	}
+
+	indexed := make(map[string]*perflib.PerfObject)
+	for _, obj := range objects {
+		indexed[obj.Name] = obj
+	}
+	return indexed, nil
+}
+
+func unmarshalObject(obj *perflib.PerfObject, vs interface{}) error {
+	if obj == nil {
+		return fmt.Errorf("counter not found")
+	}
+	rv := reflect.ValueOf(vs)
+	if rv.Kind() != reflect.Ptr || rv.IsNil() {
+		return fmt.Errorf("%v is nil or not a pointer to slice", reflect.TypeOf(vs))
+	}
+	ev := rv.Elem()
+	if ev.Kind() != reflect.Slice {
+		return fmt.Errorf("%v is not slice", reflect.TypeOf(vs))
+	}
+
+	// Ensure sufficient length
+	if ev.Cap() < len(obj.Instances) {
+		nvs := reflect.MakeSlice(ev.Type(), len(obj.Instances), len(obj.Instances))
+		ev.Set(nvs)
+	}
+
+	for idx, instance := range obj.Instances {
+		target := ev.Index(idx)
+		rt := target.Type()
+
+		counters := make(map[string]*perflib.PerfCounter, len(instance.Counters))
+		for _, ctr := range instance.Counters {
+			if ctr.Def.IsBaseValue && !ctr.Def.IsNanosecondCounter {
+				counters[ctr.Def.Name+"_Base"] = ctr
+			} else {
+				counters[ctr.Def.Name] = ctr
+			}
+		}
+
+		for i := 0; i < target.NumField(); i++ {
+			f := rt.Field(i)
+			tag := f.Tag.Get("perflib")
+			if tag == "" {
+				continue
+			}
+
+			ctr, found := counters[tag]
+			if !found {
+				log.Debugf("missing counter %q, have %v", tag, counterMapKeys(counters))
+				continue
+			}
+			if !target.Field(i).CanSet() {
+				return fmt.Errorf("tagged field %v cannot be written to", f.Name)
+			}
+			if fieldType := target.Field(i).Type(); fieldType != reflect.TypeOf((*float64)(nil)).Elem() {
+				return fmt.Errorf("tagged field %v has wrong type %v, must be float64", f.Name, fieldType)
+			}
+
+			switch ctr.Def.CounterType {
+			case perflibCollector.PERF_ELAPSED_TIME:
+				target.Field(i).SetFloat(float64(ctr.Value-windowsEpoch) / float64(obj.Frequency))
+			case perflibCollector.PERF_100NSEC_TIMER, perflibCollector.PERF_PRECISION_100NS_TIMER:
+				target.Field(i).SetFloat(float64(ctr.Value) * ticksToSecondsScaleFactor)
+			default:
+				target.Field(i).SetFloat(float64(ctr.Value))
+			}
+		}
+
+		if instance.Name != "" && target.FieldByName("Name").CanSet() {
+			target.FieldByName("Name").SetString(instance.Name)
+		}
+	}
+
+	return nil
+}
+
+func counterMapKeys(m map[string]*perflib.PerfCounter) []string {
+	keys := make([]string, 0, len(m))
+	for k := range m {
+		keys = append(keys, k)
+	}
+	return keys
+}

collector/perflib_test.go

@@ -0,0 +1,125 @@
+package collector
+
+import (
+	"reflect"
+	"testing"
+
+	perflibCollector "github.com/leoluk/perflib_exporter/collector"
+	"github.com/leoluk/perflib_exporter/perflib"
+)
+
+type simple struct {
+	ValA float64 `perflib:"Something"`
+	ValB float64 `perflib:"Something Else"`
+}
+
+func TestUnmarshalPerflib(t *testing.T) {
+	cases := []struct {
+		name string
+		obj  *perflib.PerfObject
+
+		expectedOutput []simple
+		expectError    bool
+	}{
+		{
+			name:           "nil check",
+			obj:            nil,
+			expectedOutput: []simple{},
+			expectError:    true,
+		},
+		{
+			name: "Simple",
+			obj: &perflib.PerfObject{
+				Instances: []*perflib.PerfInstance{
+					{
+						Counters: []*perflib.PerfCounter{
+							{
+								Def: &perflib.PerfCounterDef{
+									Name:        "Something",
+									CounterType: perflibCollector.PERF_COUNTER_COUNTER,
+								},
+								Value: 123,
+							},
+						},
+					},
+				},
+			},
+			expectedOutput: []simple{{ValA: 123}},
+			expectError:    false,
+		},
+		{
+			name: "Multiple properties",
+			obj: &perflib.PerfObject{
+				Instances: []*perflib.PerfInstance{
+					{
+						Counters: []*perflib.PerfCounter{
+							{
+								Def: &perflib.PerfCounterDef{
+									Name:        "Something",
+									CounterType: perflibCollector.PERF_COUNTER_COUNTER,
+								},
+								Value: 123,
+							},
+							{
+								Def: &perflib.PerfCounterDef{
+									Name:        "Something Else",
+									CounterType: perflibCollector.PERF_COUNTER_COUNTER,
+								},
+								Value: 256,
+							},
+						},
+					},
+				},
+			},
+			expectedOutput: []simple{{ValA: 123, ValB: 256}},
+			expectError:    false,
+		},
+		{
+			name: "Multiple instances",
+			obj: &perflib.PerfObject{
+				Instances: []*perflib.PerfInstance{
+					{
+						Counters: []*perflib.PerfCounter{
+							{
+								Def: &perflib.PerfCounterDef{
+									Name:        "Something",
+									CounterType: perflibCollector.PERF_COUNTER_COUNTER,
+								},
+								Value: 321,
+							},
+						},
+					},
+					{
+						Counters: []*perflib.PerfCounter{
+							{
+								Def: &perflib.PerfCounterDef{
+									Name:        "Something",
+									CounterType: perflibCollector.PERF_COUNTER_COUNTER,
+								},
+								Value: 231,
+							},
+						},
+					},
+				},
+			},
+			expectedOutput: []simple{{ValA: 321}, {ValA: 231}},
+			expectError:    false,
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			output := make([]simple, 0)
+			err := unmarshalObject(c.obj, &output)
+			if err != nil && !c.expectError {
+				t.Errorf("Did not expect error, got %q", err)
+			}
+			if err == nil && c.expectError {
+				t.Errorf("Expected an error, but got ok")
+			}
+
+			if err == nil && !reflect.DeepEqual(output, c.expectedOutput) {
+				t.Errorf("Output mismatch, expected %+v, got %+v", c.expectedOutput, output)
+			}
+		})
+	}
+}

collector/process.go

@@ -1,5 +1,5 @@
-// returns data points from Win32_PerfRawData_PerfProc_Process
-// https://msdn.microsoft.com/en-us/library/aa394323(v=vs.85).aspx - Win32_PerfRawData_PerfProc_Process class
+// +build windows
+
 package collector
 
 import (
@@ -135,7 +135,7 @@ func NewProcessCollector() (Collector, error) {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *ProcessCollector) Collect(ch chan<- prometheus.Metric) error {
+func (c *ProcessCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
 	if desc, err := c.collect(ch); err != nil {
 		log.Error("failed collecting process metrics:", desc, err)
 		return err
@@ -143,6 +143,8 @@ func (c *ProcessCollector) Collect(ch chan<- prometheus.Metric) error {
 	return nil
 }
 
+// Win32_PerfRawData_PerfProc_Process docs:
+// - https://msdn.microsoft.com/en-us/library/aa394323(v=vs.85).aspx
 type Win32_PerfRawData_PerfProc_Process struct {
 	Name                    string
 	CreatingProcessID       uint32
@@ -191,7 +193,9 @@ func (c *ProcessCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Des
 
 	var dst_wp []WorkerProcess
 	q_wp := queryAll(&dst_wp)
-	wmi.QueryNamespace(q_wp, &dst_wp, "root\\WebAdministration")
+	if err := wmi.QueryNamespace(q_wp, &dst_wp, "root\\WebAdministration"); err != nil {
+		log.Debugf("Could not query WebAdministration namespace for IIS worker processes: %v. Skipping", err)
+	}
 
 	for _, process := range dst {
 

collector/service.go

@@ -1,5 +1,5 @@
-// returns data points from Win32_Service
-// https://msdn.microsoft.com/en-us/library/aa394418(v=vs.85).aspx - Win32_Service class
+// +build windows
+
 package collector
 
 import (
@@ -64,7 +64,7 @@ func NewserviceCollector() (Collector, error) {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *serviceCollector) Collect(ch chan<- prometheus.Metric) error {
+func (c *serviceCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
 	if desc, err := c.collect(ch); err != nil {
 		log.Error("failed collecting service metrics:", desc, err)
 		return err
@@ -72,6 +72,8 @@ func (c *serviceCollector) Collect(ch chan<- prometheus.Metric) error {
 	return nil
 }
 
+// Win32_Service docs:
+// - https://msdn.microsoft.com/en-us/library/aa394418(v=vs.85).aspx
 type Win32_Service struct {
 	Name      string
 	State     string

collector/system.go

@@ -1,5 +1,4 @@
-// returns data points from Win32_PerfRawData_PerfOS_System class
-// https://web.archive.org/web/20050830140516/http://msdn.microsoft.com/library/en-us/wmisdk/wmi/win32_perfrawdata_perfos_system.asp
+// +build windows
 
 package collector
 
@@ -70,7 +69,7 @@ func NewSystemCollector() (Collector, error) {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *SystemCollector) Collect(ch chan<- prometheus.Metric) error {
+func (c *SystemCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
 	if desc, err := c.collect(ch); err != nil {
 		log.Error("failed collecting system metrics:", desc, err)
 		return err
@@ -78,6 +77,8 @@ func (c *SystemCollector) Collect(ch chan<- prometheus.Metric) error {
 	return nil
 }
 
+// Win32_PerfRawData_PerfOS_System docs:
+// - https://web.archive.org/web/20050830140516/http://msdn.microsoft.com/library/en-us/wmisdk/wmi/win32_perfrawdata_perfos_system.asp
 type Win32_PerfRawData_PerfOS_System struct {
 	ContextSwitchesPersec     uint32
 	ExceptionDispatchesPersec uint32

collector/tcp.go

@@ -1,6 +1,4 @@
-// returns data points from Win32_PerfRawData_Tcpip_TCPv4
-
-// https://msdn.microsoft.com/en-us/library/aa394341(v=vs.85).aspx (Win32_PerfRawData_Tcpip_TCPv4 class)
+// +build windows
 
 package collector
 
@@ -92,7 +90,7 @@ func NewTCPCollector() (Collector, error) {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *TCPCollector) Collect(ch chan<- prometheus.Metric) error {
+func (c *TCPCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
 	if desc, err := c.collect(ch); err != nil {
 		log.Error("failed collecting tcp metrics:", desc, err)
 		return err
@@ -100,6 +98,8 @@ func (c *TCPCollector) Collect(ch chan<- prometheus.Metric) error {
 	return nil
 }
 
+// Win32_PerfRawData_Tcpip_TCPv4 docs
+// - https://msdn.microsoft.com/en-us/library/aa394341(v=vs.85).aspx
 type Win32_PerfRawData_Tcpip_TCPv4 struct {
 	ConnectionFailures          uint64
 	ConnectionsActive           uint64

collector/textfile.go

@@ -25,6 +25,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/dimchansky/utfbom"
 	"github.com/prometheus/client_golang/prometheus"
 	dto "github.com/prometheus/client_model/go"
 	"github.com/prometheus/common/expfmt"
@@ -211,7 +212,7 @@ func (cr carriageReturnFilteringReader) Read(p []byte) (int, error) {
 }
 
 // Update implements the Collector interface.
-func (c *textFileCollector) Collect(ch chan<- prometheus.Metric) error {
+func (c *textFileCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
 	error := 0.0
 	mtimes := map[string]time.Time{}
 
@@ -236,8 +237,17 @@ fileLoop:
 			continue
 		}
 		var parser expfmt.TextParser
-		parsedFamilies, err := parser.TextToMetricFamilies(carriageReturnFilteringReader{r: file})
-		file.Close()
+		r, encoding := utfbom.Skip(carriageReturnFilteringReader{r: file})
+		if err = checkBOM(encoding); err != nil {
+			log.Errorf("Invalid file encoding detected in %s: %s - file must be UTF8", path, err.Error())
+			error = 1.0
+			continue
+		}
+		parsedFamilies, err := parser.TextToMetricFamilies(r)
+		closeErr := file.Close()
+		if closeErr != nil {
+			log.Warnf("Error closing file: %v", err)
+		}
 		if err != nil {
 			log.Errorf("Error parsing %q: %v", path, err)
 			error = 1.0
@@ -279,3 +289,11 @@ fileLoop:
 	)
 	return nil
 }
+
+func checkBOM(encoding utfbom.Encoding) error {
+	if encoding == utfbom.Unknown || encoding == utfbom.UTF8 {
+		return nil
+	}
+
+	return fmt.Errorf(encoding.String())
+}

collector/textfile_test.go

@@ -1,14 +1,15 @@
 package collector
 
 import (
-	"testing"
-	"strings"
+	"github.com/dimchansky/utfbom"
 	"io/ioutil"
+	"strings"
+	"testing"
 )
 
 func TestCRFilter(t *testing.T) {
 	sr := strings.NewReader("line 1\r\nline 2")
-	cr := carriageReturnFilteringReader{ r: sr }
+	cr := carriageReturnFilteringReader{r: sr}
 	b, err := ioutil.ReadAll(cr)
 	if err != nil {
 		t.Error(err)
@@ -17,4 +18,30 @@ func TestCRFilter(t *testing.T) {
 	if string(b) != "line 1\nline 2" {
 		t.Errorf("Unexpected output %q", b)
 	}
-}
+}
+
+func TestCheckBOM(t *testing.T) {
+	testdata := []struct {
+		encoding utfbom.Encoding
+		err      string
+	}{
+		{utfbom.Unknown, ""},
+		{utfbom.UTF8, ""},
+		{utfbom.UTF16BigEndian, "UTF16BigEndian"},
+		{utfbom.UTF16LittleEndian, "UTF16LittleEndian"},
+		{utfbom.UTF32BigEndian, "UTF32BigEndian"},
+		{utfbom.UTF32LittleEndian, "UTF32LittleEndian"},
+	}
+	for _, d := range testdata {
+		err := checkBOM(d.encoding)
+		if d.err == "" && err != nil {
+			t.Error(err)
+		}
+		if d.err != "" && err == nil {
+			t.Errorf("Missing expected error %s", d.err)
+		}
+		if err != nil && !strings.Contains(err.Error(), d.err) {
+			t.Error(err)
+		}
+	}
+}

collector/thermalzone.go

@@ -0,0 +1,103 @@
+package collector
+
+import (
+	"github.com/StackExchange/wmi"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/common/log"
+)
+
+func init() {
+	Factories["thermalzone"] = NewThermalZoneCollector
+}
+
+// A thermalZoneCollector is a Prometheus collector for WMI Win32_PerfRawData_Counters_ThermalZoneInformation metrics
+type thermalZoneCollector struct {
+	PercentPassiveLimit *prometheus.Desc
+	Temperature         *prometheus.Desc
+	ThrottleReasons     *prometheus.Desc
+}
+
+// NewThermalZoneCollector ...
+func NewThermalZoneCollector() (Collector, error) {
+	const subsystem = "thermalzone"
+	return &thermalZoneCollector{
+		Temperature: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "temperature_celsius"),
+			"(Temperature)",
+			[]string{
+				"name",
+			},
+			nil,
+		),
+		PercentPassiveLimit: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "percent_passive_limit"),
+			"(PercentPassiveLimit)",
+			[]string{
+				"name",
+			},
+			nil,
+		),
+		ThrottleReasons: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "throttle_reasons"),
+			"(ThrottleReasons)",
+			[]string{
+				"name",
+			},
+			nil,
+		),
+	}, nil
+}
+
+// Collect sends the metric values for each metric
+// to the provided prometheus Metric channel.
+func (c *thermalZoneCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
+	if desc, err := c.collect(ch); err != nil {
+		log.Error("failed collecting thermalzone metrics:", desc, err)
+		return err
+	}
+	return nil
+}
+
+// Win32_PerfRawData_Counters_ThermalZoneInformation docs:
+// https://wutils.com/wmi/root/cimv2/win32_perfrawdata_counters_thermalzoneinformation/
+type Win32_PerfRawData_Counters_ThermalZoneInformation struct {
+	Name string
+
+	HighPrecisionTemperature uint32
+	PercentPassiveLimit      uint32
+	ThrottleReasons          uint32
+}
+
+func (c *thermalZoneCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
+	var dst []Win32_PerfRawData_Counters_ThermalZoneInformation
+	q := queryAll(&dst)
+	if err := wmi.Query(q, &dst); err != nil {
+		return nil, err
+	}
+
+	for _, info := range dst {
+		//Divide by 10 and subtract 273.15 to convert decikelvin to celsius
+		ch <- prometheus.MustNewConstMetric(
+			c.Temperature,
+			prometheus.GaugeValue,
+			(float64(info.HighPrecisionTemperature)/10.0)-273.15,
+			info.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.PercentPassiveLimit,
+			prometheus.GaugeValue,
+			float64(info.PercentPassiveLimit),
+			info.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.ThrottleReasons,
+			prometheus.GaugeValue,
+			float64(info.ThrottleReasons),
+			info.Name,
+		)
+	}
+
+	return nil, nil
+}

collector/vmware.go

@@ -1,4 +1,5 @@
-// returns data points from Win32_PerfRawData_vmGuestLib_VMem and Win32_PerfRawData_vmGuestLib_VCPU
+// +build windows
+
 package collector
 
 import (
@@ -37,6 +38,7 @@ type VmwareCollector struct {
 	HostProcessorSpeedMHz *prometheus.Desc
 }
 
+// NewVmwareCollector constructs a new VmwareCollector
 func NewVmwareCollector() (Collector, error) {
 	const subsystem = "vmware"
 	return &VmwareCollector{
@@ -160,7 +162,7 @@ func NewVmwareCollector() (Collector, error) {
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *VmwareCollector) Collect(ch chan<- prometheus.Metric) error {
+func (c *VmwareCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
 	if desc, err := c.collectMem(ch); err != nil {
 		log.Error("failed collecting vmware memory metrics:", desc, err)
 		return err

collector/wmi.go

@@ -4,27 +4,9 @@ import (
 	"bytes"
 	"reflect"
 
-	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/common/log"
 )
 
-// ...
-const (
-	Namespace = "wmi"
-
-	// Conversion factors
-	ticksToSecondsScaleFactor = 1 / 1e7
-)
-
-// Factories ...
-var Factories = make(map[string]func() (Collector, error))
-
-// Collector is the interface a collector has to implement.
-type Collector interface {
-	// Get new metrics and expose them via prometheus registry.
-	Collect(ch chan<- prometheus.Metric) (err error)
-}
-
 func className(src interface{}) string {
 	s := reflect.Indirect(reflect.ValueOf(src))
 	t := s.Type()

contrib/console_templates/wmi-overview.html

@@ -0,0 +1,140 @@
+{{ template "head" . }}
+
+{{ template "prom_content_head" . }}
+  <h1>Node Overview - {{ reReplaceAll "(.*?://)([^:/]+?)(:\\d+)?/.*" "$2" .Params.instance }}</h1>
+
+  <h3>CPU Usage</h3>
+  <div id="cpuGraph"></div>
+  <script>
+  new PromConsole.Graph({
+    node: document.querySelector("#cpuGraph"),
+    expr: "sum by (mode)(irate(wmi_cpu_time_total{job='node',instance='{{ .Params.instance }}',mode!='idle'}[5m]))",
+    renderer: 'area',
+    max: {{ with printf "count(count by (cpu)(wmi_cpu_time_total{job='node',instance='%s'}))" .Params.instance | query }}{{ . | first | value }}{{ else}}undefined{{end}},
+    yAxisFormatter: PromConsole.NumberFormatter.humanizeNoSmallPrefix,
+    yHoverFormatter: PromConsole.NumberFormatter.humanizeNoSmallPrefix,
+    yTitle: 'Cores'
+  })
+  </script>
+
+  <h3>Network Utilization</h3>
+  <div id="networkioGraph"></div>
+  <script>
+  new PromConsole.Graph({
+    node: document.querySelector("#networkioGraph"),
+    expr: [
+      "irate(wmi_net_bytes_sent_total{job='node',instance='{{ .Params.instance }}',nic!~'^isatap_ec2_internal'}[5m])",
+      "irate(wmi_net_bytes_received_total{job='node',instance='{{ .Params.instance }}',nic!~'^isatap_ec2_internal'}[5m])",
+    ],
+    min: 0,
+    name: [ 'sent', 'received' ],
+    yAxisFormatter: PromConsole.NumberFormatter.humanizeNoSmallPrefix,
+    yHoverFormatter: PromConsole.NumberFormatter.humanizeNoSmallPrefix,
+    yUnits: "B",
+    yTitle: 'Network IO'
+  })
+  </script>
+
+  <h3>Disk I/O Utilization</h3>
+  <div id="diskioGraph"></div>
+  <script>
+  new PromConsole.Graph({
+    node: document.querySelector("#diskioGraph"),
+    expr: [
+      "100 - irate(wmi_logical_disk_idle_seconds_total{job='node',instance='{{ .Params.instance }}',volume!~'^HarddiskVolume.*$'}[5m]) * 100",
+    ],
+    min: 0,
+    name: '[[ volume ]]',
+    yAxisFormatter: PromConsole.NumberFormatter.humanizeNoSmallPrefix,
+    yHoverFormatter: PromConsole.NumberFormatter.humanizeNoSmallPrefix,
+    yUnits: "%",
+    yTitle: 'Disk I/O Utilization'
+  })
+  </script>
+
+  <h3>Memory</h3>
+  <div id="memoryGraph"></div>
+  <script>
+  new PromConsole.Graph({
+    node: document.querySelector("#memoryGraph"),
+    renderer: 'area',
+    expr: [
+      "wmi_cs_physical_memory_bytes{job='node',instance='{{ .Params.instance }}'}",
+      "wmi_os_physical_memory_free_bytes{job='node',instance='{{ .Params.instance }}'}",
+      "wmi_cs_physical_memory__bytes{job='node',instance='{{ .Params.instance }}'} - wmi_os_physical_memory_free_bytes{job='node',instance='{{.Params.instance}}'}",
+      "wmi_os_virtual_memory_bytes{job='node',instance='{{ .Params.instance }}'}",
+    ],
+    name: ["Physical", "Free", "Used", "Virtual"],
+    min: 0,
+    yUnits: "B",
+    yAxisFormatter: PromConsole.NumberFormatter.humanize1024,
+    yHoverFormatter: PromConsole.NumberFormatter.humanize1024,
+    yTitle: 'Memory'
+  })
+  </script>
+
+{{ template "prom_right_table_head" }}
+  <tr><th colspan="2">Overview</th></tr>
+  <tr>
+    <td>User CPU</td>
+    <td>{{ template "prom_query_drilldown" (args (printf "sum(irate(wmi_cpu_time_total{job='node',instance='%s',mode='user'}[5m])) * 100 / count(count by (cpu)(wmi_cpu_time_total{job='node',instance='%s'}))" .Params.instance .Params.instance) "%" "printf.1f") }}</td>
+  </tr>
+  <tr>
+    <td>Privileged CPU</td>
+    <td>{{ template "prom_query_drilldown" (args (printf "sum(irate(wmi_cpu_time_total{job='node',instance='%s',mode='privileged'}[5m])) * 100 / count(count by (cpu)(wmi_cpu_time_total{job='node',instance='%s'}))" .Params.instance .Params.instance) "%" "printf.1f") }}</td>
+  </tr>
+  <tr>
+    <td>Memory Total</td>
+    <td>{{ template "prom_query_drilldown" (args (printf "wmi_cs_physical_memory_bytes{job='node',instance='%s'}" .Params.instance) "B" "humanize1024") }}</td>
+  </tr>
+  <tr>
+    <td>Memory Free</td>
+    <td>{{ template "prom_query_drilldown" (args (printf "wmi_os_physical_memory_free_bytes{job='node',instance='%s'}" .Params.instance) "B" "humanize1024") }}</td>
+  </tr>
+<tr>
+  <th colspan="2">Network</th>
+</tr>
+{{ range printf "wmi_net_bytes_received_total{job='node',instance='%s',nic!='isatap_ec2_internal'}" .Params.instance | query | sortByLabel "nic" }}
+  <tr>
+    <td>{{ .Labels.nic }} Received</td>
+    <td>{{ template "prom_query_drilldown" (args (printf "irate(wmi_net_bytes_received_total{job='node',instance='%s',nic='%s'}[5m])" .Labels.instance .Labels.nic) "B/s" "humanize") }}</td>
+  </tr>
+  <tr>
+    <td>{{ .Labels.nic }} Transmitted</td>
+    <td>{{ template "prom_query_drilldown" (args (printf "irate(wmi_net_bytes_sent_total{job='node',instance='%s',nic='%s'}[5m])" .Labels.instance .Labels.nic) "B/s" "humanize") }}</td>
+  </tr>
+{{ end }}
+</tr>
+<tr>
+  <th colspan="2">Disks</th>
+</tr>
+{{ range printf "wmi_logical_disk_size_bytes{job='node',instance='%s',volume!~'^HarddiskVolume.*$'}" .Params.instance | query | sortByLabel "volume" }}
+  <tr>
+    <td>{{ .Labels.volume }} Utilization</td>
+    <td>{{ template "prom_query_drilldown" (args (printf "100 - irate(wmi_logical_disk_idle_seconds_total{job='node',instance='%s',volume='%s'}[5m]) * 100" .Labels.instance .Labels.volume) "%" "printf.1f") }}</td>
+  </tr>
+{{ end }}
+{{ range printf "wmi_logical_disk_size_bytes{job='node',instance='%s',volume!~'^HarddiskVolume.*$'}" .Params.instance | query | sortByLabel "volume" }}
+  <tr>
+    <td>{{ .Labels.volume }} Throughput</td>
+    <td>{{ template "prom_query_drilldown" (args (printf "irate(wmi_logical_disk_read_bytes_total{job='node',instance='%s',volume='%s'}[5m]) + irate(wmi_logical_disk_write_bytes_total{job='node',instance='%s',volume='%s'}[5m])" .Labels.instance .Labels.volume .Labels.instance .Labels.volume) "B/s" "humanize") }}</td>
+  </tr>
+{{ end }}
+<tr>
+  <th colspan="2">Filesystem Fullness</th>
+</tr>
+{{ define "roughlyNearZero" }}
+{{ if gt .1 . }}~0{{ else }}{{ printf "%.1f" . }}{{ end }}
+{{ end }}
+{{ range printf "wmi_logical_disk_size_bytes{job='node',instance='%s',volume!~'^HarddiskVolume.*$'}" .Params.instance | query | sortByLabel "volume" }}
+  <tr>
+    <td>{{ .Labels.volume }}</td>
+    <td>{{ template "prom_query_drilldown" (args (printf "100 - wmi_logical_disk_free_bytes{job='node',instance='%s',volume='%s'} / wmi_logical_disk_size_bytes{job='node'} * 100" .Labels.instance .Labels.volume) "%" "roughlyNearZero") }}</td>
+  </tr>
+{{ end }}
+</tr>
+{{ template "prom_right_table_tail" }}
+
+{{ template "prom_content_tail" . }}
+
+{{ template "tail" }}

docs/README.md

@@ -0,0 +1,31 @@
+# Documentation
+This directory contains documentation of the collectors in the WMI exporter, with information such as what metrics are exported, any flags for additional configuration, and some example usage in alerts and queries.
+
+# Collectors
+- [`ad`](collector.ad.md)
+- [`cpu`](collector.cpu.md)
+- [`cs`](collector.cs.md)
+- [`dns`](collector.dns.md)
+- [`hyperv`](collector.hyperv.md)
+- [`iis`](collector.iis.md)
+- [`logical_disk`](collector.logical_disk.md)
+- [`logon`](collector.logon.md)
+- [`memory`](collector.memory.md)
+- [`msmq`](collector.msmq.md)
+- [`mssql`](collector.mssql.md)
+- [`netframework_clrexceptions`](collector.netframework_clrexceptions.md)
+- [`netframework_clrinterop`](collector.netframework_clrinterop.md)
+- [`netframework_clrjit`](collector.netframework_clrjit.md)
+- [`netframework_clrloading`](collector.netframework_clrloading.md)
+- [`netframework_clrlocksandthreads`](collector.netframework_clrlocksandthreads.md)
+- [`netframework_clrmemory`](collector.netframework_clrmemory.md)
+- [`netframework_clrremoting`](collector.netframework_clrremoting.md)
+- [`netframework_clrsecurity`](collector.netframework_clrsecurity.md)
+- [`net`](collector.net.md)
+- [`os`](collector.os.md)
+- [`process`](collector.process.md)
+- [`service`](collector.service.md)
+- [`system`](collector.system.md)
+- [`tcp`](collector.tcp.md)
+- [`textfile`](collector.textfile.md)
+- [`vmware`](collector.vmware.md)

docs/collector-template.md

@@ -0,0 +1,47 @@
+# %name% collector
+
+The %name% collector exposes metrics about ...
+
+|||
+-|-
+Metric name prefix  | `%name%`
+Classes             | [`...`](https://msdn.microsoft.com/en-us/library/...)
+Enabled by default? | Yes/No
+
+## Flags
+
+### `--collector....`
+
+Add description...
+
+Example: `--collector....`
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_...` | ... | counter/gauge/histogram/summary | ...
+
+### Example metric
+
+...:
+
+`wmi_...{...} 1`
+
+## Useful queries
+### Add queries...
+
+`...`
+
+## Alerting examples
+### Add alerts...
+
+```yaml
+  - alert: ""
+    expr: ""
+    for: ""
+    labels:
+      urgency: ""
+    annotations:
+      summary: ""
+```

docs/collector.ad.md

@@ -0,0 +1,88 @@
+# ad collector
+
+The ad collector exposes metrics about a Active Directory Domain Services domain controller
+
+|||
+-|-
+Metric name prefix  | `ad`
+Classes             | [`Win32_PerfRawData_DirectoryServices_DirectoryServices`](https://msdn.microsoft.com/en-us/library/ms803980.aspx)
+Enabled by default? | No
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_ad_address_book_operations_total` | _Not yet documented_ | counter | `operation`
+`wmi_ad_address_book_client_sessions` | _Not yet documented_ | gauge | None
+`wmi_ad_approximate_highest_distinguished_name_tag` | _Not yet documented_ | gauge | None
+`wmi_ad_atq_estimated_delay_seconds` | _Not yet documented_ | gauge | None
+`wmi_ad_atq_outstanding_requests` | _Not yet documented_ | gauge | None
+`wmi_ad_atq_average_request_latency` | _Not yet documented_ | gauge | None
+`wmi_ad_atq_current_threads` | _Not yet documented_ | gauge | `service`
+`wmi_ad_searches_total` | _Not yet documented_ | counter | `scope`
+`wmi_ad_database_operations_total` | _Not yet documented_ | counter | `operation`
+`wmi_ad_binds_total` | _Not yet documented_ | counter | `bind_method`
+`wmi_ad_replication_highest_usn` | _Not yet documented_ | counter | `state`
+`wmi_ad_replication_data_intrasite_bytes_total` | _Not yet documented_ | counter | `direction`
+`wmi_ad_replication_data_intersite_bytes_total` | _Not yet documented_ | counter | `direction`
+`wmi_ad_replication_inbound_sync_objects_remaining` | _Not yet documented_ | gauge | None
+`wmi_ad_replication_inbound_link_value_updates_remaining` | _Not yet documented_ | gauge | None
+`wmi_ad_replication_inbound_objects_updated_total` | _Not yet documented_ | counter | None
+`wmi_ad_replication_inbound_objects_filtered_total` | _Not yet documented_ | counter | None
+`wmi_ad_replication_inbound_properties_updated_total` | _Not yet documented_ | counter | None
+`wmi_ad_replication_inbound_properties_filtered_total` | _Not yet documented_ | counter | None
+`wmi_ad_replication_pending_operations` | _Not yet documented_ | gauge | None
+`wmi_ad_replication_pending_synchronizations` | _Not yet documented_ | gauge | None
+`wmi_ad_replication_sync_requests_total` | _Not yet documented_ | counter | None
+`wmi_ad_replication_sync_requests_success_total` | _Not yet documented_ | counter | None
+`wmi_ad_replication_sync_requests_schema_mismatch_failure_total` | _Not yet documented_ | counter | None
+`wmi_ad_name_translations_total` | _Not yet documented_ | counter | `target_name`
+`wmi_ad_change_monitors_registered` | _Not yet documented_ | gauge | None
+`wmi_ad_change_monitor_updates_pending` | _Not yet documented_ | gauge | None
+`wmi_ad_name_cache_hits_total` | _Not yet documented_ | counter | None
+`wmi_ad_name_cache_lookups_total` | _Not yet documented_ | counter | None
+`wmi_ad_directory_operations_total` | _Not yet documented_ | counter | `operation`, `origin`
+`wmi_ad_directory_search_suboperations_total` | _Not yet documented_ | counter | None
+`wmi_ad_security_descriptor_propagation_events_total` | _Not yet documented_ | counter | None
+`wmi_ad_security_descriptor_propagation_events_queued` | _Not yet documented_ | gauge | None
+`wmi_ad_security_descriptor_propagation_access_wait_total_seconds` | _Not yet documented_ | gauge | None
+`wmi_ad_security_descriptor_propagation_items_queued_total` | _Not yet documented_ | counter | None
+`wmi_ad_directory_service_threads` | _Not yet documented_ | gauge | None
+`wmi_ad_ldap_closed_connections_total` | _Not yet documented_ | counter | None
+`wmi_ad_ldap_opened_connections_total` | _Not yet documented_ | counter | `type`
+`wmi_ad_ldap_active_threads` | _Not yet documented_ | gauge | None
+`wmi_ad_ldap_last_bind_time_seconds` | _Not yet documented_ | gauge | None
+`wmi_ad_ldap_searches_total` | _Not yet documented_ | counter | None
+`wmi_ad_ldap_udp_operations_total` | _Not yet documented_ | counter | None
+`wmi_ad_ldap_writes_total` | _Not yet documented_ | counter | None
+`wmi_ad_link_values_cleaned_total` | _Not yet documented_ | counter | None
+`wmi_ad_phantom_objects_cleaned_total` | _Not yet documented_ | counter | None
+`wmi_ad_phantom_objects_visited_total` | _Not yet documented_ | counter | None
+`wmi_ad_sam_group_membership_evaluations_total` | _Not yet documented_ | counter | `group_type`
+`wmi_ad_sam_group_membership_global_catalog_evaluations_total` | _Not yet documented_ | counter | None
+`wmi_ad_sam_group_membership_evaluations_nontransitive_total` | _Not yet documented_ | counter | None
+`wmi_ad_sam_group_membership_evaluations_transitive_total` | _Not yet documented_ | counter | None
+`wmi_ad_sam_group_evaluation_latency` | _Not yet documented_ | gauge | `evaluation_type`
+`wmi_ad_sam_computer_creation_requests_total` | _Not yet documented_ | counter | None
+`wmi_ad_sam_computer_creation_successful_requests_total` | _Not yet documented_ | counter | None
+`wmi_ad_sam_user_creation_requests_total` | _Not yet documented_ | counter | None
+`wmi_ad_sam_user_creation_successful_requests_total` | _Not yet documented_ | counter | None
+`wmi_ad_sam_query_display_requests_total` | _Not yet documented_ | counter | None
+`wmi_ad_sam_enumerations_total` | _Not yet documented_ | counter | None
+`wmi_ad_sam_membership_changes_total` | _Not yet documented_ | counter | None
+`wmi_ad_sam_password_changes_total` | _Not yet documented_ | counter | None
+`wmi_ad_tombstoned_objects_collected_total` | _Not yet documented_ | counter | None
+`wmi_ad_tombstoned_objects_visited_total` | _Not yet documented_ | counter | None
+
+### 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.container.md

@@ -0,0 +1,42 @@
+# container collector
+
+The container collector exposes metrics about containers running on system
+
+|||
+-|-
+Metric name prefix  | `container`
+Enabled by default? | No
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_container_available` | Available | counter | `container_id`
+`wmi_container_count` | Number of containers | gauge | `container_id`
+`wmi_container_cpu_usage_seconds_kernelmode` | Run time in Kernel mode in Seconds | counter | `container_id`
+`wmi_container_cpu_usage_seconds_usermode` | Run Time in User mode in Seconds | counter | `container_id`
+`wmi_container_cpu_usage_seconds_total` | Total Run time in Seconds | counter | `container_id`
+`wmi_container_memory_usage_commit_bytes` | Memory Usage Commit Bytes | gauge | `container_id`
+`wmi_container_memory_usage_commit_peak_bytes` | Memory Usage Commit Peak Bytes | gauge | `container_id`
+`wmi_container_memory_usage_private_working_set_bytes` | Memory Usage Private Working Set Bytes | gauge | `container_id`
+`wmi_container_network_receive_bytes_total` | Bytes Received on Interface | counter | `container_id`, `interface`
+`wmi_container_network_receive_packets_total` | Packets Received on Interface | counter | `container_id`, `interface`
+`wmi_container_network_receive_packets_dropped_total` | Dropped Incoming Packets on Interface | counter | `container_id`, `interface`
+`wmi_container_network_transmit_bytes_total` | Bytes Sent on Interface | counter | `container_id`, `interface`
+`wmi_container_network_transmit_packets_total` | Packets Sent on Interface | counter | `container_id`, `interface`
+`wmi_container_network_transmit_packets_dropped_total` | Dropped Outgoing Packets on Interface | counter | `container_id`, `interface`
+
+### Example metric
+_wmi_container_network_receive_bytes_total{container_id="docker://1bd30e8b8ac28cbd76a9b697b4d7bb9d760267b0733d1bc55c60024e98d1e43e",interface="822179E7-002C-4280-ABBA-28BCFE401826"} 9.3305343e+07_
+
+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!_
+
+## Alerting examples
+_This collector does not yet have alerting examples, we would appreciate your help adding them!_

docs/collector.cpu.md

@@ -0,0 +1,60 @@
+# cpu collector
+
+The cpu collector exposes metrics about CPU usage
+
+|||
+-|-
+Metric name prefix  | `cpu`
+Data source         | Perflib
+Counters            | `ProcessorInformation` (Windows Server 2008R2 and later) `Processor` (older versions)
+Enabled by default? | Yes
+
+## Flags
+
+None
+
+## Metrics
+These metrics are available on all versions of Windows:
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_cpu_cstate_seconds_total` | Time spent in low-power idle states | counter | `core`, `state`
+`wmi_cpu_time_total` | Time that processor spent in different modes (idle, user, system, ...) | counter | `core`, `mode`
+`wmi_cpu_interrupts_total` | Total number of received and serviced hardware interrupts | counter | `core`
+`wmi_cpu_dpcs_total` | Total number of received and serviced deferred procedure calls (DPCs) | counter | `core`
+
+These metrics are only exposed on Windows Server 2008R2 and later:
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_cpu_clock_interrupts_total` | Total number of received and serviced clock tick interrupts | `core`
+`wmi_cpu_idle_break_events_total` | Total number of time processor was woken from idle | `core`
+`wmi_cpu_parking_status` | Parking Status represents whether a processor is parked or not | `gauge`
+`wmi_cpu_core_frequency_mhz` | Core frequency in megahertz | `gauge`
+`wmi_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% | `gauge`
+
+### Example metric
+Show frequency of host CPU cores
+```
+wmi_cpu_core_frequency_mhz{instance="localhost"}
+```
+
+## Useful queries
+Show cpu usage by mode.
+```
+sum by (mode) (irate(wmi_cpu_time_total{instance="localhost"}[5m]))
+```
+
+## Alerting examples
+**prometheus.rules**
+```
+# Alert on hosts with more than 80% CPU usage over a 10 minute period
+- alert: CpuUsage
+  expr: 100 - (avg by (instance) (irate(wmi_cpu_time_total{mode="idle"}[2m])) * 100) > 80
+  for: 10m
+  labels:
+    severity: warning
+  annotations:
+    summary: "CPU Usage (instance {{ $labels.instance }})"
+    description: "CPU Usage is more than 80%\n  VALUE = {{ $value }}\n  LABELS: {{ $labels }}"
+```

docs/collector.cs.md

@@ -0,0 +1,29 @@
+# cs collector
+
+The cs collector exposes metrics detailing the hardware of the computer system
+
+|||
+-|-
+Metric name prefix  | `cs`
+Classes             | [`Win32_ComputerSystem`](https://msdn.microsoft.com/en-us/library/aa394102)
+Enabled by default? | Yes
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_cs_logical_processors` | Number of installed logical processors | gauge | None
+`wmi_cs_physical_memory_bytes` | Total installed physical memory | gauge | None
+
+### 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.dns.md

@@ -0,0 +1,49 @@
+# dns collector
+
+The dns collector exposes metrics about the DNS server
+
+|||
+-|-
+Metric name prefix  | `dns`
+Classes             | [`Win32_PerfRawData_DNS_DNS`](https://technet.microsoft.com/en-us/library/cc977686.aspx)
+Enabled by default? | No
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_dns_zone_transfer_requests_received_total` | _Not yet documented_ | counter | `qtype`
+`wmi_dns_zone_transfer_requests_sent_total` | _Not yet documented_ | counter | `qtype`
+`wmi_dns_zone_transfer_response_received_total` | _Not yet documented_ | counter | `qtype`
+`wmi_dns_zone_transfer_success_received_total` | _Not yet documented_ | counter | `qtype`, `protocol`
+`wmi_dns_zone_transfer_success_sent_total` | _Not yet documented_ | counter | `qtype`
+`wmi_dns_zone_transfer_failures_total` | _Not yet documented_ | counter | None
+`wmi_dns_memory_used_bytes_total` | _Not yet documented_ | gauge | `area`
+`wmi_dns_dynamic_updates_queued` | _Not yet documented_ | gauge | None
+`wmi_dns_dynamic_updates_received_total` | _Not yet documented_ | counter | `operation`
+`wmi_dns_dynamic_updates_failures_total` | _Not yet documented_ | counter | `reason`
+`wmi_dns_notify_received_total` | _Not yet documented_ | counter | None
+`wmi_dns_notify_sent_total` | _Not yet documented_ | counter | None
+`wmi_dns_secure_update_failures_total` | _Not yet documented_ | counter | None
+`wmi_dns_secure_update_received_total` | _Not yet documented_ | counter | None
+`wmi_dns_queries_total` | _Not yet documented_ | counter | `protocol`
+`wmi_dns_responses_total` | _Not yet documented_ | counter | `protocol`
+`wmi_dns_recursive_queries_total` | _Not yet documented_ | counter | None
+`wmi_dns_recursive_query_failures_total` | _Not yet documented_ | counter | None
+`wmi_dns_recursive_query_send_timeouts_total` | _Not yet documented_ | counter | None
+`wmi_dns_wins_queries_total` | _Not yet documented_ | counter | `direction`
+`wmi_dns_wins_responses_total` | _Not yet documented_ | counter | `direction`
+`wmi_dns_unmatched_responses_total` | _Not yet documented_ | counter | None
+
+### 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.hyperv.md

@@ -0,0 +1,102 @@
+# hyperv collector
+
+The hyperv collector exposes metrics about the Hyper-V hypervisor
+
+|||
+-|-
+Metric name prefix  | `hyperv`
+Classes             | `Win32_PerfRawData_VmmsVirtualMachineStats_HyperVVirtualMachineHealthSummary`<br/>`Win32_PerfRawData_VidPerfProvider_HyperVVMVidPartition`<br/>`Win32_PerfRawData_HvStats_HyperVHypervisorRootPartition`<br/>`Win32_PerfRawData_HvStats_HyperVHypervisor`<br/>`Win32_PerfRawData_HvStats_HyperVHypervisorRootVirtualProcessor`<br/>`Win32_PerfRawData_HvStats_HyperVHypervisorVirtualProcessor`<br/>`Win32_PerfRawData_NvspSwitchStats_HyperVVirtualSwitch`<br/>`Win32_PerfRawData_EthernetPerfProvider_HyperVLegacyNetworkAdapter`<br/>`Win32_PerfRawData_Counters_HyperVVirtualStorageDevice`<br/>`Win32_PerfRawData_NvspNicStats_HyperVVirtualNetworkAdapter`
+Enabled by default? | No
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_hyper_health_critical` | _Not yet documented_ | counter | None
+`wmi_hyper_health_ok` | _Not yet documented_ | counter | None
+`wmi_hyper_vid_physical_pages_allocated` | _Not yet documented_ | counter | `vm`
+`wmi_hyper_vid_preferred_numa_node_index` | _Not yet documented_ | counter | `vm`
+`wmi_hyper_vid_remote_physical_pages` | _Not yet documented_ | counter | `vm`
+`wmi_hyper_root_partition_address_spaces` | _Not yet documented_ | counter | None
+`wmi_hyper_root_partition_attached_devices` | _Not yet documented_ | counter | None
+`wmi_hyper_root_partition_deposited_pages` | _Not yet documented_ | counter | None
+`wmi_hyper_root_partition_device_dma_errors` | _Not yet documented_ | counter | None
+`wmi_hyper_root_partition_device_interrupt_errors` | _Not yet documented_ | counter | None
+`wmi_hyper_root_partition_device_interrupt_mappings` | _Not yet documented_ | counter | None
+`wmi_hyper_root_partition_device_interrupt_throttle_events` | _Not yet documented_ | counter | None
+`wmi_hyper_root_partition_preferred_numa_node_index` | _Not yet documented_ | counter | None
+`wmi_hyper_root_partition_gpa_space_modifications` | _Not yet documented_ | counter | None
+`wmi_hyper_root_partition_io_tlb_flush_cost` | _Not yet documented_ | counter | None
+`wmi_hyper_root_partition_io_tlb_flush` | _Not yet documented_ | counter | None
+`wmi_hyper_root_partition_recommended_virtual_tlb_size` | _Not yet documented_ | counter | None
+`wmi_hyper_root_partition_physical_pages_allocated` | _Not yet documented_ | counter | None
+`wmi_hyper_root_partition_1G_device_pages` | _Not yet documented_ | counter | None
+`wmi_hyper_root_partition_1G_gpa_pages` | _Not yet documented_ | counter | None
+`wmi_hyper_root_partition_2M_device_pages` | _Not yet documented_ | counter | None
+`wmi_hyper_root_partition_2M_gpa_pages` | _Not yet documented_ | counter | None
+`wmi_hyper_root_partition_4K_device_pages` | _Not yet documented_ | counter | None
+`wmi_hyper_root_partition_4K_gpa_pages` | _Not yet documented_ | counter | None
+`wmi_hyper_root_partition_virtual_tlb_flush_entires` | _Not yet documented_ | counter | None
+`wmi_hyper_root_partition_virtual_tlb_pages` | _Not yet documented_ | counter | None
+`wmi_hyper_hypervisor_virtual_processors` | _Not yet documented_ | counter | None
+`wmi_hyper_hypervisor_logical_processors` | _Not yet documented_ | counter | None
+`wmi_hyper_host_cpu_guest_run_time` | _Not yet documented_ | counter | `core`
+`wmi_hyper_host_cpu_hypervisor_run_time` | _Not yet documented_ | counter | `core`
+`wmi_hyper_host_cpu_remote_run_time` | _Not yet documented_ | counter | `core`
+`wmi_hyper_host_cpu_total_run_time` | _Not yet documented_ | counter | `core`
+`wmi_hyper_vm_cpu_guest_run_time` | _Not yet documented_ | counter | `vm`, `core`
+`wmi_hyper_vm_cpu_hypervisor_run_time` | _Not yet documented_ | counter | `vm`, `core`
+`wmi_hyper_vm_cpu_remote_run_time` | _Not yet documented_ | counter | `vm`, `core`
+`wmi_hyper_vm_cpu_total_run_time` | _Not yet documented_ | counter | `vm`, `core`
+`wmi_hyper_vswitch_broadcast_packets_received_total` | _Not yet documented_ | counter | `vswitch`
+`wmi_hyper_vswitch_broadcast_packets_sent_total` | _Not yet documented_ | counter | `vswitch`
+`wmi_hyper_vswitch_bytes_total` | _Not yet documented_ | counter | `vswitch`
+`wmi_hyper_vswitch_bytes_received_total` | _Not yet documented_ | counter | `vswitch`
+`wmi_hyper_vswitch_bytes_sent_total` | _Not yet documented_ | counter | `vswitch`
+`wmi_hyper_vswitch_directed_packets_received_total` | _Not yet documented_ | counter | `vswitch`
+`wmi_hyper_vswitch_directed_packets_send_total` | _Not yet documented_ | counter | `vswitch`
+`wmi_hyper_vswitch_dropped_packets_incoming_total` | _Not yet documented_ | counter | `vswitch`
+`wmi_hyper_vswitch_dropped_packets_outcoming_total` | _Not yet documented_ | counter | `vswitch`
+`wmi_hyper_vswitch_extensions_dropped_packets_incoming_total` | _Not yet documented_ | counter | `vswitch`
+`wmi_hyper_vswitch_extensions_dropped_packets_outcoming_total` | _Not yet documented_ | counter | `vswitch`
+`wmi_hyper_vswitch_learned_mac_addresses_total` | _Not yet documented_ | counter | `vswitch`
+`wmi_hyper_vswitch_multicast_packets_received_total` | _Not yet documented_ | counter | `vswitch`
+`wmi_hyper_vswitch_multicast_packets_sent_total` | _Not yet documented_ | counter | `vswitch`
+`wmi_hyper_vswitch_number_of_send_channel_moves_total` | _Not yet documented_ | counter | `vswitch`
+`wmi_hyper_vswitch_number_of_vmq_moves_total` | _Not yet documented_ | counter | `vswitch`
+`wmi_hyper_vswitch_packets_flooded_total` | _Not yet documented_ | counter | `vswitch`
+`wmi_hyper_vswitch_packets_total` | _Not yet documented_ | counter | `vswitch`
+`wmi_hyper_vswitch_packets_received_total` | _Not yet documented_ | counter | `vswitch`
+`wmi_hyper_vswitch_packets_sent_total` | _Not yet documented_ | counter | `vswitch`
+`wmi_hyper_vswitch_purged_mac_addresses_total` | _Not yet documented_ | counter | `vswitch`
+`wmi_hyper_ethernet_bytes_dropped` | _Not yet documented_ | counter | `adapter`
+`wmi_hyper_ethernet_bytes_received` | _Not yet documented_ | counter | `adapter`
+`wmi_hyper_ethernet_bytes_sent` | _Not yet documented_ | counter | `adapter`
+`wmi_hyper_ethernet_frames_dropped` | _Not yet documented_ | counter | `adapter`
+`wmi_hyper_ethernet_frames_received` | _Not yet documented_ | counter | `adapter`
+`wmi_hyper_ethernet_frames_sent` | _Not yet documented_ | counter | `adapter`
+`wmi_hyper_vm_device_error_count` | _Not yet documented_ | counter | `vm_device`
+`wmi_hyper_vm_device_queue_length` | _Not yet documented_ | counter | `vm_device`
+`wmi_hyper_vm_device_bytes_read` | _Not yet documented_ | counter | `vm_device`
+`wmi_hyper_vm_device_operations_read` | _Not yet documented_ | counter | `vm_device`
+`wmi_hyper_vm_device_bytes_written` | _Not yet documented_ | counter | `vm_device`
+`wmi_hyper_vm_device_operations_written` | _Not yet documented_ | counter | `vm_device`
+`wmi_hyper_vm_interface_bytes_received` | _Not yet documented_ | counter | `vm_interface`
+`wmi_hyper_vm_interface_bytes_sent` | _Not yet documented_ | counter | `vm_interface`
+`wmi_hyper_vm_interface_packets_incoming_dropped` | _Not yet documented_ | counter | `vm_interface`
+`wmi_hyper_vm_interface_packets_outgoing_dropped` | _Not yet documented_ | counter | `vm_interface`
+`wmi_hyper_vm_interface_packets_received` | _Not yet documented_ | counter | `vm_interface`
+`wmi_hyper_vm_interface_packets_sent` | _Not yet documented_ | counter | `vm_interface`
+
+### 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.iis.md

@@ -0,0 +1,140 @@
+# iis collector
+
+The iis collector exposes metrics about the IIS server
+
+|||
+-|-
+Metric name prefix  | `iis`
+Classes             | `Win32_PerfRawData_W3SVC_WebService`<br/>`Win32_PerfRawData_APPPOOLCountersProvider_APPPOOLWAS`<br/>`Win32_PerfRawData_W3SVCW3WPCounterProvider_W3SVCW3WP`<br/>`Win32_PerfRawData_W3SVC_WebServiceCache`
+Enabled by default? | No
+
+## Flags
+
+### `--collector.iis.site-whitelist`
+
+If given, a site needs to match the whitelist regexp in order for the corresponding metrics to be reported.
+
+### `--collector.iis.site-blacklist`
+
+If given, a site needs to *not* match the blacklist regexp in order for the corresponding metrics to be reported.
+
+### `--collector.iis.app-whitelist`
+
+If given, an application needs to match the whitelist regexp in order for the corresponding metrics to be reported.
+
+### `--collector.iis.app-blacklist`
+
+If given, an application needs to *not* match the blacklist regexp in order for the corresponding metrics to be reported.
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_iis_current_anonymous_users` | _Not yet documented_ | counter | `site`
+`wmi_iis_current_blocked_async_io_requests` | _Not yet documented_ | counter | `site`
+`wmi_iis_current_cgi_requests` | _Not yet documented_ | counter | `site`
+`wmi_iis_current_connections` | _Not yet documented_ | counter | `site`
+`wmi_iis_current_isapi_extension_requests` | _Not yet documented_ | counter | `site`
+`wmi_iis_current_non_anonymous_users` | _Not yet documented_ | counter | `site`
+`wmi_iis_received_bytes_total` | _Not yet documented_ | counter | `site`
+`wmi_iis_sent_bytes_total` | _Not yet documented_ | counter | `site`
+`wmi_iis_anonymous_users_total` | _Not yet documented_ | counter | `site`
+`wmi_iis_blocked_async_io_requests_total` | _Not yet documented_ | counter | `site`
+`wmi_iis_cgi_requests_total` | _Not yet documented_ | counter | `site`
+`wmi_iis_connection_attempts_all_instances_total` | _Not yet documented_ | counter | `site`
+`wmi_iis_requests_total` | _Not yet documented_ | counter | `site`, `method`
+`wmi_iis_files_received_total` | _Not yet documented_ | counter | `site`
+`wmi_iis_files_sent_total` | _Not yet documented_ | counter | `site`
+`wmi_iis_ipapi_extension_requests_total` | _Not yet documented_ | counter | `site`
+`wmi_iis_locked_errors_total` | _Not yet documented_ | counter | `site`
+`wmi_iis_logon_attempts_total` | _Not yet documented_ | counter | `site`
+`wmi_iis_non_anonymous_users_total` | _Not yet documented_ | counter | `site`
+`wmi_iis_not_found_errors_total` | _Not yet documented_ | counter | `site`
+`wmi_iis_rejected_async_io_requests_total` | _Not yet documented_ | counter | `site`
+`wmi_iis_current_application_pool_state` | _Not yet documented_ | counter | `app`, `state`
+`wmi_iis_current_application_pool_start_time` | _Not yet documented_ | counter | `app`
+`wmi_iis_current_worker_processes` | _Not yet documented_ | counter | `app`
+`wmi_iis_maximum_worker_processes` | _Not yet documented_ | counter | `app`
+`wmi_iis_recent_worker_process_failures` | _Not yet documented_ | counter | `app`
+`wmi_iis_time_since_last_worker_process_failure` | _Not yet documented_ | counter | `app`
+`wmi_iis_total_application_pool_recycles` | _Not yet documented_ | counter | `app`
+`wmi_iis_total_application_pool_start_time` | _Not yet documented_ | counter | `app`
+`wmi_iis_total_worker_processes_created` | _Not yet documented_ | counter | `app`
+`wmi_iis_total_worker_process_failures` | _Not yet documented_ | counter | `app`
+`wmi_iis_total_worker_process_ping_failures` | _Not yet documented_ | counter | `app`
+`wmi_iis_total_worker_process_shutdown_failures` | _Not yet documented_ | counter | `app`
+`wmi_iis_total_worker_process_startup_failures` | _Not yet documented_ | counter | `app`
+`wmi_iis_worker_cache_active_flushed_entries` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_file_cache_memory_bytes` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_file_cache_max_memory_bytes` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_file_cache_flushes_total` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_file_cache_queries_total` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_file_cache_hits_total` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_file_cache_items` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_file_cache_items_total` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_file_cache_items_flushed_total` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_uri_cache_flushes_total` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_uri_cache_queries_total` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_uri_cache_hits_total` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_uri_cache_items` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_uri_cache_items_total` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_uri_cache_items_flushed_total` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_metadata_cache_items` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_metadata_cache_flushes_total` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_metadata_cache_queries_total` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_metadata_cache_hits_total` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_metadata_cache_items_cached_total` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_metadata_cache_items_flushed_total` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_output_cache_active_flushed_items` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_output_cache_items` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_output_cache_memory_bytes` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_output_queries_total` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_output_cache_hits_total` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_output_cache_items_flushed_total` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_output_cache_flushes_total` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_threads` | _Not yet documented_ | counter | `app`, `pid`, `state`
+`wmi_iis_worker_max_threads` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_requests_total` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_current_requests` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_request_errors_total` | _Not yet documented_ | counter | `app`, `pid`, `status_code`
+`wmi_iis_worker_current_websocket_requests` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_websocket_connection_attempts_total` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_websocket_connection_accepted_total` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_worker_websocket_connection_rejected_total` | _Not yet documented_ | counter | `app`, `pid`
+`wmi_iis_server_cache_active_flushed_entries` | _Not yet documented_ | counter | None
+`wmi_iis_server_file_cache_memory_bytes` | _Not yet documented_ | counter | None
+`wmi_iis_server_file_cache_max_memory_bytes` | _Not yet documented_ | counter | None
+`wmi_iis_server_file_cache_flushes_total` | _Not yet documented_ | counter | None
+`wmi_iis_server_file_cache_queries_total` | _Not yet documented_ | counter | None
+`wmi_iis_server_file_cache_hits_total` | _Not yet documented_ | counter | None
+`wmi_iis_server_file_cache_items` | _Not yet documented_ | counter | None
+`wmi_iis_server_file_cache_items_total` | _Not yet documented_ | counter | None
+`wmi_iis_server_file_cache_items_flushed_total` | _Not yet documented_ | counter | None
+`wmi_iis_server_uri_cache_flushes_total` | _Not yet documented_ | counter | `mode`
+`wmi_iis_server_uri_cache_queries_total` | _Not yet documented_ | counter | `mode`
+`wmi_iis_server_uri_cache_hits_total` | _Not yet documented_ | counter | `mode`
+`wmi_iis_server_uri_cache_items` | _Not yet documented_ | counter | `mode`
+`wmi_iis_server_uri_cache_items_total` | _Not yet documented_ | counter | `mode`
+`wmi_iis_server_uri_cache_items_flushed_total` | _Not yet documented_ | counter | `mode`
+`wmi_iis_server_metadata_cache_items` | _Not yet documented_ | counter | None
+`wmi_iis_server_metadata_cache_flushes_total` | _Not yet documented_ | counter | None
+`wmi_iis_server_metadata_cache_queries_total` | _Not yet documented_ | counter | None
+`wmi_iis_server_metadata_cache_hits_total` | _Not yet documented_ | counter | None
+`wmi_iis_server_metadata_cache_items_cached_total` | _Not yet documented_ | counter | None
+`wmi_iis_server_metadata_cache_items_flushed_total` | _Not yet documented_ | counter | None
+`wmi_iis_server_output_cache_active_flushed_items` | _Not yet documented_ | counter | None
+`wmi_iis_server_output_cache_items` | _Not yet documented_ | counter | None
+`wmi_iis_server_output_cache_memory_bytes` | _Not yet documented_ | counter | None
+`wmi_iis_server_output_cache_queries_total` | _Not yet documented_ | counter | None
+`wmi_iis_server_output_cache_hits_total` | _Not yet documented_ | counter | None
+`wmi_iis_server_output_cache_items_flushed_total` | _Not yet documented_ | counter | None
+`wmi_iis_server_output_cache_flushes_total` | _Not yet documented_ | counter | None
+
+### 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.logical_disk.md

@@ -0,0 +1,75 @@
+# logical_disk collector
+
+The logical_disk collector exposes metrics about logical disks (in contrast to physical disks)
+
+|||
+-|-
+Metric name prefix  | `logical_disk`
+Classes             | [`Win32_PerfRawData_PerfDisk_LogicalDisk`](https://msdn.microsoft.com/en-us/windows/hardware/aa394307(v=vs.71))
+Enabled by default? | Yes
+
+## Flags
+
+### `--collector.logical_disk.volume-whitelist`
+
+If given, a disk needs to match the whitelist regexp in order for the corresponding disk metrics to be reported
+
+### `--collector.logical_disk.volume-blacklist`
+
+If given, a disk needs to *not* match the blacklist regexp in order for the corresponding disk metrics to be reported
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`requests_queued` | Number of requests outstanding on the disk at the time the performance data is collected | gauge | `volume`
+`read_bytes_total` | Rate at which bytes are transferred from the disk during read operations | counter | `volume`
+`reads_total` | Rate of read operations on the disk | counter | `volume`
+`write_bytes_total` | Rate at which bytes are transferred to the disk during write operations  | counter | `volume`
+`writes_total` | Rate of write operations on the disk  | counter | `volume`
+`read_seconds_total` | Seconds the disk was busy servicing read requests | counter | `volume`
+`write_seconds_total` | Seconds the disk was busy servicing write requests | counter | `volume`
+`free_bytes` | Unused space of the disk in bytes | gauge | `volume`
+`size_bytes` | Total size of the disk in bytes | gauge | `volume`
+`idle_seconds_total` | Seconds the disk was idle (not servicing read/write requests) | counter | `volume`
+`split_ios_total` | Number of I/Os to the disk split into multiple I/Os | counter | `volume`
+
+### Example metric
+Query the rate of write operations to a disk
+```
+rate(wmi_logical_disk_read_bytes_total{instance="localhost", volume=~"C:"}[2m])
+```
+
+## Useful queries
+Calculate rate of total IOPS for disk
+```
+rate(wmi_logical_disk_reads_total{instance="localhost", volume="C:"}[2m]) + rate(wmi_logical_disk_writes_total{instance="localhost", volume="C:"}[2m])
+```
+
+## Alerting examples
+**prometheus.rules**
+```
+groups:
+- name: Windows Disk Alerts
+  rules:
+
+  # Sends an alert when disk space usage is above 95%
+  - alert: DiskSpaceUsage
+    expr: 100.0 - 100 * (wmi_logical_disk_free_bytes / wmi_logical_disk_size_bytes) > 95
+    for: 10m
+    labels:
+      severity: high
+    annotations:
+      summary: "Disk Space Usage (instance {{ $labels.instance }})"
+      description: "Disk Space on Drive is used more than 95%\n  VALUE = {{ $value }}\n  LABELS: {{ $labels }}"
+
+  # Alerts on disks with over 85% space usage predicted to fill within the next four days
+  - alert: DiskFilling
+    expr: 100 * (wmi_logical_disk_free_bytes / wmi_logical_disk_size_bytes) < 15 and predict_linear(wmi_logical_disk_free_bytes[6h], 4 * 24 * 3600) < 0
+    for: 10m
+    labels:
+      severity: warning
+    annotations:
+      summary: "Disk full in four days (instance {{ $labels.instance }})"
+      description: "{{ $labels.volume }} is expected to fill up within four days. Currently {{ $value | humanize }}% is available.\n VALUE = {{ $value }}\n LABELS: {{ $labels }}"
+```

docs/collector.logon.md

@@ -0,0 +1,34 @@
+# logon collector
+
+The logon collector exposes metrics detailing the active user logon sessions.
+
+|||
+-|-
+Metric name prefix  | `logon`
+Classes             | [`Win32_LogonSession`](https://docs.microsoft.com/en-us/windows/win32/cimwin32prov/win32-logonsession)
+Enabled by default? | No
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_logon_logon_type` | Number of active user logon sessions | gauge | status
+
+### Example metric
+Query the total number of interactive logon sessions
+```
+wmi_logon_logon_type{status="interactive"}
+```
+
+## Useful queries
+Query the total number of local and remote (I.E. Terminal Services) interactive sessions.
+```
+wmi_logon_logon_type{status=~"interactive|remoteinteractive"}
+```
+
+## Alerting examples
+_This collector does not yet have alerting examples, we would appreciate your help adding them!_

docs/collector.memory.md

@@ -0,0 +1,61 @@
+# memory collector
+
+The memory collector exposes metrics about system memory usage
+
+|||
+-|-
+Metric name prefix  | `memory`
+Classes             | `Win32_PerfRawData_PerfOS_Memory`
+Enabled by default? | Yes
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_cs_logical_processors` | Number of installed logical processors | gauge | None
+`wmi_cs_physical_memory_bytes` | Total installed physical memory | gauge | None
+`wmi_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
+`wmi_memory_cache_bytes` | Number of bytes currently being used by the file system cache | gauge | None
+`wmi_memory_cache_bytes_peak` | Maximum number of CacheBytes after the system was last restarted | gauge | None
+`wmi_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
+`wmi_memory_commit_limit` | Amount of virtual memory, in bytes, that can be committed without having to extend the paging file(s) | gauge | None
+`wmi_memory_committed_bytes` | Amount of committed virtual memory, in bytes | gauge | None
+`wmi_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
+`wmi_memory_free_and_zero_page_list_bytes` | _Not yet documented_ | gauge | None
+`wmi_memory_free_system_page_table_entries` | Number of page table entries not being used by the system | gauge | None
+`wmi_memory_modified_page_list_bytes` | _Not yet documented_ | gauge | None
+`wmi_memory_page_faults_total` | Overall rate at which faulted pages are handled by the processor | gauge | None
+`wmi_memory_swap_page_reads_total` | Number of disk page reads (a single read operation reading several pages is still only counted once) | gauge | None
+`wmi_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
+`wmi_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
+`wmi_memory_swap_page_operations_total` | Total number of swap page read and writes (PagesPersec) | gauge | None
+`wmi_memory_swap_page_writes_total` | Number of disk page writes (a single write operation writing several pages is still only counted once) | gauge | None
+`wmi_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
+`wmi_memory_pool_nonpaged_bytes_total` | Number of bytes in the non-paged pool | gauge | None
+`wmi_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
+`wmi_memory_pool_paged_bytes` | Number of bytes in the paged pool | gauge | None
+`wmi_memory_pool_paged_resident_bytes` | _Not yet documented_ | gauge | None
+`wmi_memory_standby_cache_core_bytes` | _Not yet documented_ | gauge | None
+`wmi_memory_standby_cache_normal_priority_bytes` | _Not yet documented_ | gauge | None
+`wmi_memory_standby_cache_reserve_bytes` | _Not yet documented_ | gauge | None
+`wmi_memory_system_cache_resident_bytes` | _Not yet documented_ | gauge | None
+`wmi_memory_system_code_resident_bytes` | _Not yet documented_ | gauge | None
+`wmi_memory_system_code_total_bytes` | _Not yet documented_ | gauge | None
+`wmi_memory_system_driver_resident_bytes` | _Not yet documented_ | gauge | None
+`wmi_memory_system_driver_total_bytes` | _Not yet documented_ | gauge | None
+`wmi_memory_transition_faults_total` | _Not yet documented_ | gauge | None
+`wmi_memory_transition_pages_repurposed_total` | _Not yet documented_ | gauge | None
+`wmi_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
+
+### 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.msmq.md

@@ -0,0 +1,33 @@
+# msmq collector
+
+The msmq collector exposes metrics about the queues on a MSMQ server
+
+|||
+-|-
+Metric name prefix  | `msmq`
+Classes             | `Win32_PerfRawData_MSMQ_MSMQQueue`
+Enabled by default? | No
+
+## Flags
+
+### `--collector.msmq.msmq-where`
+
+A WMI filter on which queues to include. `%` is a wildcard, and can be used to match on substrings.
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_msmq_bytes_in_journal_queue` | Size of queue journal in bytes | gauge | `name`
+`wmi_msmq_bytes_in_queue` | Size of queue in bytes | gauge | `name`
+`wmi_msmq_messages_in_journal_queue` | Count messages in queue journal | gauge | `name`
+`wmi_msmq_messages_in_queue` | Count messages in queue | 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.mssql.md

@@ -0,0 +1,255 @@
+# mssql collector
+
+The mssql collector exposes metrics about the MSSQL server
+
+|||
+-|-
+Metric name prefix  | `mssql`
+Classes             | [`Win32_PerfRawData_MSSQLSERVER_SQLServerAccessMethods`](https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-access-methods-object)<br/>[`Win32_PerfRawData_MSSQLSERVER_SQLServerAvailabilityReplica`](https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-availability-replica)<br/>[`Win32_PerfRawData_MSSQLSERVER_SQLServerBufferManager`](https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-buffer-manager-object)<br/>[`Win32_PerfRawData_MSSQLSERVER_SQLServerDatabaseReplica`](https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-database-replica)<br/>[`Win32_PerfRawData_MSSQLSERVER_SQLServerDatabases`](https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-databases-object?view=sql-server-2017)<br/>[`Win32_PerfRawData_MSSQLSERVER_SQLServerGeneralStatistics`](https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-general-statistics-object)<br/>[`Win32_PerfRawData_MSSQLSERVER_SQLServerLocks`](https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-locks-object)<br/>[`Win32_PerfRawData_MSSQLSERVER_SQLServerMemoryManager`](https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-memory-manager-object)<br/>[`Win32_PerfRawData_MSSQLSERVER_SQLServerSQLStatistics`](https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-sql-statistics-object)<br/>[`Win32_PerfRawData_MSSQLSERVER_SQLServerSQLErrors`](https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-sql-errors-object)<br/>[`Win32_PerfRawData_MSSQLSERVER_SQLServerTransactions`](https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-transactions-object)
+Enabled by default? | No
+
+## Flags
+
+### `--collectors.mssql.classes-enabled`
+
+Comma-separated list of MSSQL WMI classes to use. Supported values are `accessmethods`, `availreplica`, `bufman`, `databases`, `dbreplica`, `genstats`, `locks`, `memmgr`, `sqlstats`, `sqlerrors` and `transactions`.
+
+### `--collectors.mssql.class-print`
+
+If true, print available mssql WMI classes and exit.  Only displays if the mssql collector is enabled.
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_mssql_collector_duration_seconds` | The time taken for each sub-collector to return | counter | `collector`, `instance`
+`wmi_mssql_collector_success` | 1 if sub-collector succeeded, 0 otherwise | counter | `collector`, `instance`
+`wmi_mssql_accessmethods_au_batch_cleanups` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_au_cleanups` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_by_reference_lob_creates` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_by_reference_lob_uses` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_lob_read_aheads` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_column_value_pulls` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_column_value_pushes` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_deferred_dropped_aus` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_deferred_dropped_rowsets` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_dropped_rowset_cleanups` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_dropped_rowset_skips` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_extent_deallocations` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_extent_allocations` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_au_batch_cleanup_failures` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_leaf_page_cookie_failures` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_tree_page_cookie_failures` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_forwarded_records` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_free_space_page_fetches` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_free_space_scans` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_full_scans` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_index_searches` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_insysxact_waits` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_lob_handle_creates` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_lob_handle_destroys` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_lob_ss_provider_creates` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_lob_ss_provider_destroys` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_lob_ss_provider_truncations` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_mixed_page_allocations` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_page_compression_attempts` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_page_deallocations` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_page_allocations` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_page_compressions` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_page_splits` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_probe_scans` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_range_scans` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_scan_point_revalidations` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_ghost_record_skips` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_table_lock_escalations` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_leaf_page_cookie_uses` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_tree_page_cookie_uses` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_workfile_creates` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_worktables_creates` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_accessmethods_worktables_from_cache_ratio` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_availreplica_received_from_replica_bytes` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_availreplica_sent_to_replica_bytes` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_availreplica_sent_to_transport_bytes` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_availreplica_initiated_flow_controls` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_availreplica_flow_control_wait_seconds` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_availreplica_receives_from_replica` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_availreplica_resent_messages` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_availreplica_sends_to_replica` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_availreplica_sends_to_transport` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_bufman_background_writer_pages` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_bufman_buffer_cache_hit_ratio` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_bufman_checkpoint_pages` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_bufman_database_pages` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_bufman_extension_allocated_pages` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_bufman_extension_free_pages` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_bufman_extension_in_use_as_percentage` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_bufman_extension_outstanding_io` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_bufman_extension_page_evictions` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_bufman_extension_page_reads` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_bufman_extension_page_unreferenced_seconds` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_bufman_extension_page_writes` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_bufman_free_list_stalls` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_bufman_integral_controller_slope` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_bufman_lazywrites` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_bufman_page_life_expectancy_seconds` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_bufman_page_lookups` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_bufman_page_reads` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_bufman_page_writes` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_bufman_read_ahead_pages` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_bufman_read_ahead_issuing_seconds` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_bufman_target_pages` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_dbreplica_database_flow_control_wait_seconds` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_dbreplica_database_initiated_flow_controls` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_dbreplica_received_file_bytes` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_dbreplica_group_commits` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_dbreplica_group_commit_stall_seconds` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_dbreplica_log_apply_pending_queue` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_dbreplica_log_apply_ready_queue` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_dbreplica_log_compressed_bytes` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_dbreplica_log_decompressed_bytes` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_dbreplica_log_received_bytes` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_dbreplica_log_compression_cachehits` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_dbreplica_log_compression_cachemisses` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_dbreplica_log_compressions` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_dbreplica_log_decompressions` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_dbreplica_log_remaining_for_undo` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_dbreplica_log_send_queue` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_dbreplica_mirrored_write_transactions` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_dbreplica_recovery_queue_records` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_dbreplica_redo_blocks` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_dbreplica_redo_remaining_bytes` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_dbreplica_redone_bytes` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_dbreplica_redones` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_dbreplica_total_log_requiring_undo` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_dbreplica_transaction_delay_seconds` | _Not yet documented_ | counter | `instance`, `replica`
+`wmi_mssql_databases_active_transactions` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_backup_restore_operations` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_bulk_copy_rows` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_bulk_copy_bytes` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_commit_table_entries` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_data_files_size_bytes` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_dbcc_logical_scan_bytes` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_group_commit_stall_seconds` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_flushed_bytes` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_cache_hit_ratio` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_cache_reads` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_files_size_bytes` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_files_used_size_bytes` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_flushes` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_flush_waits` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_flush_wait_seconds` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_flush_write_seconds` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_growths` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_pool_cache_misses` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_pool_disk_reads` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_pool_hash_deletes` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_pool_hash_inserts` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_pool_invalid_hash_entries` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_pool_log_scan_pushes` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_pool_log_writer_pushes` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_pool_empty_free_pool_pushes` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_pool_low_memory_pushes` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_pool_no_free_buffer_pushes` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_pool_req_behind_trunc` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_pool_requests_old_vlf` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_pool_requests` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_pool_total_active_log_bytes` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_pool_total_shared_pool_bytes` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_shrinks` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_truncations` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_log_used_percent` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_pending_repl_transactions` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_repl_transactions` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_shrink_data_movement_bytes` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_tracked_transactions` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_transactions` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_write_transactions` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_xtp_controller_dlc_fetch_latency_seconds` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_xtp_controller_dlc_peak_latency_seconds` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_xtp_controller_log_processed_bytes` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_databases_xtp_memory_used_bytes` | _Not yet documented_ | counter | `instance`, `database`
+`wmi_mssql_genstats_active_temp_tables` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_genstats_connection_resets` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_genstats_event_notifications_delayed_drop` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_genstats_http_authenticated_requests` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_genstats_logical_connections` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_genstats_logins` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_genstats_logouts` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_genstats_mars_deadlocks` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_genstats_non_atomic_yields` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_genstats_blocked_processes` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_genstats_soap_empty_requests` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_genstats_soap_method_invocations` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_genstats_soap_session_initiate_requests` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_genstats_soap_session_terminate_requests` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_genstats_soapsql_requests` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_genstats_soapwsdl_requests` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_genstats_sql_trace_io_provider_lock_waits` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_genstats_tempdb_recovery_unit_ids_generated` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_genstats_tempdb_rowset_ids_generated` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_genstats_temp_tables_creations` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_genstats_temp_tables_awaiting_destruction` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_genstats_trace_event_notification_queue_size` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_genstats_transactions` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_genstats_user_connections` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_locks_average_wait_seconds` | _Not yet documented_ | counter | `instance`, `resource`
+`wmi_mssql_locks_lock_requests` | _Not yet documented_ | counter | `instance`, `resource`
+`wmi_mssql_locks_lock_timeouts` | _Not yet documented_ | counter | `instance`, `resource`
+`wmi_mssql_locks_lock_timeouts_excluding_NOWAIT` | _Not yet documented_ | counter | `instance`, `resource`
+`wmi_mssql_locks_lock_waits` | _Not yet documented_ | counter | `instance`, `resource`
+`wmi_mssql_locks_lock_wait_seconds` | _Not yet documented_ | counter | `instance`, `resource`
+`wmi_mssql_locks_deadlocks` | _Not yet documented_ | counter | `instance`, `resource`
+`wmi_mssql_memmgr_connection_memory_bytes` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_memmgr_database_cache_memory_bytes` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_memmgr_external_benefit_of_memory` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_memmgr_free_memory_bytes` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_memmgr_granted_workspace_memory_bytes` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_memmgr_lock_blocks` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_memmgr_allocated_lock_blocks` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_memmgr_lock_memory_bytes` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_memmgr_lock_owner_blocks` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_memmgr_allocated_lock_owner_blocks` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_memmgr_log_pool_memory_bytes` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_memmgr_maximum_workspace_memory_bytes` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_memmgr_outstanding_memory_grants` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_memmgr_pending_memory_grants` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_memmgr_optimizer_memory_bytes` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_memmgr_reserved_server_memory_bytes` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_memmgr_sql_cache_memory_bytes` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_memmgr_stolen_server_memory_bytes` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_memmgr_target_server_memory_bytes` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_memmgr_total_server_memory_bytes` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_sqlstats_auto_parameterization_attempts` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_sqlstats_batch_requests` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_sqlstats_failed_auto_parameterization_attempts` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_sqlstats_forced_parameterizations` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_sqlstats_guided_plan_executions` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_sqlstats_misguided_plan_executions` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_sqlstats_safe_auto_parameterization_attempts` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_sqlstats_sql_attentions` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_sqlstats_sql_compilations` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_sqlstats_sql_recompilations` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_sqlstats_unsafe_auto_parameterization_attempts` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_sql_errors_total` | _Not yet documented_ | counter | `instance`, `resource`
+`wmi_mssql_transactions_tempdb_free_space_bytes` | _Not yet documented_ | gauge | `instance`
+`wmi_mssql_transactions_longest_transaction_running_seconds` | _Not yet documented_ | gauge | `instance`
+`wmi_mssql_transactions_nonsnapshot_version_active_total` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_transactions_snapshot_active_total` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_transactions_active_total` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_transactions_update_conflicts_total` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_transactions_update_snapshot_active_total` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_transactions_version_cleanup_rate_bytes` | _Not yet documented_ | gauge | `instance`
+`wmi_mssql_transactions_version_generation_rate_bytes` | _Not yet documented_ | gauge | `instance`
+`wmi_mssql_transactions_version_store_size_bytes` | _Not yet documented_ | gauge | `instance`
+`wmi_mssql_transactions_version_store_units` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_transactions_version_store_creation_units` | _Not yet documented_ | counter | `instance`
+`wmi_mssql_transactions_version_store_truncation_units` | _Not yet documented_ | counter | `instance`
+
+### 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.net.md

@@ -0,0 +1,61 @@
+# net collector
+
+The net collector exposes metrics about network interfaces
+
+|||
+-|-
+Metric name prefix  | `net`
+Classes             | [`Win32_PerfRawData_Tcpip_NetworkInterface`](https://technet.microsoft.com/en-us/security/aa394340(v=vs.80))
+Enabled by default? | Yes
+
+## Flags
+
+### `--collector.net.nic-whitelist`
+
+If given, an interface name needs to match the whitelist regexp in order for the corresponding metrics to be reported
+
+### `--collector.net.nic-blacklist`
+
+If given, an interface name needs to *not* match the blacklist regexp in order for the corresponding metrics to be reported
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_net_bytes_received_total` | Total bytes received by interface | counter | `nic`
+`wmi_net_bytes_sent_total` | Total bytes transmitted by interface | counter | `nic`
+`wmi_net_bytes_total` | Total bytes received and transmitted by interface | counter | `nic`
+`wmi_net_packets_outbound_discarded` | Total outbound packets that were chosen to be discarded even though no errors had been detected to prevent transmission | counter | `nic`
+`wmi_net_packets_outbound_errors` | Total packets that could not be transmitted due to errors | counter | `nic`
+`wmi_net_packets_received_discarded` | Total inbound packets that were chosen to be discarded even though no errors had been detected to prevent delivery | counter | `nic`
+`wmi_net_packets_received_errors` | Total packets that could not be received due to errors  | counter | `nic`
+`wmi_net_packets_received_total` | Total packets received by interface | counter | `nic`
+`wmi_net_packets_received_unknown` | Total packets received by interface that were discarded because of an unknown or unsupported protocol | counter | `nic`
+`wmi_net_packets_total` | Total packets received and transmitted by interface | counter | `nic`
+`wmi_net_packets_sent_total` | Total packets transmitted by interface | counter | `nic`
+`wmi_net_current_bandwidth` | Estimate of the interface's current bandwidth in bits per second (bps) | counter | `nic`
+
+### Example metric
+Query the rate of transmitted network traffic
+```
+rate(wmi_net_bytes_sent_total{instance="localhost"}[2m])
+```
+
+## Useful queries
+Get total utilisation of network interface as a percentage
+```
+rate(wmi_net_bytes_total{instance="localhost", nic="Microsoft_Hyper_V_Network_Adapter__1"}[2m]) * 8 / wmi_net_current_bandwidth{instance="locahost", nic="Microsoft_Hyper_V_Network_Adapter__1"} * 100
+```
+
+## Alerting examples
+**prometheus.rules**
+```
+- alert: NetInterfaceUsage
+  expr: rate(wmi_net_bytes_total[2m]) * 8 / wmi_net_current_bandwidth * 100 > 90
+  for: 10m
+  labels:
+    severity: high
+  annotations:
+    summary: "Network Interface Usage (instance {{ $labels.instance }})"
+    description: "Network traffic usage is greater than 95% for interface {{ $labels.nic }}\n  VALUE = {{ $value }}\n  LABELS: {{ $labels }}"
+```

docs/collector.netframework_clrexceptions.md

@@ -0,0 +1,32 @@
+# netframework_clrexceptions collector
+
+The netframework_clrexceptions collector exposes metrics about CLR exceptions in the dotnet framework.
+
+|||
+-|-
+Metric name prefix  | `netframework_clrexceptions`
+Classes             | `Win32_PerfRawData_NETFramework_NETCLRExceptions`
+Enabled by default? | No
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_...` | ... | counter/gauge/histogram/summary | ...
+`wmi_netframework_clrexceptions_exceptions_thrown_total` | Displays the total number of exceptions thrown since the application started. This includes both .NET exceptions and unmanaged exceptions that are converted into .NET exceptions. | counter | `process`
+`wmi_netframework_clrexceptions_exceptions_filters_total` | Displays the total number of .NET exception filters executed. An exception filter evaluates regardless of whether an exception is handled. | counter | `process`
+`wmi_netframework_clrexceptions_exceptions_finallys_total` | Displays the total number of finally blocks executed. Only the finally blocks executed for an exception are counted; finally blocks on normal code paths are not counted by this counter. | counter | `process`
+`wmi_netframework_clrexceptions_throw_to_catch_depth_total` | Displays the total number of stack frames traversed, from the frame that threw the exception to the frame that handled the exception. | counter | `process`
+
+### 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.netframework_clrinterop.md

@@ -0,0 +1,31 @@
+# netframework_clrinterop collector
+
+The netframework_clrinterop collector exposes metrics about interop between the dotnet framework and outside components.
+
+|||
+-|-
+Metric name prefix  | `netframework_clrinterop`
+Classes             | `Win32_PerfRawData_NETFramework_NETCLRInterop`
+Enabled by default? | No
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_...` | ... | counter/gauge/histogram/summary | ...
+`wmi_netframework_clrinterop_com_callable_wrappers_total` | Displays the current number of COM callable wrappers (CCWs). A CCW is a proxy for a managed object being referenced from an unmanaged COM client. | counter | `process`
+`wmi_netframework_clrinterop_interop_marshalling_total` | Displays the total number of times arguments and return values have been marshaled from managed to unmanaged code, and vice versa, since the application started. | counter | `process`
+`wmi_netframework_clrinterop_interop_stubs_created_total` | Displays the current number of stubs created by the common language runtime. Stubs are responsible for marshaling arguments and return values from managed to unmanaged code, and vice versa, during a COM interop call or a platform invoke call. | counter | `process`
+
+### 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.netframework_clrjit.md

@@ -0,0 +1,32 @@
+# netframework_clrjit collector
+
+The netframework_clrjit collector exposes metrics about the dotnet Just-in-Time compiler.
+
+|||
+-|-
+Metric name prefix  | `netframework_clrjit`
+Classes             | `Win32_PerfRawData_NETFramework_NETCLRJit`
+Enabled by default? | No
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_...` | ... | counter/gauge/histogram/summary | ...
+`wmi_netframework_clrjit_jit_methods_total` | Displays the total number of methods JIT-compiled since the application started. This counter does not include pre-JIT-compiled methods. | counter | `process`
+`wmi_netframework_clrjit_jit_time_percent` | Displays the percentage of time spent in JIT compilation. This counter is updated at the end of every JIT compilation phase. A JIT compilation phase occurs when a method and its dependencies are compiled. | gauge | `process`
+`wmi_netframework_clrjit_jit_standard_failures_total` | Displays the peak number of methods the JIT compiler has failed to compile since the application started. This failure can occur if the MSIL cannot be verified or if there is an internal error in the JIT compiler. | counter | `process`
+`wmi_netframework_clrjit_jit_il_bytes_total` | Displays the total number of Microsoft intermediate language (MSIL) bytes compiled by the just-in-time (JIT) compiler since the application started | counter | `process`
+
+### 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.netframework_clrloading.md

@@ -0,0 +1,37 @@
+# netframework_clrloading collector
+
+The netframework_clrloading collector exposes metrics about the dotnet loader.
+
+|||
+-|-
+Metric name prefix  | `netframework_clrloading`
+Classes             | `Win32_PerfRawData_NETFramework_NETCLRLoading`
+Enabled by default? | No
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_...` | ... | counter/gauge/histogram/summary | ...
+`wmi_netframework_clrloading_loader_heap_size_bytes` | Displays the current size, in bytes, of the memory committed by the class loader across all application domains. Committed memory is the physical space reserved in the disk paging file. | gauge | `process`
+`wmi_netframework_clrloading_appdomains_loaded_current` | Displays the current number of application domains loaded in this application. | gauge | `process`
+`wmi_netframework_clrloading_assemblies_loaded_current` | Displays the current number of assemblies loaded across all application domains in the currently running application. If the assembly is loaded as domain-neutral from multiple application domains, this counter is incremented only once. | gauge | `process`
+`wmi_netframework_clrloading_classes_loaded_current` | Displays the current number of classes loaded in all assemblies. | gauge | `process`
+`wmi_netframework_clrloading_appdomains_loaded_total` | Displays the peak number of application domains loaded since the application started. | counter | `process`
+`wmi_netframework_clrloading_appdomains_unloaded_total` | Displays the total number of application domains unloaded since the application started. If an application domain is loaded and unloaded multiple times, this counter increments each time the application domain is unloaded. | counter | `process`
+`wmi_netframework_clrloading_assemblies_loaded_total` | Displays the total number of assemblies loaded since the application started. If the assembly is loaded as domain-neutral from multiple application domains, this counter is incremented only once. | counter | `process`
+`wmi_netframework_clrloading_classes_loaded_total` | Displays the cumulative number of classes loaded in all assemblies since the application started. | counter | `process`
+`wmi_netframework_clrloading_class_load_failures_total` | Displays the peak number of classes that have failed to load since the application started. | counter | `process`
+
+### 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.netframework_clrlocksandthreads.md

@@ -0,0 +1,35 @@
+# netframework_clrlocksandthreads collector
+
+The netframework_clrlocksandthreads collector exposes metrics about locks and threads in dotnet applications.
+
+|||
+-|-
+Metric name prefix  | `netframework_clrlocksandthreads`
+Classes             | `Win32_PerfRawData_NETFramework_NETCLRLocksAndThreads`
+Enabled by default? | No
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_...` | ... | counter/gauge/histogram/summary | ...
+`wmi_netframework_clrlocksandthreads_current_queue_length` | Displays the total number of threads that are currently waiting to acquire a managed lock in the application. | gauge | `process`
+`wmi_netframework_clrlocksandthreads_current_logical_threads` | Displays the number of current managed thread objects in the application. This counter maintains the count of both running and stopped threads.  | gauge | `process`
+`wmi_netframework_clrlocksandthreads_physical_threads_current` | Displays the number of native operating system threads created and owned by the common language runtime to act as underlying threads for managed thread objects. This counter's value does not include the threads used by the runtime in its internal operations; it is a subset of the threads in the operating system process. | gauge | `process`
+`wmi_netframework_clrlocksandthreads_recognized_threads_current` | Displays the number of threads that are currently recognized by the runtime. These threads are associated with a corresponding managed thread object. The runtime does not create these threads, but they have run inside the runtime at least once. | gauge | `process`
+`wmi_netframework_clrlocksandthreads_recognized_threads_total` | Displays the total number of threads that have been recognized by the runtime since the application started. These threads are associated with a corresponding managed thread object. The runtime does not create these threads, but they have run inside the runtime at least once. | counter | `process`
+`wmi_netframework_clrlocksandthreads_queue_length_total` | Displays the total number of threads that waited to acquire a managed lock since the application started. | counter | `process`
+`wmi_netframework_clrlocksandthreads_contentions_total` | Displays the total number of times that threads in the runtime have attempted to acquire a managed lock unsuccessfully. | counter | `process`
+
+### 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.netframework_clrmemory.md

@@ -0,0 +1,40 @@
+# netframework_clrmemory collector
+
+The netframework_clrmemory collector exposes metrics about memory in dotnet applications.
+
+|||
+-|-
+Metric name prefix  | `netframework_clrmemory`
+Classes             | `Win32_PerfRawData_NETFramework_NETCLRMemory`
+Enabled by default? | No
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_...` | ... | counter/gauge/histogram/summary | ...
+`wmi_netframework_clrmemory_allocated_bytes_total` | Displays the total number of bytes allocated on the garbage collection heap. | counter | `process`
+`wmi_netframework_clrmemory_finalization_survivors` | Displays the number of garbage-collected objects that survive a collection because they are waiting to be finalized. | gauge | `process`
+`wmi_netframework_clrmemory_heap_size_bytes` | Displays the maximum bytes that can be allocated; it does not indicate the current number of bytes allocated. | gauge | `process`
+`wmi_netframework_clrmemory_promoted_bytes` | Displays the bytes that were promoted from the generation to the next one during the last GC. Memory is promoted when it survives a garbage collection. | gauge | `process`
+`wmi_netframework_clrmemory_number_gc_handles` | Displays the current number of garbage collection handles in use. Garbage collection handles are handles to resources external to the common language runtime and the managed environment. | gauge | `process`
+`wmi_netframework_clrmemory_collections_total` | Displays the number of times the generation objects are garbage collected since the application started. | counter | `process`
+`wmi_netframework_clrmemory_induced_gc_total` | Displays the peak number of times garbage collection was performed because of an explicit call to GC.Collect. | counter | `process`
+`wmi_netframework_clrmemory_number_pinned_objects` | Displays the number of pinned objects encountered in the last garbage collection. | gauge | `process`
+`wmi_netframework_clrmemory_number_sink_blocksinuse` | Displays the current number of synchronization blocks in use. Synchronization blocks are per-object data structures allocated for storing synchronization information. They hold weak references to managed objects and must be scanned by the garbage collector. | gauge | `process`
+`wmi_netframework_clrmemory_committed_bytes` | Displays the amount of virtual memory, in bytes, currently committed by the garbage collector. Committed memory is the physical memory for which space has been reserved in the disk paging file. | gauge | `process`
+`wmi_netframework_clrmemory_reserved_bytes` | Displays the amount of virtual memory, in bytes, currently reserved by the garbage collector. Reserved memory is the virtual memory space reserved for the application when no disk or main memory pages have been used. | gauge | `process`
+`wmi_netframework_clrmemory_gc_time_percent` | Displays the percentage of time that was spent performing a garbage collection in the last sample. | gauge | `process`
+
+### 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.netframework_clrremoting.md

@@ -0,0 +1,33 @@
+# netframework_clrremoting collector
+
+The netframework_clrremoting collector exposes metrics about dotnet remoting.
+
+|||
+-|-
+Metric name prefix  | `netframework_clrremoting`
+Classes             | `Win32_PerfRawData_NETFramework_NETCLRRemoting`
+Enabled by default? | No
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_netframework_clrremoting_channels_total` | Displays the total number of remoting channels registered across all application domains since application started. | counter | `process`
+`wmi_netframework_clrremoting_context_bound_classes_loaded` | Displays the current number of context-bound classes that are loaded. | gauge | `process`
+`wmi_netframework_clrremoting_context_bound_objects_total` | Displays the total number of context-bound objects allocated. | counter | `process`
+`wmi_netframework_clrremoting_context_proxies_total` | Displays the total number of remoting proxy objects in this process since it started. | counter | `process`
+`wmi_netframework_clrremoting_contexts` | Displays the current number of remoting contexts in the application. | gauge | `process`
+`wmi_netframework_clrremoting_remote_calls_total` | Displays the total number of remote procedure calls invoked since the application started. | counter | `process`
+
+### 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.netframework_clrsecurity.md

@@ -0,0 +1,31 @@
+# netframework_clrsecurity collector
+
+The netframework_clrsecurity collector exposes metrics about security checks in dotnet applications
+
+|||
+-|-
+Metric name prefix  | `netframework_clrsecurity`
+Classes             | `Win32_PerfRawData_NETFramework_NETCLRSecurity`
+Enabled by default? | No
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_netframework_clrsecurity_link_time_checks_total` | Displays the total number of link-time code access security checks since the application started. | counter | `process`
+`wmi_netframework_clrsecurity_rt_checks_time_percent` | Displays the percentage of time spent performing runtime code access security checks in the last sample. | gauge | `process`
+`wmi_netframework_clrsecurity_stack_walk_depth` | Displays the depth of the stack during that last runtime code access security check. | gauge | `process`
+`wmi_netframework_clrsecurity_runtime_checks_total` | Displays the total number of runtime code access security checks performed since the application started. | counter | `process`
+
+### 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.os.md

@@ -0,0 +1,39 @@
+# os collector
+
+The os collector exposes metrics about the operating system
+
+|||
+-|-
+Metric name prefix  | `os`
+Classes             | [`Win32_OperatingSystem`](https://msdn.microsoft.com/en-us/library/aa394239)
+Enabled by default? | Yes
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_os_paging_limit_bytes` | _Not yet documented_ | gauge | None
+`wmi_os_paging_free_bytes` | _Not yet documented_ | gauge | None
+`wmi_os_physical_memory_free_bytes` | _Not yet documented_ | gauge | None
+`wmi_os_time` | _Not yet documented_ | gauge | None
+`wmi_os_timezone` | _Not yet documented_ | gauge | `timezone`
+`wmi_os_processes` | _Not yet documented_ | gauge | None
+`wmi_os_processes_limit` | _Not yet documented_ | gauge | None
+`wmi_os_process_memory_limix_bytes` | _Not yet documented_ | gauge | None
+`wmi_os_users` | _Not yet documented_ | gauge | None
+`wmi_os_virtual_memory_bytes` | _Not yet documented_ | gauge | None
+`wmi_os_visible_memory_bytes` | _Not yet documented_ | gauge | None
+`wmi_os_virtual_memory_free_bytes` | _Not yet documented_ | gauge | None
+
+### 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

@@ -0,0 +1,46 @@
+# process collector
+
+The process collector exposes metrics about processes
+
+|||
+-|-
+Metric name prefix  | `process`
+Classes             | [`Win32_PerfRawData_PerfProc_Process`](https://msdn.microsoft.com/en-us/library/aa394323(v=vs.85).aspx)
+Enabled by default? | No
+
+## Flags
+
+### `--collector.process.processes-where`
+
+A WMI filter on which processes to include. Recommended to keep down number of returned metrics.
+
+`%` is a wildcard, and can be used to match on substrings.
+
+Example: `--collector.process.processes-where="Name LIKE 'firefox%'`
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_process_start_time` | _Not yet documented_ | gauge | `process`, `process_id`, `creating_process_id`
+`wmi_process_cpu_time_total` | _Not yet documented_ | counter | `process`, `process_id`, `creating_process_id`
+`wmi_process_handle_count` | _Not yet documented_ | gauge | `process`, `process_id`, `creating_process_id`
+`wmi_process_io_bytes_total` | _Not yet documented_ | counter | `process`, `process_id`, `creating_process_id`
+`wmi_process_io_operations_total` | _Not yet documented_ | counter | `process`, `process_id`, `creating_process_id`
+`wmi_process_page_faults_total` | _Not yet documented_ | counter | `process`, `process_id`, `creating_process_id`
+`wmi_process_page_file_bytes` | _Not yet documented_ | gauge | `process`, `process_id`, `creating_process_id`
+`wmi_process_pool_bytes` | _Not yet documented_ | gauge | `process`, `process_id`, `creating_process_id`
+`wmi_process_priority_base` | _Not yet documented_ | gauge | `process`, `process_id`, `creating_process_id`
+`wmi_process_private_bytes` | _Not yet documented_ | gauge | `process`, `process_id`, `creating_process_id`
+`wmi_process_thread_count` | _Not yet documented_ | gauge | `process`, `process_id`, `creating_process_id`
+`wmi_process_virtual_bytes` | _Not yet documented_ | gauge | `process`, `process_id`, `creating_process_id`
+`wmi_process_working_set` | _Not yet documented_ | gauge | `process`, `process_id`, `creating_process_id`
+
+### 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.service.md

@@ -0,0 +1,107 @@
+# service collector
+
+The service collector exposes metrics about Windows Services
+
+|||
+-|-
+Metric name prefix  | `service`
+Classes             | [`Win32_Service`](https://msdn.microsoft.com/en-us/library/aa394418(v=vs.85).aspx)
+Enabled by default? | Yes
+
+## Flags
+
+### `--collector.service.services-where`
+
+A WMI filter on which services to include. Recommended to keep down number of returned metrics.
+
+Example: `--collector.service.services-where="Name='wmi_exporter'"`
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_service_state` | The state of the service, 1 if the current state, 0 otherwise | gauge | name, state
+`wmi_service_start_mode` | The start mode of the service, 1 if the current start mode, 0 otherwise | gauge | name, start_mode
+`wmi_service_status` | The status of the service, 1 if the current status, 0 otherwise | gauge | name, status
+
+For the values of the `state`, `start_mode` and `status` labels, see below.
+
+### States
+
+A service can be in the following states:
+- `stopped`
+- `start pending`
+- `stop pending`
+- `running`
+- `continue pending`
+- `pause pending`
+- `paused`
+- `unknown`
+
+### Start modes
+
+A service can have the following start modes:
+- `boot`
+- `system`
+- `auto`
+- `manual`
+- `disabled`
+
+### Status
+
+A service can have any of the following statuses:
+- `ok`
+- `error`
+- `degraded`
+- `unknown`
+- `pred fail`
+- `starting`
+- `stopping`
+- `service`
+- `stressed`
+- `nonrecover`
+- `no contact`
+- `lost comm`
+
+Note that there is some overlap with service state.
+
+### Example metric
+Lists the services that have a 'disabled' start mode.
+```
+wmi_service_start_mode{exported_name=~"(mssqlserver|sqlserveragent)",start_mode="disabled"}
+```
+
+## Useful queries
+Counts the number of Microsoft SQL Server/Agent Processes
+```
+count(wmi_service_state{exported_name=~"(sqlserveragent|mssqlserver)",state="running"})
+```
+
+## Alerting examples
+**prometheus.rules**
+```
+groups:
+- name: Microsoft SQL Server Alerts
+  rules:
+
+  # Sends an alert when the 'sqlserveragent' service is not in the running state for 3 minutes. 
+  - alert: SQL Server Agent DOWN
+    expr: wmi_service_state{instance="SQL",exported_name="sqlserveragent",state="running"} == 0
+    for: 3m
+    labels:
+      severity: high
+    annotations:
+      summary: "Service {{ $labels.exported_name }} down"
+      description: "Service {{ $labels.exported_name }} on instance {{ $labels.instance }} has been down for more than 3 minutes."
+      
+  # Sends an alert when the 'mssqlserver' service is not in the running state for 3 minutes. 
+  - alert: SQL Server DOWN
+    expr: wmi_service_state{instance="SQL",exported_name="mssqlserver",state="running"} == 0
+    for: 3m
+    labels:
+      severity: high
+    annotations:
+      summary: "Service {{ $labels.exported_name }} down"
+      description: "Service {{ $labels.exported_name }} on instance {{ $labels.instance }} has been down for more than 3 minutes."
+```
+In this example, `instance` is the target label of the host. So each alert will be processed per host, which is then used in the alert description.

docs/collector.system.md

@@ -0,0 +1,39 @@
+# system collector
+
+The system collector exposes metrics about ...
+
+|||
+-|-
+Metric name prefix  | `system`
+Classes             | [`Win32_PerfRawData_PerfOS_System`](https://web.archive.org/web/20050830140516/http://msdn.microsoft.com/library/en-us/wmisdk/wmi/win32_perfrawdata_perfos_system.asp)
+Enabled by default? | Yes
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_system_context_switches_total` | Total number of [context switches](https://en.wikipedia.org/wiki/Context_switch) | counter | None
+`wmi_system_exception_dispatches_total` | Total exceptions dispatched by the system | counter | None
+`wmi_system_processor_queue_length` | Number of threads in the processor queue. There is a single queue for processor time even on computers with multiple processors. | gauge | None
+`wmi_system_system_calls_total` | Total combined calls to Windows NT system service routines by all processes running on the computer | counter | None
+`wmi_system_system_up_time` | Time of last boot of system | gauge | None
+`wmi_system_threads` | Number of Windows system [threads](https://en.wikipedia.org/wiki/Thread_(computing)) | gauge | None
+
+### Example metric
+Show current number of system threads
+```
+wmi_system_threads{instance="localhost"}
+```
+
+## Useful queries
+Find hosts that have rebooted in the last 24 hours
+```
+time() - wmi_system_system_up_time < 86400
+```
+
+## Alerting examples
+_This collector does not yet have alerting examples, we would appreciate your help adding them!_

docs/collector.tcp.md

@@ -0,0 +1,36 @@
+# tcp collector
+
+The tcp collector exposes metrics about the TCP/IPv4 network stack.
+
+|||
+-|-
+Metric name prefix  | `tcp`
+Classes             | [`Win32_PerfRawData_Tcpip_TCPv4`](https://msdn.microsoft.com/en-us/library/aa394341(v=vs.85).aspx)
+Enabled by default? | No
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_tcp_connection_failures` | _Not yet documented_ | counter | None
+`wmi_tcp_connections_active` | _Not yet documented_ | counter | None
+`wmi_tcp_connections_established` | _Not yet documented_ | counter | None
+`wmi_tcp_connections_passive` | _Not yet documented_ | counter | None
+`wmi_tcp_connections_reset` | _Not yet documented_ | counter | None
+`wmi_tcp_segments_total` | _Not yet documented_ | counter | None
+`wmi_tcp_segments_received_total` | _Not yet documented_ | counter | None
+`wmi_tcp_segments_retransmitted_total` | _Not yet documented_ | counter | None
+`wmi_tcp_segments_sent_total` | _Not yet documented_ | counter | None
+
+### 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.textfile.md

@@ -0,0 +1,56 @@
+# textfile collector
+
+The textfile collector exposes metrics from files written by other processes.
+
+|||
+-|-
+Metric name prefix  | `textfile`
+Classes             | None
+Enabled by default? | Yes
+
+## Flags
+
+### `--collector.textfile.directory`
+
+The directory containing the files to be ingested. Only files with the extension `.prom` are read.
+
+Default value: `C:\Program Files\wmi_exporter\textfile_inputs`
+
+Required: No
+
+## Metrics
+
+Metrics will primarily come from the files on disk. The below listed metrics
+are collected to give information about the reading of the metrics themselves.
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_textfile_scrape_error` | 1 if there was an error opening or reading a file, 0 otherwise | gauge | None
+`wmi_textfile_mtime_seconds` | Unix epoch-formatted mtime (modified time) of textfiles successfully read | gauge | file
+
+### 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!_
+
+# Example use
+This Powershell script, when run in the `collector.textfile.directory` (default `C:\Program Files\wmi_exporter\textfile_inputs`), generates a valid `.prom` file that should successfully ingested by wmi_exporter.
+
+```Powershell
+$alpha = 42
+$beta = @{ left=3.1415; right=2.718281828; }
+
+Set-Content -Path test1.prom -Encoding Ascii -NoNewline -Value ""
+Add-Content -Path test1.prom -Encoding Ascii -NoNewline -Value "# HELP test_alpha_total Some random metric.`n"
+Add-Content -Path test1.prom -Encoding Ascii -NoNewline -Value "# TYPE test_alpha_total counter`n"
+Add-Content -Path test1.prom -Encoding Ascii -NoNewline -Value "test_alpha_total ${alpha}`n"
+Add-Content -Path test1.prom -Encoding Ascii -NoNewline -Value "# HELP test_beta_bytes Some other metric.`n"
+Add-Content -Path test1.prom -Encoding Ascii -NoNewline -Value "# TYPE test_beta_bytes gauge`n"
+foreach ($k in $beta.Keys) {
+  Add-Content -Path test1.prom -Encoding Ascii -NoNewline -Value "test_beta_bytes{spin=""${k}""} $( $beta[$k] )`n"
+}
+```

docs/collector.thermalzone.md

@@ -0,0 +1,32 @@
+# thermalzone collector
+
+The thermalzone collector exposes metrics about system temps. Note that temperature is given in Kelvin
+
+|||
+-|-
+Metric name prefix  | `thermalzone`
+Classes             | [`Win32_PerfRawData_Counters_ThermalZoneInformation`](https://wutils.com/wmi/root/cimv2/win32_perfrawdata_counters_thermalzoneinformation/#temperature_properties)
+Enabled by default? | No
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_thermalzone_percent_passive_limit` | % Passive Limit is the current limit this thermal zone is placing on the devices it controls. A limit of 100% indicates the devices are unconstrained. A limit of 0% indicates the devices are fully constrained. | gauge | None
+`wmi_thermalzone_temperature_celsius ` | Temperature of the thermal zone, in degrees Celsius. | gauge | None
+`wmi_thermalzone_throttle_reasons ` | Throttle Reasons indicate reasons why the thermal zone is limiting performance of the devices it controls. 0x0 – The zone is not throttled. 0x1 – The zone is throttled for thermal reasons. 0x2 – The zone is throttled to limit electrical current. | gauge | None
+
+[`Throttle reasons` source](https://docs.microsoft.com/en-us/windows-hardware/design/device-experiences/examples--requirements-and-diagnostics)
+
+### 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.vmware.md

@@ -0,0 +1,46 @@
+# vmware collector
+
+The vmware collector exposes metrics about a VMware guest VM
+
+|||
+-|-
+Metric name prefix  | `vmware`
+Classes             | `Win32_PerfRawData_vmGuestLib_VMem`, `Win32_PerfRawData_vmGuestLib_VCPU`
+Enabled by default? | No
+
+## Flags
+
+None
+
+## Metrics
+
+Name | Description | Type | Labels
+-----|-------------|------|-------
+`wmi_vmware_mem_active_bytes` | _Not yet documented_ | gauge | None
+`wmi_vmware_mem_ballooned_bytes` | _Not yet documented_ | gauge | None
+`wmi_vmware_mem_limit_bytes` | _Not yet documented_ | gauge | None
+`wmi_vmware_mem_mapped_bytes` | _Not yet documented_ | gauge | None
+`wmi_vmware_mem_overhead_bytes` | _Not yet documented_ | gauge | None
+`wmi_vmware_mem_reservation_bytes` | _Not yet documented_ | gauge | None
+`wmi_vmware_mem_shared_bytes` | _Not yet documented_ | gauge | None
+`wmi_vmware_mem_shared_saved_bytes` | _Not yet documented_ | gauge | None
+`wmi_vmware_mem_shares` | _Not yet documented_ | gauge | None
+`wmi_vmware_mem_swapped_bytes` | _Not yet documented_ | gauge | None
+`wmi_vmware_mem_target_size_bytes` | _Not yet documented_ | gauge | None
+`wmi_vmware_mem_used_bytes` | _Not yet documented_ | gauge | None
+`wmi_vmware_cpu_limit_mhz` | _Not yet documented_ | gauge | None
+`wmi_vmware_cpu_reservation_mhz` | _Not yet documented_ | gauge | None
+`wmi_vmware_cpu_shares` | _Not yet documented_ | gauge | None
+`wmi_vmware_cpu_stolen_seconds_total` | _Not yet documented_ | counter | None
+`wmi_vmware_cpu_time_seconds_total` | _Not yet documented_ | counter | None
+`wmi_vmware_effective_vm_speed_mhz` | _Not yet documented_ | gauge | None
+`wmi_vmware_host_processor_speed_mhz` | _Not yet documented_ | gauge | None
+
+### 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!_

exporter.go

@@ -1,10 +1,14 @@
+// +build windows
+
 package main
 
 import (
 	"fmt"
-	"io"
 	"net/http"
+	_ "net/http/pprof"
+	"os"
 	"sort"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -22,7 +26,8 @@ import (
 
 // WmiCollector implements the prometheus.Collector interface.
 type WmiCollector struct {
-	collectors map[string]collector.Collector
+	maxScrapeDuration time.Duration
+	collectors        map[string]collector.Collector
 }
 
 const (
@@ -44,6 +49,18 @@ var (
 		[]string{"collector"},
 		nil,
 	)
+	scrapeTimeoutDesc = prometheus.NewDesc(
+		prometheus.BuildFQName(collector.Namespace, "exporter", "collector_timeout"),
+		"wmi_exporter: Whether the collector timed out.",
+		[]string{"collector"},
+		nil,
+	)
+	snapshotDuration = prometheus.NewDesc(
+		prometheus.BuildFQName(collector.Namespace, "exporter", "perflib_snapshot_duration_seconds"),
+		"Duration of perflib snapshot capture",
+		nil,
+		nil,
+	)
 
 	// This can be removed when client_golang exposes this on Windows
 	// (See https://github.com/prometheus/client_golang/issues/376)
@@ -63,25 +80,113 @@ func (coll WmiCollector) Describe(ch chan<- *prometheus.Desc) {
 	ch <- scrapeSuccessDesc
 }
 
-// Collect sends the collected metrics from each of the collectors to
-// prometheus. Collect could be called several times concurrently
-// and thus its run is protected by a single mutex.
-func (coll WmiCollector) Collect(ch chan<- prometheus.Metric) {
-	wg := sync.WaitGroup{}
-	wg.Add(len(coll.collectors))
-	for name, c := range coll.collectors {
-		go func(name string, c collector.Collector) {
-			execute(name, c, ch)
-			wg.Done()
-		}(name, c)
-	}
+type collectorOutcome int
 
+const (
+	pending collectorOutcome = iota
+	success
+	failed
+)
+
+// Collect sends the collected metrics from each of the collectors to
+// prometheus.
+func (coll WmiCollector) Collect(ch chan<- prometheus.Metric) {
 	ch <- prometheus.MustNewConstMetric(
 		startTimeDesc,
 		prometheus.CounterValue,
 		startTime,
 	)
-	wg.Wait()
+
+	t := time.Now()
+	scrapeContext, err := collector.PrepareScrapeContext()
+	ch <- prometheus.MustNewConstMetric(
+		snapshotDuration,
+		prometheus.GaugeValue,
+		time.Since(t).Seconds(),
+	)
+	if err != nil {
+		ch <- prometheus.NewInvalidMetric(scrapeSuccessDesc, fmt.Errorf("failed to prepare scrape: %v", err))
+		return
+	}
+
+	wg := sync.WaitGroup{}
+	wg.Add(len(coll.collectors))
+	collectorOutcomes := make(map[string]collectorOutcome)
+	for name := range coll.collectors {
+		collectorOutcomes[name] = pending
+	}
+
+	metricsBuffer := make(chan prometheus.Metric)
+	l := sync.Mutex{}
+	finished := false
+	go func() {
+		for m := range metricsBuffer {
+			l.Lock()
+			if !finished {
+				ch <- m
+			}
+			l.Unlock()
+		}
+	}()
+
+	for name, c := range coll.collectors {
+		go func(name string, c collector.Collector) {
+			defer wg.Done()
+			outcome := execute(name, c, scrapeContext, metricsBuffer)
+			l.Lock()
+			if !finished {
+				collectorOutcomes[name] = outcome
+			}
+			l.Unlock()
+		}(name, c)
+	}
+
+	allDone := make(chan struct{})
+	go func() {
+		wg.Wait()
+		close(allDone)
+		close(metricsBuffer)
+	}()
+
+	// Wait until either all collectors finish, or timeout expires
+	select {
+	case <-allDone:
+	case <-time.After(coll.maxScrapeDuration):
+	}
+
+	l.Lock()
+	finished = true
+
+	remainingCollectorNames := make([]string, 0)
+	for name, outcome := range collectorOutcomes {
+		var successValue, timeoutValue float64
+		if outcome == pending {
+			timeoutValue = 1.0
+			remainingCollectorNames = append(remainingCollectorNames, name)
+		}
+		if outcome == success {
+			successValue = 1.0
+		}
+
+		ch <- prometheus.MustNewConstMetric(
+			scrapeSuccessDesc,
+			prometheus.GaugeValue,
+			successValue,
+			name,
+		)
+		ch <- prometheus.MustNewConstMetric(
+			scrapeTimeoutDesc,
+			prometheus.GaugeValue,
+			timeoutValue,
+			name,
+		)
+	}
+
+	if len(remainingCollectorNames) > 0 {
+		log.Warn("Collection timed out, still waiting for ", remainingCollectorNames)
+	}
+
+	l.Unlock()
 }
 
 func filterAvailableCollectors(collectors string) string {
@@ -95,31 +200,23 @@ func filterAvailableCollectors(collectors string) string {
 	return strings.Join(availableCollectors, ",")
 }
 
-func execute(name string, c collector.Collector, ch chan<- prometheus.Metric) {
-	begin := time.Now()
-	err := c.Collect(ch)
-	duration := time.Since(begin)
-	var success float64
-
-	if err != nil {
-		log.Errorf("collector %s failed after %fs: %s", name, duration.Seconds(), err)
-		success = 0
-	} else {
-		log.Debugf("collector %s succeeded after %fs.", name, duration.Seconds())
-		success = 1
-	}
+func execute(name string, c collector.Collector, ctx *collector.ScrapeContext, ch chan<- prometheus.Metric) collectorOutcome {
+	t := time.Now()
+	err := c.Collect(ctx, ch)
+	duration := time.Since(t).Seconds()
 	ch <- prometheus.MustNewConstMetric(
 		scrapeDurationDesc,
 		prometheus.GaugeValue,
-		duration.Seconds(),
-		name,
-	)
-	ch <- prometheus.MustNewConstMetric(
-		scrapeSuccessDesc,
-		prometheus.GaugeValue,
-		success,
+		duration,
 		name,
 	)
+
+	if err != nil {
+		log.Errorf("collector %s failed after %fs: %s", name, duration, err)
+		return failed
+	}
+	log.Debugf("collector %s succeeded after %fs.", name, duration)
+	return success
 }
 
 func expandEnabledCollectors(enabled string) []string {
@@ -156,10 +253,6 @@ func loadCollectors(list string) (map[string]collector.Collector, error) {
 	return collectors, nil
 }
 
-func init() {
-	prometheus.MustRegister(version.NewCollector("wmi_exporter"))
-}
-
 func initWbem() {
 	// This initialization prevents a memory leak on WMF 5+. See
 	// https://github.com/martinlindhe/wmi_exporter/issues/77 and linked issues
@@ -191,6 +284,10 @@ func main() {
 			"collectors.print",
 			"If true, print available collectors and exit.",
 		).Bool()
+		timeoutMargin = kingpin.Flag(
+			"scrape.timeout-margin",
+			"Seconds to subtract from the timeout allowed by the client. Tune to allow for overhead or high loads.",
+		).Default("0.5").Float64()
 	)
 
 	log.AddFlags(kingpin.CommandLine)
@@ -220,7 +317,12 @@ func main() {
 
 	stopCh := make(chan bool)
 	if !isInteractive {
-		go svc.Run(serviceName, &wmiExporterService{stopCh: stopCh})
+		go func() {
+			err = svc.Run(serviceName, &wmiExporterService{stopCh: stopCh})
+			if err != nil {
+				log.Errorf("Failed to start service: %v", err)
+			}
+		}()
 	}
 
 	collectors, err := loadCollectors(*enabledCollectors)
@@ -230,10 +332,17 @@ func main() {
 
 	log.Infof("Enabled collectors: %v", strings.Join(keys(collectors), ", "))
 
-	nodeCollector := WmiCollector{collectors: collectors}
-	prometheus.MustRegister(nodeCollector)
+	h := &metricsHandler{
+		timeoutMargin: *timeoutMargin,
+		collectorFactory: func(timeout time.Duration) *WmiCollector {
+			return &WmiCollector{
+				collectors:        collectors,
+				maxScrapeDuration: timeout,
+			}
+		},
+	}
 
-	http.Handle(*metricsPath, promhttp.Handler())
+	http.Handle(*metricsPath, h)
 	http.HandleFunc("/health", healthCheck)
 	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		http.Redirect(w, r, *metricsPath, http.StatusMovedPermanently)
@@ -257,7 +366,10 @@ func main() {
 
 func healthCheck(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
-	io.WriteString(w, `{"status":"ok"}`)
+	_, err := fmt.Fprintln(w, `{"status":"ok"}`)
+	if err != nil {
+		log.Debugf("Failed to write to stream: %v", err)
+	}
 }
 
 func keys(m map[string]collector.Collector) []string {
@@ -294,3 +406,36 @@ loop:
 	changes <- svc.Status{State: svc.StopPending}
 	return
 }
+
+type metricsHandler struct {
+	timeoutMargin    float64
+	collectorFactory func(timeout time.Duration) *WmiCollector
+}
+
+func (mh *metricsHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	const defaultTimeout = 10.0
+
+	var timeoutSeconds float64
+	if v := r.Header.Get("X-Prometheus-Scrape-Timeout-Seconds"); v != "" {
+		var err error
+		timeoutSeconds, err = strconv.ParseFloat(v, 64)
+		if err != nil {
+			log.Warnf("Couldn't parse X-Prometheus-Scrape-Timeout-Seconds: %q. Defaulting timeout to %f", v, defaultTimeout)
+		}
+	}
+	if timeoutSeconds == 0 {
+		timeoutSeconds = defaultTimeout
+	}
+	timeoutSeconds = timeoutSeconds - mh.timeoutMargin
+
+	reg := prometheus.NewRegistry()
+	reg.MustRegister(mh.collectorFactory(time.Duration(timeoutSeconds * float64(time.Second))))
+	reg.MustRegister(
+		prometheus.NewProcessCollector(os.Getpid(), ""),
+		prometheus.NewGoCollector(),
+		version.NewCollector("wmi_exporter"),
+	)
+
+	h := promhttp.HandlerFor(reg, promhttp.HandlerOpts{})
+	h.ServeHTTP(w, r)
+}

exporter_test.go

@@ -1,3 +1,5 @@
+// +build windows
+
 package main
 
 import (

gometalinter.config

@@ -0,0 +1,28 @@
+{
+    "Disable": [
+        "goconst",
+        "gocyclo",
+        "gosec",
+        "maligned",
+        "megacheck"
+    ],
+    "Enable": [
+        "deadcode",
+        "errcheck",
+        "golint",
+        "gotype",
+        "gotypex",
+        "ineffassign",
+        "interfacer",
+        "structcheck",
+        "unconvert",
+        "varcheck",
+        "vet",
+        "vetshadow"
+    ],
+    "Exclude": [
+        "don't use underscores in Go names",
+        "exported type .+ should have comment or be unexported",
+        "should be"
+    ]
+}

installer/wmi_exporter.wxs

@@ -19,6 +19,9 @@
     <Property Id="ENABLED_COLLECTORS" Secure="yes"/>
     <SetProperty Id="CollectorsFlag" After="InstallFiles" Sequence="execute" Value="--collectors.enabled [ENABLED_COLLECTORS]">ENABLED_COLLECTORS</SetProperty>
 
+    <Property Id="EXTRA_FLAGS" Secure="yes"/>
+    <SetProperty Id="ExtraFlags" After="InstallFiles" Sequence="execute" Value="[EXTRA_FLAGS]">EXTRA_FLAGS</SetProperty>
+
     <Property Id="LISTEN_ADDR" Secure="yes" />
     <Property Id="LISTEN_PORT" Secure="yes" Value="9182" />
     <SetProperty Id="ListenFlag" After="InstallFiles" Sequence="execute" Value="--telemetry.addr [LISTEN_ADDR]:[LISTEN_PORT]">LISTEN_ADDR OR LISTEN_PORT</SetProperty>
@@ -42,10 +45,11 @@
         <File Id="wmi_exporter.exe" Name="wmi_exporter.exe" Source="Work\wmi_exporter.exe" KeyPath="yes">
           <fw:FirewallException Id="MetricsEndpoint" Name="WMI Exporter (HTTP [LISTEN_PORT])" Description="WMI Exporter HTTP endpoint" Port="[LISTEN_PORT]" Protocol="tcp" Scope="any" IgnoreFailure="yes" />
         </File>
-        <ServiceInstall Id="InstallExporterService" Name="wmi_exporter" DisplayName="WMI exporter" Description="Exports Prometheus metrics from WMI queries" ErrorControl="normal" Start="auto" Type="ownProcess" Arguments="--log.format logger:eventlog?name=wmi_exporter [CollectorsFlag] [ListenFlag] [MetricsPathFlag] [TextfileDirFlag]">
+        <ServiceInstall Id="InstallExporterService" Name="wmi_exporter" DisplayName="WMI exporter" Description="Exports Prometheus metrics from WMI queries" ErrorControl="normal" Start="auto" Type="ownProcess" Arguments="--log.format logger:eventlog?name=wmi_exporter [CollectorsFlag] [ListenFlag] [MetricsPathFlag] [TextfileDirFlag] [ExtraFlags]">
           <util:ServiceConfig FirstFailureActionType="restart" SecondFailureActionType="restart" ThirdFailureActionType="restart" RestartServiceDelayInSeconds="5" />
         </ServiceInstall>
         <ServiceControl Id="ServiceStateControl" Name="wmi_exporter" Remove="uninstall" Start="install" Stop="both" />
+        <util:EventSource Log="Application" Name="wmi_exporter" EventMessageFile="%SystemRoot%\System32\EventCreate.exe" />
       </Component>
       <Component Id="CreateTextfileDirectory" Directory="textfile_inputs" Guid="d03ef58a-9cbf-4165-ad39-d143e9b27e14">
         <CreateFolder />

tools/collector-generator/New-Collector.ps1

@@ -20,7 +20,7 @@ else {
 $members = $wmiObject `
     | Get-Member -MemberType Properties `
     | Where-Object { $_.Definition -Match '^u?int' -and $_.Name -NotMatch '_' } `
-    | Select-Object Name, @{Name="Type";Expression={$_.Definition.Split(" ")[0]}}
+    | Select-Object Name, @{Name="Type";Expression={$_.Definition.Split(" ")[0]}})
 $input = @{
     "Class"=$Class;
     "CollectorName"=$CollectorName;

tools/collector-generator/collector.template

@@ -1,5 +1,3 @@
-// returns data points from {{ .Class }}
-// <add link to documentation here> - {{ .Class }} class
 package collector
 import (
     "github.com/StackExchange/wmi"
@@ -31,13 +29,15 @@ func New{{ .CollectorName }}Collector() (Collector, error) {
 }
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *{{ .CollectorName }}Collector) Collect(ch chan<- prometheus.Metric) error {
+func (c *{{ .CollectorName }}Collector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
     if desc, err := c.collect(ch); err != nil {
         log.Error("failed collecting {{ .CollectorName | toLower }} metrics:", desc, err)
         return err
     }
     return nil
 }
+// {{ .Class }} docs:
+// - <add link to documentation here>
 type {{ .Class }} struct {
     Name string
 {{ range $m := .Members }}

tools/collector-generator/generate-collector.go

@@ -25,7 +25,7 @@ func main() {
 		panic(err)
 	}
 	var data TemplateData
-	if err := json.Unmarshal(bytes, &data); err != nil {
+	if err = json.Unmarshal(bytes, &data); err != nil {
 		panic(err)
 	}
 
@@ -33,11 +33,11 @@ func main() {
 		"toLower":     strings.ToLower,
 		"toSnakeCase": toSnakeCase,
 	}
-	template, err := template.New("template").Funcs(funcs).ParseFiles("collector.template")
+	tmpl, err := template.New("template").Funcs(funcs).ParseFiles("collector.template")
 	if err != nil {
 		panic(err)
 	}
-	err = template.ExecuteTemplate(os.Stdout, "collector.template", data)
+	err = tmpl.ExecuteTemplate(os.Stdout, "collector.template", data)
 	if err != nil {
 		panic(err)
 	}

vendor/github.com/Microsoft/go-winio/.gitignore

@@ -0,0 +1 @@
+*.exe

vendor/github.com/Microsoft/go-winio/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Microsoft
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

vendor/github.com/Microsoft/go-winio/README.md

@@ -0,0 +1,22 @@
+# go-winio
+
+This repository contains utilities for efficiently performing Win32 IO operations in
+Go. Currently, this is focused on accessing named pipes and other file handles, and
+for using named pipes as a net transport.
+
+This code relies on IO completion ports to avoid blocking IO on system threads, allowing Go
+to reuse the thread to schedule another goroutine. This limits support to Windows Vista and
+newer operating systems. This is similar to the implementation of network sockets in Go's net
+package.
+
+Please see the LICENSE file for licensing information.
+
+This project has adopted the [Microsoft Open Source Code of
+Conduct](https://opensource.microsoft.com/codeofconduct/). For more information
+see the [Code of Conduct
+FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact
+[opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional
+questions or comments.
+
+Thanks to natefinch for the inspiration for this library. See https://github.com/natefinch/npipe
+for another named pipe implementation.

vendor/github.com/Microsoft/go-winio/archive/tar/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2012 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/github.com/Microsoft/go-winio/archive/tar/common.go

@@ -0,0 +1,344 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package tar implements access to tar archives.
+// It aims to cover most of the variations, including those produced
+// by GNU and BSD tars.
+//
+// References:
+//   http://www.freebsd.org/cgi/man.cgi?query=tar&sektion=5
+//   http://www.gnu.org/software/tar/manual/html_node/Standard.html
+//   http://pubs.opengroup.org/onlinepubs/9699919799/utilities/pax.html
+package tar
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os"
+	"path"
+	"time"
+)
+
+const (
+	blockSize = 512
+
+	// Types
+	TypeReg           = '0'    // regular file
+	TypeRegA          = '\x00' // regular file
+	TypeLink          = '1'    // hard link
+	TypeSymlink       = '2'    // symbolic link
+	TypeChar          = '3'    // character device node
+	TypeBlock         = '4'    // block device node
+	TypeDir           = '5'    // directory
+	TypeFifo          = '6'    // fifo node
+	TypeCont          = '7'    // reserved
+	TypeXHeader       = 'x'    // extended header
+	TypeXGlobalHeader = 'g'    // global extended header
+	TypeGNULongName   = 'L'    // Next file has a long name
+	TypeGNULongLink   = 'K'    // Next file symlinks to a file w/ a long name
+	TypeGNUSparse     = 'S'    // sparse file
+)
+
+// A Header represents a single header in a tar archive.
+// Some fields may not be populated.
+type Header struct {
+	Name         string    // name of header file entry
+	Mode         int64     // permission and mode bits
+	Uid          int       // user id of owner
+	Gid          int       // group id of owner
+	Size         int64     // length in bytes
+	ModTime      time.Time // modified time
+	Typeflag     byte      // type of header entry
+	Linkname     string    // target name of link
+	Uname        string    // user name of owner
+	Gname        string    // group name of owner
+	Devmajor     int64     // major number of character or block device
+	Devminor     int64     // minor number of character or block device
+	AccessTime   time.Time // access time
+	ChangeTime   time.Time // status change time
+	CreationTime time.Time // creation time
+	Xattrs       map[string]string
+	Winheaders   map[string]string
+}
+
+// File name constants from the tar spec.
+const (
+	fileNameSize       = 100 // Maximum number of bytes in a standard tar name.
+	fileNamePrefixSize = 155 // Maximum number of ustar extension bytes.
+)
+
+// FileInfo returns an os.FileInfo for the Header.
+func (h *Header) FileInfo() os.FileInfo {
+	return headerFileInfo{h}
+}
+
+// headerFileInfo implements os.FileInfo.
+type headerFileInfo struct {
+	h *Header
+}
+
+func (fi headerFileInfo) Size() int64        { return fi.h.Size }
+func (fi headerFileInfo) IsDir() bool        { return fi.Mode().IsDir() }
+func (fi headerFileInfo) ModTime() time.Time { return fi.h.ModTime }
+func (fi headerFileInfo) Sys() interface{}   { return fi.h }
+
+// Name returns the base name of the file.
+func (fi headerFileInfo) Name() string {
+	if fi.IsDir() {
+		return path.Base(path.Clean(fi.h.Name))
+	}
+	return path.Base(fi.h.Name)
+}
+
+// Mode returns the permission and mode bits for the headerFileInfo.
+func (fi headerFileInfo) Mode() (mode os.FileMode) {
+	// Set file permission bits.
+	mode = os.FileMode(fi.h.Mode).Perm()
+
+	// Set setuid, setgid and sticky bits.
+	if fi.h.Mode&c_ISUID != 0 {
+		// setuid
+		mode |= os.ModeSetuid
+	}
+	if fi.h.Mode&c_ISGID != 0 {
+		// setgid
+		mode |= os.ModeSetgid
+	}
+	if fi.h.Mode&c_ISVTX != 0 {
+		// sticky
+		mode |= os.ModeSticky
+	}
+
+	// Set file mode bits.
+	// clear perm, setuid, setgid and sticky bits.
+	m := os.FileMode(fi.h.Mode) &^ 07777
+	if m == c_ISDIR {
+		// directory
+		mode |= os.ModeDir
+	}
+	if m == c_ISFIFO {
+		// named pipe (FIFO)
+		mode |= os.ModeNamedPipe
+	}
+	if m == c_ISLNK {
+		// symbolic link
+		mode |= os.ModeSymlink
+	}
+	if m == c_ISBLK {
+		// device file
+		mode |= os.ModeDevice
+	}
+	if m == c_ISCHR {
+		// Unix character device
+		mode |= os.ModeDevice
+		mode |= os.ModeCharDevice
+	}
+	if m == c_ISSOCK {
+		// Unix domain socket
+		mode |= os.ModeSocket
+	}
+
+	switch fi.h.Typeflag {
+	case TypeSymlink:
+		// symbolic link
+		mode |= os.ModeSymlink
+	case TypeChar:
+		// character device node
+		mode |= os.ModeDevice
+		mode |= os.ModeCharDevice
+	case TypeBlock:
+		// block device node
+		mode |= os.ModeDevice
+	case TypeDir:
+		// directory
+		mode |= os.ModeDir
+	case TypeFifo:
+		// fifo node
+		mode |= os.ModeNamedPipe
+	}
+
+	return mode
+}
+
+// sysStat, if non-nil, populates h from system-dependent fields of fi.
+var sysStat func(fi os.FileInfo, h *Header) error
+
+// Mode constants from the tar spec.
+const (
+	c_ISUID  = 04000   // Set uid
+	c_ISGID  = 02000   // Set gid
+	c_ISVTX  = 01000   // Save text (sticky bit)
+	c_ISDIR  = 040000  // Directory
+	c_ISFIFO = 010000  // FIFO
+	c_ISREG  = 0100000 // Regular file
+	c_ISLNK  = 0120000 // Symbolic link
+	c_ISBLK  = 060000  // Block special file
+	c_ISCHR  = 020000  // Character special file
+	c_ISSOCK = 0140000 // Socket
+)
+
+// Keywords for the PAX Extended Header
+const (
+	paxAtime        = "atime"
+	paxCharset      = "charset"
+	paxComment      = "comment"
+	paxCtime        = "ctime" // please note that ctime is not a valid pax header.
+	paxCreationTime = "LIBARCHIVE.creationtime"
+	paxGid          = "gid"
+	paxGname        = "gname"
+	paxLinkpath     = "linkpath"
+	paxMtime        = "mtime"
+	paxPath         = "path"
+	paxSize         = "size"
+	paxUid          = "uid"
+	paxUname        = "uname"
+	paxXattr        = "SCHILY.xattr."
+	paxWindows      = "MSWINDOWS."
+	paxNone         = ""
+)
+
+// FileInfoHeader creates a partially-populated Header from fi.
+// If fi describes a symlink, FileInfoHeader records link as the link target.
+// If fi describes a directory, a slash is appended to the name.
+// Because os.FileInfo's Name method returns only the base name of
+// the file it describes, it may be necessary to modify the Name field
+// of the returned header to provide the full path name of the file.
+func FileInfoHeader(fi os.FileInfo, link string) (*Header, error) {
+	if fi == nil {
+		return nil, errors.New("tar: FileInfo is nil")
+	}
+	fm := fi.Mode()
+	h := &Header{
+		Name:    fi.Name(),
+		ModTime: fi.ModTime(),
+		Mode:    int64(fm.Perm()), // or'd with c_IS* constants later
+	}
+	switch {
+	case fm.IsRegular():
+		h.Mode |= c_ISREG
+		h.Typeflag = TypeReg
+		h.Size = fi.Size()
+	case fi.IsDir():
+		h.Typeflag = TypeDir
+		h.Mode |= c_ISDIR
+		h.Name += "/"
+	case fm&os.ModeSymlink != 0:
+		h.Typeflag = TypeSymlink
+		h.Mode |= c_ISLNK
+		h.Linkname = link
+	case fm&os.ModeDevice != 0:
+		if fm&os.ModeCharDevice != 0 {
+			h.Mode |= c_ISCHR
+			h.Typeflag = TypeChar
+		} else {
+			h.Mode |= c_ISBLK
+			h.Typeflag = TypeBlock
+		}
+	case fm&os.ModeNamedPipe != 0:
+		h.Typeflag = TypeFifo
+		h.Mode |= c_ISFIFO
+	case fm&os.ModeSocket != 0:
+		h.Mode |= c_ISSOCK
+	default:
+		return nil, fmt.Errorf("archive/tar: unknown file mode %v", fm)
+	}
+	if fm&os.ModeSetuid != 0 {
+		h.Mode |= c_ISUID
+	}
+	if fm&os.ModeSetgid != 0 {
+		h.Mode |= c_ISGID
+	}
+	if fm&os.ModeSticky != 0 {
+		h.Mode |= c_ISVTX
+	}
+	// If possible, populate additional fields from OS-specific
+	// FileInfo fields.
+	if sys, ok := fi.Sys().(*Header); ok {
+		// This FileInfo came from a Header (not the OS). Use the
+		// original Header to populate all remaining fields.
+		h.Uid = sys.Uid
+		h.Gid = sys.Gid
+		h.Uname = sys.Uname
+		h.Gname = sys.Gname
+		h.AccessTime = sys.AccessTime
+		h.ChangeTime = sys.ChangeTime
+		if sys.Xattrs != nil {
+			h.Xattrs = make(map[string]string)
+			for k, v := range sys.Xattrs {
+				h.Xattrs[k] = v
+			}
+		}
+		if sys.Typeflag == TypeLink {
+			// hard link
+			h.Typeflag = TypeLink
+			h.Size = 0
+			h.Linkname = sys.Linkname
+		}
+	}
+	if sysStat != nil {
+		return h, sysStat(fi, h)
+	}
+	return h, nil
+}
+
+var zeroBlock = make([]byte, blockSize)
+
+// POSIX specifies a sum of the unsigned byte values, but the Sun tar uses signed byte values.
+// We compute and return both.
+func checksum(header []byte) (unsigned int64, signed int64) {
+	for i := 0; i < len(header); i++ {
+		if i == 148 {
+			// The chksum field (header[148:156]) is special: it should be treated as space bytes.
+			unsigned += ' ' * 8
+			signed += ' ' * 8
+			i += 7
+			continue
+		}
+		unsigned += int64(header[i])
+		signed += int64(int8(header[i]))
+	}
+	return
+}
+
+type slicer []byte
+
+func (sp *slicer) next(n int) (b []byte) {
+	s := *sp
+	b, *sp = s[0:n], s[n:]
+	return
+}
+
+func isASCII(s string) bool {
+	for _, c := range s {
+		if c >= 0x80 {
+			return false
+		}
+	}
+	return true
+}
+
+func toASCII(s string) string {
+	if isASCII(s) {
+		return s
+	}
+	var buf bytes.Buffer
+	for _, c := range s {
+		if c < 0x80 {
+			buf.WriteByte(byte(c))
+		}
+	}
+	return buf.String()
+}
+
+// isHeaderOnlyType checks if the given type flag is of the type that has no
+// data section even if a size is specified.
+func isHeaderOnlyType(flag byte) bool {
+	switch flag {
+	case TypeLink, TypeSymlink, TypeChar, TypeBlock, TypeDir, TypeFifo:
+		return true
+	default:
+		return false
+	}
+}

vendor/github.com/Microsoft/go-winio/archive/tar/example_test.go

@@ -0,0 +1,80 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package tar_test
+
+import (
+	"archive/tar"
+	"bytes"
+	"fmt"
+	"io"
+	"log"
+	"os"
+)
+
+func Example() {
+	// Create a buffer to write our archive to.
+	buf := new(bytes.Buffer)
+
+	// Create a new tar archive.
+	tw := tar.NewWriter(buf)
+
+	// Add some files to the archive.
+	var files = []struct {
+		Name, Body string
+	}{
+		{"readme.txt", "This archive contains some text files."},
+		{"gopher.txt", "Gopher names:\nGeorge\nGeoffrey\nGonzo"},
+		{"todo.txt", "Get animal handling license."},
+	}
+	for _, file := range files {
+		hdr := &tar.Header{
+			Name: file.Name,
+			Mode: 0600,
+			Size: int64(len(file.Body)),
+		}
+		if err := tw.WriteHeader(hdr); err != nil {
+			log.Fatalln(err)
+		}
+		if _, err := tw.Write([]byte(file.Body)); err != nil {
+			log.Fatalln(err)
+		}
+	}
+	// Make sure to check the error on Close.
+	if err := tw.Close(); err != nil {
+		log.Fatalln(err)
+	}
+
+	// Open the tar archive for reading.
+	r := bytes.NewReader(buf.Bytes())
+	tr := tar.NewReader(r)
+
+	// Iterate through the files in the archive.
+	for {
+		hdr, err := tr.Next()
+		if err == io.EOF {
+			// end of tar archive
+			break
+		}
+		if err != nil {
+			log.Fatalln(err)
+		}
+		fmt.Printf("Contents of %s:\n", hdr.Name)
+		if _, err := io.Copy(os.Stdout, tr); err != nil {
+			log.Fatalln(err)
+		}
+		fmt.Println()
+	}
+
+	// Output:
+	// Contents of readme.txt:
+	// This archive contains some text files.
+	// Contents of gopher.txt:
+	// Gopher names:
+	// George
+	// Geoffrey
+	// Gonzo
+	// Contents of todo.txt:
+	// Get animal handling license.
+}

vendor/github.com/Microsoft/go-winio/archive/tar/stat_atim.go

@@ -0,0 +1,20 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build linux dragonfly openbsd solaris
+
+package tar
+
+import (
+	"syscall"
+	"time"
+)
+
+func statAtime(st *syscall.Stat_t) time.Time {
+	return time.Unix(st.Atim.Unix())
+}
+
+func statCtime(st *syscall.Stat_t) time.Time {
+	return time.Unix(st.Ctim.Unix())
+}

vendor/github.com/Microsoft/go-winio/archive/tar/stat_atimespec.go

@@ -0,0 +1,20 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build darwin freebsd netbsd
+
+package tar
+
+import (
+	"syscall"
+	"time"
+)
+
+func statAtime(st *syscall.Stat_t) time.Time {
+	return time.Unix(st.Atimespec.Unix())
+}
+
+func statCtime(st *syscall.Stat_t) time.Time {
+	return time.Unix(st.Ctimespec.Unix())
+}

vendor/github.com/Microsoft/go-winio/archive/tar/stat_unix.go

@@ -0,0 +1,32 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build linux darwin dragonfly freebsd openbsd netbsd solaris
+
+package tar
+
+import (
+	"os"
+	"syscall"
+)
+
+func init() {
+	sysStat = statUnix
+}
+
+func statUnix(fi os.FileInfo, h *Header) error {
+	sys, ok := fi.Sys().(*syscall.Stat_t)
+	if !ok {
+		return nil
+	}
+	h.Uid = int(sys.Uid)
+	h.Gid = int(sys.Gid)
+	// TODO(bradfitz): populate username & group.  os/user
+	// doesn't cache LookupId lookups, and lacks group
+	// lookup functions.
+	h.AccessTime = statAtime(sys)
+	h.ChangeTime = statCtime(sys)
+	// TODO(bradfitz): major/minor device numbers?
+	return nil
+}

vendor/github.com/Microsoft/go-winio/archive/tar/tar_test.go

@@ -0,0 +1,325 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package tar
+
+import (
+	"bytes"
+	"io/ioutil"
+	"os"
+	"path"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestFileInfoHeader(t *testing.T) {
+	fi, err := os.Stat("testdata/small.txt")
+	if err != nil {
+		t.Fatal(err)
+	}
+	h, err := FileInfoHeader(fi, "")
+	if err != nil {
+		t.Fatalf("FileInfoHeader: %v", err)
+	}
+	if g, e := h.Name, "small.txt"; g != e {
+		t.Errorf("Name = %q; want %q", g, e)
+	}
+	if g, e := h.Mode, int64(fi.Mode().Perm())|c_ISREG; g != e {
+		t.Errorf("Mode = %#o; want %#o", g, e)
+	}
+	if g, e := h.Size, int64(5); g != e {
+		t.Errorf("Size = %v; want %v", g, e)
+	}
+	if g, e := h.ModTime, fi.ModTime(); !g.Equal(e) {
+		t.Errorf("ModTime = %v; want %v", g, e)
+	}
+	// FileInfoHeader should error when passing nil FileInfo
+	if _, err := FileInfoHeader(nil, ""); err == nil {
+		t.Fatalf("Expected error when passing nil to FileInfoHeader")
+	}
+}
+
+func TestFileInfoHeaderDir(t *testing.T) {
+	fi, err := os.Stat("testdata")
+	if err != nil {
+		t.Fatal(err)
+	}
+	h, err := FileInfoHeader(fi, "")
+	if err != nil {
+		t.Fatalf("FileInfoHeader: %v", err)
+	}
+	if g, e := h.Name, "testdata/"; g != e {
+		t.Errorf("Name = %q; want %q", g, e)
+	}
+	// Ignoring c_ISGID for golang.org/issue/4867
+	if g, e := h.Mode&^c_ISGID, int64(fi.Mode().Perm())|c_ISDIR; g != e {
+		t.Errorf("Mode = %#o; want %#o", g, e)
+	}
+	if g, e := h.Size, int64(0); g != e {
+		t.Errorf("Size = %v; want %v", g, e)
+	}
+	if g, e := h.ModTime, fi.ModTime(); !g.Equal(e) {
+		t.Errorf("ModTime = %v; want %v", g, e)
+	}
+}
+
+func TestFileInfoHeaderSymlink(t *testing.T) {
+	h, err := FileInfoHeader(symlink{}, "some-target")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if g, e := h.Name, "some-symlink"; g != e {
+		t.Errorf("Name = %q; want %q", g, e)
+	}
+	if g, e := h.Linkname, "some-target"; g != e {
+		t.Errorf("Linkname = %q; want %q", g, e)
+	}
+}
+
+type symlink struct{}
+
+func (symlink) Name() string       { return "some-symlink" }
+func (symlink) Size() int64        { return 0 }
+func (symlink) Mode() os.FileMode  { return os.ModeSymlink }
+func (symlink) ModTime() time.Time { return time.Time{} }
+func (symlink) IsDir() bool        { return false }
+func (symlink) Sys() interface{}   { return nil }
+
+func TestRoundTrip(t *testing.T) {
+	data := []byte("some file contents")
+
+	var b bytes.Buffer
+	tw := NewWriter(&b)
+	hdr := &Header{
+		Name:    "file.txt",
+		Uid:     1 << 21, // too big for 8 octal digits
+		Size:    int64(len(data)),
+		ModTime: time.Now(),
+	}
+	// tar only supports second precision.
+	hdr.ModTime = hdr.ModTime.Add(-time.Duration(hdr.ModTime.Nanosecond()) * time.Nanosecond)
+	if err := tw.WriteHeader(hdr); err != nil {
+		t.Fatalf("tw.WriteHeader: %v", err)
+	}
+	if _, err := tw.Write(data); err != nil {
+		t.Fatalf("tw.Write: %v", err)
+	}
+	if err := tw.Close(); err != nil {
+		t.Fatalf("tw.Close: %v", err)
+	}
+
+	// Read it back.
+	tr := NewReader(&b)
+	rHdr, err := tr.Next()
+	if err != nil {
+		t.Fatalf("tr.Next: %v", err)
+	}
+	if !reflect.DeepEqual(rHdr, hdr) {
+		t.Errorf("Header mismatch.\n got %+v\nwant %+v", rHdr, hdr)
+	}
+	rData, err := ioutil.ReadAll(tr)
+	if err != nil {
+		t.Fatalf("Read: %v", err)
+	}
+	if !bytes.Equal(rData, data) {
+		t.Errorf("Data mismatch.\n got %q\nwant %q", rData, data)
+	}
+}
+
+type headerRoundTripTest struct {
+	h  *Header
+	fm os.FileMode
+}
+
+func TestHeaderRoundTrip(t *testing.T) {
+	golden := []headerRoundTripTest{
+		// regular file.
+		{
+			h: &Header{
+				Name:     "test.txt",
+				Mode:     0644 | c_ISREG,
+				Size:     12,
+				ModTime:  time.Unix(1360600916, 0),
+				Typeflag: TypeReg,
+			},
+			fm: 0644,
+		},
+		// symbolic link.
+		{
+			h: &Header{
+				Name:     "link.txt",
+				Mode:     0777 | c_ISLNK,
+				Size:     0,
+				ModTime:  time.Unix(1360600852, 0),
+				Typeflag: TypeSymlink,
+			},
+			fm: 0777 | os.ModeSymlink,
+		},
+		// character device node.
+		{
+			h: &Header{
+				Name:     "dev/null",
+				Mode:     0666 | c_ISCHR,
+				Size:     0,
+				ModTime:  time.Unix(1360578951, 0),
+				Typeflag: TypeChar,
+			},
+			fm: 0666 | os.ModeDevice | os.ModeCharDevice,
+		},
+		// block device node.
+		{
+			h: &Header{
+				Name:     "dev/sda",
+				Mode:     0660 | c_ISBLK,
+				Size:     0,
+				ModTime:  time.Unix(1360578954, 0),
+				Typeflag: TypeBlock,
+			},
+			fm: 0660 | os.ModeDevice,
+		},
+		// directory.
+		{
+			h: &Header{
+				Name:     "dir/",
+				Mode:     0755 | c_ISDIR,
+				Size:     0,
+				ModTime:  time.Unix(1360601116, 0),
+				Typeflag: TypeDir,
+			},
+			fm: 0755 | os.ModeDir,
+		},
+		// fifo node.
+		{
+			h: &Header{
+				Name:     "dev/initctl",
+				Mode:     0600 | c_ISFIFO,
+				Size:     0,
+				ModTime:  time.Unix(1360578949, 0),
+				Typeflag: TypeFifo,
+			},
+			fm: 0600 | os.ModeNamedPipe,
+		},
+		// setuid.
+		{
+			h: &Header{
+				Name:     "bin/su",
+				Mode:     0755 | c_ISREG | c_ISUID,
+				Size:     23232,
+				ModTime:  time.Unix(1355405093, 0),
+				Typeflag: TypeReg,
+			},
+			fm: 0755 | os.ModeSetuid,
+		},
+		// setguid.
+		{
+			h: &Header{
+				Name:     "group.txt",
+				Mode:     0750 | c_ISREG | c_ISGID,
+				Size:     0,
+				ModTime:  time.Unix(1360602346, 0),
+				Typeflag: TypeReg,
+			},
+			fm: 0750 | os.ModeSetgid,
+		},
+		// sticky.
+		{
+			h: &Header{
+				Name:     "sticky.txt",
+				Mode:     0600 | c_ISREG | c_ISVTX,
+				Size:     7,
+				ModTime:  time.Unix(1360602540, 0),
+				Typeflag: TypeReg,
+			},
+			fm: 0600 | os.ModeSticky,
+		},
+		// hard link.
+		{
+			h: &Header{
+				Name:     "hard.txt",
+				Mode:     0644 | c_ISREG,
+				Size:     0,
+				Linkname: "file.txt",
+				ModTime:  time.Unix(1360600916, 0),
+				Typeflag: TypeLink,
+			},
+			fm: 0644,
+		},
+		// More information.
+		{
+			h: &Header{
+				Name:     "info.txt",
+				Mode:     0600 | c_ISREG,
+				Size:     0,
+				Uid:      1000,
+				Gid:      1000,
+				ModTime:  time.Unix(1360602540, 0),
+				Uname:    "slartibartfast",
+				Gname:    "users",
+				Typeflag: TypeReg,
+			},
+			fm: 0600,
+		},
+	}
+
+	for i, g := range golden {
+		fi := g.h.FileInfo()
+		h2, err := FileInfoHeader(fi, "")
+		if err != nil {
+			t.Error(err)
+			continue
+		}
+		if strings.Contains(fi.Name(), "/") {
+			t.Errorf("FileInfo of %q contains slash: %q", g.h.Name, fi.Name())
+		}
+		name := path.Base(g.h.Name)
+		if fi.IsDir() {
+			name += "/"
+		}
+		if got, want := h2.Name, name; got != want {
+			t.Errorf("i=%d: Name: got %v, want %v", i, got, want)
+		}
+		if got, want := h2.Size, g.h.Size; got != want {
+			t.Errorf("i=%d: Size: got %v, want %v", i, got, want)
+		}
+		if got, want := h2.Uid, g.h.Uid; got != want {
+			t.Errorf("i=%d: Uid: got %d, want %d", i, got, want)
+		}
+		if got, want := h2.Gid, g.h.Gid; got != want {
+			t.Errorf("i=%d: Gid: got %d, want %d", i, got, want)
+		}
+		if got, want := h2.Uname, g.h.Uname; got != want {
+			t.Errorf("i=%d: Uname: got %q, want %q", i, got, want)
+		}
+		if got, want := h2.Gname, g.h.Gname; got != want {
+			t.Errorf("i=%d: Gname: got %q, want %q", i, got, want)
+		}
+		if got, want := h2.Linkname, g.h.Linkname; got != want {
+			t.Errorf("i=%d: Linkname: got %v, want %v", i, got, want)
+		}
+		if got, want := h2.Typeflag, g.h.Typeflag; got != want {
+			t.Logf("%#v %#v", g.h, fi.Sys())
+			t.Errorf("i=%d: Typeflag: got %q, want %q", i, got, want)
+		}
+		if got, want := h2.Mode, g.h.Mode; got != want {
+			t.Errorf("i=%d: Mode: got %o, want %o", i, got, want)
+		}
+		if got, want := fi.Mode(), g.fm; got != want {
+			t.Errorf("i=%d: fi.Mode: got %o, want %o", i, got, want)
+		}
+		if got, want := h2.AccessTime, g.h.AccessTime; got != want {
+			t.Errorf("i=%d: AccessTime: got %v, want %v", i, got, want)
+		}
+		if got, want := h2.ChangeTime, g.h.ChangeTime; got != want {
+			t.Errorf("i=%d: ChangeTime: got %v, want %v", i, got, want)
+		}
+		if got, want := h2.ModTime, g.h.ModTime; got != want {
+			t.Errorf("i=%d: ModTime: got %v, want %v", i, got, want)
+		}
+		if sysh, ok := fi.Sys().(*Header); !ok || sysh != g.h {
+			t.Errorf("i=%d: Sys didn't return original *Header", i)
+		}
+	}
+}

vendor/github.com/Microsoft/go-winio/archive/tar/writer.go

@@ -0,0 +1,444 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package tar
+
+// TODO(dsymonds):
+// - catch more errors (no first header, etc.)
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"path"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+)
+
+var (
+	ErrWriteTooLong    = errors.New("archive/tar: write too long")
+	ErrFieldTooLong    = errors.New("archive/tar: header field too long")
+	ErrWriteAfterClose = errors.New("archive/tar: write after close")
+	errInvalidHeader   = errors.New("archive/tar: header field too long or contains invalid values")
+)
+
+// A Writer provides sequential writing of a tar archive in POSIX.1 format.
+// A tar archive consists of a sequence of files.
+// Call WriteHeader to begin a new file, and then call Write to supply that file's data,
+// writing at most hdr.Size bytes in total.
+type Writer struct {
+	w          io.Writer
+	err        error
+	nb         int64 // number of unwritten bytes for current file entry
+	pad        int64 // amount of padding to write after current file entry
+	closed     bool
+	usedBinary bool            // whether the binary numeric field extension was used
+	preferPax  bool            // use pax header instead of binary numeric header
+	hdrBuff    [blockSize]byte // buffer to use in writeHeader when writing a regular header
+	paxHdrBuff [blockSize]byte // buffer to use in writeHeader when writing a pax header
+}
+
+type formatter struct {
+	err error // Last error seen
+}
+
+// NewWriter creates a new Writer writing to w.
+func NewWriter(w io.Writer) *Writer { return &Writer{w: w, preferPax: true} }
+
+// Flush finishes writing the current file (optional).
+func (tw *Writer) Flush() error {
+	if tw.nb > 0 {
+		tw.err = fmt.Errorf("archive/tar: missed writing %d bytes", tw.nb)
+		return tw.err
+	}
+
+	n := tw.nb + tw.pad
+	for n > 0 && tw.err == nil {
+		nr := n
+		if nr > blockSize {
+			nr = blockSize
+		}
+		var nw int
+		nw, tw.err = tw.w.Write(zeroBlock[0:nr])
+		n -= int64(nw)
+	}
+	tw.nb = 0
+	tw.pad = 0
+	return tw.err
+}
+
+// Write s into b, terminating it with a NUL if there is room.
+func (f *formatter) formatString(b []byte, s string) {
+	if len(s) > len(b) {
+		f.err = ErrFieldTooLong
+		return
+	}
+	ascii := toASCII(s)
+	copy(b, ascii)
+	if len(ascii) < len(b) {
+		b[len(ascii)] = 0
+	}
+}
+
+// Encode x as an octal ASCII string and write it into b with leading zeros.
+func (f *formatter) formatOctal(b []byte, x int64) {
+	s := strconv.FormatInt(x, 8)
+	// leading zeros, but leave room for a NUL.
+	for len(s)+1 < len(b) {
+		s = "0" + s
+	}
+	f.formatString(b, s)
+}
+
+// fitsInBase256 reports whether x can be encoded into n bytes using base-256
+// encoding. Unlike octal encoding, base-256 encoding does not require that the
+// string ends with a NUL character. Thus, all n bytes are available for output.
+//
+// If operating in binary mode, this assumes strict GNU binary mode; which means
+// that the first byte can only be either 0x80 or 0xff. Thus, the first byte is
+// equivalent to the sign bit in two's complement form.
+func fitsInBase256(n int, x int64) bool {
+	var binBits = uint(n-1) * 8
+	return n >= 9 || (x >= -1<<binBits && x < 1<<binBits)
+}
+
+// Write x into b, as binary (GNUtar/star extension).
+func (f *formatter) formatNumeric(b []byte, x int64) {
+	if fitsInBase256(len(b), x) {
+		for i := len(b) - 1; i >= 0; i-- {
+			b[i] = byte(x)
+			x >>= 8
+		}
+		b[0] |= 0x80 // Highest bit indicates binary format
+		return
+	}
+
+	f.formatOctal(b, 0) // Last resort, just write zero
+	f.err = ErrFieldTooLong
+}
+
+var (
+	minTime = time.Unix(0, 0)
+	// There is room for 11 octal digits (33 bits) of mtime.
+	maxTime = minTime.Add((1<<33 - 1) * time.Second)
+)
+
+// WriteHeader writes hdr and prepares to accept the file's contents.
+// WriteHeader calls Flush if it is not the first header.
+// Calling after a Close will return ErrWriteAfterClose.
+func (tw *Writer) WriteHeader(hdr *Header) error {
+	return tw.writeHeader(hdr, true)
+}
+
+// WriteHeader writes hdr and prepares to accept the file's contents.
+// WriteHeader calls Flush if it is not the first header.
+// Calling after a Close will return ErrWriteAfterClose.
+// As this method is called internally by writePax header to allow it to
+// suppress writing the pax header.
+func (tw *Writer) writeHeader(hdr *Header, allowPax bool) error {
+	if tw.closed {
+		return ErrWriteAfterClose
+	}
+	if tw.err == nil {
+		tw.Flush()
+	}
+	if tw.err != nil {
+		return tw.err
+	}
+
+	// a map to hold pax header records, if any are needed
+	paxHeaders := make(map[string]string)
+
+	// TODO(shanemhansen): we might want to use PAX headers for
+	// subsecond time resolution, but for now let's just capture
+	// too long fields or non ascii characters
+
+	var f formatter
+	var header []byte
+
+	// We need to select which scratch buffer to use carefully,
+	// since this method is called recursively to write PAX headers.
+	// If allowPax is true, this is the non-recursive call, and we will use hdrBuff.
+	// If allowPax is false, we are being called by writePAXHeader, and hdrBuff is
+	// already being used by the non-recursive call, so we must use paxHdrBuff.
+	header = tw.hdrBuff[:]
+	if !allowPax {
+		header = tw.paxHdrBuff[:]
+	}
+	copy(header, zeroBlock)
+	s := slicer(header)
+
+	// Wrappers around formatter that automatically sets paxHeaders if the
+	// argument extends beyond the capacity of the input byte slice.
+	var formatString = func(b []byte, s string, paxKeyword string) {
+		needsPaxHeader := paxKeyword != paxNone && len(s) > len(b) || !isASCII(s)
+		if needsPaxHeader {
+			paxHeaders[paxKeyword] = s
+			return
+		}
+		f.formatString(b, s)
+	}
+	var formatNumeric = func(b []byte, x int64, paxKeyword string) {
+		// Try octal first.
+		s := strconv.FormatInt(x, 8)
+		if len(s) < len(b) {
+			f.formatOctal(b, x)
+			return
+		}
+
+		// If it is too long for octal, and PAX is preferred, use a PAX header.
+		if paxKeyword != paxNone && tw.preferPax {
+			f.formatOctal(b, 0)
+			s := strconv.FormatInt(x, 10)
+			paxHeaders[paxKeyword] = s
+			return
+		}
+
+		tw.usedBinary = true
+		f.formatNumeric(b, x)
+	}
+	var formatTime = func(b []byte, t time.Time, paxKeyword string) {
+		var unixTime int64
+		if !t.Before(minTime) && !t.After(maxTime) {
+			unixTime = t.Unix()
+		}
+		formatNumeric(b, unixTime, paxNone)
+
+		// Write a PAX header if the time didn't fit precisely.
+		if paxKeyword != "" && tw.preferPax && allowPax && (t.Nanosecond() != 0 || !t.Before(minTime) || !t.After(maxTime)) {
+			paxHeaders[paxKeyword] = formatPAXTime(t)
+		}
+	}
+
+	// keep a reference to the filename to allow to overwrite it later if we detect that we can use ustar longnames instead of pax
+	pathHeaderBytes := s.next(fileNameSize)
+
+	formatString(pathHeaderBytes, hdr.Name, paxPath)
+
+	f.formatOctal(s.next(8), hdr.Mode)               // 100:108
+	formatNumeric(s.next(8), int64(hdr.Uid), paxUid) // 108:116
+	formatNumeric(s.next(8), int64(hdr.Gid), paxGid) // 116:124
+	formatNumeric(s.next(12), hdr.Size, paxSize)     // 124:136
+	formatTime(s.next(12), hdr.ModTime, paxMtime)    // 136:148
+	s.next(8)                                        // chksum (148:156)
+	s.next(1)[0] = hdr.Typeflag                      // 156:157
+
+	formatString(s.next(100), hdr.Linkname, paxLinkpath)
+
+	copy(s.next(8), []byte("ustar\x0000"))          // 257:265
+	formatString(s.next(32), hdr.Uname, paxUname)   // 265:297
+	formatString(s.next(32), hdr.Gname, paxGname)   // 297:329
+	formatNumeric(s.next(8), hdr.Devmajor, paxNone) // 329:337
+	formatNumeric(s.next(8), hdr.Devminor, paxNone) // 337:345
+
+	// keep a reference to the prefix to allow to overwrite it later if we detect that we can use ustar longnames instead of pax
+	prefixHeaderBytes := s.next(155)
+	formatString(prefixHeaderBytes, "", paxNone) // 345:500  prefix
+
+	// Use the GNU magic instead of POSIX magic if we used any GNU extensions.
+	if tw.usedBinary {
+		copy(header[257:265], []byte("ustar  \x00"))
+	}
+
+	_, paxPathUsed := paxHeaders[paxPath]
+	// try to use a ustar header when only the name is too long
+	if !tw.preferPax && len(paxHeaders) == 1 && paxPathUsed {
+		prefix, suffix, ok := splitUSTARPath(hdr.Name)
+		if ok {
+			// Since we can encode in USTAR format, disable PAX header.
+			delete(paxHeaders, paxPath)
+
+			// Update the path fields
+			formatString(pathHeaderBytes, suffix, paxNone)
+			formatString(prefixHeaderBytes, prefix, paxNone)
+		}
+	}
+
+	// The chksum field is terminated by a NUL and a space.
+	// This is different from the other octal fields.
+	chksum, _ := checksum(header)
+	f.formatOctal(header[148:155], chksum) // Never fails
+	header[155] = ' '
+
+	// Check if there were any formatting errors.
+	if f.err != nil {
+		tw.err = f.err
+		return tw.err
+	}
+
+	if allowPax {
+		if !hdr.AccessTime.IsZero() {
+			paxHeaders[paxAtime] = formatPAXTime(hdr.AccessTime)
+		}
+		if !hdr.ChangeTime.IsZero() {
+			paxHeaders[paxCtime] = formatPAXTime(hdr.ChangeTime)
+		}
+		if !hdr.CreationTime.IsZero() {
+			paxHeaders[paxCreationTime] = formatPAXTime(hdr.CreationTime)
+		}
+		for k, v := range hdr.Xattrs {
+			paxHeaders[paxXattr+k] = v
+		}
+		for k, v := range hdr.Winheaders {
+			paxHeaders[paxWindows+k] = v
+		}
+	}
+
+	if len(paxHeaders) > 0 {
+		if !allowPax {
+			return errInvalidHeader
+		}
+		if err := tw.writePAXHeader(hdr, paxHeaders); err != nil {
+			return err
+		}
+	}
+	tw.nb = int64(hdr.Size)
+	tw.pad = (blockSize - (tw.nb % blockSize)) % blockSize
+
+	_, tw.err = tw.w.Write(header)
+	return tw.err
+}
+
+func formatPAXTime(t time.Time) string {
+	sec := t.Unix()
+	usec := t.Nanosecond()
+	s := strconv.FormatInt(sec, 10)
+	if usec != 0 {
+		s = fmt.Sprintf("%s.%09d", s, usec)
+	}
+	return s
+}
+
+// splitUSTARPath splits a path according to USTAR prefix and suffix rules.
+// If the path is not splittable, then it will return ("", "", false).
+func splitUSTARPath(name string) (prefix, suffix string, ok bool) {
+	length := len(name)
+	if length <= fileNameSize || !isASCII(name) {
+		return "", "", false
+	} else if length > fileNamePrefixSize+1 {
+		length = fileNamePrefixSize + 1
+	} else if name[length-1] == '/' {
+		length--
+	}
+
+	i := strings.LastIndex(name[:length], "/")
+	nlen := len(name) - i - 1 // nlen is length of suffix
+	plen := i                 // plen is length of prefix
+	if i <= 0 || nlen > fileNameSize || nlen == 0 || plen > fileNamePrefixSize {
+		return "", "", false
+	}
+	return name[:i], name[i+1:], true
+}
+
+// writePaxHeader writes an extended pax header to the
+// archive.
+func (tw *Writer) writePAXHeader(hdr *Header, paxHeaders map[string]string) error {
+	// Prepare extended header
+	ext := new(Header)
+	ext.Typeflag = TypeXHeader
+	// Setting ModTime is required for reader parsing to
+	// succeed, and seems harmless enough.
+	ext.ModTime = hdr.ModTime
+	// The spec asks that we namespace our pseudo files
+	// with the current pid.  However, this results in differing outputs
+	// for identical inputs.  As such, the constant 0 is now used instead.
+	// golang.org/issue/12358
+	dir, file := path.Split(hdr.Name)
+	fullName := path.Join(dir, "PaxHeaders.0", file)
+
+	ascii := toASCII(fullName)
+	if len(ascii) > 100 {
+		ascii = ascii[:100]
+	}
+	ext.Name = ascii
+	// Construct the body
+	var buf bytes.Buffer
+
+	// Keys are sorted before writing to body to allow deterministic output.
+	var keys []string
+	for k := range paxHeaders {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+
+	for _, k := range keys {
+		fmt.Fprint(&buf, formatPAXRecord(k, paxHeaders[k]))
+	}
+
+	ext.Size = int64(len(buf.Bytes()))
+	if err := tw.writeHeader(ext, false); err != nil {
+		return err
+	}
+	if _, err := tw.Write(buf.Bytes()); err != nil {
+		return err
+	}
+	if err := tw.Flush(); err != nil {
+		return err
+	}
+	return nil
+}
+
+// formatPAXRecord formats a single PAX record, prefixing it with the
+// appropriate length.
+func formatPAXRecord(k, v string) string {
+	const padding = 3 // Extra padding for ' ', '=', and '\n'
+	size := len(k) + len(v) + padding
+	size += len(strconv.Itoa(size))
+	record := fmt.Sprintf("%d %s=%s\n", size, k, v)
+
+	// Final adjustment if adding size field increased the record size.
+	if len(record) != size {
+		size = len(record)
+		record = fmt.Sprintf("%d %s=%s\n", size, k, v)
+	}
+	return record
+}
+
+// Write writes to the current entry in the tar archive.
+// Write returns the error ErrWriteTooLong if more than
+// hdr.Size bytes are written after WriteHeader.
+func (tw *Writer) Write(b []byte) (n int, err error) {
+	if tw.closed {
+		err = ErrWriteAfterClose
+		return
+	}
+	overwrite := false
+	if int64(len(b)) > tw.nb {
+		b = b[0:tw.nb]
+		overwrite = true
+	}
+	n, err = tw.w.Write(b)
+	tw.nb -= int64(n)
+	if err == nil && overwrite {
+		err = ErrWriteTooLong
+		return
+	}
+	tw.err = err
+	return
+}
+
+// Close closes the tar archive, flushing any unwritten
+// data to the underlying writer.
+func (tw *Writer) Close() error {
+	if tw.err != nil || tw.closed {
+		return tw.err
+	}
+	tw.Flush()
+	tw.closed = true
+	if tw.err != nil {
+		return tw.err
+	}
+
+	// trailer: two zero blocks
+	for i := 0; i < 2; i++ {
+		_, tw.err = tw.w.Write(zeroBlock)
+		if tw.err != nil {
+			break
+		}
+	}
+	return tw.err
+}

vendor/github.com/Microsoft/go-winio/archive/tar/writer_test.go

@@ -0,0 +1,739 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package tar
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"math"
+	"os"
+	"reflect"
+	"sort"
+	"strings"
+	"testing"
+	"testing/iotest"
+	"time"
+)
+
+type writerTestEntry struct {
+	header   *Header
+	contents string
+}
+
+type writerTest struct {
+	file    string // filename of expected output
+	entries []*writerTestEntry
+}
+
+var writerTests = []*writerTest{
+	// The writer test file was produced with this command:
+	// tar (GNU tar) 1.26
+	//   ln -s small.txt link.txt
+	//   tar -b 1 --format=ustar -c -f writer.tar small.txt small2.txt link.txt
+	{
+		file: "testdata/writer.tar",
+		entries: []*writerTestEntry{
+			{
+				header: &Header{
+					Name:     "small.txt",
+					Mode:     0640,
+					Uid:      73025,
+					Gid:      5000,
+					Size:     5,
+					ModTime:  time.Unix(1246508266, 0),
+					Typeflag: '0',
+					Uname:    "dsymonds",
+					Gname:    "eng",
+				},
+				contents: "Kilts",
+			},
+			{
+				header: &Header{
+					Name:     "small2.txt",
+					Mode:     0640,
+					Uid:      73025,
+					Gid:      5000,
+					Size:     11,
+					ModTime:  time.Unix(1245217492, 0),
+					Typeflag: '0',
+					Uname:    "dsymonds",
+					Gname:    "eng",
+				},
+				contents: "Google.com\n",
+			},
+			{
+				header: &Header{
+					Name:     "link.txt",
+					Mode:     0777,
+					Uid:      1000,
+					Gid:      1000,
+					Size:     0,
+					ModTime:  time.Unix(1314603082, 0),
+					Typeflag: '2',
+					Linkname: "small.txt",
+					Uname:    "strings",
+					Gname:    "strings",
+				},
+				// no contents
+			},
+		},
+	},
+	// The truncated test file was produced using these commands:
+	//   dd if=/dev/zero bs=1048576 count=16384 > /tmp/16gig.txt
+	//   tar -b 1 -c -f- /tmp/16gig.txt | dd bs=512 count=8 > writer-big.tar
+	{
+		file: "testdata/writer-big.tar",
+		entries: []*writerTestEntry{
+			{
+				header: &Header{
+					Name:     "tmp/16gig.txt",
+					Mode:     0640,
+					Uid:      73025,
+					Gid:      5000,
+					Size:     16 << 30,
+					ModTime:  time.Unix(1254699560, 0),
+					Typeflag: '0',
+					Uname:    "dsymonds",
+					Gname:    "eng",
+				},
+				// fake contents
+				contents: strings.Repeat("\x00", 4<<10),
+			},
+		},
+	},
+	// The truncated test file was produced using these commands:
+	//   dd if=/dev/zero bs=1048576 count=16384 > (longname/)*15 /16gig.txt
+	//   tar -b 1 -c -f- (longname/)*15 /16gig.txt | dd bs=512 count=8 > writer-big-long.tar
+	{
+		file: "testdata/writer-big-long.tar",
+		entries: []*writerTestEntry{
+			{
+				header: &Header{
+					Name:     strings.Repeat("longname/", 15) + "16gig.txt",
+					Mode:     0644,
+					Uid:      1000,
+					Gid:      1000,
+					Size:     16 << 30,
+					ModTime:  time.Unix(1399583047, 0),
+					Typeflag: '0',
+					Uname:    "guillaume",
+					Gname:    "guillaume",
+				},
+				// fake contents
+				contents: strings.Repeat("\x00", 4<<10),
+			},
+		},
+	},
+	// This file was produced using gnu tar 1.17
+	// gnutar  -b 4 --format=ustar (longname/)*15 + file.txt
+	{
+		file: "testdata/ustar.tar",
+		entries: []*writerTestEntry{
+			{
+				header: &Header{
+					Name:     strings.Repeat("longname/", 15) + "file.txt",
+					Mode:     0644,
+					Uid:      0765,
+					Gid:      024,
+					Size:     06,
+					ModTime:  time.Unix(1360135598, 0),
+					Typeflag: '0',
+					Uname:    "shane",
+					Gname:    "staff",
+				},
+				contents: "hello\n",
+			},
+		},
+	},
+	// This file was produced using gnu tar 1.26
+	// echo "Slartibartfast" > file.txt
+	// ln file.txt hard.txt
+	// tar -b 1 --format=ustar -c -f hardlink.tar file.txt hard.txt
+	{
+		file: "testdata/hardlink.tar",
+		entries: []*writerTestEntry{
+			{
+				header: &Header{
+					Name:     "file.txt",
+					Mode:     0644,
+					Uid:      1000,
+					Gid:      100,
+					Size:     15,
+					ModTime:  time.Unix(1425484303, 0),
+					Typeflag: '0',
+					Uname:    "vbatts",
+					Gname:    "users",
+				},
+				contents: "Slartibartfast\n",
+			},
+			{
+				header: &Header{
+					Name:     "hard.txt",
+					Mode:     0644,
+					Uid:      1000,
+					Gid:      100,
+					Size:     0,
+					ModTime:  time.Unix(1425484303, 0),
+					Typeflag: '1',
+					Linkname: "file.txt",
+					Uname:    "vbatts",
+					Gname:    "users",
+				},
+				// no contents
+			},
+		},
+	},
+}
+
+// Render byte array in a two-character hexadecimal string, spaced for easy visual inspection.
+func bytestr(offset int, b []byte) string {
+	const rowLen = 32
+	s := fmt.Sprintf("%04x ", offset)
+	for _, ch := range b {
+		switch {
+		case '0' <= ch && ch <= '9', 'A' <= ch && ch <= 'Z', 'a' <= ch && ch <= 'z':
+			s += fmt.Sprintf("  %c", ch)
+		default:
+			s += fmt.Sprintf(" %02x", ch)
+		}
+	}
+	return s
+}
+
+// Render a pseudo-diff between two blocks of bytes.
+func bytediff(a []byte, b []byte) string {
+	const rowLen = 32
+	s := fmt.Sprintf("(%d bytes vs. %d bytes)\n", len(a), len(b))
+	for offset := 0; len(a)+len(b) > 0; offset += rowLen {
+		na, nb := rowLen, rowLen
+		if na > len(a) {
+			na = len(a)
+		}
+		if nb > len(b) {
+			nb = len(b)
+		}
+		sa := bytestr(offset, a[0:na])
+		sb := bytestr(offset, b[0:nb])
+		if sa != sb {
+			s += fmt.Sprintf("-%v\n+%v\n", sa, sb)
+		}
+		a = a[na:]
+		b = b[nb:]
+	}
+	return s
+}
+
+func TestWriter(t *testing.T) {
+testLoop:
+	for i, test := range writerTests {
+		expected, err := ioutil.ReadFile(test.file)
+		if err != nil {
+			t.Errorf("test %d: Unexpected error: %v", i, err)
+			continue
+		}
+
+		buf := new(bytes.Buffer)
+		tw := NewWriter(iotest.TruncateWriter(buf, 4<<10)) // only catch the first 4 KB
+		big := false
+		for j, entry := range test.entries {
+			big = big || entry.header.Size > 1<<10
+			if err := tw.WriteHeader(entry.header); err != nil {
+				t.Errorf("test %d, entry %d: Failed writing header: %v", i, j, err)
+				continue testLoop
+			}
+			if _, err := io.WriteString(tw, entry.contents); err != nil {
+				t.Errorf("test %d, entry %d: Failed writing contents: %v", i, j, err)
+				continue testLoop
+			}
+		}
+		// Only interested in Close failures for the small tests.
+		if err := tw.Close(); err != nil && !big {
+			t.Errorf("test %d: Failed closing archive: %v", i, err)
+			continue testLoop
+		}
+
+		actual := buf.Bytes()
+		if !bytes.Equal(expected, actual) {
+			t.Errorf("test %d: Incorrect result: (-=expected, +=actual)\n%v",
+				i, bytediff(expected, actual))
+		}
+		if testing.Short() { // The second test is expensive.
+			break
+		}
+	}
+}
+
+func TestPax(t *testing.T) {
+	// Create an archive with a large name
+	fileinfo, err := os.Stat("testdata/small.txt")
+	if err != nil {
+		t.Fatal(err)
+	}
+	hdr, err := FileInfoHeader(fileinfo, "")
+	if err != nil {
+		t.Fatalf("os.Stat: %v", err)
+	}
+	// Force a PAX long name to be written
+	longName := strings.Repeat("ab", 100)
+	contents := strings.Repeat(" ", int(hdr.Size))
+	hdr.Name = longName
+	var buf bytes.Buffer
+	writer := NewWriter(&buf)
+	if err := writer.WriteHeader(hdr); err != nil {
+		t.Fatal(err)
+	}
+	if _, err = writer.Write([]byte(contents)); err != nil {
+		t.Fatal(err)
+	}
+	if err := writer.Close(); err != nil {
+		t.Fatal(err)
+	}
+	// Simple test to make sure PAX extensions are in effect
+	if !bytes.Contains(buf.Bytes(), []byte("PaxHeaders.0")) {
+		t.Fatal("Expected at least one PAX header to be written.")
+	}
+	// Test that we can get a long name back out of the archive.
+	reader := NewReader(&buf)
+	hdr, err = reader.Next()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if hdr.Name != longName {
+		t.Fatal("Couldn't recover long file name")
+	}
+}
+
+func TestPaxSymlink(t *testing.T) {
+	// Create an archive with a large linkname
+	fileinfo, err := os.Stat("testdata/small.txt")
+	if err != nil {
+		t.Fatal(err)
+	}
+	hdr, err := FileInfoHeader(fileinfo, "")
+	hdr.Typeflag = TypeSymlink
+	if err != nil {
+		t.Fatalf("os.Stat:1 %v", err)
+	}
+	// Force a PAX long linkname to be written
+	longLinkname := strings.Repeat("1234567890/1234567890", 10)
+	hdr.Linkname = longLinkname
+
+	hdr.Size = 0
+	var buf bytes.Buffer
+	writer := NewWriter(&buf)
+	if err := writer.WriteHeader(hdr); err != nil {
+		t.Fatal(err)
+	}
+	if err := writer.Close(); err != nil {
+		t.Fatal(err)
+	}
+	// Simple test to make sure PAX extensions are in effect
+	if !bytes.Contains(buf.Bytes(), []byte("PaxHeaders.0")) {
+		t.Fatal("Expected at least one PAX header to be written.")
+	}
+	// Test that we can get a long name back out of the archive.
+	reader := NewReader(&buf)
+	hdr, err = reader.Next()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if hdr.Linkname != longLinkname {
+		t.Fatal("Couldn't recover long link name")
+	}
+}
+
+func TestPaxNonAscii(t *testing.T) {
+	// Create an archive with non ascii. These should trigger a pax header
+	// because pax headers have a defined utf-8 encoding.
+	fileinfo, err := os.Stat("testdata/small.txt")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	hdr, err := FileInfoHeader(fileinfo, "")
+	if err != nil {
+		t.Fatalf("os.Stat:1 %v", err)
+	}
+
+	// some sample data
+	chineseFilename := "文件名"
+	chineseGroupname := "組"
+	chineseUsername := "用戶名"
+
+	hdr.Name = chineseFilename
+	hdr.Gname = chineseGroupname
+	hdr.Uname = chineseUsername
+
+	contents := strings.Repeat(" ", int(hdr.Size))
+
+	var buf bytes.Buffer
+	writer := NewWriter(&buf)
+	if err := writer.WriteHeader(hdr); err != nil {
+		t.Fatal(err)
+	}
+	if _, err = writer.Write([]byte(contents)); err != nil {
+		t.Fatal(err)
+	}
+	if err := writer.Close(); err != nil {
+		t.Fatal(err)
+	}
+	// Simple test to make sure PAX extensions are in effect
+	if !bytes.Contains(buf.Bytes(), []byte("PaxHeaders.0")) {
+		t.Fatal("Expected at least one PAX header to be written.")
+	}
+	// Test that we can get a long name back out of the archive.
+	reader := NewReader(&buf)
+	hdr, err = reader.Next()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if hdr.Name != chineseFilename {
+		t.Fatal("Couldn't recover unicode name")
+	}
+	if hdr.Gname != chineseGroupname {
+		t.Fatal("Couldn't recover unicode group")
+	}
+	if hdr.Uname != chineseUsername {
+		t.Fatal("Couldn't recover unicode user")
+	}
+}
+
+func TestPaxXattrs(t *testing.T) {
+	xattrs := map[string]string{
+		"user.key": "value",
+	}
+
+	// Create an archive with an xattr
+	fileinfo, err := os.Stat("testdata/small.txt")
+	if err != nil {
+		t.Fatal(err)
+	}
+	hdr, err := FileInfoHeader(fileinfo, "")
+	if err != nil {
+		t.Fatalf("os.Stat: %v", err)
+	}
+	contents := "Kilts"
+	hdr.Xattrs = xattrs
+	var buf bytes.Buffer
+	writer := NewWriter(&buf)
+	if err := writer.WriteHeader(hdr); err != nil {
+		t.Fatal(err)
+	}
+	if _, err = writer.Write([]byte(contents)); err != nil {
+		t.Fatal(err)
+	}
+	if err := writer.Close(); err != nil {
+		t.Fatal(err)
+	}
+	// Test that we can get the xattrs back out of the archive.
+	reader := NewReader(&buf)
+	hdr, err = reader.Next()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(hdr.Xattrs, xattrs) {
+		t.Fatalf("xattrs did not survive round trip: got %+v, want %+v",
+			hdr.Xattrs, xattrs)
+	}
+}
+
+func TestPaxHeadersSorted(t *testing.T) {
+	fileinfo, err := os.Stat("testdata/small.txt")
+	if err != nil {
+		t.Fatal(err)
+	}
+	hdr, err := FileInfoHeader(fileinfo, "")
+	if err != nil {
+		t.Fatalf("os.Stat: %v", err)
+	}
+	contents := strings.Repeat(" ", int(hdr.Size))
+
+	hdr.Xattrs = map[string]string{
+		"foo": "foo",
+		"bar": "bar",
+		"baz": "baz",
+		"qux": "qux",
+	}
+
+	var buf bytes.Buffer
+	writer := NewWriter(&buf)
+	if err := writer.WriteHeader(hdr); err != nil {
+		t.Fatal(err)
+	}
+	if _, err = writer.Write([]byte(contents)); err != nil {
+		t.Fatal(err)
+	}
+	if err := writer.Close(); err != nil {
+		t.Fatal(err)
+	}
+	// Simple test to make sure PAX extensions are in effect
+	if !bytes.Contains(buf.Bytes(), []byte("PaxHeaders.0")) {
+		t.Fatal("Expected at least one PAX header to be written.")
+	}
+
+	// xattr bar should always appear before others
+	indices := []int{
+		bytes.Index(buf.Bytes(), []byte("bar=bar")),
+		bytes.Index(buf.Bytes(), []byte("baz=baz")),
+		bytes.Index(buf.Bytes(), []byte("foo=foo")),
+		bytes.Index(buf.Bytes(), []byte("qux=qux")),
+	}
+	if !sort.IntsAreSorted(indices) {
+		t.Fatal("PAX headers are not sorted")
+	}
+}
+
+func TestUSTARLongName(t *testing.T) {
+	// Create an archive with a path that failed to split with USTAR extension in previous versions.
+	fileinfo, err := os.Stat("testdata/small.txt")
+	if err != nil {
+		t.Fatal(err)
+	}
+	hdr, err := FileInfoHeader(fileinfo, "")
+	hdr.Typeflag = TypeDir
+	if err != nil {
+		t.Fatalf("os.Stat:1 %v", err)
+	}
+	// Force a PAX long name to be written. The name was taken from a practical example
+	// that fails and replaced ever char through numbers to anonymize the sample.
+	longName := "/0000_0000000/00000-000000000/0000_0000000/00000-0000000000000/0000_0000000/00000-0000000-00000000/0000_0000000/00000000/0000_0000000/000/0000_0000000/00000000v00/0000_0000000/000000/0000_0000000/0000000/0000_0000000/00000y-00/0000/0000/00000000/0x000000/"
+	hdr.Name = longName
+
+	hdr.Size = 0
+	var buf bytes.Buffer
+	writer := NewWriter(&buf)
+	if err := writer.WriteHeader(hdr); err != nil {
+		t.Fatal(err)
+	}
+	if err := writer.Close(); err != nil {
+		t.Fatal(err)
+	}
+	// Test that we can get a long name back out of the archive.
+	reader := NewReader(&buf)
+	hdr, err = reader.Next()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if hdr.Name != longName {
+		t.Fatal("Couldn't recover long name")
+	}
+}
+
+func TestValidTypeflagWithPAXHeader(t *testing.T) {
+	var buffer bytes.Buffer
+	tw := NewWriter(&buffer)
+
+	fileName := strings.Repeat("ab", 100)
+
+	hdr := &Header{
+		Name:     fileName,
+		Size:     4,
+		Typeflag: 0,
+	}
+	if err := tw.WriteHeader(hdr); err != nil {
+		t.Fatalf("Failed to write header: %s", err)
+	}
+	if _, err := tw.Write([]byte("fooo")); err != nil {
+		t.Fatalf("Failed to write the file's data: %s", err)
+	}
+	tw.Close()
+
+	tr := NewReader(&buffer)
+
+	for {
+		header, err := tr.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			t.Fatalf("Failed to read header: %s", err)
+		}
+		if header.Typeflag != 0 {
+			t.Fatalf("Typeflag should've been 0, found %d", header.Typeflag)
+		}
+	}
+}
+
+func TestWriteAfterClose(t *testing.T) {
+	var buffer bytes.Buffer
+	tw := NewWriter(&buffer)
+
+	hdr := &Header{
+		Name: "small.txt",
+		Size: 5,
+	}
+	if err := tw.WriteHeader(hdr); err != nil {
+		t.Fatalf("Failed to write header: %s", err)
+	}
+	tw.Close()
+	if _, err := tw.Write([]byte("Kilts")); err != ErrWriteAfterClose {
+		t.Fatalf("Write: got %v; want ErrWriteAfterClose", err)
+	}
+}
+
+func TestSplitUSTARPath(t *testing.T) {
+	var sr = strings.Repeat
+
+	var vectors = []struct {
+		input  string // Input path
+		prefix string // Expected output prefix
+		suffix string // Expected output suffix
+		ok     bool   // Split success?
+	}{
+		{"", "", "", false},
+		{"abc", "", "", false},
+		{"用戶名", "", "", false},
+		{sr("a", fileNameSize), "", "", false},
+		{sr("a", fileNameSize) + "/", "", "", false},
+		{sr("a", fileNameSize) + "/a", sr("a", fileNameSize), "a", true},
+		{sr("a", fileNamePrefixSize) + "/", "", "", false},
+		{sr("a", fileNamePrefixSize) + "/a", sr("a", fileNamePrefixSize), "a", true},
+		{sr("a", fileNameSize+1), "", "", false},
+		{sr("/", fileNameSize+1), sr("/", fileNameSize-1), "/", true},
+		{sr("a", fileNamePrefixSize) + "/" + sr("b", fileNameSize),
+			sr("a", fileNamePrefixSize), sr("b", fileNameSize), true},
+		{sr("a", fileNamePrefixSize) + "//" + sr("b", fileNameSize), "", "", false},
+		{sr("a/", fileNameSize), sr("a/", 77) + "a", sr("a/", 22), true},
+	}
+
+	for _, v := range vectors {
+		prefix, suffix, ok := splitUSTARPath(v.input)
+		if prefix != v.prefix || suffix != v.suffix || ok != v.ok {
+			t.Errorf("splitUSTARPath(%q):\ngot  (%q, %q, %v)\nwant (%q, %q, %v)",
+				v.input, prefix, suffix, ok, v.prefix, v.suffix, v.ok)
+		}
+	}
+}
+
+func TestFormatPAXRecord(t *testing.T) {
+	var medName = strings.Repeat("CD", 50)
+	var longName = strings.Repeat("AB", 100)
+
+	var vectors = []struct {
+		inputKey string
+		inputVal string
+		output   string
+	}{
+		{"k", "v", "6 k=v\n"},
+		{"path", "/etc/hosts", "19 path=/etc/hosts\n"},
+		{"path", longName, "210 path=" + longName + "\n"},
+		{"path", medName, "110 path=" + medName + "\n"},
+		{"foo", "ba", "9 foo=ba\n"},
+		{"foo", "bar", "11 foo=bar\n"},
+		{"foo", "b=\nar=\n==\x00", "18 foo=b=\nar=\n==\x00\n"},
+		{"foo", "hello9 foo=ba\nworld", "27 foo=hello9 foo=ba\nworld\n"},
+		{"☺☻☹", "日a本b語ç", "27 ☺☻☹=日a本b語ç\n"},
+		{"\x00hello", "\x00world", "17 \x00hello=\x00world\n"},
+	}
+
+	for _, v := range vectors {
+		output := formatPAXRecord(v.inputKey, v.inputVal)
+		if output != v.output {
+			t.Errorf("formatPAXRecord(%q, %q): got %q, want %q",
+				v.inputKey, v.inputVal, output, v.output)
+		}
+	}
+}
+
+func TestFitsInBase256(t *testing.T) {
+	var vectors = []struct {
+		input int64
+		width int
+		ok    bool
+	}{
+		{+1, 8, true},
+		{0, 8, true},
+		{-1, 8, true},
+		{1 << 56, 8, false},
+		{(1 << 56) - 1, 8, true},
+		{-1 << 56, 8, true},
+		{(-1 << 56) - 1, 8, false},
+		{121654, 8, true},
+		{-9849849, 8, true},
+		{math.MaxInt64, 9, true},
+		{0, 9, true},
+		{math.MinInt64, 9, true},
+		{math.MaxInt64, 12, true},
+		{0, 12, true},
+		{math.MinInt64, 12, true},
+	}
+
+	for _, v := range vectors {
+		ok := fitsInBase256(v.width, v.input)
+		if ok != v.ok {
+			t.Errorf("checkNumeric(%d, %d): got %v, want %v", v.input, v.width, ok, v.ok)
+		}
+	}
+}
+
+func TestFormatNumeric(t *testing.T) {
+	var vectors = []struct {
+		input  int64
+		output string
+		ok     bool
+	}{
+		// Test base-256 (binary) encoded values.
+		{-1, "\xff", true},
+		{-1, "\xff\xff", true},
+		{-1, "\xff\xff\xff", true},
+		{(1 << 0), "0", false},
+		{(1 << 8) - 1, "\x80\xff", true},
+		{(1 << 8), "0\x00", false},
+		{(1 << 16) - 1, "\x80\xff\xff", true},
+		{(1 << 16), "00\x00", false},
+		{-1 * (1 << 0), "\xff", true},
+		{-1*(1<<0) - 1, "0", false},
+		{-1 * (1 << 8), "\xff\x00", true},
+		{-1*(1<<8) - 1, "0\x00", false},
+		{-1 * (1 << 16), "\xff\x00\x00", true},
+		{-1*(1<<16) - 1, "00\x00", false},
+		{537795476381659745, "0000000\x00", false},
+		{537795476381659745, "\x80\x00\x00\x00\x07\x76\xa2\x22\xeb\x8a\x72\x61", true},
+		{-615126028225187231, "0000000\x00", false},
+		{-615126028225187231, "\xff\xff\xff\xff\xf7\x76\xa2\x22\xeb\x8a\x72\x61", true},
+		{math.MaxInt64, "0000000\x00", false},
+		{math.MaxInt64, "\x80\x00\x00\x00\x7f\xff\xff\xff\xff\xff\xff\xff", true},
+		{math.MinInt64, "0000000\x00", false},
+		{math.MinInt64, "\xff\xff\xff\xff\x80\x00\x00\x00\x00\x00\x00\x00", true},
+		{math.MaxInt64, "\x80\x7f\xff\xff\xff\xff\xff\xff\xff", true},
+		{math.MinInt64, "\xff\x80\x00\x00\x00\x00\x00\x00\x00", true},
+	}
+
+	for _, v := range vectors {
+		var f formatter
+		output := make([]byte, len(v.output))
+		f.formatNumeric(output, v.input)
+		ok := (f.err == nil)
+		if ok != v.ok {
+			if v.ok {
+				t.Errorf("formatNumeric(%d): got formatting failure, want success", v.input)
+			} else {
+				t.Errorf("formatNumeric(%d): got formatting success, want failure", v.input)
+			}
+		}
+		if string(output) != v.output {
+			t.Errorf("formatNumeric(%d): got %q, want %q", v.input, output, v.output)
+		}
+	}
+}
+
+func TestFormatPAXTime(t *testing.T) {
+	t1 := time.Date(2000, 1, 1, 11, 0, 0, 0, time.UTC)
+	t2 := time.Date(2000, 1, 1, 11, 0, 0, 100, time.UTC)
+	t3 := time.Date(1960, 1, 1, 11, 0, 0, 0, time.UTC)
+	t4 := time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC)
+	verify := func(time time.Time, s string) {
+		p := formatPAXTime(time)
+		if p != s {
+			t.Errorf("for %v, expected %s, got %s", time, s, p)
+		}
+	}
+	verify(t1, "946724400")
+	verify(t2, "946724400.000000100")
+	verify(t3, "-315579600")
+	verify(t4, "0")
+}

vendor/github.com/Microsoft/go-winio/backup.go

@@ -0,0 +1,280 @@
+// +build windows
+
+package winio
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"runtime"
+	"syscall"
+	"unicode/utf16"
+)
+
+//sys backupRead(h syscall.Handle, b []byte, bytesRead *uint32, abort bool, processSecurity bool, context *uintptr) (err error) = BackupRead
+//sys backupWrite(h syscall.Handle, b []byte, bytesWritten *uint32, abort bool, processSecurity bool, context *uintptr) (err error) = BackupWrite
+
+const (
+	BackupData = uint32(iota + 1)
+	BackupEaData
+	BackupSecurity
+	BackupAlternateData
+	BackupLink
+	BackupPropertyData
+	BackupObjectId
+	BackupReparseData
+	BackupSparseBlock
+	BackupTxfsData
+)
+
+const (
+	StreamSparseAttributes = uint32(8)
+)
+
+const (
+	WRITE_DAC              = 0x40000
+	WRITE_OWNER            = 0x80000
+	ACCESS_SYSTEM_SECURITY = 0x1000000
+)
+
+// BackupHeader represents a backup stream of a file.
+type BackupHeader struct {
+	Id         uint32 // The backup stream ID
+	Attributes uint32 // Stream attributes
+	Size       int64  // The size of the stream in bytes
+	Name       string // The name of the stream (for BackupAlternateData only).
+	Offset     int64  // The offset of the stream in the file (for BackupSparseBlock only).
+}
+
+type win32StreamId struct {
+	StreamId   uint32
+	Attributes uint32
+	Size       uint64
+	NameSize   uint32
+}
+
+// BackupStreamReader reads from a stream produced by the BackupRead Win32 API and produces a series
+// of BackupHeader values.
+type BackupStreamReader struct {
+	r         io.Reader
+	bytesLeft int64
+}
+
+// NewBackupStreamReader produces a BackupStreamReader from any io.Reader.
+func NewBackupStreamReader(r io.Reader) *BackupStreamReader {
+	return &BackupStreamReader{r, 0}
+}
+
+// Next returns the next backup stream and prepares for calls to Read(). It skips the remainder of the current stream if
+// it was not completely read.
+func (r *BackupStreamReader) Next() (*BackupHeader, error) {
+	if r.bytesLeft > 0 {
+		if s, ok := r.r.(io.Seeker); ok {
+			// Make sure Seek on io.SeekCurrent sometimes succeeds
+			// before trying the actual seek.
+			if _, err := s.Seek(0, io.SeekCurrent); err == nil {
+				if _, err = s.Seek(r.bytesLeft, io.SeekCurrent); err != nil {
+					return nil, err
+				}
+				r.bytesLeft = 0
+			}
+		}
+		if _, err := io.Copy(ioutil.Discard, r); err != nil {
+			return nil, err
+		}
+	}
+	var wsi win32StreamId
+	if err := binary.Read(r.r, binary.LittleEndian, &wsi); err != nil {
+		return nil, err
+	}
+	hdr := &BackupHeader{
+		Id:         wsi.StreamId,
+		Attributes: wsi.Attributes,
+		Size:       int64(wsi.Size),
+	}
+	if wsi.NameSize != 0 {
+		name := make([]uint16, int(wsi.NameSize/2))
+		if err := binary.Read(r.r, binary.LittleEndian, name); err != nil {
+			return nil, err
+		}
+		hdr.Name = syscall.UTF16ToString(name)
+	}
+	if wsi.StreamId == BackupSparseBlock {
+		if err := binary.Read(r.r, binary.LittleEndian, &hdr.Offset); err != nil {
+			return nil, err
+		}
+		hdr.Size -= 8
+	}
+	r.bytesLeft = hdr.Size
+	return hdr, nil
+}
+
+// Read reads from the current backup stream.
+func (r *BackupStreamReader) Read(b []byte) (int, error) {
+	if r.bytesLeft == 0 {
+		return 0, io.EOF
+	}
+	if int64(len(b)) > r.bytesLeft {
+		b = b[:r.bytesLeft]
+	}
+	n, err := r.r.Read(b)
+	r.bytesLeft -= int64(n)
+	if err == io.EOF {
+		err = io.ErrUnexpectedEOF
+	} else if r.bytesLeft == 0 && err == nil {
+		err = io.EOF
+	}
+	return n, err
+}
+
+// BackupStreamWriter writes a stream compatible with the BackupWrite Win32 API.
+type BackupStreamWriter struct {
+	w         io.Writer
+	bytesLeft int64
+}
+
+// NewBackupStreamWriter produces a BackupStreamWriter on top of an io.Writer.
+func NewBackupStreamWriter(w io.Writer) *BackupStreamWriter {
+	return &BackupStreamWriter{w, 0}
+}
+
+// WriteHeader writes the next backup stream header and prepares for calls to Write().
+func (w *BackupStreamWriter) WriteHeader(hdr *BackupHeader) error {
+	if w.bytesLeft != 0 {
+		return fmt.Errorf("missing %d bytes", w.bytesLeft)
+	}
+	name := utf16.Encode([]rune(hdr.Name))
+	wsi := win32StreamId{
+		StreamId:   hdr.Id,
+		Attributes: hdr.Attributes,
+		Size:       uint64(hdr.Size),
+		NameSize:   uint32(len(name) * 2),
+	}
+	if hdr.Id == BackupSparseBlock {
+		// Include space for the int64 block offset
+		wsi.Size += 8
+	}
+	if err := binary.Write(w.w, binary.LittleEndian, &wsi); err != nil {
+		return err
+	}
+	if len(name) != 0 {
+		if err := binary.Write(w.w, binary.LittleEndian, name); err != nil {
+			return err
+		}
+	}
+	if hdr.Id == BackupSparseBlock {
+		if err := binary.Write(w.w, binary.LittleEndian, hdr.Offset); err != nil {
+			return err
+		}
+	}
+	w.bytesLeft = hdr.Size
+	return nil
+}
+
+// Write writes to the current backup stream.
+func (w *BackupStreamWriter) Write(b []byte) (int, error) {
+	if w.bytesLeft < int64(len(b)) {
+		return 0, fmt.Errorf("too many bytes by %d", int64(len(b))-w.bytesLeft)
+	}
+	n, err := w.w.Write(b)
+	w.bytesLeft -= int64(n)
+	return n, err
+}
+
+// BackupFileReader provides an io.ReadCloser interface on top of the BackupRead Win32 API.
+type BackupFileReader struct {
+	f               *os.File
+	includeSecurity bool
+	ctx             uintptr
+}
+
+// NewBackupFileReader returns a new BackupFileReader from a file handle. If includeSecurity is true,
+// Read will attempt to read the security descriptor of the file.
+func NewBackupFileReader(f *os.File, includeSecurity bool) *BackupFileReader {
+	r := &BackupFileReader{f, includeSecurity, 0}
+	return r
+}
+
+// Read reads a backup stream from the file by calling the Win32 API BackupRead().
+func (r *BackupFileReader) Read(b []byte) (int, error) {
+	var bytesRead uint32
+	err := backupRead(syscall.Handle(r.f.Fd()), b, &bytesRead, false, r.includeSecurity, &r.ctx)
+	if err != nil {
+		return 0, &os.PathError{"BackupRead", r.f.Name(), err}
+	}
+	runtime.KeepAlive(r.f)
+	if bytesRead == 0 {
+		return 0, io.EOF
+	}
+	return int(bytesRead), nil
+}
+
+// Close frees Win32 resources associated with the BackupFileReader. It does not close
+// the underlying file.
+func (r *BackupFileReader) Close() error {
+	if r.ctx != 0 {
+		backupRead(syscall.Handle(r.f.Fd()), nil, nil, true, false, &r.ctx)
+		runtime.KeepAlive(r.f)
+		r.ctx = 0
+	}
+	return nil
+}
+
+// BackupFileWriter provides an io.WriteCloser interface on top of the BackupWrite Win32 API.
+type BackupFileWriter struct {
+	f               *os.File
+	includeSecurity bool
+	ctx             uintptr
+}
+
+// NewBackupFileWriter returns a new BackupFileWriter from a file handle. If includeSecurity is true,
+// Write() will attempt to restore the security descriptor from the stream.
+func NewBackupFileWriter(f *os.File, includeSecurity bool) *BackupFileWriter {
+	w := &BackupFileWriter{f, includeSecurity, 0}
+	return w
+}
+
+// Write restores a portion of the file using the provided backup stream.
+func (w *BackupFileWriter) Write(b []byte) (int, error) {
+	var bytesWritten uint32
+	err := backupWrite(syscall.Handle(w.f.Fd()), b, &bytesWritten, false, w.includeSecurity, &w.ctx)
+	if err != nil {
+		return 0, &os.PathError{"BackupWrite", w.f.Name(), err}
+	}
+	runtime.KeepAlive(w.f)
+	if int(bytesWritten) != len(b) {
+		return int(bytesWritten), errors.New("not all bytes could be written")
+	}
+	return len(b), nil
+}
+
+// Close frees Win32 resources associated with the BackupFileWriter. It does not
+// close the underlying file.
+func (w *BackupFileWriter) Close() error {
+	if w.ctx != 0 {
+		backupWrite(syscall.Handle(w.f.Fd()), nil, nil, true, false, &w.ctx)
+		runtime.KeepAlive(w.f)
+		w.ctx = 0
+	}
+	return nil
+}
+
+// OpenForBackup opens a file or directory, potentially skipping access checks if the backup
+// or restore privileges have been acquired.
+//
+// If the file opened was a directory, it cannot be used with Readdir().
+func OpenForBackup(path string, access uint32, share uint32, createmode uint32) (*os.File, error) {
+	winPath, err := syscall.UTF16FromString(path)
+	if err != nil {
+		return nil, err
+	}
+	h, err := syscall.CreateFile(&winPath[0], access, share, nil, createmode, syscall.FILE_FLAG_BACKUP_SEMANTICS|syscall.FILE_FLAG_OPEN_REPARSE_POINT, 0)
+	if err != nil {
+		err = &os.PathError{Op: "open", Path: path, Err: err}
+		return nil, err
+	}
+	return os.NewFile(uintptr(h), path), nil
+}

vendor/github.com/Microsoft/go-winio/backup_test.go

@@ -0,0 +1,255 @@
+package winio
+
+import (
+	"io"
+	"io/ioutil"
+	"os"
+	"syscall"
+	"testing"
+)
+
+var testFileName string
+
+func TestMain(m *testing.M) {
+	f, err := ioutil.TempFile("", "tmp")
+	if err != nil {
+		panic(err)
+	}
+	testFileName = f.Name()
+	f.Close()
+	defer os.Remove(testFileName)
+	os.Exit(m.Run())
+}
+
+func makeTestFile(makeADS bool) error {
+	os.Remove(testFileName)
+	f, err := os.Create(testFileName)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	_, err = f.Write([]byte("testing 1 2 3\n"))
+	if err != nil {
+		return err
+	}
+	if makeADS {
+		a, err := os.Create(testFileName + ":ads.txt")
+		if err != nil {
+			return err
+		}
+		defer a.Close()
+		_, err = a.Write([]byte("alternate data stream\n"))
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func TestBackupRead(t *testing.T) {
+	err := makeTestFile(true)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	f, err := os.Open(testFileName)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f.Close()
+	r := NewBackupFileReader(f, false)
+	defer r.Close()
+	b, err := ioutil.ReadAll(r)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(b) == 0 {
+		t.Fatal("no data")
+	}
+}
+
+func TestBackupStreamRead(t *testing.T) {
+	err := makeTestFile(true)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	f, err := os.Open(testFileName)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f.Close()
+	r := NewBackupFileReader(f, false)
+	defer r.Close()
+
+	br := NewBackupStreamReader(r)
+	gotData := false
+	gotAltData := false
+	for {
+		hdr, err := br.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		switch hdr.Id {
+		case BackupData:
+			if gotData {
+				t.Fatal("duplicate data")
+			}
+			if hdr.Name != "" {
+				t.Fatalf("unexpected name %s", hdr.Name)
+			}
+			b, err := ioutil.ReadAll(br)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if string(b) != "testing 1 2 3\n" {
+				t.Fatalf("incorrect data %v", b)
+			}
+			gotData = true
+		case BackupAlternateData:
+			if gotAltData {
+				t.Fatal("duplicate alt data")
+			}
+			if hdr.Name != ":ads.txt:$DATA" {
+				t.Fatalf("incorrect name %s", hdr.Name)
+			}
+			b, err := ioutil.ReadAll(br)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if string(b) != "alternate data stream\n" {
+				t.Fatalf("incorrect data %v", b)
+			}
+			gotAltData = true
+		default:
+			t.Fatalf("unknown stream ID %d", hdr.Id)
+		}
+	}
+	if !gotData || !gotAltData {
+		t.Fatal("missing stream")
+	}
+}
+
+func TestBackupStreamWrite(t *testing.T) {
+	f, err := os.Create(testFileName)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f.Close()
+	w := NewBackupFileWriter(f, false)
+	defer w.Close()
+
+	data := "testing 1 2 3\n"
+	altData := "alternate stream\n"
+
+	br := NewBackupStreamWriter(w)
+	err = br.WriteHeader(&BackupHeader{Id: BackupData, Size: int64(len(data))})
+	if err != nil {
+		t.Fatal(err)
+	}
+	n, err := br.Write([]byte(data))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if n != len(data) {
+		t.Fatal("short write")
+	}
+
+	err = br.WriteHeader(&BackupHeader{Id: BackupAlternateData, Size: int64(len(altData)), Name: ":ads.txt:$DATA"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	n, err = br.Write([]byte(altData))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if n != len(altData) {
+		t.Fatal("short write")
+	}
+
+	f.Close()
+
+	b, err := ioutil.ReadFile(testFileName)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(b) != data {
+		t.Fatalf("wrong data %v", b)
+	}
+
+	b, err = ioutil.ReadFile(testFileName + ":ads.txt")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(b) != altData {
+		t.Fatalf("wrong data %v", b)
+	}
+}
+
+func makeSparseFile() error {
+	os.Remove(testFileName)
+	f, err := os.Create(testFileName)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	const (
+		FSCTL_SET_SPARSE    = 0x000900c4
+		FSCTL_SET_ZERO_DATA = 0x000980c8
+	)
+
+	err = syscall.DeviceIoControl(syscall.Handle(f.Fd()), FSCTL_SET_SPARSE, nil, 0, nil, 0, nil, nil)
+	if err != nil {
+		return err
+	}
+
+	_, err = f.Write([]byte("testing 1 2 3\n"))
+	if err != nil {
+		return err
+	}
+
+	_, err = f.Seek(1000000, 0)
+	if err != nil {
+		return err
+	}
+
+	_, err = f.Write([]byte("more data later\n"))
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func TestBackupSparseFile(t *testing.T) {
+	err := makeSparseFile()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	f, err := os.Open(testFileName)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f.Close()
+	r := NewBackupFileReader(f, false)
+	defer r.Close()
+
+	br := NewBackupStreamReader(r)
+	for {
+		hdr, err := br.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		t.Log(hdr)
+	}
+}

vendor/github.com/Microsoft/go-winio/backuptar/noop.go

@@ -0,0 +1,4 @@
+// +build !windows
+// This file only exists to allow go get on non-Windows platforms.
+
+package backuptar

vendor/github.com/Microsoft/go-winio/backuptar/tar.go

@@ -0,0 +1,439 @@
+// +build windows
+
+package backuptar
+
+import (
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/Microsoft/go-winio"
+	"github.com/Microsoft/go-winio/archive/tar" // until archive/tar supports pax extensions in its interface
+)
+
+const (
+	c_ISUID  = 04000   // Set uid
+	c_ISGID  = 02000   // Set gid
+	c_ISVTX  = 01000   // Save text (sticky bit)
+	c_ISDIR  = 040000  // Directory
+	c_ISFIFO = 010000  // FIFO
+	c_ISREG  = 0100000 // Regular file
+	c_ISLNK  = 0120000 // Symbolic link
+	c_ISBLK  = 060000  // Block special file
+	c_ISCHR  = 020000  // Character special file
+	c_ISSOCK = 0140000 // Socket
+)
+
+const (
+	hdrFileAttributes        = "fileattr"
+	hdrSecurityDescriptor    = "sd"
+	hdrRawSecurityDescriptor = "rawsd"
+	hdrMountPoint            = "mountpoint"
+	hdrEaPrefix              = "xattr."
+)
+
+func writeZeroes(w io.Writer, count int64) error {
+	buf := make([]byte, 8192)
+	c := len(buf)
+	for i := int64(0); i < count; i += int64(c) {
+		if int64(c) > count-i {
+			c = int(count - i)
+		}
+		_, err := w.Write(buf[:c])
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func copySparse(t *tar.Writer, br *winio.BackupStreamReader) error {
+	curOffset := int64(0)
+	for {
+		bhdr, err := br.Next()
+		if err == io.EOF {
+			err = io.ErrUnexpectedEOF
+		}
+		if err != nil {
+			return err
+		}
+		if bhdr.Id != winio.BackupSparseBlock {
+			return fmt.Errorf("unexpected stream %d", bhdr.Id)
+		}
+
+		// archive/tar does not support writing sparse files
+		// so just write zeroes to catch up to the current offset.
+		err = writeZeroes(t, bhdr.Offset-curOffset)
+		if bhdr.Size == 0 {
+			break
+		}
+		n, err := io.Copy(t, br)
+		if err != nil {
+			return err
+		}
+		curOffset = bhdr.Offset + n
+	}
+	return nil
+}
+
+// BasicInfoHeader creates a tar header from basic file information.
+func BasicInfoHeader(name string, size int64, fileInfo *winio.FileBasicInfo) *tar.Header {
+	hdr := &tar.Header{
+		Name:         filepath.ToSlash(name),
+		Size:         size,
+		Typeflag:     tar.TypeReg,
+		ModTime:      time.Unix(0, fileInfo.LastWriteTime.Nanoseconds()),
+		ChangeTime:   time.Unix(0, fileInfo.ChangeTime.Nanoseconds()),
+		AccessTime:   time.Unix(0, fileInfo.LastAccessTime.Nanoseconds()),
+		CreationTime: time.Unix(0, fileInfo.CreationTime.Nanoseconds()),
+		Winheaders:   make(map[string]string),
+	}
+	hdr.Winheaders[hdrFileAttributes] = fmt.Sprintf("%d", fileInfo.FileAttributes)
+
+	if (fileInfo.FileAttributes & syscall.FILE_ATTRIBUTE_DIRECTORY) != 0 {
+		hdr.Mode |= c_ISDIR
+		hdr.Size = 0
+		hdr.Typeflag = tar.TypeDir
+	}
+	return hdr
+}
+
+// WriteTarFileFromBackupStream writes a file to a tar writer using data from a Win32 backup stream.
+//
+// This encodes Win32 metadata as tar pax vendor extensions starting with MSWINDOWS.
+//
+// The additional Win32 metadata is:
+//
+// MSWINDOWS.fileattr: The Win32 file attributes, as a decimal value
+//
+// MSWINDOWS.rawsd: The Win32 security descriptor, in raw binary format
+//
+// MSWINDOWS.mountpoint: If present, this is a mount point and not a symlink, even though the type is '2' (symlink)
+func WriteTarFileFromBackupStream(t *tar.Writer, r io.Reader, name string, size int64, fileInfo *winio.FileBasicInfo) error {
+	name = filepath.ToSlash(name)
+	hdr := BasicInfoHeader(name, size, fileInfo)
+
+	// If r can be seeked, then this function is two-pass: pass 1 collects the
+	// tar header data, and pass 2 copies the data stream. If r cannot be
+	// seeked, then some header data (in particular EAs) will be silently lost.
+	var (
+		restartPos int64
+		err        error
+	)
+	sr, readTwice := r.(io.Seeker)
+	if readTwice {
+		if restartPos, err = sr.Seek(0, io.SeekCurrent); err != nil {
+			readTwice = false
+		}
+	}
+
+	br := winio.NewBackupStreamReader(r)
+	var dataHdr *winio.BackupHeader
+	for dataHdr == nil {
+		bhdr, err := br.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return err
+		}
+		switch bhdr.Id {
+		case winio.BackupData:
+			hdr.Mode |= c_ISREG
+			if !readTwice {
+				dataHdr = bhdr
+			}
+		case winio.BackupSecurity:
+			sd, err := ioutil.ReadAll(br)
+			if err != nil {
+				return err
+			}
+			hdr.Winheaders[hdrRawSecurityDescriptor] = base64.StdEncoding.EncodeToString(sd)
+
+		case winio.BackupReparseData:
+			hdr.Mode |= c_ISLNK
+			hdr.Typeflag = tar.TypeSymlink
+			reparseBuffer, err := ioutil.ReadAll(br)
+			rp, err := winio.DecodeReparsePoint(reparseBuffer)
+			if err != nil {
+				return err
+			}
+			if rp.IsMountPoint {
+				hdr.Winheaders[hdrMountPoint] = "1"
+			}
+			hdr.Linkname = rp.Target
+
+		case winio.BackupEaData:
+			eab, err := ioutil.ReadAll(br)
+			if err != nil {
+				return err
+			}
+			eas, err := winio.DecodeExtendedAttributes(eab)
+			if err != nil {
+				return err
+			}
+			for _, ea := range eas {
+				// Use base64 encoding for the binary value. Note that there
+				// is no way to encode the EA's flags, since their use doesn't
+				// make any sense for persisted EAs.
+				hdr.Winheaders[hdrEaPrefix+ea.Name] = base64.StdEncoding.EncodeToString(ea.Value)
+			}
+
+		case winio.BackupAlternateData, winio.BackupLink, winio.BackupPropertyData, winio.BackupObjectId, winio.BackupTxfsData:
+			// ignore these streams
+		default:
+			return fmt.Errorf("%s: unknown stream ID %d", name, bhdr.Id)
+		}
+	}
+
+	err = t.WriteHeader(hdr)
+	if err != nil {
+		return err
+	}
+
+	if readTwice {
+		// Get back to the data stream.
+		if _, err = sr.Seek(restartPos, io.SeekStart); err != nil {
+			return err
+		}
+		for dataHdr == nil {
+			bhdr, err := br.Next()
+			if err == io.EOF {
+				break
+			}
+			if err != nil {
+				return err
+			}
+			if bhdr.Id == winio.BackupData {
+				dataHdr = bhdr
+			}
+		}
+	}
+
+	if dataHdr != nil {
+		// A data stream was found. Copy the data.
+		if (dataHdr.Attributes & winio.StreamSparseAttributes) == 0 {
+			if size != dataHdr.Size {
+				return fmt.Errorf("%s: mismatch between file size %d and header size %d", name, size, dataHdr.Size)
+			}
+			_, err = io.Copy(t, br)
+			if err != nil {
+				return err
+			}
+		} else {
+			err = copySparse(t, br)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	// Look for streams after the data stream. The only ones we handle are alternate data streams.
+	// Other streams may have metadata that could be serialized, but the tar header has already
+	// been written. In practice, this means that we don't get EA or TXF metadata.
+	for {
+		bhdr, err := br.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return err
+		}
+		switch bhdr.Id {
+		case winio.BackupAlternateData:
+			altName := bhdr.Name
+			if strings.HasSuffix(altName, ":$DATA") {
+				altName = altName[:len(altName)-len(":$DATA")]
+			}
+			if (bhdr.Attributes & winio.StreamSparseAttributes) == 0 {
+				hdr = &tar.Header{
+					Name:       name + altName,
+					Mode:       hdr.Mode,
+					Typeflag:   tar.TypeReg,
+					Size:       bhdr.Size,
+					ModTime:    hdr.ModTime,
+					AccessTime: hdr.AccessTime,
+					ChangeTime: hdr.ChangeTime,
+				}
+				err = t.WriteHeader(hdr)
+				if err != nil {
+					return err
+				}
+				_, err = io.Copy(t, br)
+				if err != nil {
+					return err
+				}
+
+			} else {
+				// Unsupported for now, since the size of the alternate stream is not present
+				// in the backup stream until after the data has been read.
+				return errors.New("tar of sparse alternate data streams is unsupported")
+			}
+		case winio.BackupEaData, winio.BackupLink, winio.BackupPropertyData, winio.BackupObjectId, winio.BackupTxfsData:
+			// ignore these streams
+		default:
+			return fmt.Errorf("%s: unknown stream ID %d after data", name, bhdr.Id)
+		}
+	}
+	return nil
+}
+
+// FileInfoFromHeader retrieves basic Win32 file information from a tar header, using the additional metadata written by
+// WriteTarFileFromBackupStream.
+func FileInfoFromHeader(hdr *tar.Header) (name string, size int64, fileInfo *winio.FileBasicInfo, err error) {
+	name = hdr.Name
+	if hdr.Typeflag == tar.TypeReg || hdr.Typeflag == tar.TypeRegA {
+		size = hdr.Size
+	}
+	fileInfo = &winio.FileBasicInfo{
+		LastAccessTime: syscall.NsecToFiletime(hdr.AccessTime.UnixNano()),
+		LastWriteTime:  syscall.NsecToFiletime(hdr.ModTime.UnixNano()),
+		ChangeTime:     syscall.NsecToFiletime(hdr.ChangeTime.UnixNano()),
+		CreationTime:   syscall.NsecToFiletime(hdr.CreationTime.UnixNano()),
+	}
+	if attrStr, ok := hdr.Winheaders[hdrFileAttributes]; ok {
+		attr, err := strconv.ParseUint(attrStr, 10, 32)
+		if err != nil {
+			return "", 0, nil, err
+		}
+		fileInfo.FileAttributes = uint32(attr)
+	} else {
+		if hdr.Typeflag == tar.TypeDir {
+			fileInfo.FileAttributes |= syscall.FILE_ATTRIBUTE_DIRECTORY
+		}
+	}
+	return
+}
+
+// WriteBackupStreamFromTarFile writes a Win32 backup stream from the current tar file. Since this function may process multiple
+// tar file entries in order to collect all the alternate data streams for the file, it returns the next
+// tar file that was not processed, or io.EOF is there are no more.
+func WriteBackupStreamFromTarFile(w io.Writer, t *tar.Reader, hdr *tar.Header) (*tar.Header, error) {
+	bw := winio.NewBackupStreamWriter(w)
+	var sd []byte
+	var err error
+	// Maintaining old SDDL-based behavior for backward compatibility.  All new tar headers written
+	// by this library will have raw binary for the security descriptor.
+	if sddl, ok := hdr.Winheaders[hdrSecurityDescriptor]; ok {
+		sd, err = winio.SddlToSecurityDescriptor(sddl)
+		if err != nil {
+			return nil, err
+		}
+	}
+	if sdraw, ok := hdr.Winheaders[hdrRawSecurityDescriptor]; ok {
+		sd, err = base64.StdEncoding.DecodeString(sdraw)
+		if err != nil {
+			return nil, err
+		}
+	}
+	if len(sd) != 0 {
+		bhdr := winio.BackupHeader{
+			Id:   winio.BackupSecurity,
+			Size: int64(len(sd)),
+		}
+		err := bw.WriteHeader(&bhdr)
+		if err != nil {
+			return nil, err
+		}
+		_, err = bw.Write(sd)
+		if err != nil {
+			return nil, err
+		}
+	}
+	var eas []winio.ExtendedAttribute
+	for k, v := range hdr.Winheaders {
+		if !strings.HasPrefix(k, hdrEaPrefix) {
+			continue
+		}
+		data, err := base64.StdEncoding.DecodeString(v)
+		if err != nil {
+			return nil, err
+		}
+		eas = append(eas, winio.ExtendedAttribute{
+			Name:  k[len(hdrEaPrefix):],
+			Value: data,
+		})
+	}
+	if len(eas) != 0 {
+		eadata, err := winio.EncodeExtendedAttributes(eas)
+		if err != nil {
+			return nil, err
+		}
+		bhdr := winio.BackupHeader{
+			Id:   winio.BackupEaData,
+			Size: int64(len(eadata)),
+		}
+		err = bw.WriteHeader(&bhdr)
+		if err != nil {
+			return nil, err
+		}
+		_, err = bw.Write(eadata)
+		if err != nil {
+			return nil, err
+		}
+	}
+	if hdr.Typeflag == tar.TypeSymlink {
+		_, isMountPoint := hdr.Winheaders[hdrMountPoint]
+		rp := winio.ReparsePoint{
+			Target:       filepath.FromSlash(hdr.Linkname),
+			IsMountPoint: isMountPoint,
+		}
+		reparse := winio.EncodeReparsePoint(&rp)
+		bhdr := winio.BackupHeader{
+			Id:   winio.BackupReparseData,
+			Size: int64(len(reparse)),
+		}
+		err := bw.WriteHeader(&bhdr)
+		if err != nil {
+			return nil, err
+		}
+		_, err = bw.Write(reparse)
+		if err != nil {
+			return nil, err
+		}
+	}
+	if hdr.Typeflag == tar.TypeReg || hdr.Typeflag == tar.TypeRegA {
+		bhdr := winio.BackupHeader{
+			Id:   winio.BackupData,
+			Size: hdr.Size,
+		}
+		err := bw.WriteHeader(&bhdr)
+		if err != nil {
+			return nil, err
+		}
+		_, err = io.Copy(bw, t)
+		if err != nil {
+			return nil, err
+		}
+	}
+	// Copy all the alternate data streams and return the next non-ADS header.
+	for {
+		ahdr, err := t.Next()
+		if err != nil {
+			return nil, err
+		}
+		if ahdr.Typeflag != tar.TypeReg || !strings.HasPrefix(ahdr.Name, hdr.Name+":") {
+			return ahdr, nil
+		}
+		bhdr := winio.BackupHeader{
+			Id:   winio.BackupAlternateData,
+			Size: ahdr.Size,
+			Name: ahdr.Name[len(hdr.Name):] + ":$DATA",
+		}
+		err = bw.WriteHeader(&bhdr)
+		if err != nil {
+			return nil, err
+		}
+		_, err = io.Copy(bw, t)
+		if err != nil {
+			return nil, err
+		}
+	}
+}

vendor/github.com/Microsoft/go-winio/backuptar/tar_test.go

@@ -0,0 +1,84 @@
+package backuptar
+
+import (
+	"bytes"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	"github.com/Microsoft/go-winio"
+	"github.com/Microsoft/go-winio/archive/tar"
+)
+
+func ensurePresent(t *testing.T, m map[string]string, keys ...string) {
+	for _, k := range keys {
+		if _, ok := m[k]; !ok {
+			t.Error(k, "not present in tar header")
+		}
+	}
+}
+
+func TestRoundTrip(t *testing.T) {
+	f, err := ioutil.TempFile("", "tst")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f.Close()
+	defer os.Remove(f.Name())
+
+	if _, err = f.Write([]byte("testing 1 2 3\n")); err != nil {
+		t.Fatal(err)
+	}
+
+	if _, err = f.Seek(0, 0); err != nil {
+		t.Fatal(err)
+	}
+
+	fi, err := f.Stat()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	bi, err := winio.GetFileBasicInfo(f)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	br := winio.NewBackupFileReader(f, true)
+	defer br.Close()
+
+	var buf bytes.Buffer
+	tw := tar.NewWriter(&buf)
+
+	err = WriteTarFileFromBackupStream(tw, br, f.Name(), fi.Size(), bi)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	tr := tar.NewReader(&buf)
+	hdr, err := tr.Next()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	name, size, bi2, err := FileInfoFromHeader(hdr)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if name != filepath.ToSlash(f.Name()) {
+		t.Errorf("got name %s, expected %s", name, filepath.ToSlash(f.Name()))
+	}
+
+	if size != fi.Size() {
+		t.Errorf("got size %d, expected %d", size, fi.Size())
+	}
+
+	if !reflect.DeepEqual(*bi, *bi2) {
+		t.Errorf("got %#v, expected %#v", *bi, *bi2)
+	}
+
+	ensurePresent(t, hdr.Winheaders, "fileattr", "rawsd")
+}

vendor/github.com/Microsoft/go-winio/ea.go

@@ -0,0 +1,137 @@
+package winio
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+)
+
+type fileFullEaInformation struct {
+	NextEntryOffset uint32
+	Flags           uint8
+	NameLength      uint8
+	ValueLength     uint16
+}
+
+var (
+	fileFullEaInformationSize = binary.Size(&fileFullEaInformation{})
+
+	errInvalidEaBuffer = errors.New("invalid extended attribute buffer")
+	errEaNameTooLarge  = errors.New("extended attribute name too large")
+	errEaValueTooLarge = errors.New("extended attribute value too large")
+)
+
+// ExtendedAttribute represents a single Windows EA.
+type ExtendedAttribute struct {
+	Name  string
+	Value []byte
+	Flags uint8
+}
+
+func parseEa(b []byte) (ea ExtendedAttribute, nb []byte, err error) {
+	var info fileFullEaInformation
+	err = binary.Read(bytes.NewReader(b), binary.LittleEndian, &info)
+	if err != nil {
+		err = errInvalidEaBuffer
+		return
+	}
+
+	nameOffset := fileFullEaInformationSize
+	nameLen := int(info.NameLength)
+	valueOffset := nameOffset + int(info.NameLength) + 1
+	valueLen := int(info.ValueLength)
+	nextOffset := int(info.NextEntryOffset)
+	if valueLen+valueOffset > len(b) || nextOffset < 0 || nextOffset > len(b) {
+		err = errInvalidEaBuffer
+		return
+	}
+
+	ea.Name = string(b[nameOffset : nameOffset+nameLen])
+	ea.Value = b[valueOffset : valueOffset+valueLen]
+	ea.Flags = info.Flags
+	if info.NextEntryOffset != 0 {
+		nb = b[info.NextEntryOffset:]
+	}
+	return
+}
+
+// DecodeExtendedAttributes decodes a list of EAs from a FILE_FULL_EA_INFORMATION
+// buffer retrieved from BackupRead, ZwQueryEaFile, etc.
+func DecodeExtendedAttributes(b []byte) (eas []ExtendedAttribute, err error) {
+	for len(b) != 0 {
+		ea, nb, err := parseEa(b)
+		if err != nil {
+			return nil, err
+		}
+
+		eas = append(eas, ea)
+		b = nb
+	}
+	return
+}
+
+func writeEa(buf *bytes.Buffer, ea *ExtendedAttribute, last bool) error {
+	if int(uint8(len(ea.Name))) != len(ea.Name) {
+		return errEaNameTooLarge
+	}
+	if int(uint16(len(ea.Value))) != len(ea.Value) {
+		return errEaValueTooLarge
+	}
+	entrySize := uint32(fileFullEaInformationSize + len(ea.Name) + 1 + len(ea.Value))
+	withPadding := (entrySize + 3) &^ 3
+	nextOffset := uint32(0)
+	if !last {
+		nextOffset = withPadding
+	}
+	info := fileFullEaInformation{
+		NextEntryOffset: nextOffset,
+		Flags:           ea.Flags,
+		NameLength:      uint8(len(ea.Name)),
+		ValueLength:     uint16(len(ea.Value)),
+	}
+
+	err := binary.Write(buf, binary.LittleEndian, &info)
+	if err != nil {
+		return err
+	}
+
+	_, err = buf.Write([]byte(ea.Name))
+	if err != nil {
+		return err
+	}
+
+	err = buf.WriteByte(0)
+	if err != nil {
+		return err
+	}
+
+	_, err = buf.Write(ea.Value)
+	if err != nil {
+		return err
+	}
+
+	_, err = buf.Write([]byte{0, 0, 0}[0 : withPadding-entrySize])
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// EncodeExtendedAttributes encodes a list of EAs into a FILE_FULL_EA_INFORMATION
+// buffer for use with BackupWrite, ZwSetEaFile, etc.
+func EncodeExtendedAttributes(eas []ExtendedAttribute) ([]byte, error) {
+	var buf bytes.Buffer
+	for i := range eas {
+		last := false
+		if i == len(eas)-1 {
+			last = true
+		}
+
+		err := writeEa(&buf, &eas[i], last)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return buf.Bytes(), nil
+}