Merge pull request #226 from szook/fix-iis-collector-panic

fix iis collector panic

collector/ad.go

@@ -612,7 +612,7 @@ type Win32_PerfRawData_DirectoryServices_DirectoryServices struct {
 
 func (c *ADCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_DirectoryServices_DirectoryServices
-	q := wmi.CreateQuery(&dst, "")
+	q := queryAll(&dst)
 	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}

collector/cpu.go

@@ -117,7 +117,7 @@ type Win32_PerfRawData_Counters_ProcessorInformation struct {
 
 func (c *CPUCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_PerfOS_Processor
-	q := wmi.CreateQuery(&dst, "")
+	q := queryAll(&dst)
 	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}

collector/cs.go

@@ -56,7 +56,8 @@ type Win32_ComputerSystem struct {
 
 func (c *CSCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_ComputerSystem
-	if err := wmi.Query(wmi.CreateQuery(&dst, ""), &dst); err != nil {
+	q := queryAll(&dst)
+	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}
 

collector/dns.go

@@ -233,7 +233,7 @@ type Win32_PerfRawData_DNS_DNS struct {
 
 func (c *DNSCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_DNS_DNS
-	q := wmi.CreateQuery(&dst, "")
+	q := queryAll(&dst)
 	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}

collector/hyperv.go

@@ -92,6 +92,22 @@ type HyperVCollector struct {
 	AdapterFramesDropped  *prometheus.Desc
 	AdapterFramesReceived *prometheus.Desc
 	AdapterFramesSent     *prometheus.Desc
+
+	// Win32_PerfRawData_Counters_HyperVVirtualStorageDevice
+	VMStorageErrorCount      *prometheus.Desc
+	VMStorageQueueLength     *prometheus.Desc
+	VMStorageReadBytes       *prometheus.Desc
+	VMStorageReadOperations  *prometheus.Desc
+	VMStorageWriteBytes      *prometheus.Desc
+	VMStorageWriteOperations *prometheus.Desc
+
+	// Win32_PerfRawData_NvspNicStats_HyperVVirtualNetworkAdapter
+	VMNetworkBytesReceived          *prometheus.Desc
+	VMNetworkBytesSent              *prometheus.Desc
+	VMNetworkDroppedPacketsIncoming *prometheus.Desc
+	VMNetworkDroppedPacketsOutgoing *prometheus.Desc
+	VMNetworkPacketsReceived        *prometheus.Desc
+	VMNetworkPacketsSent            *prometheus.Desc
 }
 
 // NewHyperVCollector ...
@@ -496,6 +512,84 @@ func NewHyperVCollector() (Collector, error) {
 			[]string{"adapter"},
 			nil,
 		),
+
+		//
+
+		VMStorageErrorCount: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, buildSubsystemName("vm_device"), "error_count"),
+			"This counter represents the total number of errors that have occurred on this virtual device",
+			[]string{"vm_device"},
+			nil,
+		),
+		VMStorageQueueLength: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, buildSubsystemName("vm_device"), "queue_length"),
+			"This counter represents the current queue length on this virtual device",
+			[]string{"vm_device"},
+			nil,
+		),
+		VMStorageReadBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, buildSubsystemName("vm_device"), "bytes_read"),
+			"This counter represents the total number of bytes that have been read per second on this virtual device",
+			[]string{"vm_device"},
+			nil,
+		),
+		VMStorageReadOperations: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, buildSubsystemName("vm_device"), "operations_read"),
+			"This counter represents the number of read operations that have occurred per second on this virtual device",
+			[]string{"vm_device"},
+			nil,
+		),
+		VMStorageWriteBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, buildSubsystemName("vm_device"), "bytes_written"),
+			"This counter represents the total number of bytes that have been written per second on this virtual device",
+			[]string{"vm_device"},
+			nil,
+		),
+		VMStorageWriteOperations: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, buildSubsystemName("vm_device"), "operations_written"),
+			"This counter represents the number of write operations that have occurred per second on this virtual device",
+			[]string{"vm_device"},
+			nil,
+		),
+
+		//
+
+		VMNetworkBytesReceived: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, buildSubsystemName("vm_interface"), "bytes_received"),
+			"This counter represents the total number of bytes received per second by the network adapter",
+			[]string{"vm_interface"},
+			nil,
+		),
+		VMNetworkBytesSent: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, buildSubsystemName("vm_interface"), "bytes_sent"),
+			"This counter represents the total number of bytes sent per second by the network adapter",
+			[]string{"vm_interface"},
+			nil,
+		),
+		VMNetworkDroppedPacketsIncoming: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, buildSubsystemName("vm_interface"), "packets_incoming_dropped"),
+			"This counter represents the total number of dropped packets per second in the incoming direction of the network adapter",
+			[]string{"vm_interface"},
+			nil,
+		),
+		VMNetworkDroppedPacketsOutgoing: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, buildSubsystemName("vm_interface"), "packets_outgoing_dropped"),
+			"This counter represents the total number of dropped packets per second in the outgoing direction of the network adapter",
+			[]string{"vm_interface"},
+			nil,
+		),
+		VMNetworkPacketsReceived: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, buildSubsystemName("vm_interface"), "packets_received"),
+			"This counter represents the total number of packets received per second by the network adapter",
+			[]string{"vm_interface"},
+			nil,
+		),
+		VMNetworkPacketsSent: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, buildSubsystemName("vm_interface"), "packets_sent"),
+			"This counter represents the total number of packets sent per second by the network adapter",
+			[]string{"vm_interface"},
+			nil,
+		),
 	}, nil
 }
 
@@ -541,6 +635,17 @@ func (c *HyperVCollector) Collect(ch chan<- prometheus.Metric) error {
 		log.Error("failed collecting hyperV ethernet metrics:", desc, err)
 		return err
 	}
