udp: Added UDP collector (#1725)

internal/collector/tcp/tcp.go

@@ -3,6 +3,7 @@
 package tcp
 
 import (
+	"errors"
 	"fmt"
 	"log/slog"
 	"slices"
@@ -97,6 +98,11 @@ func (c *Collector) GetPerfCounter(_ *slog.Logger) ([]string, error) {
 }
 
 func (c *Collector) Close(_ *slog.Logger) error {
+	if slices.Contains(c.config.CollectorsEnabled, "metrics") {
+		c.perfDataCollector4.Close()
+		c.perfDataCollector6.Close()
+	}
+
 	return nil
 }
 
@@ -115,12 +121,12 @@ func (c *Collector) Build(_ *slog.Logger, _ *mi.Session) error {
 
 	var err error
 
-	c.perfDataCollector4, err = perfdata.NewCollector(perfdata.V1, "TCPv4", nil, counters)
+	c.perfDataCollector4, err = perfdata.NewCollector(perfdata.V2, "TCPv4", nil, counters)
 	if err != nil {
 		return fmt.Errorf("failed to create TCPv4 collector: %w", err)
 	}
 
-	c.perfDataCollector6, err = perfdata.NewCollector(perfdata.V1, "TCPv6", nil, counters)
+	c.perfDataCollector6, err = perfdata.NewCollector(perfdata.V2, "TCPv6", nil, counters)
 	if err != nil {
 		return fmt.Errorf("failed to create TCPv6 collector: %w", err)
 	}
@@ -190,30 +196,22 @@ func (c *Collector) Build(_ *slog.Logger, _ *mi.Session) error {
 
 // 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 {
-	logger = logger.With(slog.String("collector", Name))
+func (c *Collector) Collect(_ *types.ScrapeContext, _ *slog.Logger, ch chan<- prometheus.Metric) error {
+	errs := make([]error, 0, 2)
 
 	if slices.Contains(c.config.CollectorsEnabled, "metrics") {
 		if err := c.collect(ch); err != nil {
-			logger.Error("failed collecting tcp metrics",
-				slog.Any("err", err),
-			)
-
-			return err
+			errs = append(errs, fmt.Errorf("failed collecting tcp metrics: %w", err))
 		}
 	}
 
 	if slices.Contains(c.config.CollectorsEnabled, "connections_state") {
 		if err := c.collectConnectionsState(ch); err != nil {
-			logger.Error("failed collecting tcp connection state metrics",
-				slog.Any("err", err),
-			)
-
-			return err
+			errs = append(errs, fmt.Errorf("failed collecting tcp connection state metrics: %w", err))
 		}
 	}
 
-	return nil
+	return errors.Join(errs...)
 }
 
 func (c *Collector) collect(ch chan<- prometheus.Metric) error {

internal/collector/time/time.go

@@ -145,7 +145,7 @@ func (c *Collector) Collect(ctx *types.ScrapeContext, logger *slog.Logger, ch ch
 
 // Perflib "Windows Time Service".
 type windowsTime struct {
-	ClockFrequencyAdjustmentPPBTotal float64 `perflib:"Clock Frequency Adjustment (ppb)"`
+	ClockFrequencyAdjustmentPPBTotal float64 `perflib:"Clock Frequency Adjustment (PPB)"`
 	ComputedTimeOffset               float64 `perflib:"Computed Time Offset"`
 	NTPClientTimeSourceCount         float64 `perflib:"NTP Client Time Source Count"`
 	NTPRoundTripDelay                float64 `perflib:"NTP Roundtrip Delay"`

internal/collector/udp/const.go

@@ -0,0 +1,15 @@
+package udp
+
+// The TCPv6 performance object uses the same fields.
+// https://learn.microsoft.com/en-us/dotnet/api/system.net.networkinformation.tcpstate?view=net-8.0.
+const (
+	datagramsNoPortPerSec   = "Datagrams No Port/sec"
+	datagramsReceivedPerSec = "Datagrams Received/sec"
+	datagramsReceivedErrors = "Datagrams Received Errors"
+	datagramsSentPerSec     = "Datagrams Sent/sec"
+)
+
+// Datagrams No Port/sec is the rate of received UDP datagrams for which there was no application at the destination port.
+// Datagrams Received Errors is the number of received UDP datagrams that could not be delivered for reasons other than the lack of an application at the destination port.
+// Datagrams Received/sec is the rate at which UDP datagrams are delivered to UDP users.
+// Datagrams Sent/sec is the rate at which UDP datagrams are sent from the entity.

internal/collector/udp/udp.go

@@ -0,0 +1,168 @@
+//go:build windows
+
+package udp
+
+import (
+	"fmt"
+	"log/slog"
+
+	"github.com/alecthomas/kingpin/v2"
+	"github.com/prometheus-community/windows_exporter/internal/mi"
+	"github.com/prometheus-community/windows_exporter/internal/perfdata"
+	"github.com/prometheus-community/windows_exporter/internal/perfdata/perftypes"
+	"github.com/prometheus-community/windows_exporter/internal/types"
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+const Name = "udp"
+
+type Config struct{}
+
+var ConfigDefaults = Config{}
+
+// A Collector is a Prometheus Collector for WMI Win32_PerfRawData_Tcpip_TCPv{4,6} metrics.
+type Collector struct {
+	config Config
+
+	perfDataCollector4 perfdata.Collector
+	perfDataCollector6 perfdata.Collector
+
+	datagramsNoPortTotal         *prometheus.Desc
+	datagramsReceivedTotal       *prometheus.Desc
+	datagramsReceivedErrorsTotal *prometheus.Desc
+	datagramsSentTotal           *prometheus.Desc
+}
+
+func New(config *Config) *Collector {
+	if config == nil {
+		config = &ConfigDefaults
+	}
+
+	c := &Collector{
+		config: *config,
+	}
+
+	return c
+}
+
+func NewWithFlags(_ *kingpin.Application) *Collector {
+	c := &Collector{
+		config: ConfigDefaults,
+	}
+
+	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 {
+	c.perfDataCollector4.Close()
+	c.perfDataCollector6.Close()
+
+	return nil
+}
+
+func (c *Collector) Build(_ *slog.Logger, _ *mi.Session) error {
+	counters := []string{
+		datagramsNoPortPerSec,
+		datagramsReceivedPerSec,
+		datagramsReceivedErrors,
+		datagramsSentPerSec,
+	}
+
+	var err error
+
+	c.perfDataCollector4, err = perfdata.NewCollector(perfdata.V2, "UDPv4", nil, counters)
+	if err != nil {
+		return fmt.Errorf("failed to create UDPv4 collector: %w", err)
+	}
+
+	c.perfDataCollector6, err = perfdata.NewCollector(perfdata.V2, "UDPv6", nil, counters)
+	if err != nil {
+		return fmt.Errorf("failed to create UDPv6 collector: %w", err)
+	}
+
+	c.datagramsNoPortTotal = prometheus.NewDesc(
+		prometheus.BuildFQName(types.Namespace, Name, "datagram_no_port_total"),
+		"Number of received UDP datagrams for which there was no application at the destination port",
+		[]string{"af"},
+		nil,
+	)
+	c.datagramsReceivedTotal = prometheus.NewDesc(
+		prometheus.BuildFQName(types.Namespace, Name, "datagram_received_total"),
+		"UDP datagrams are delivered to UDP users",
+		[]string{"af"},
+		nil,
+	)
+	c.datagramsReceivedErrorsTotal = prometheus.NewDesc(
+		prometheus.BuildFQName(types.Namespace, Name, "datagram_received_errors_total"),
+		"Number of received UDP datagrams that could not be delivered for reasons other than the lack of an application at the destination port",
+		[]string{"af"},
+		nil,
+	)
+	c.datagramsSentTotal = prometheus.NewDesc(
+		prometheus.BuildFQName(types.Namespace, Name, "datagram_sent_total"),
+		"UDP datagrams are sent from the entity",
+		[]string{"af"},
+		nil,
+	)
+
+	return nil
+}
+
+// Collect sends the metric values for each metric
+// to the provided prometheus Metric channel.
+func (c *Collector) Collect(_ *types.ScrapeContext, _ *slog.Logger, ch chan<- prometheus.Metric) error {
+	return c.collect(ch)
+}
+
+func (c *Collector) collect(ch chan<- prometheus.Metric) error {
+	data, err := c.perfDataCollector4.Collect()
+	if err != nil {
+		return fmt.Errorf("failed to collect UDPv4 metrics: %w", err)
+	}
+
+	c.writeUDPCounters(ch, data[perftypes.EmptyInstance], []string{"ipv4"})
+
+	data, err = c.perfDataCollector6.Collect()
+	if err != nil {
+		return fmt.Errorf("failed to collect UDPv6 metrics: %w", err)
+	}
+
+	c.writeUDPCounters(ch, data[perftypes.EmptyInstance], []string{"ipv6"})
+
+	return nil
+}
+
+func (c *Collector) writeUDPCounters(ch chan<- prometheus.Metric, metrics map[string]perftypes.CounterValues, labels []string) {
+	ch <- prometheus.MustNewConstMetric(
+		c.datagramsNoPortTotal,
+		prometheus.CounterValue,
+		metrics[datagramsNoPortPerSec].FirstValue,
+		labels...,
+	)
+	ch <- prometheus.MustNewConstMetric(
+		c.datagramsReceivedErrorsTotal,
+		prometheus.CounterValue,
+		metrics[datagramsReceivedErrors].FirstValue,
+		labels...,
+	)
+	ch <- prometheus.MustNewConstMetric(
+		c.datagramsReceivedTotal,
+		prometheus.GaugeValue,
+		metrics[datagramsReceivedPerSec].FirstValue,
+		labels...,
+	)
+	ch <- prometheus.MustNewConstMetric(
+		c.datagramsSentTotal,
+		prometheus.CounterValue,
+		metrics[datagramsSentPerSec].FirstValue,
+		labels...,
+	)
+}

internal/collector/udp/udp_test.go

@@ -0,0 +1,16 @@
+package udp_test
+
+import (
+	"testing"
+
+	"github.com/prometheus-community/windows_exporter/internal/collector/udp"
+	"github.com/prometheus-community/windows_exporter/internal/testutils"
+)
+
+func BenchmarkCollector(b *testing.B) {
+	testutils.FuncBenchmarkCollector(b, udp.Name, udp.NewWithFlags)
+}
+
+func TestCollector(t *testing.T) {
+	testutils.TestCollector(t, udp.New, nil)
+}