chore: release 0.29.0.rc0 (#1600)

pkg/collector/perfdata/perfdata.go

@@ -0,0 +1,181 @@
+//go:build windows
+
+package perfdata
+
+import (
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"maps"
+	"slices"
+	"strings"
+
+	"github.com/alecthomas/kingpin/v2"
+	"github.com/prometheus-community/windows_exporter/pkg/perfdata"
+	"github.com/prometheus-community/windows_exporter/pkg/types"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/yusufpapurcu/wmi"
+)
+
+const (
+	Name = "perfdata"
+)
+
+type Config struct {
+	Objects []Object `yaml:"objects"`
+}
+
+var ConfigDefaults = Config{
+	Objects: make([]Object, 0),
+}
+
+// A Collector is a Prometheus collector for perfdata metrics.
+type Collector struct {
+	config Config
+}
+
+func New(config *Config) *Collector {
+	if config == nil {
+		config = &ConfigDefaults
+	}
+
+	if config.Objects == nil {
+		config.Objects = ConfigDefaults.Objects
+	}
+
+	c := &Collector{
+		config: *config,
+	}
+
+	return c
+}
+
+func NewWithFlags(app *kingpin.Application) *Collector {
+	c := &Collector{
+		config: ConfigDefaults,
+	}
+
+	var objects string
+
+	app.Flag(
+		"collector.perfdata.objects",
+		"Objects of performance data to observe. See docs for more information on how to use this flag. By default, no objects are observed.",
+	).Default("").StringVar(&objects)
+
+	app.Action(func(*kingpin.ParseContext) error {
+		if objects == "" {
+			return nil
+		}
+
+		if err := json.Unmarshal([]byte(objects), &c.config.Objects); err != nil {
+			return fmt.Errorf("failed to parse objects: %w", err)
+		}
+
+		return nil
+	})
+
+	return c
+}
+
+func (c *Collector) GetName() string {
+	return Name
+}
+
+func (c *Collector) GetPerfCounter(_ *slog.Logger) ([]string, error) {
+	return []string{}, nil
+}
+
+func (c *Collector) Close(_ *slog.Logger) error {
+	for _, object := range c.config.Objects {
+		object.collector.Close()
+	}
+
+	return nil
+}
+
+func (c *Collector) Build(logger *slog.Logger, _ *wmi.Client) error {
+	logger.Warn("The perfdata collector is in an experimental state! The configuration may change in future. Please report any issues.")
+
+	for i, object := range c.config.Objects {
+		collector, err := perfdata.NewCollector(object.Object, object.Instances, slices.Sorted(maps.Keys(object.Counters)))
+		if err != nil {
+			return fmt.Errorf("failed to create pdh collector: %w", err)
+		}
+
+		if object.InstanceLabel == "" {
+			c.config.Objects[i].InstanceLabel = "instance"
+		}
+
+		c.config.Objects[i].collector = collector
+	}
+
+	return nil
+}
+
+// Collect sends the metric values for each metric
+// to the provided prometheus Metric channel.
+func (c *Collector) Collect(_ *types.ScrapeContext, logger *slog.Logger, ch chan<- prometheus.Metric) error {
+	if err := c.collect(ch); err != nil {
+		logger.Error("failed collecting performance data metrics",
+			slog.Any("err", err),
+		)
+
+		return err
+	}
+
+	return nil
+}
+
+func (c *Collector) collect(ch chan<- prometheus.Metric) error {
+	for _, object := range c.config.Objects {
+		data, err := object.collector.Collect()
+		if err != nil {
+			return fmt.Errorf("failed to collect data: %w", err)
+		}
+
+		for instance, counters := range data {
+			for counter, value := range counters {
+				var labels prometheus.Labels
+				if instance != perfdata.EmptyInstance {
+					labels = prometheus.Labels{object.InstanceLabel: instance}
+				}
+
+				metricType := value.Type
+
+				if val, ok := object.Counters[counter]; ok {
+					switch val.Type {
+					case "counter":
+						metricType = prometheus.CounterValue
+					case "gauge":
+						metricType = prometheus.GaugeValue
+					}
+				}
+
+				ch <- prometheus.MustNewConstMetric(
+					prometheus.NewDesc(
+						sanitizeMetricName(fmt.Sprintf("%s_perfdata_%s_%s", types.Namespace, object.Object, counter)),
+						fmt.Sprintf("Performance data for \\%s\\%s", object.Object, counter),
+						nil,
+						labels,
+					),
+					metricType,
+					value.FirstValue,
+				)
+			}
+		}
+	}
+
+	return nil
+}
+
+func sanitizeMetricName(name string) string {
+	replacer := strings.NewReplacer(
+		".", "",
+		"%", "",
+		"/", "_",
+		" ", "_",
+		"-", "_",
+	)
+
+	return strings.Trim(replacer.Replace(strings.ToLower(name)), "_")
+}

pkg/collector/perfdata/perfdata_collector_test.go

@@ -0,0 +1,87 @@
+//go:build windows
+
+package perfdata_test
+
+import (
+	"fmt"
+	"io"
+	"log/slog"
+	"net/http"
+	"net/http/httptest"
+	"regexp"
+	"testing"
+
+	"github.com/prometheus-community/windows_exporter/pkg/collector/perfdata"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+type collectorAdapter struct {
+	perfdata.Collector
+}
+
+// Describe implements the prometheus.Collector interface.
+func (a collectorAdapter) Describe(_ chan<- *prometheus.Desc) {}
+
+// Collect implements the prometheus.Collector interface.
+func (a collectorAdapter) Collect(ch chan<- prometheus.Metric) {
+	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
+
+	if err := a.Collector.Collect(nil, logger, ch); err != nil {
+		panic(fmt.Sprintf("failed to update collector: %v", err))
+	}
+}
+
+func TestCollector(t *testing.T) {
+	t.Parallel()
+
+	for _, tc := range []struct {
+		object          string
+		instances       []string
+		counters        map[string]perfdata.Counter
+		expectedMetrics *regexp.Regexp
+	}{
+		{
+			object:          "Memory",
+			instances:       nil,
+			counters:        map[string]perfdata.Counter{"Available Bytes": {Type: "gauge"}},
+			expectedMetrics: regexp.MustCompile(`^# HELP windows_perfdata_memory_available_bytes Performance data for \\\\Memory\\\\Available Bytes\s*# TYPE windows_perfdata_memory_available_bytes gauge\s*windows_perfdata_memory_available_bytes \d`),
+		},
+		{
+			object:          "Process",
+			instances:       []string{"*"},
+			counters:        map[string]perfdata.Counter{"Thread Count": {Type: "counter"}},
+			expectedMetrics: regexp.MustCompile(`^# HELP windows_perfdata_process_thread_count Performance data for \\\\Process\\\\Thread Count\s*# TYPE windows_perfdata_process_thread_count counter\s*windows_perfdata_process_thread_count\{instance=".+"} \d`),
+		},
+	} {
+		t.Run(tc.object, func(t *testing.T) {
+			t.Parallel()
+
+			perfDataCollector := perfdata.New(&perfdata.Config{
+				Objects: []perfdata.Object{
+					{
+						Object:    tc.object,
+						Instances: tc.instances,
+						Counters:  tc.counters,
+					},
+				},
+			})
+
+			logger := slog.New(slog.NewTextHandler(io.Discard, nil))
+			err := perfDataCollector.Build(logger, nil)
+			require.NoError(t, err)
+
+			registry := prometheus.NewRegistry()
+			registry.MustRegister(collectorAdapter{*perfDataCollector})
+
+			rw := httptest.NewRecorder()
+			promhttp.HandlerFor(registry, promhttp.HandlerOpts{ErrorHandling: promhttp.ContinueOnError}).ServeHTTP(rw, &http.Request{})
+			got := rw.Body.String()
+
+			assert.NotEmpty(t, got)
+			assert.Regexp(t, tc.expectedMetrics, got)
+		})
+	}
+}

pkg/collector/perfdata/perfdata_test.go

@@ -0,0 +1,18 @@
+//go:build windows
+
+package perfdata_test
+
+import (
+	"testing"
+
+	"github.com/alecthomas/kingpin/v2"
+	"github.com/prometheus-community/windows_exporter/pkg/collector/perfdata"
+	"github.com/prometheus-community/windows_exporter/pkg/testutils"
+)
+
+func BenchmarkCollector(b *testing.B) {
+	perfDataObjects := `[{"object":"Processor Information","instances":["*"],"counters":{"*": {}}}]`
+	kingpin.CommandLine.GetArg("collector.perfdata.objects").StringVar(&perfDataObjects)
+
+	testutils.FuncBenchmarkCollector(b, perfdata.Name, perfdata.NewWithFlags)
+}

pkg/collector/perfdata/types.go

@@ -0,0 +1,18 @@
+package perfdata
+
+import (
+	"github.com/prometheus-community/windows_exporter/pkg/perfdata"
+)
+
+type Object struct {
+	Object        string             `json:"object"         yaml:"object"`
+	Instances     []string           `json:"instances"      yaml:"instances"`
+	Counters      map[string]Counter `json:"counters"       yaml:"counters"`
+	InstanceLabel string             `json:"instance_label" yaml:"instance_label"` //nolint:tagliatelle
+
+	collector *perfdata.Collector
+}
+
+type Counter struct {
+	Type string `json:"type" yaml:"type"`
+}