chore: release 0.29.0.rc0 (#1600)

pkg/collector/system/system.go

@@ -3,9 +3,10 @@
 package system
 
 import (
+	"errors"
+	"log/slog"
+
 	"github.com/alecthomas/kingpin/v2"
-	"github.com/go-kit/log"
-	"github.com/go-kit/log/level"
 	"github.com/prometheus-community/windows_exporter/pkg/perflib"
 	"github.com/prometheus-community/windows_exporter/pkg/types"
 	"github.com/prometheus/client_golang/prometheus"
@@ -25,6 +26,8 @@ type Collector struct {
 	contextSwitchesTotal     *prometheus.Desc
 	exceptionDispatchesTotal *prometheus.Desc
 	processorQueueLength     *prometheus.Desc
+	processes                *prometheus.Desc
+	processesLimit           *prometheus.Desc
 	systemCallsTotal         *prometheus.Desc
 	systemUpTime             *prometheus.Desc
 	threads                  *prometheus.Desc
@@ -50,15 +53,15 @@ func (c *Collector) GetName() string {
 	return Name
 }
 
-func (c *Collector) GetPerfCounter(_ log.Logger) ([]string, error) {
+func (c *Collector) GetPerfCounter(_ *slog.Logger) ([]string, error) {
 	return []string{"System"}, nil
 }
 
-func (c *Collector) Close() error {
+func (c *Collector) Close(_ *slog.Logger) error {
 	return nil
 }
 
-func (c *Collector) Build(_ log.Logger, _ *wmi.Client) error {
+func (c *Collector) Build(_ *slog.Logger, _ *wmi.Client) error {
 	c.contextSwitchesTotal = prometheus.NewDesc(
 		prometheus.BuildFQName(types.Namespace, Name, "context_switches_total"),
 		"Total number of context switches (WMI source: PerfOS_System.ContextSwitchesPersec)",
@@ -71,6 +74,19 @@ func (c *Collector) Build(_ log.Logger, _ *wmi.Client) error {
 		nil,
 		nil,
 	)
+	c.processes = prometheus.NewDesc(
+		prometheus.BuildFQName(types.Namespace, Name, "processes"),
+		"Current number of processes (WMI source: PerfOS_System.Processes)",
+		nil,
+		nil,
+	)
+	c.processesLimit = prometheus.NewDesc(
+		prometheus.BuildFQName(types.Namespace, Name, "processes_limit"),
+		"Maximum number of processes.",
+		nil,
+		nil,
+	)
+
 	c.processorQueueLength = prometheus.NewDesc(
 		prometheus.BuildFQName(types.Namespace, Name, "processor_queue_length"),
 		"Length of processor queue (WMI source: PerfOS_System.ProcessorQueueLength)",
@@ -95,17 +111,22 @@ func (c *Collector) Build(_ log.Logger, _ *wmi.Client) error {
 		nil,
 		nil,
 	)
+
 	return nil
 }
 
 // Collect sends the metric values for each metric
 // to the provided prometheus Metric channel.
-func (c *Collector) Collect(ctx *types.ScrapeContext, logger log.Logger, ch chan<- prometheus.Metric) error {
-	logger = log.With(logger, "collector", Name)
+func (c *Collector) Collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+	logger = logger.With(slog.String("collector", Name))
 	if err := c.collect(ctx, logger, ch); err != nil {
-		_ = level.Error(logger).Log("msg", "failed collecting system metrics", "err", err)
+		logger.Error("failed collecting system metrics",
+			slog.Any("err", err),
+		)
+
 		return err
 	}
+
 	return nil
 }
 
@@ -117,16 +138,23 @@ type system struct {
 	ProcessorQueueLength      float64 `perflib:"Processor Queue Length"`
 	SystemCallsPersec         float64 `perflib:"System Calls/sec"`
 	SystemUpTime              float64 `perflib:"System Up Time"`
+	Processes                 float64 `perflib:"Processes"`
 	Threads                   float64 `perflib:"Threads"`
 }
 
-func (c *Collector) collect(ctx *types.ScrapeContext, logger log.Logger, ch chan<- prometheus.Metric) error {
-	logger = log.With(logger, "collector", Name)
+func (c *Collector) collect(ctx *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+	logger = logger.With(slog.String("collector", Name))
+
 	var dst []system
+
 	if err := perflib.UnmarshalObject(ctx.PerfObjects["System"], &dst, logger); err != nil {
 		return err
 	}
 
+	if len(dst) == 0 {
+		return errors.New("no data returned from Performance Counter")
+	}
+
 	ch <- prometheus.MustNewConstMetric(
 		c.contextSwitchesTotal,
 		prometheus.CounterValue,
@@ -142,6 +170,11 @@ func (c *Collector) collect(ctx *types.ScrapeContext, logger log.Logger, ch chan
 		prometheus.GaugeValue,
 		dst[0].ProcessorQueueLength,
 	)
+	ch <- prometheus.MustNewConstMetric(
+		c.processes,
+		prometheus.GaugeValue,
+		dst[0].Processes,
+	)
 	ch <- prometheus.MustNewConstMetric(
 		c.systemCallsTotal,
 		prometheus.CounterValue,
@@ -157,5 +190,15 @@ func (c *Collector) collect(ctx *types.ScrapeContext, logger log.Logger, ch chan
 		prometheus.GaugeValue,
 		dst[0].Threads,
 	)
+
+	// Windows has no defined limit, and is based off available resources. This currently isn't calculated by WMI and is set to default value.
+	// https://techcommunity.microsoft.com/t5/windows-blog-archive/pushing-the-limits-of-windows-processes-and-threads/ba-p/723824
+	// https://docs.microsoft.com/en-us/windows/win32/cimwin32prov/win32-operatingsystem
+	ch <- prometheus.MustNewConstMetric(
+		c.processesLimit,
+		prometheus.GaugeValue,
+		float64(4294967295),
+	)
+
 	return nil
 }