+
+	if desc, err := c.collectVmStorage(ch); err != nil {
+		log.Error("failed collecting hyperV virtual storage metrics:", desc, err)
+		return err
+	}
+
+	if desc, err := c.collectVmNetwork(ch); err != nil {
+		log.Error("failed collecting hyperV virtual network metrics:", desc, err)
+		return err
+	}
+
 	return nil
 }
 
@@ -552,7 +657,8 @@ type Win32_PerfRawData_VmmsVirtualMachineStats_HyperVVirtualMachineHealthSummary
 
 func (c *HyperVCollector) collectVmHealth(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_VmmsVirtualMachineStats_HyperVVirtualMachineHealthSummary
-	if err := wmi.Query(wmi.CreateQuery(&dst, ""), &dst); err != nil {
+	q := queryAll(&dst)
+	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}
 
@@ -584,7 +690,8 @@ type Win32_PerfRawData_VidPerfProvider_HyperVVMVidPartition struct {
 
 func (c *HyperVCollector) collectVmVid(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_VidPerfProvider_HyperVVMVidPartition
-	if err := wmi.Query(wmi.CreateQuery(&dst, ""), &dst); err != nil {
+	q := queryAll(&dst)
+	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}
 
@@ -647,7 +754,8 @@ type Win32_PerfRawData_HvStats_HyperVHypervisorRootPartition struct {
 
 func (c *HyperVCollector) collectVmHv(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_HvStats_HyperVHypervisorRootPartition
-	if err := wmi.Query(wmi.CreateQuery(&dst, ""), &dst); err != nil {
+	q := queryAll(&dst)
+	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}
 
@@ -784,7 +892,8 @@ type Win32_PerfRawData_HvStats_HyperVHypervisor struct {
 
 func (c *HyperVCollector) collectVmProcessor(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_HvStats_HyperVHypervisor
-	if err := wmi.Query(wmi.CreateQuery(&dst, ""), &dst); err != nil {
+	q := queryAll(&dst)
+	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}
 
@@ -818,7 +927,8 @@ type Win32_PerfRawData_HvStats_HyperVHypervisorRootVirtualProcessor struct {
 
 func (c *HyperVCollector) collectHostCpuUsage(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_HvStats_HyperVHypervisorRootVirtualProcessor
-	if err := wmi.Query(wmi.CreateQuery(&dst, ""), &dst); err != nil {
+	q := queryAll(&dst)
+	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}
 
@@ -878,7 +988,8 @@ type Win32_PerfRawData_HvStats_HyperVHypervisorVirtualProcessor struct {
 
 func (c *HyperVCollector) collectVmCpuUsage(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_HvStats_HyperVHypervisorVirtualProcessor
-	if err := wmi.Query(wmi.CreateQuery(&dst, ""), &dst); err != nil {
+	q := queryAll(&dst)
+	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}
 
@@ -955,7 +1066,8 @@ type Win32_PerfRawData_NvspSwitchStats_HyperVVirtualSwitch struct {
 
 func (c *HyperVCollector) collectVmSwitch(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_NvspSwitchStats_HyperVVirtualSwitch
-	if err := wmi.Query(wmi.CreateQuery(&dst, ""), &dst); err != nil {
+	q := queryAll(&dst)
+	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}
 
@@ -1113,7 +1225,8 @@ type Win32_PerfRawData_EthernetPerfProvider_HyperVLegacyNetworkAdapter struct {
 
 func (c *HyperVCollector) collectVmEthernet(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_EthernetPerfProvider_HyperVLegacyNetworkAdapter
-	if err := wmi.Query(wmi.CreateQuery(&dst, ""), &dst); err != nil {
+	q := queryAll(&dst)
+	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}
 
@@ -1168,3 +1281,141 @@ func (c *HyperVCollector) collectVmEthernet(ch chan<- prometheus.Metric) (*prome
 
 	return nil, nil
 }
+
+// Win32_PerfRawData_Counters_HyperVVirtualStorageDevice ...
+type Win32_PerfRawData_Counters_HyperVVirtualStorageDevice struct {
+	Name                  string
+	ErrorCount            uint64
+	QueueLength           uint32
+	ReadBytesPersec       uint64
+	ReadOperationsPerSec  uint64
+	WriteBytesPersec      uint64
+	WriteOperationsPerSec uint64
+}
+
+func (c *HyperVCollector) collectVmStorage(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
+	var dst []Win32_PerfRawData_Counters_HyperVVirtualStorageDevice
+	q := queryAll(&dst)
+	if err := wmi.Query(q, &dst); err != nil {
+		return nil, err
+	}
+
+	for _, obj := range dst {
+		if strings.Contains(obj.Name, "_Total") {
+			continue
+		}
+
+		ch <- prometheus.MustNewConstMetric(
+			c.VMStorageErrorCount,
+			prometheus.CounterValue,
+			float64(obj.ErrorCount),
+			obj.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.VMStorageQueueLength,
+			prometheus.CounterValue,
+			float64(obj.QueueLength),
+			obj.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.VMStorageReadBytes,
+			prometheus.CounterValue,
+			float64(obj.ReadBytesPersec),
+			obj.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.VMStorageReadOperations,
+			prometheus.CounterValue,
+			float64(obj.ReadOperationsPerSec),
+			obj.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.VMStorageWriteBytes,
+			prometheus.CounterValue,
+			float64(obj.WriteBytesPersec),
+			obj.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.VMStorageWriteOperations,
+			prometheus.CounterValue,
+			float64(obj.WriteOperationsPerSec),
+			obj.Name,
+		)
+	}
+
+	return nil, nil
+}
+
+// Win32_PerfRawData_NvspNicStats_HyperVVirtualNetworkAdapter ...
+type Win32_PerfRawData_NvspNicStats_HyperVVirtualNetworkAdapter struct {
+	Name                         string
+	BytesReceivedPersec          uint64
+	BytesSentPersec              uint64
+	DroppedPacketsIncomingPersec uint64
+	DroppedPacketsOutgoingPersec uint64
+	PacketsReceivedPersec        uint64
+	PacketsSentPersec            uint64
+}
+
+func (c *HyperVCollector) collectVmNetwork(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
+	var dst []Win32_PerfRawData_NvspNicStats_HyperVVirtualNetworkAdapter
+	q := queryAll(&dst)
+	if err := wmi.Query(q, &dst); err != nil {
+		return nil, err
+	}
+
+	for _, obj := range dst {
+		if strings.Contains(obj.Name, "_Total") {
+			continue
+		}
+
+		ch <- prometheus.MustNewConstMetric(
+			c.VMNetworkBytesReceived,
+			prometheus.CounterValue,
+			float64(obj.BytesReceivedPersec),
+			obj.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.VMNetworkBytesSent,
+			prometheus.CounterValue,
+			float64(obj.BytesSentPersec),
+			obj.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.VMNetworkDroppedPacketsIncoming,
+			prometheus.CounterValue,
+			float64(obj.DroppedPacketsIncomingPersec),
+			obj.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.VMNetworkDroppedPacketsOutgoing,
+			prometheus.CounterValue,
+			float64(obj.DroppedPacketsOutgoingPersec),
+			obj.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.VMNetworkPacketsReceived,
+			prometheus.CounterValue,
+			float64(obj.PacketsReceivedPersec),
+			obj.Name,
+		)
+
+		ch <- prometheus.MustNewConstMetric(
+			c.VMNetworkPacketsSent,
+			prometheus.CounterValue,
+			float64(obj.PacketsSentPersec),
+			obj.Name,
+		)
+	}
+
+	return nil, nil
+}

collector/iis.go

@@ -20,7 +20,6 @@ import (
 
 func init() {
 	Factories["iis"] = NewIISCollector
-	iis_version = getIISVersion()
 }
 
 type simple_version struct {
@@ -60,8 +59,6 @@ var (
 	siteBlacklist = kingpin.Flag("collector.iis.site-blacklist", "Regexp of sites to blacklist. Site name must both match whitelist and not match blacklist to be included.").String()
 	appWhitelist  = kingpin.Flag("collector.iis.app-whitelist", "Regexp of apps to whitelist. App name must both match whitelist and not match blacklist to be included.").Default(".+").String()
 	appBlacklist  = kingpin.Flag("collector.iis.app-blacklist", "Regexp of apps to blacklist. App name must both match whitelist and not match blacklist to be included.").String()
-
-	iis_version = simple_version{}
 )
 
 type IISCollector struct {
@@ -188,13 +185,15 @@ type IISCollector struct {
 
 	appWhitelistPattern *regexp.Regexp
 	appBlacklistPattern *regexp.Regexp
+
+	iis_version simple_version
 }
 
 // NewIISCollector ...
 func NewIISCollector() (Collector, error) {
 	const subsystem = "iis"
 
-	return &IISCollector{
+	buildIIS := &IISCollector{
 		// Websites
 		// Gauges
 		CurrentAnonymousUsers: prometheus.NewDesc(
@@ -808,7 +807,11 @@ func NewIISCollector() (Collector, error) {
 
 		appWhitelistPattern: regexp.MustCompile(fmt.Sprintf("^(?:%s)$", *siteWhitelist)),
 		appBlacklistPattern: regexp.MustCompile(fmt.Sprintf("^(?:%s)$", *siteBlacklist)),
-	}, nil
+	}
+
+	buildIIS.iis_version = getIISVersion()
+
+	return buildIIS, nil
 }
 
 // Collect sends the metric values for each metric
@@ -995,7 +998,7 @@ var workerProcessNameExtractor = regexp.MustCompile(`^(\d+)_(.+)$`)
 
 func (c *IISCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_W3SVC_WebService
-	q := wmi.CreateQuery(&dst, "")
+	q := queryAll(&dst)
 	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}
@@ -1248,7 +1251,7 @@ func (c *IISCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, e
 	}
 
 	var dst2 []Win32_PerfRawData_APPPOOLCountersProvider_APPPOOLWAS
-	q2 := wmi.CreateQuery(&dst2, "")
+	q2 := queryAll(&dst2)
 	if err := wmi.Query(q2, &dst2); err != nil {
 		return nil, err
 	}
@@ -1365,7 +1368,7 @@ func (c *IISCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, e
 	}
 
 	var dst_worker []Win32_PerfRawData_W3SVCW3WPCounterProvider_W3SVCW3WP
-	q = wmi.CreateQuery(&dst_worker, "")
+	q = queryAll(&dst_worker)
 	if err := wmi.Query(q, &dst_worker); err != nil {
 		return nil, err
 	}
@@ -1645,9 +1648,9 @@ func (c *IISCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, e
 		)
 	}
 
-	if iis_version.major >= 8 {
+	if c.iis_version.major >= 8 {
 		var dst_worker_iis8 []Win32_PerfRawData_W3SVCW3WPCounterProvider_W3SVCW3WP_IIS8
-		q = createQuery(&dst_worker_iis8, "Win32_PerfRawData_W3SVCW3WPCounterProvider_W3SVCW3WP", "")
+		q = queryAllForClass(&dst_worker_iis8, "Win32_PerfRawData_W3SVCW3WPCounterProvider_W3SVCW3WP")
 		if err := wmi.Query(q, &dst_worker_iis8); err != nil {
 			return nil, err
 		}
@@ -1730,219 +1733,221 @@ func (c *IISCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, e
 	}
 
 	var dst_cache []Win32_PerfRawData_W3SVC_WebServiceCache
-	q = wmi.CreateQuery(&dst_cache, "")
+	q = queryAll(&dst_cache)
 	if err := wmi.Query(q, &dst_cache); err != nil {
 		return nil, err
 	}
 
-	ch <- prometheus.MustNewConstMetric(
+	if len(dst_cache) > 0 {
-		c.ServiceCache_ActiveFlushedEntries,
+		ch <- prometheus.MustNewConstMetric(
-		prometheus.GaugeValue,
+			c.ServiceCache_ActiveFlushedEntries,
-		float64(dst_cache[0].ActiveFlushedEntries),
+			prometheus.GaugeValue,
-	)
+			float64(dst_cache[0].ActiveFlushedEntries),
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_FileCacheMemoryUsage,
+			c.ServiceCache_FileCacheMemoryUsage,
-		prometheus.GaugeValue,
+			prometheus.GaugeValue,
-		float64(dst_cache[0].CurrentFileCacheMemoryUsage),
+			float64(dst_cache[0].CurrentFileCacheMemoryUsage),
-	)
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_MaximumFileCacheMemoryUsage,
+			c.ServiceCache_MaximumFileCacheMemoryUsage,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].MaximumFileCacheMemoryUsage),
+			float64(dst_cache[0].MaximumFileCacheMemoryUsage),
-	)
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_FileCacheFlushesTotal,
+			c.ServiceCache_FileCacheFlushesTotal,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].TotalFlushedFiles),
+			float64(dst_cache[0].TotalFlushedFiles),
-	)
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_FileCacheQueriesTotal,
+			c.ServiceCache_FileCacheQueriesTotal,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].FileCacheHits+dst_cache[0].FileCacheMisses),
+			float64(dst_cache[0].FileCacheHits+dst_cache[0].FileCacheMisses),
-	)
+		)
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_FileCacheHitsTotal,
+			c.ServiceCache_FileCacheHitsTotal,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].FileCacheHits),
+			float64(dst_cache[0].FileCacheHits),
-	)
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_FilesCached,
+			c.ServiceCache_FilesCached,
-		prometheus.GaugeValue,
+			prometheus.GaugeValue,
-		float64(dst_cache[0].CurrentFilesCached),
+			float64(dst_cache[0].CurrentFilesCached),
-	)
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_FilesCachedTotal,
+			c.ServiceCache_FilesCachedTotal,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].TotalFilesCached),
+			float64(dst_cache[0].TotalFilesCached),
-	)
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_FilesFlushedTotal,
+			c.ServiceCache_FilesFlushedTotal,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].TotalFlushedFiles),
+			float64(dst_cache[0].TotalFlushedFiles),
-	)
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_URICacheFlushesTotal,
+			c.ServiceCache_URICacheFlushesTotal,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].TotalFlushedURIs),
+			float64(dst_cache[0].TotalFlushedURIs),
-		"user",
+			"user",
-	)
+		)
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_URICacheFlushesTotal,
+			c.ServiceCache_URICacheFlushesTotal,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].KernelTotalFlushedURIs),
+			float64(dst_cache[0].KernelTotalFlushedURIs),
-		"kernel",
+			"kernel",
-	)
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_URICacheQueriesTotal,
+			c.ServiceCache_URICacheQueriesTotal,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].URICacheHits+dst_cache[0].URICacheMisses),
+			float64(dst_cache[0].URICacheHits+dst_cache[0].URICacheMisses),
-		"user",
+			"user",
-	)
+		)
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_URICacheQueriesTotal,
+			c.ServiceCache_URICacheQueriesTotal,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].KernelURICacheHits+dst_cache[0].KernelURICacheMisses),
+			float64(dst_cache[0].KernelURICacheHits+dst_cache[0].KernelURICacheMisses),
-		"kernel",
+			"kernel",
-	)
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_URICacheHitsTotal,
+			c.ServiceCache_URICacheHitsTotal,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].URICacheHits),
+			float64(dst_cache[0].URICacheHits),
-		"user",
+			"user",
-	)
+		)
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_URICacheHitsTotal,
+			c.ServiceCache_URICacheHitsTotal,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].KernelURICacheHits),
+			float64(dst_cache[0].KernelURICacheHits),
-		"kernel",
+			"kernel",
-	)
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_URIsCached,
+			c.ServiceCache_URIsCached,
-		prometheus.GaugeValue,
+			prometheus.GaugeValue,
-		float64(dst_cache[0].CurrentURIsCached),
+			float64(dst_cache[0].CurrentURIsCached),
-		"user",
+			"user",
-	)
+		)
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_URIsCached,
+			c.ServiceCache_URIsCached,
-		prometheus.GaugeValue,
+			prometheus.GaugeValue,
-		float64(dst_cache[0].KernelCurrentURIsCached),
+			float64(dst_cache[0].KernelCurrentURIsCached),
-		"kernel",
+			"kernel",
-	)
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_URIsCachedTotal,
+			c.ServiceCache_URIsCachedTotal,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].TotalURIsCached),
+			float64(dst_cache[0].TotalURIsCached),
-		"user",
+			"user",
-	)
+		)
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_URIsCachedTotal,
+			c.ServiceCache_URIsCachedTotal,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].KernelTotalURIsCached),
+			float64(dst_cache[0].KernelTotalURIsCached),
-		"kernel",
+			"kernel",
-	)
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_URIsFlushedTotal,
+			c.ServiceCache_URIsFlushedTotal,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].TotalFlushedURIs),
+			float64(dst_cache[0].TotalFlushedURIs),
-		"user",
+			"user",
-	)
+		)
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_URIsFlushedTotal,
+			c.ServiceCache_URIsFlushedTotal,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].KernelTotalFlushedURIs),
+			float64(dst_cache[0].KernelTotalFlushedURIs),
-		"kernel",
+			"kernel",
-	)
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_MetadataCached,
+			c.ServiceCache_MetadataCached,
-		prometheus.GaugeValue,
+			prometheus.GaugeValue,
-		float64(dst_cache[0].CurrentMetadataCached),
+			float64(dst_cache[0].CurrentMetadataCached),
-	)
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_MetadataCacheFlushes,
+			c.ServiceCache_MetadataCacheFlushes,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].TotalFlushedMetadata),
+			float64(dst_cache[0].TotalFlushedMetadata),
-	)
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_MetadataCacheQueriesTotal,
+			c.ServiceCache_MetadataCacheQueriesTotal,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].MetadataCacheHits+dst_cache[0].MetadataCacheMisses),
+			float64(dst_cache[0].MetadataCacheHits+dst_cache[0].MetadataCacheMisses),
-	)
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_MetadataCacheHitsTotal,
+			c.ServiceCache_MetadataCacheHitsTotal,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].MetadataCacheHits),
+			float64(dst_cache[0].MetadataCacheHits),
-	)
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_MetadataCachedTotal,
+			c.ServiceCache_MetadataCachedTotal,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].TotalMetadataCached),
+			float64(dst_cache[0].TotalMetadataCached),
-	)
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_MetadataFlushedTotal,
+			c.ServiceCache_MetadataFlushedTotal,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].TotalFlushedMetadata),
+			float64(dst_cache[0].TotalFlushedMetadata),
-	)
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_OutputCacheActiveFlushedItems,
+			c.ServiceCache_OutputCacheActiveFlushedItems,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].OutputCacheCurrentFlushedItems),
+			float64(dst_cache[0].OutputCacheCurrentFlushedItems),
-	)
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_OutputCacheItems,
+			c.ServiceCache_OutputCacheItems,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].OutputCacheCurrentItems),
+			float64(dst_cache[0].OutputCacheCurrentItems),
-	)
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_OutputCacheMemoryUsage,
+			c.ServiceCache_OutputCacheMemoryUsage,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].OutputCacheCurrentMemoryUsage),
+			float64(dst_cache[0].OutputCacheCurrentMemoryUsage),
-	)
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_OutputCacheQueriesTotal,
+			c.ServiceCache_OutputCacheQueriesTotal,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].OutputCacheTotalHits+dst_cache[0].OutputCacheTotalMisses),
+			float64(dst_cache[0].OutputCacheTotalHits+dst_cache[0].OutputCacheTotalMisses),
-	)
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_OutputCacheHitsTotal,
+			c.ServiceCache_OutputCacheHitsTotal,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].OutputCacheTotalHits),
+			float64(dst_cache[0].OutputCacheTotalHits),
-	)
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_OutputCacheFlushedItemsTotal,
+			c.ServiceCache_OutputCacheFlushedItemsTotal,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].OutputCacheTotalFlushedItems),
+			float64(dst_cache[0].OutputCacheTotalFlushedItems),
-	)
+		)
 
