From 1caa6589a8430fc81e4592039899d614af672497 Mon Sep 17 00:00:00 2001 From: Calle Pettersson Date: Sat, 27 Aug 2016 11:34:27 +0200 Subject: [PATCH] Improve metrics from LogicalDisk --- README.md | 2 +- collectors/logical_disk.go | 265 +++++++++++++++ collectors/perf.go | 650 ------------------------------------- exporter.go | 2 +- 4 files changed, 267 insertions(+), 652 deletions(-) create mode 100644 collectors/logical_disk.go delete mode 100644 collectors/perf.go diff --git a/README.md b/README.md index 5edd0fd4..aaa22c66 100644 --- a/README.md +++ b/README.md @@ -12,7 +12,7 @@ Prometheus exporter for Windows machines, using the WMI (Windows Management Inst Name | Description ---------|------------- os | [Win32_OperatingSystem](https://msdn.microsoft.com/en-us/library/aa394239) metrics (memory, processes, users) -perf | [Win32_PerfRawData_PerfDisk_LogicalDisk](https://msdn.microsoft.com/en-us/windows/hardware/aa394307(v=vs.71)) metrics (disk I/O) +logical_disk | [Win32_PerfRawData_PerfDisk_LogicalDisk](https://msdn.microsoft.com/en-us/windows/hardware/aa394307(v=vs.71)) metrics (disk I/O) The HELP texts shows the WMI data source, please see MSDN documentation for details. diff --git a/collectors/logical_disk.go b/collectors/logical_disk.go new file mode 100644 index 00000000..37be1e1d --- /dev/null +++ b/collectors/logical_disk.go @@ -0,0 +1,265 @@ +// 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 + +package collectors + +import ( + "flag" + "fmt" + "log" + "regexp" + + "github.com/StackExchange/wmi" + "github.com/prometheus/client_golang/prometheus" +) + +const ( + subsystem = "logical_disk" + ticksToSecondsScaleFactor = 1 / 1e7 +) + +var ( + volumeWhitelist = flag.String("collector.logical_disk.volume-whitelist", ".+", "Regexp of volumes to whitelist. Volume name must both match whitelist and not match blacklist to be included.") + volumeBlacklist = flag.String("collector.logical_disk.volume-blacklist", "", "Regexp of volumes to blacklist. Volume name must both match whitelist and not match blacklist to be included.") +) + +// 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 + + volumeWhitelistPattern *regexp.Regexp + volumeBlacklistPattern *regexp.Regexp +} + +// NewLogicalDiskCollector ... +func NewLogicalDiskCollector() *LogicalDiskCollector { + + return &LogicalDiskCollector{ + RequestsQueued: prometheus.NewDesc( + prometheus.BuildFQName(wmiNamespace, subsystem, "requests_queued"), + "The number of requests queued to the disk (LogicalDisk.CurrentDiskQueueLength)", + []string{"volume"}, + nil, + ), + + ReadBytesTotal: prometheus.NewDesc( + prometheus.BuildFQName(wmiNamespace, subsystem, "read_bytes_total"), + "The number of bytes transferred from the disk during read operations (LogicalDisk.DiskReadBytesPerSec)", + []string{"volume"}, + nil, + ), + + ReadsTotal: prometheus.NewDesc( + prometheus.BuildFQName(wmiNamespace, subsystem, "reads_total"), + "The number of read operations on the disk (LogicalDisk.DiskReadsPerSec)", + []string{"volume"}, + nil, + ), + + WriteBytesTotal: prometheus.NewDesc( + prometheus.BuildFQName(wmiNamespace, subsystem, "write_bytes_total"), + "The number of bytes transferred to the disk during write operations (LogicalDisk.DiskWriteBytesPerSec)", + []string{"volume"}, + nil, + ), + + WritesTotal: prometheus.NewDesc( + prometheus.BuildFQName(wmiNamespace, subsystem, "writes_total"), + "The number of write operations on the disk (LogicalDisk.DiskWritesPerSec)", + []string{"volume"}, + nil, + ), + + ReadTime: prometheus.NewDesc( + prometheus.BuildFQName(wmiNamespace, subsystem, "read_seconds_total"), + "Seconds that the disk was busy servicing read requests (LogicalDisk.PercentDiskReadTime)", + []string{"volume"}, + nil, + ), + + WriteTime: prometheus.NewDesc( + prometheus.BuildFQName(wmiNamespace, subsystem, "write_seconds_total"), + "Seconds that the disk was busy servicing write requests (LogicalDisk.PercentDiskWriteTime)", + []string{"volume"}, + nil, + ), + + FreeSpace: prometheus.NewDesc( + prometheus.BuildFQName(wmiNamespace, subsystem, "free_bytes"), + "Free space in bytes (LogicalDisk.PercentFreeSpace)", + []string{"volume"}, + nil, + ), + + TotalSpace: prometheus.NewDesc( + prometheus.BuildFQName(wmiNamespace, subsystem, "size_bytes"), + "Total space in bytes (LogicalDisk.PercentFreeSpace_Base)", + []string{"volume"}, + nil, + ), + + IdleTime: prometheus.NewDesc( + prometheus.BuildFQName(wmiNamespace, subsystem, "idle_seconds_total"), + "Seconds that the disk was idle (LogicalDisk.PercentIdleTime)", + []string{"volume"}, + nil, + ), + + SplitIOs: prometheus.NewDesc( + prometheus.BuildFQName(wmiNamespace, subsystem, "split_ios_total"), + "The number of I/Os to the disk were split into multiple I/Os (LogicalDisk.SplitIOPerSec)", + []string{"volume"}, + nil, + ), + + volumeWhitelistPattern: regexp.MustCompile(fmt.Sprintf("^(?:%s)$", *volumeWhitelist)), + volumeBlacklistPattern: regexp.MustCompile(fmt.Sprintf("^(?:%s)$", *volumeBlacklist)), + } +} + +// Collect sends the metric values for each metric +// to the provided prometheus Metric channel. +func (c *LogicalDiskCollector) Collect(ch chan<- prometheus.Metric) { + if desc, err := c.collect(ch); err != nil { + log.Println("[ERROR] failed collecting logical_disk metrics:", desc, err) + return + } +} + +// Describe sends the descriptors of each metric over to the provided channel. +// The corresponding metric values are sent separately. +func (c *LogicalDiskCollector) Describe(ch chan<- *prometheus.Desc) { + + ch <- c.RequestsQueued + ch <- c.ReadBytesTotal + ch <- c.ReadsTotal + ch <- c.WriteBytesTotal + ch <- c.WritesTotal + ch <- c.ReadTime + ch <- c.WriteTime + ch <- c.FreeSpace + ch <- c.TotalSpace + ch <- c.IdleTime + ch <- c.SplitIOs +} + +type Win32_PerfRawData_PerfDisk_LogicalDisk struct { + Name string + CurrentDiskQueueLength uint32 + DiskReadBytesPerSec uint64 + DiskReadsPerSec uint32 + DiskWriteBytesPerSec uint64 + DiskWritesPerSec uint32 + PercentDiskReadTime uint64 + PercentDiskWriteTime uint64 + PercentFreeSpace uint32 + PercentFreeSpace_Base uint32 + PercentIdleTime uint64 + SplitIOPerSec uint32 +} + +func (c *LogicalDiskCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) { + var dst []Win32_PerfRawData_PerfDisk_LogicalDisk + q := wmi.CreateQuery(&dst, "") + if err := wmi.Query(q, &dst); err != nil { + return nil, err + } + + for _, volume := range dst { + if volume.Name == "_Total" || + c.volumeBlacklistPattern.MatchString(volume.Name) || + !c.volumeWhitelistPattern.MatchString(volume.Name) { + continue + } + + ch <- prometheus.MustNewConstMetric( + c.RequestsQueued, + prometheus.GaugeValue, + float64(volume.CurrentDiskQueueLength), + volume.Name, + ) + + ch <- prometheus.MustNewConstMetric( + c.ReadBytesTotal, + prometheus.CounterValue, + float64(volume.DiskReadBytesPerSec), + volume.Name, + ) + + ch <- prometheus.MustNewConstMetric( + c.ReadsTotal, + prometheus.CounterValue, + float64(volume.DiskReadsPerSec), + volume.Name, + ) + + ch <- prometheus.MustNewConstMetric( + c.WriteBytesTotal, + prometheus.CounterValue, + float64(volume.DiskWriteBytesPerSec), + volume.Name, + ) + + ch <- prometheus.MustNewConstMetric( + c.WritesTotal, + prometheus.CounterValue, + float64(volume.DiskWritesPerSec), + volume.Name, + ) + + ch <- prometheus.MustNewConstMetric( + c.ReadTime, + prometheus.CounterValue, + float64(volume.PercentDiskReadTime)*ticksToSecondsScaleFactor, + volume.Name, + ) + + ch <- prometheus.MustNewConstMetric( + c.WriteTime, + prometheus.CounterValue, + float64(volume.PercentDiskWriteTime)*ticksToSecondsScaleFactor, + volume.Name, + ) + + ch <- prometheus.MustNewConstMetric( + c.FreeSpace, + prometheus.GaugeValue, + float64(volume.PercentFreeSpace)*1024*1024, + volume.Name, + ) + + ch <- prometheus.MustNewConstMetric( + c.TotalSpace, + prometheus.GaugeValue, + float64(volume.PercentFreeSpace_Base)*1024*1024, + volume.Name, + ) + + ch <- prometheus.MustNewConstMetric( + c.IdleTime, + prometheus.CounterValue, + float64(volume.PercentIdleTime)*ticksToSecondsScaleFactor, + volume.Name, + ) + + ch <- prometheus.MustNewConstMetric( + c.SplitIOs, + prometheus.CounterValue, + float64(volume.SplitIOPerSec), + volume.Name, + ) + } + + return nil, nil +} diff --git a/collectors/perf.go b/collectors/perf.go deleted file mode 100644 index ed9062a3..00000000 --- a/collectors/perf.go +++ /dev/null @@ -1,650 +0,0 @@ -// 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 - -package collectors - -import ( - "flag" - "fmt" - "log" - "regexp" - - "github.com/StackExchange/wmi" - "github.com/prometheus/client_golang/prometheus" -) - -var ( - volumeWhitelist = flag.String("collector.perf.volume-whitelist", ".+", "Regexp of volumes to whitelist. Volume name must both match whitelist and not match blacklist to be included.") - volumeBlacklist = flag.String("collector.perf.volume-blacklist", "", "Regexp of volumes to blacklist. Volume name must both match whitelist and not match blacklist to be included.") -) - -// A PerfCollector is a Prometheus collector for WMI Win32_PerfRawData_PerfDisk_LogicalDisk metrics -type PerfCollector struct { - AvgDiskBytesPerRead *prometheus.Desc - AvgDiskBytesPerRead_Base *prometheus.Desc - AvgDiskBytesPerTransfer *prometheus.Desc - AvgDiskBytesPerTransfer_Base *prometheus.Desc - AvgDiskBytesPerWrite *prometheus.Desc - AvgDiskBytesPerWrite_Base *prometheus.Desc - AvgDiskQueueLength *prometheus.Desc - AvgDiskReadQueueLength *prometheus.Desc - AvgDiskSecPerRead *prometheus.Desc - AvgDiskSecPerRead_Base *prometheus.Desc - AvgDiskSecPerTransfer *prometheus.Desc - AvgDiskSecPerTransfer_Base *prometheus.Desc - AvgDiskSecPerWrite *prometheus.Desc - AvgDiskSecPerWrite_Base *prometheus.Desc - AvgDiskWriteQueueLength *prometheus.Desc - CurrentDiskQueueLength *prometheus.Desc - DiskBytesPerSec *prometheus.Desc - DiskReadBytesPerSec *prometheus.Desc - DiskReadsPerSec *prometheus.Desc - DiskTransfersPerSec *prometheus.Desc - DiskWriteBytesPerSec *prometheus.Desc - DiskWritesPerSec *prometheus.Desc - FreeMegabytes *prometheus.Desc - PercentDiskReadTime *prometheus.Desc - PercentDiskReadTime_Base *prometheus.Desc - PercentDiskTime *prometheus.Desc - PercentDiskTime_Base *prometheus.Desc - PercentDiskWriteTime *prometheus.Desc - PercentDiskWriteTime_Base *prometheus.Desc - PercentFreeSpace *prometheus.Desc - PercentFreeSpace_Base *prometheus.Desc - PercentIdleTime *prometheus.Desc - PercentIdleTime_Base *prometheus.Desc - SplitIOPerSec *prometheus.Desc - - volumeWhitelistPattern *regexp.Regexp - volumeBlacklistPattern *regexp.Regexp -} - -// NewPerfCollector ... -func NewPerfCollector() *PerfCollector { - - return &PerfCollector{ - AvgDiskBytesPerRead: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "avg_disk_bytes_per_read"), - "AvgDiskBytesPerRead", - []string{"volume"}, - nil, - ), - - AvgDiskBytesPerRead_Base: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "avg_disk_bytes_per_read_base"), - "AvgDiskBytesPerRead_Base", - []string{"volume"}, - nil, - ), - - AvgDiskBytesPerTransfer: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "avg_disk_bytes_per_transfer"), - "AvgDiskBytesPerTransfer", - []string{"volume"}, - nil, - ), - - AvgDiskBytesPerTransfer_Base: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "avg_disk_bytes_per_transfer_base"), - "AvgDiskBytesPerTransfer_Base", - []string{"volume"}, - nil, - ), - - AvgDiskBytesPerWrite: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "avg_disk_bytes_per_write"), - "AvgDiskBytesPerWrite", - []string{"volume"}, - nil, - ), - - AvgDiskBytesPerWrite_Base: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "avg_disk_bytes_per_write_base"), - "AvgDiskBytesPerWrite_Base", - []string{"volume"}, - nil, - ), - - AvgDiskQueueLength: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "avg_disk_queue_length"), - "AvgDiskQueueLength", - []string{"volume"}, - nil, - ), - - AvgDiskReadQueueLength: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "avg_disk_read_queue_length"), - "AvgDiskReadQueueLength", - []string{"volume"}, - nil, - ), - - AvgDiskSecPerRead: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "avg_disk_sec_per_read"), - "AvgDiskSecPerRead", - []string{"volume"}, - nil, - ), - - AvgDiskSecPerRead_Base: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "avg_disk_sec_per_read_base"), - "AvgDiskSecPerRead_Base", - []string{"volume"}, - nil, - ), - - AvgDiskSecPerTransfer: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "avg_disk_sec_per_transfer"), - "AvgDiskSecPerTransfer", - []string{"volume"}, - nil, - ), - - AvgDiskSecPerTransfer_Base: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "avg_disk_sec_per_transfer_base"), - "AvgDiskSecPerTransfer_Base", - []string{"volume"}, - nil, - ), - - AvgDiskSecPerWrite: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "avg_disk_sec_per_write"), - "AvgDiskSecPerWrite", - []string{"volume"}, - nil, - ), - - AvgDiskSecPerWrite_Base: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "avg_disk_sec_per_write_base"), - "AvgDiskSecPerWrite_Base", - []string{"volume"}, - nil, - ), - - AvgDiskWriteQueueLength: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "avg_disk_write_queue_length"), - "AvgDiskWriteQueueLength", - []string{"volume"}, - nil, - ), - - CurrentDiskQueueLength: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "current_disk_queue_length"), - "CurrentDiskQueueLength", - []string{"volume"}, - nil, - ), - - DiskBytesPerSec: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "disk_bytes_per_sec"), - "DiskBytesPerSec", - []string{"volume"}, - nil, - ), - - DiskReadBytesPerSec: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "disk_read_bytes_per_sec"), - "DiskReadBytesPerSec", - []string{"volume"}, - nil, - ), - - DiskReadsPerSec: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "disk_reads_per_sec"), - "DiskReadsPerSec", - []string{"volume"}, - nil, - ), - - DiskTransfersPerSec: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "disk_transfers_per_sec"), - "DiskTransfersPerSec", - []string{"volume"}, - nil, - ), - - DiskWriteBytesPerSec: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "disk_write_bytes_per_sec"), - "DiskWriteBytesPerSec", - []string{"volume"}, - nil, - ), - - DiskWritesPerSec: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "disk_writes_per_sec"), - "DiskWritesPerSec", - []string{"volume"}, - nil, - ), - - FreeMegabytes: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "free_megabytes"), // XXX in bytes - "FreeMegabytes", - []string{"volume"}, - nil, - ), - - PercentDiskReadTime: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "percent_disk_read_time"), - "PercentDiskReadTime", - []string{"volume"}, - nil, - ), - - PercentDiskReadTime_Base: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "percent_disk_read_time_base"), - "PercentDiskReadTime_Base", - []string{"volume"}, - nil, - ), - - PercentDiskTime: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "percent_disk_time"), - "PercentDiskTime", - []string{"volume"}, - nil, - ), - - PercentDiskTime_Base: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "percent_disk_time_base"), - "PercentDiskTime_Base", - []string{"volume"}, - nil, - ), - - PercentDiskWriteTime: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "percent_disk_write_time"), - "PercentDiskWriteTime", - []string{"volume"}, - nil, - ), - - PercentDiskWriteTime_Base: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "percent_disk_write_time_base"), - "PercentDiskWriteTime_Base", - []string{"volume"}, - nil, - ), - - PercentFreeSpace: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "percent_free_space"), - "PercentFreeSpace", - []string{"volume"}, - nil, - ), - - PercentFreeSpace_Base: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "percent_free_space_base"), - "PercentFreeSpace_Base", - []string{"volume"}, - nil, - ), - - PercentIdleTime: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "percent_idle_time"), - "PercentIdleTime", - []string{"volume"}, - nil, - ), - - PercentIdleTime_Base: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "percent_idle_time_base"), - "PercentIdleTime_Base", - []string{"volume"}, - nil, - ), - - SplitIOPerSec: prometheus.NewDesc( - prometheus.BuildFQName(wmiNamespace, "perf", "split_io_per_sec"), - "SplitIOPerSec", - []string{"volume"}, - nil, - ), - - volumeWhitelistPattern: regexp.MustCompile(fmt.Sprintf("^(?:%s)$", *volumeWhitelist)), - volumeBlacklistPattern: regexp.MustCompile(fmt.Sprintf("^(?:%s)$", *volumeBlacklist)), - } -} - -// Collect sends the metric values for each metric -// to the provided prometheus Metric channel. -func (c *PerfCollector) Collect(ch chan<- prometheus.Metric) { - if desc, err := c.collect(ch); err != nil { - log.Println("[ERROR] failed collecting perf metrics:", desc, err) - return - } -} - -// Describe sends the descriptors of each metric over to the provided channel. -// The corresponding metric values are sent separately. -func (c *PerfCollector) Describe(ch chan<- *prometheus.Desc) { - - ch <- c.AvgDiskBytesPerRead - ch <- c.AvgDiskBytesPerRead_Base - ch <- c.AvgDiskBytesPerTransfer - ch <- c.AvgDiskBytesPerTransfer_Base - ch <- c.AvgDiskBytesPerWrite - ch <- c.AvgDiskBytesPerWrite_Base - ch <- c.AvgDiskQueueLength - ch <- c.AvgDiskReadQueueLength - ch <- c.AvgDiskSecPerRead - ch <- c.AvgDiskSecPerRead_Base - ch <- c.AvgDiskSecPerTransfer - ch <- c.AvgDiskSecPerTransfer_Base - ch <- c.AvgDiskSecPerWrite - ch <- c.AvgDiskSecPerWrite_Base - ch <- c.AvgDiskWriteQueueLength - ch <- c.CurrentDiskQueueLength - ch <- c.DiskBytesPerSec - ch <- c.DiskReadBytesPerSec - ch <- c.DiskReadsPerSec - ch <- c.DiskTransfersPerSec - ch <- c.DiskWriteBytesPerSec - ch <- c.DiskWritesPerSec - ch <- c.FreeMegabytes - ch <- c.PercentDiskReadTime - ch <- c.PercentDiskReadTime_Base - ch <- c.PercentDiskTime - ch <- c.PercentDiskTime_Base - ch <- c.PercentDiskWriteTime - ch <- c.PercentDiskWriteTime_Base - ch <- c.PercentFreeSpace - ch <- c.PercentFreeSpace_Base - ch <- c.PercentIdleTime - ch <- c.PercentIdleTime_Base - ch <- c.SplitIOPerSec -} - -type Win32_PerfRawData_PerfDisk_LogicalDisk struct { - Name string - AvgDiskBytesPerRead uint64 - AvgDiskBytesPerRead_Base uint32 - AvgDiskBytesPerTransfer uint64 - AvgDiskBytesPerTransfer_Base uint32 - AvgDiskBytesPerWrite uint64 - AvgDiskBytesPerWrite_Base uint32 - AvgDiskQueueLength uint64 - AvgDiskReadQueueLength uint64 - AvgDiskSecPerRead uint32 - AvgDiskSecPerRead_Base uint32 - AvgDiskSecPerTransfer uint32 - AvgDiskSecPerTransfer_Base uint32 - AvgDiskSecPerWrite uint32 - AvgDiskSecPerWrite_Base uint32 - AvgDiskWriteQueueLength uint64 - CurrentDiskQueueLength uint32 - DiskBytesPerSec uint64 - DiskReadBytesPerSec uint64 - DiskReadsPerSec uint32 - DiskTransfersPerSec uint32 - DiskWriteBytesPerSec uint64 - DiskWritesPerSec uint32 - FreeMegabytes uint32 - PercentDiskReadTime uint64 - PercentDiskReadTime_Base uint64 - PercentDiskTime uint64 - PercentDiskTime_Base uint64 - PercentDiskWriteTime uint64 - PercentDiskWriteTime_Base uint64 - PercentFreeSpace uint32 - PercentFreeSpace_Base uint32 - PercentIdleTime uint64 - PercentIdleTime_Base uint64 - SplitIOPerSec uint32 -} - -func (c *PerfCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) { - var dst []Win32_PerfRawData_PerfDisk_LogicalDisk - q := wmi.CreateQuery(&dst, "") - if err := wmi.Query(q, &dst); err != nil { - return nil, err - } - - for _, volume := range dst { - if volume.Name == "_Total" || - c.volumeBlacklistPattern.MatchString(volume.Name) || - !c.volumeWhitelistPattern.MatchString(volume.Name) { - continue - } - - ch <- prometheus.MustNewConstMetric( - c.AvgDiskBytesPerRead, - prometheus.GaugeValue, - float64(volume.AvgDiskBytesPerRead), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.AvgDiskBytesPerRead_Base, - prometheus.GaugeValue, - float64(volume.AvgDiskBytesPerRead_Base), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.AvgDiskBytesPerTransfer, - prometheus.GaugeValue, - float64(volume.AvgDiskBytesPerTransfer), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.AvgDiskBytesPerTransfer_Base, - prometheus.GaugeValue, - float64(volume.AvgDiskBytesPerTransfer_Base), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.AvgDiskBytesPerWrite, - prometheus.GaugeValue, - float64(volume.AvgDiskBytesPerWrite), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.AvgDiskBytesPerWrite_Base, - prometheus.GaugeValue, - float64(volume.AvgDiskBytesPerWrite_Base), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.AvgDiskQueueLength, - prometheus.GaugeValue, - float64(volume.AvgDiskQueueLength), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.AvgDiskReadQueueLength, - prometheus.GaugeValue, - float64(volume.AvgDiskReadQueueLength), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.AvgDiskSecPerRead, - prometheus.GaugeValue, - float64(volume.AvgDiskSecPerRead), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.AvgDiskSecPerRead_Base, - prometheus.GaugeValue, - float64(volume.AvgDiskSecPerRead_Base), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.AvgDiskSecPerTransfer, - prometheus.GaugeValue, - float64(volume.AvgDiskSecPerTransfer), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.AvgDiskSecPerTransfer_Base, - prometheus.GaugeValue, - float64(volume.AvgDiskSecPerTransfer_Base), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.AvgDiskSecPerWrite, - prometheus.GaugeValue, - float64(volume.AvgDiskSecPerWrite), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.AvgDiskSecPerWrite_Base, - prometheus.GaugeValue, - float64(volume.AvgDiskSecPerWrite_Base), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.AvgDiskWriteQueueLength, - prometheus.GaugeValue, - float64(volume.AvgDiskWriteQueueLength), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.CurrentDiskQueueLength, - prometheus.GaugeValue, - float64(volume.CurrentDiskQueueLength), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.DiskBytesPerSec, - prometheus.GaugeValue, - float64(volume.DiskBytesPerSec), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.DiskReadBytesPerSec, - prometheus.GaugeValue, - float64(volume.DiskReadBytesPerSec), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.DiskReadsPerSec, - prometheus.GaugeValue, - float64(volume.DiskReadsPerSec), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.DiskTransfersPerSec, - prometheus.GaugeValue, - float64(volume.DiskTransfersPerSec), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.DiskWriteBytesPerSec, - prometheus.GaugeValue, - float64(volume.DiskWriteBytesPerSec), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.DiskWritesPerSec, - prometheus.GaugeValue, - float64(volume.DiskWritesPerSec), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.FreeMegabytes, - prometheus.GaugeValue, - float64(volume.FreeMegabytes), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.PercentDiskReadTime, - prometheus.GaugeValue, - float64(volume.PercentDiskReadTime), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.PercentDiskReadTime_Base, - prometheus.GaugeValue, - float64(volume.PercentDiskReadTime_Base), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.PercentDiskTime, - prometheus.GaugeValue, - float64(volume.PercentDiskTime), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.PercentDiskTime_Base, - prometheus.GaugeValue, - float64(volume.PercentDiskTime_Base), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.PercentDiskWriteTime, - prometheus.GaugeValue, - float64(volume.PercentDiskWriteTime), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.PercentDiskWriteTime_Base, - prometheus.GaugeValue, - float64(volume.PercentDiskWriteTime_Base), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.PercentFreeSpace, - prometheus.GaugeValue, - float64(volume.PercentFreeSpace), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.PercentFreeSpace_Base, - prometheus.GaugeValue, - float64(volume.PercentFreeSpace_Base), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.PercentIdleTime, - prometheus.GaugeValue, - float64(volume.PercentIdleTime), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.PercentIdleTime_Base, - prometheus.GaugeValue, - float64(volume.PercentIdleTime_Base), - volume.Name, - ) - - ch <- prometheus.MustNewConstMetric( - c.SplitIOPerSec, - prometheus.GaugeValue, - float64(volume.SplitIOPerSec), - volume.Name, - ) - } - - return nil, nil -} diff --git a/exporter.go b/exporter.go index 138123b7..a14e640c 100644 --- a/exporter.go +++ b/exporter.go @@ -30,7 +30,7 @@ func NewWmiExporter() *WmiExporter { return &WmiExporter{ collectors: []prometheus.Collector{ collectors.NewOSCollector(), - collectors.NewPerfCollector(), + collectors.NewLogicalDiskCollector(), }, } }