-	ch <- prometheus.MustNewConstMetric(
+		ch <- prometheus.MustNewConstMetric(
-		c.ServiceCache_OutputCacheFlushesTotal,
+			c.ServiceCache_OutputCacheFlushesTotal,
-		prometheus.CounterValue,
+			prometheus.CounterValue,
-		float64(dst_cache[0].OutputCacheTotalFlushes),
+			float64(dst_cache[0].OutputCacheTotalFlushes),
-	)
+		)
+	}
 
 	return nil, nil
 }

collector/logical_disk.go

@@ -161,7 +161,7 @@ type Win32_PerfRawData_PerfDisk_LogicalDisk struct {
 
 func (c *LogicalDiskCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_PerfDisk_LogicalDisk
-	q := wmi.CreateQuery(&dst, "")
+	q := queryAll(&dst)
 	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}

collector/msmq.go

@@ -3,7 +3,6 @@
 package collector
 
 import (
-	"bytes"
 	"strings"
 
 	"github.com/StackExchange/wmi"
@@ -34,10 +33,7 @@ type Win32_PerfRawData_MSMQ_MSMQQueueCollector struct {
 func NewMSMQCollector() (Collector, error) {
 	const subsystem = "msmq"
 
-	var wc bytes.Buffer
 	if *msmqWhereClause != "" {
-		wc.WriteString("WHERE ")
-		wc.WriteString(*msmqWhereClause)
 		log.Warn("No where-clause specified for msmq collector. This will generate a very large number of metrics!")
 	}
 
@@ -66,7 +62,7 @@ func NewMSMQCollector() (Collector, error) {
 			[]string{"name"},
 			nil,
 		),
-		queryWhereClause: wc.String(),
+		queryWhereClause: *msmqWhereClause,
 	}, nil
 }
 
@@ -91,7 +87,7 @@ type Win32_PerfRawData_MSMQ_MSMQQueue struct {
 
 func (c *Win32_PerfRawData_MSMQ_MSMQQueueCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_MSMQ_MSMQQueue
-	q := wmi.CreateQuery(&dst, c.queryWhereClause)
+	q := queryAllWhere(&dst, c.queryWhereClause)
 	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}

collector/net.go

@@ -169,7 +169,7 @@ type Win32_PerfRawData_Tcpip_NetworkInterface struct {
 func (c *NetworkCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_Tcpip_NetworkInterface
 
-	q := wmi.CreateQuery(&dst, "")
+	q := queryAll(&dst)
 	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}

collector/netframework_clrexceptions.go

@@ -73,7 +73,7 @@ type Win32_PerfRawData_NETFramework_NETCLRExceptions struct {
 
 func (c *NETFramework_NETCLRExceptionsCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_NETFramework_NETCLRExceptions
-	q := wmi.CreateQuery(&dst, "")
+	q := queryAll(&dst)
 	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}

collector/netframework_clrinterop.go

@@ -66,7 +66,7 @@ type Win32_PerfRawData_NETFramework_NETCLRInterop struct {
 
 func (c *NETFramework_NETCLRInteropCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_NETFramework_NETCLRInterop
-	q := wmi.CreateQuery(&dst, "")
+	q := queryAll(&dst)
 	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}

collector/netframework_clrjit.go

@@ -75,7 +75,7 @@ type Win32_PerfRawData_NETFramework_NETCLRJit struct {
 
 func (c *NETFramework_NETCLRJitCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_NETFramework_NETCLRJit
-	q := wmi.CreateQuery(&dst, "")
+	q := queryAll(&dst)
 	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}

collector/netframework_clrloading.go

@@ -119,7 +119,7 @@ type Win32_PerfRawData_NETFramework_NETCLRLoading struct {
 
 func (c *NETFramework_NETCLRLoadingCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_NETFramework_NETCLRLoading
-	q := wmi.CreateQuery(&dst, "")
+	q := queryAll(&dst)
 	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}

collector/netframework_clrlocksandthreads.go

@@ -99,7 +99,7 @@ type Win32_PerfRawData_NETFramework_NETCLRLocksAndThreads struct {
 
 func (c *NETFramework_NETCLRLocksAndThreadsCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_NETFramework_NETCLRLocksAndThreads
-	q := wmi.CreateQuery(&dst, "")
+	q := queryAll(&dst)
 	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}

collector/netframework_clrmemory.go

@@ -151,7 +151,7 @@ type Win32_PerfRawData_NETFramework_NETCLRMemory struct {
 
 func (c *NETFramework_NETCLRMemoryCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_NETFramework_NETCLRMemory
-	q := wmi.CreateQuery(&dst, "")
+	q := queryAll(&dst)
 	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}

collector/netframework_clrremoting.go

@@ -89,7 +89,7 @@ type Win32_PerfRawData_NETFramework_NETCLRRemoting struct {
 
 func (c *NETFramework_NETCLRRemotingCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_NETFramework_NETCLRRemoting
-	q := wmi.CreateQuery(&dst, "")
+	q := queryAll(&dst)
 	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}

collector/netframework_clrsecurity.go

@@ -74,7 +74,7 @@ type Win32_PerfRawData_NETFramework_NETCLRSecurity struct {
 
 func (c *NETFramework_NETCLRSecurityCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_NETFramework_NETCLRSecurity
-	q := wmi.CreateQuery(&dst, "")
+	q := queryAll(&dst)
 	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}

collector/os.go

@@ -137,7 +137,8 @@ type Win32_OperatingSystem struct {
 
 func (c *OSCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_OperatingSystem
-	if err := wmi.Query(wmi.CreateQuery(&dst, ""), &dst); err != nil {
+	q := queryAll(&dst)
+	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}
 

collector/process.go

@@ -3,7 +3,6 @@
 package collector
 
 import (
-	"bytes"
 	"strconv"
 	"strings"
 
@@ -47,11 +46,7 @@ type ProcessCollector struct {
 func NewProcessCollector() (Collector, error) {
 	const subsystem = "process"
 
-	var wc bytes.Buffer
+	if *processWhereClause == "" {
-	if *processWhereClause != "" {
-		wc.WriteString("WHERE ")
-		wc.WriteString(*processWhereClause)
-	} else {
 		log.Warn("No where-clause specified for process collector. This will generate a very large number of metrics!")
 	}
 
@@ -134,7 +129,7 @@ func NewProcessCollector() (Collector, error) {
 			[]string{"process", "process_id", "creating_process_id"},
 			nil,
 		),
-		queryWhereClause: wc.String(),
+		queryWhereClause: *processWhereClause,
 	}, nil
 }
 
@@ -184,7 +179,7 @@ type Win32_PerfRawData_PerfProc_Process struct {
 
 func (c *ProcessCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_PerfProc_Process
-	q := wmi.CreateQuery(&dst, c.queryWhereClause)
+	q := queryAllWhere(&dst, c.queryWhereClause)
 	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}

collector/service.go

@@ -3,7 +3,6 @@
 package collector
 
 import (
-	"bytes"
 	"strings"
 
 	"github.com/StackExchange/wmi"
@@ -27,6 +26,7 @@ var (
 type serviceCollector struct {
 	State     *prometheus.Desc
 	StartMode *prometheus.Desc
+	Status    *prometheus.Desc
 
 	queryWhereClause string
 }
@@ -35,11 +35,7 @@ type serviceCollector struct {
 func NewserviceCollector() (Collector, error) {
 	const subsystem = "service"
 
-	var wc bytes.Buffer
+	if *serviceWhereClause == "" {
-	if *serviceWhereClause != "" {
-		wc.WriteString("WHERE ")
-		wc.WriteString(*serviceWhereClause)
-	} else {
 		log.Warn("No where-clause specified for service collector. This will generate a very large number of metrics!")
 	}
 
@@ -56,7 +52,13 @@ func NewserviceCollector() (Collector, error) {
 			[]string{"name", "start_mode"},
 			nil,
 		),
-		queryWhereClause: wc.String(),
+		Status: prometheus.NewDesc(
+			prometheus.BuildFQName(Namespace, subsystem, "status"),
+			"The status of the service (Status)",
+			[]string{"name", "status"},
+			nil,
+		),
+		queryWhereClause: *serviceWhereClause,
 	}, nil
 }
 
@@ -73,6 +75,7 @@ func (c *serviceCollector) Collect(ch chan<- prometheus.Metric) error {
 type Win32_Service struct {
 	Name      string
 	State     string
+	Status    string
 	StartMode string
 }
 
@@ -94,11 +97,25 @@ var (
 		"manual",
 		"disabled",
 	}
+	allStatuses = []string{
+		"ok",
+		"error",
+		"degraded",
+		"unknown",
+		"pred fail",
+		"starting",
+		"stopping",
+		"service",
+		"stressed",
+		"nonrecover",
+		"no contact",
+		"lost comm",
+	}
 )
 
 func (c *serviceCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_Service
-	q := wmi.CreateQuery(&dst, c.queryWhereClause)
+	q := queryAllWhere(&dst, c.queryWhereClause)
 	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}
@@ -131,6 +148,20 @@ func (c *serviceCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Des
 				startMode,
 			)
 		}
+
+		for _, status := range allStatuses {
+			isCurrentStatus := 0.0
+			if status == strings.ToLower(service.Status) {
+				isCurrentStatus = 1.0
+			}
+			ch <- prometheus.MustNewConstMetric(
+				c.Status,
+				prometheus.GaugeValue,
+				isCurrentStatus,
+				strings.ToLower(service.Name),
+				status,
+			)
+		}
 	}
 	return nil, nil
 }

collector/system.go

@@ -90,7 +90,8 @@ type Win32_PerfRawData_PerfOS_System struct {
 
 func (c *SystemCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_PerfOS_System
-	if err := wmi.Query(wmi.CreateQuery(&dst, ""), &dst); err != nil {
+	q := queryAll(&dst)
+	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}
 

collector/tcp.go

@@ -114,7 +114,7 @@ type Win32_PerfRawData_Tcpip_TCPv4 struct {
 func (c *TCPCollector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_Tcpip_TCPv4
 
-	q := wmi.CreateQuery(&dst, "")
+	q := queryAll(&dst)
 	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}

collector/textfile.go

@@ -17,6 +17,7 @@ package collector
 
 import (
 	"fmt"
+	"io"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -185,6 +186,30 @@ func (c *textFileCollector) exportMTimes(mtimes map[string]time.Time, ch chan<-
 	}
 }
 
+type carriageReturnFilteringReader struct {
+	r io.Reader
+}
+
+// Read returns data from the underlying io.Reader, but with \r filtered out
+func (cr carriageReturnFilteringReader) Read(p []byte) (int, error) {
+	buf := make([]byte, len(p))
+	n, err := cr.r.Read(buf)
+
+	if err != nil && err != io.EOF {
+		return n, err
+	}
+
+	pi := 0
+	for i := 0; i < n; i++ {
+		if buf[i] != '\r' {
+			p[pi] = buf[i]
+			pi++
+		}
+	}
+
+	return pi, err
+}
+
 // Update implements the Collector interface.
 func (c *textFileCollector) Collect(ch chan<- prometheus.Metric) error {
 	error := 0.0
@@ -203,6 +228,7 @@ fileLoop:
 			continue
 		}
 		path := filepath.Join(c.path, f.Name())
+		log.Debugf("Processing file %q", path)
 		file, err := os.Open(path)
 		if err != nil {
 			log.Errorf("Error opening %q: %v", path, err)
@@ -210,7 +236,7 @@ fileLoop:
 			continue
 		}
 		var parser expfmt.TextParser
-		parsedFamilies, err := parser.TextToMetricFamilies(file)
+		parsedFamilies, err := parser.TextToMetricFamilies(carriageReturnFilteringReader{r: file})
 		file.Close()
 		if err != nil {
 			log.Errorf("Error parsing %q: %v", path, err)

collector/textfile_test.go

@@ -0,0 +1,20 @@
+package collector
+
+import (
+	"testing"
+	"strings"
+	"io/ioutil"
+)
+
+func TestCRFilter(t *testing.T) {
+	sr := strings.NewReader("line 1\r\nline 2")
+	cr := carriageReturnFilteringReader{ r: sr }
+	b, err := ioutil.ReadAll(cr)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if string(b) != "line 1\nline 2" {
+		t.Errorf("Unexpected output %q", b)
+	}
+}

collector/vmware.go

@@ -197,7 +197,7 @@ type Win32_PerfRawData_vmGuestLib_VCPU struct {
 
 func (c *VmwareCollector) collectMem(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_vmGuestLib_VMem
-	q := wmi.CreateQuery(&dst, "")
+	q := queryAll(&dst)
 	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}
@@ -283,7 +283,7 @@ func mbToBytes(mb uint64) float64 {
 
 func (c *VmwareCollector) collectCpu(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
 	var dst []Win32_PerfRawData_vmGuestLib_VCPU
-	q := wmi.CreateQuery(&dst, "")
+	q := queryAll(&dst)
 	if err := wmi.Query(q, &dst); err != nil {
 		return nil, err
 	}

collector/wmi.go

@@ -3,9 +3,9 @@ package collector
 import (
 	"bytes"
 	"reflect"
-	"strings"
 
 	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/common/log"
 )
 
 // ...
@@ -25,29 +25,57 @@ type Collector interface {
 	Collect(ch chan<- prometheus.Metric) (err error)
 }
 
-// This is adapted from StackExchange/wmi/wmi.go, and lets us change the class
+func className(src interface{}) string {
-// name being queried for:
-// CreateQuery returns a WQL query string that queries all columns of src. where
-// is an optional string that is appended to the query, to be used with WHERE
-// clauses. In such a case, the "WHERE" string should appear at the beginning.
-func createQuery(src interface{}, class, where string) string {
-	var b bytes.Buffer
-	b.WriteString("SELECT ")
 	s := reflect.Indirect(reflect.ValueOf(src))
 	t := s.Type()
 	if s.Kind() == reflect.Slice {
 		t = t.Elem()
 	}
-	if t.Kind() != reflect.Struct {
+	return t.Name()
-		return ""
+}
-	}
+
-	var fields []string
+func queryAll(src interface{}) string {
-	for i := 0; i < t.NumField(); i++ {
+	var b bytes.Buffer
-		fields = append(fields, t.Field(i).Name)
+	b.WriteString("SELECT * FROM ")
-	}
+	b.WriteString(className(src))
-	b.WriteString(strings.Join(fields, ", "))
+
-	b.WriteString(" FROM ")
+	log.Debugf("Generated WMI query %s", b.String())
-	b.WriteString(class)
+	return b.String()
-	b.WriteString(" " + where)
+}
+
+func queryAllForClass(src interface{}, class string) string {
+	var b bytes.Buffer
+	b.WriteString("SELECT * FROM ")
+	b.WriteString(class)
+
+	log.Debugf("Generated WMI query %s", b.String())
+	return b.String()
+}
+
+func queryAllWhere(src interface{}, where string) string {
+	var b bytes.Buffer
+	b.WriteString("SELECT * FROM ")
+	b.WriteString(className(src))
+
+	if where != "" {
+		b.WriteString(" WHERE ")
+		b.WriteString(where)
+	}
+
+	log.Debugf("Generated WMI query %s", b.String())
+	return b.String()
+}
+
+func queryAllForClassWhere(src interface{}, class string, where string) string {
+	var b bytes.Buffer
+	b.WriteString("SELECT * FROM ")
+	b.WriteString(class)
+
+	if where != "" {
+		b.WriteString(" WHERE ")
+		b.WriteString(where)
+	}
+
+	log.Debugf("Generated WMI query %s", b.String())
 	return b.String()
 }

collector/wmi_test.go

@@ -0,0 +1,115 @@
+package collector
+
+import (
+	"testing"
+)
+
+type fakeWmiClass struct {
+	Name         string
+	SomeProperty int
+}
+
+var (
+	mapQueryAll = func(src interface{}, class string, where string) string {
+		return queryAll(src)
+	}
+	mapQueryAllWhere = func(src interface{}, class string, where string) string {
+		return queryAllWhere(src, where)
+	}
+	mapQueryAllForClass = func(src interface{}, class string, where string) string {
+		return queryAllForClass(src, class)
+	}
+	mapQueryAllForClassWhere = func(src interface{}, class string, where string) string {
+		return queryAllForClassWhere(src, class, where)
+	}
+)
+
+type queryFunc func(src interface{}, class string, where string) string
+
+func TestCreateQuery(t *testing.T) {
+	cases := []struct {
+		desc      string
+		dst       interface{}
+		class     string
+		where     string
+		queryFunc queryFunc
+		expected  string
+	}{
+		{
+			desc:      "queryAll on single instance",
+			dst:       fakeWmiClass{},
+			queryFunc: mapQueryAll,
+			expected:  "SELECT * FROM fakeWmiClass",
+		},
+		{
+			desc:      "queryAll on slice",
+			dst:       []fakeWmiClass{},
+			queryFunc: mapQueryAll,
+			expected:  "SELECT * FROM fakeWmiClass",
+		},
+		{
+			desc:      "queryAllWhere on single instance",
+			dst:       fakeWmiClass{},
+			where:     "foo = bar",
+			queryFunc: mapQueryAllWhere,
+			expected:  "SELECT * FROM fakeWmiClass WHERE foo = bar",
+		},
+		{
+			desc:      "queryAllWhere on slice",
+			dst:       []fakeWmiClass{},
+			where:     "foo = bar",
+			queryFunc: mapQueryAllWhere,
+			expected:  "SELECT * FROM fakeWmiClass WHERE foo = bar",
+		},
+		{
+			desc:      "queryAllWhere on single instance with empty where",
+			dst:       fakeWmiClass{},
+			queryFunc: mapQueryAllWhere,
+			expected:  "SELECT * FROM fakeWmiClass",
+		},
+		{
+			desc:      "queryAllForClass on single instance",
+			dst:       fakeWmiClass{},
+			class:     "someClass",
+			queryFunc: mapQueryAllForClass,
+			expected:  "SELECT * FROM someClass",
+		},
+		{
+			desc:      "queryAllForClass on slice",
+			dst:       []fakeWmiClass{},
+			class:     "someClass",
+			queryFunc: mapQueryAllForClass,
+			expected:  "SELECT * FROM someClass",
+		},
+		{
+			desc:      "queryAllForClassWhere on single instance",
+			dst:       fakeWmiClass{},
+			class:     "someClass",
+			where:     "foo = bar",
+			queryFunc: mapQueryAllForClassWhere,
+			expected:  "SELECT * FROM someClass WHERE foo = bar",
+		},
+		{
+			desc:      "queryAllForClassWhere on slice",
+			dst:       []fakeWmiClass{},
+			class:     "someClass",
+			where:     "foo = bar",
+			queryFunc: mapQueryAllForClassWhere,
+			expected:  "SELECT * FROM someClass WHERE foo = bar",
+		},
+		{
+			desc:      "queryAllForClassWhere on single instance with empty where",
+			dst:       fakeWmiClass{},
+			class:     "someClass",
+			queryFunc: mapQueryAllForClassWhere,
+			expected:  "SELECT * FROM someClass",
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.desc, func(t *testing.T) {
+			if q := c.queryFunc(c.dst, c.class, c.where); q != c.expected {
+				t.Errorf("Case %q failed: Expected %q, got %q", c.desc, c.expected, q)
+			}
+		})
+	}
+}

exporter.go

@@ -47,7 +47,7 @@ var (
 
 	// This can be removed when client_golang exposes this on Windows
 	// (See https://github.com/prometheus/client_golang/issues/376)
-	startTime = float64(time.Now().Unix())
+	startTime     = float64(time.Now().Unix())
 	startTimeDesc = prometheus.NewDesc(
 		"process_start_time_seconds",
 		"Start time of the process since unix epoch in seconds.",
@@ -169,6 +169,7 @@ func initWbem() {
 	if err != nil {
 		log.Fatal(err)
 	}
+	wmi.DefaultClient.AllowMissingFields = true
 	wmi.DefaultClient.SWbemServicesClient = s
 }
 

tools/collector-generator/collector.template

@@ -46,7 +46,7 @@ type {{ .Class }} struct {
 }
 func (c *{{ .CollectorName }}Collector) collect(ch chan<- prometheus.Metric) (*prometheus.Desc, error) {
     var dst []{{ .Class }}
-    q := wmi.CreateQuery(&dst, "")
+    q := queryAll(&dst)
     if err := wmi.Query(q, &dst); err != nil {
         return nil, err
     }