From f0dbecf0610c35efcded699250b57a48a1b69ca4 Mon Sep 17 00:00:00 2001 From: Danilo Egea Gondolfo Date: Fri, 25 Apr 2025 15:30:17 +0100 Subject: [PATCH 1/5] netstat_freebsd: refactoring Make the code testable and more maintainable: - Encapsulate all the CGO code so it can be tested - Fix the test file (it wasn't compiling) and improve tests - Mock the data returned by unix.SysctlRaw so the code can be tested without actually calling sysctl. No change in behavior intended Signed-off-by: Danilo Egea Gondolfo --- collector/netstat_freebsd.go | 118 +++++++++++++++++++++--------- collector/netstat_freebsd_test.go | 35 ++++++--- 2 files changed, 107 insertions(+), 46 deletions(-) diff --git a/collector/netstat_freebsd.go b/collector/netstat_freebsd.go index 3c34d8b33c..61a5f26c7e 100644 --- a/collector/netstat_freebsd.go +++ b/collector/netstat_freebsd.go @@ -37,19 +37,63 @@ import ( import "C" var ( - bsdNetstatTcpSendPacketsTotal = prometheus.NewDesc( - prometheus.BuildFQName(namespace, "netstat", "tcp_transmit_packets_total"), - "TCP packets sent", - nil, nil, - ) - - bsdNetstatTcpRecvPacketsTotal = prometheus.NewDesc( - prometheus.BuildFQName(namespace, "netstat", "tcp_receive_packets_total"), - "TCP packets received", - nil, nil, - ) + sysctlRaw = unix.SysctlRaw + tcpSendTotal = "bsdNetstatTcpSendPacketsTotal" + tcpRecvTotal = "bsdNetstatTcpRecvPacketsTotal" + + counterMetrics = map[string]*prometheus.Desc{ + tcpSendTotal: prometheus.NewDesc( + prometheus.BuildFQName(namespace, "netstat", "tcp_transmit_packets_total"), + "TCP packets sent", nil, nil), + tcpRecvTotal: prometheus.NewDesc( + prometheus.BuildFQName(namespace, "netstat", "tcp_receive_packets_total"), + "TCP packets received", nil, nil), + } ) +type NetstatData struct { + structSize int + sysctl string +} + +type NetstatMetrics map[string]float64 + +type NetstatTCPData NetstatData + +func NewTCPStat() *NetstatTCPData { + return &NetstatTCPData{ + structSize: int(unsafe.Sizeof(C.struct_tcpstat{})), + sysctl: "net.inet.tcp.stats", + } +} + +func (netstatMetric *NetstatTCPData) GetData() (NetstatMetrics, error) { + data, err := getData(netstatMetric.sysctl, netstatMetric.structSize) + if err != nil { + return nil, err + } + + tcpStats := *(*C.struct_tcpstat)(unsafe.Pointer(&data[0])) + + return NetstatMetrics{ + tcpSendTotal: float64(tcpStats.tcps_sndtotal), + tcpRecvTotal: float64(tcpStats.tcps_rcvtotal), + }, nil +} + +func getData(queryString string, expectedSize int) ([]byte, error) { + data, err := sysctlRaw(queryString) + if err != nil { + fmt.Println("Error:", err) + return nil, err + } + + if len(data) < expectedSize { + return nil, errors.New("Data Size mismatch") + } + return data, nil +} + type netStatCollector struct { netStatMetric *prometheus.Desc } @@ -70,39 +114,41 @@ func (c *netStatCollector) Collect(ch chan<- prometheus.Metric) { _ = c.Update(ch) } -func getData(queryString string) ([]byte, error) { - data, err := unix.SysctlRaw(queryString) +func (c *netStatCollector) Update(ch chan<- prometheus.Metric) error { + tcpStats, err := NewTCPStat().GetData() if err != nil { - fmt.Println("Error:", err) - return nil, err + return err } - if len(data) < int(unsafe.Sizeof(C.struct_tcpstat{})) { - return nil, errors.New("Data Size mismatch") - } - return data, nil -} + allStats := make(map[string]float64) -func (c *netStatCollector) Update(ch chan<- prometheus.Metric) error { + for k, v := range tcpStats { + allStats[k] = v + } - tcpData, err := getData("net.inet.tcp.stats") - if err != nil { - return err + for metricKey, metricData := range counterMetrics { + ch <- prometheus.MustNewConstMetric( + metricData, + prometheus.CounterValue, + allStats[metricKey], + ) } - tcpStats := *(*C.struct_tcpstat)(unsafe.Pointer(&tcpData[0])) + return nil +} - ch <- prometheus.MustNewConstMetric( - bsdNetstatTcpSendPacketsTotal, - prometheus.CounterValue, - float64(tcpStats.tcps_sndtotal), - ) +// Used by tests to mock unix.SysctlRaw +func getFreeBSDDataMock(sysctl string) []byte { - ch <- prometheus.MustNewConstMetric( - bsdNetstatTcpRecvPacketsTotal, - prometheus.CounterValue, - float64(tcpStats.tcps_rcvtotal), - ) + if sysctl == "net.inet.tcp.stats" { + tcpStats := C.struct_tcpstat{ + tcps_sndtotal: 1234, + tcps_rcvtotal: 4321, + } + size := int(unsafe.Sizeof(C.struct_tcpstat{})) - return nil + return unsafe.Slice((*byte)(unsafe.Pointer(&tcpStats)), size) + } + + return make([]byte, 0, 0) } diff --git a/collector/netstat_freebsd_test.go b/collector/netstat_freebsd_test.go index 3b3f852335..26ac371ef3 100644 --- a/collector/netstat_freebsd_test.go +++ b/collector/netstat_freebsd_test.go @@ -18,11 +18,16 @@ package collector import ( "github.com/prometheus/client_golang/prometheus" - "golang.org/x/sys/unix" "testing" - "unsafe" ) +func testSetup() { + sysctlRaw = func(name string, _ ...int) ([]byte, error) { + mockData := getFreeBSDDataMock(name) + return mockData, nil + } +} + func TestNetStatCollectorDescribe(t *testing.T) { ch := make(chan *prometheus.Desc, 1) collector := &netStatCollector{ @@ -31,24 +36,34 @@ func TestNetStatCollectorDescribe(t *testing.T) { collector.Describe(ch) desc := <-ch - if want, got := "dummy_metric", desc.String(); want != got { + expected := "Desc{fqName: \"dummy_metric\", help: \"dummy\", constLabels: {}, variableLabels: {}}" + if want, got := expected, desc.String(); want != got { t.Errorf("want %s, got %s", want, got) } } -func TestGetData(t *testing.T) { - data, err := getData("net.inet.tcp.stats") +func TestGetTCPMetrics(t *testing.T) { + testSetup() + + tcpData, err := NewTCPStat().GetData() if err != nil { t.Fatal("unexpected error:", err) } - if got, want := len(data), int(unsafe.Sizeof(unix.TCPStats{})); got < want { - t.Errorf("data length too small: want >= %d, got %d", want, got) + sndTotal := tcpData[tcpSendTotal] + rcvTotal := tcpData[tcpRecvTotal] + + if got, want := sndTotal, float64(1234); got != want { + t.Errorf("unexpected sndTotal value: want %f, got %f", want, got) + } + + if got, want := rcvTotal, float64(4321); got != want { + t.Errorf("unexpected rcvTotal value: want %f, got %f", want, got) } } func TestNetStatCollectorUpdate(t *testing.T) { - ch := make(chan prometheus.Metric, len(metrics)) + ch := make(chan prometheus.Metric, len(counterMetrics)) collector := &netStatCollector{ netStatMetric: prometheus.NewDesc("netstat_metric", "NetStat Metric", nil, nil), } @@ -57,11 +72,11 @@ func TestNetStatCollectorUpdate(t *testing.T) { t.Fatal("unexpected error:", err) } - if got, want := len(ch), len(metrics); got != want { + if got, want := len(ch), len(counterMetrics); got != want { t.Errorf("metric count mismatch: want %d, got %d", want, got) } - for range metrics { + for range len(counterMetrics) { <-ch } } From 5068195d94aaaac67fe6036772e1257bd28915b5 Mon Sep 17 00:00:00 2001 From: Danilo Egea Gondolfo Date: Sun, 27 Apr 2025 14:20:04 +0100 Subject: [PATCH 2/5] netstat_freebsd: add support for some IPv4 metrics Metrics added: - ip4_transmit_packets_total - ip4_transmit_raw_packets_total - ip4_receive_packets_total - ip4_receive_fragments_total - ip4_forward_total - ip4_fast_forward_total - ip4_delivered_total Signed-off-by: Danilo Egea Gondolfo --- collector/netstat_freebsd.go | 88 +++++++++++++++++++++++++++++-- collector/netstat_freebsd_test.go | 30 +++++++++++ 2 files changed, 115 insertions(+), 3 deletions(-) diff --git a/collector/netstat_freebsd.go b/collector/netstat_freebsd.go index 61a5f26c7e..da8ef9b098 100644 --- a/collector/netstat_freebsd.go +++ b/collector/netstat_freebsd.go @@ -33,21 +33,53 @@ import ( #include #include #include +#include */ import "C" var ( - sysctlRaw = unix.SysctlRaw - tcpSendTotal = "bsdNetstatTcpSendPacketsTotal" - tcpRecvTotal = "bsdNetstatTcpRecvPacketsTotal" + sysctlRaw = unix.SysctlRaw + tcpSendTotal = "bsdNetstatTcpSendPacketsTotal" + tcpRecvTotal = "bsdNetstatTcpRecvPacketsTotal" + ipv4SendTotal = "bsdNetstatIPv4SendPacketsTotal" + ipv4RawSendTotal = "bsdNetstatIPv4RawSendPacketsTotal" + ipv4RecvTotal = "bsdNetstatIPv4RecvPacketsTotal" + ipv4RecvFragmentsTotal = "bsdNetstatIPv4RecvFragmentsTotal" + ipv4ForwardTotal = "bsdNetstatIPv4ForwardTotal" + ipv4FastForwardTotal = "bsdNetstatIPv4FastForwardTotal" + ipv4DeliveredTotal = "bsdNetstatIPv4DeliveredTotal" counterMetrics = map[string]*prometheus.Desc{ + // TCP stats tcpSendTotal: prometheus.NewDesc( prometheus.BuildFQName(namespace, "netstat", "tcp_transmit_packets_total"), "TCP packets sent", nil, nil), tcpRecvTotal: prometheus.NewDesc( prometheus.BuildFQName(namespace, "netstat", "tcp_receive_packets_total"), "TCP packets received", nil, nil), + + // IPv4 stats + ipv4SendTotal: prometheus.NewDesc( + prometheus.BuildFQName(namespace, "netstat", "ip4_transmit_packets_total"), + "IPv4 packets sent from this host", nil, nil), + ipv4RawSendTotal: prometheus.NewDesc( + prometheus.BuildFQName(namespace, "netstat", "ip4_transmit_raw_packets_total"), + "IPv4 raw packets generated", nil, nil), + ipv4RecvTotal: prometheus.NewDesc( + prometheus.BuildFQName(namespace, "netstat", "ip4_receive_packets_total"), + "IPv4 packets received", nil, nil), + ipv4RecvFragmentsTotal: prometheus.NewDesc( + prometheus.BuildFQName(namespace, "netstat", "ip4_receive_fragments_total"), + "IPv4 fragments received", nil, nil), + ipv4ForwardTotal: prometheus.NewDesc( + prometheus.BuildFQName(namespace, "netstat", "ip4_forward_total"), + "IPv4 packets forwarded", nil, nil), + ipv4FastForwardTotal: prometheus.NewDesc( + prometheus.BuildFQName(namespace, "netstat", "ip4_fast_forward_total"), + "IPv4 packets fast forwarded", nil, nil), + ipv4DeliveredTotal: prometheus.NewDesc( + prometheus.BuildFQName(namespace, "netstat", "ip4_delivered_total"), + "IPv4 packets delivered to the upper layer (packets for this host)", nil, nil), } ) @@ -81,6 +113,34 @@ func (netstatMetric *NetstatTCPData) GetData() (NetstatMetrics, error) { }, nil } +type NetstatIPv4Data NetstatData + +func NewIPv4Stat() *NetstatIPv4Data { + return &NetstatIPv4Data{ + structSize: int(unsafe.Sizeof(C.struct_ipstat{})), + sysctl: "net.inet.ip.stats", + } +} + +func (netstatMetric *NetstatIPv4Data) GetData() (NetstatMetrics, error) { + data, err := getData(netstatMetric.sysctl, netstatMetric.structSize) + if err != nil { + return nil, err + } + + ipStats := *(*C.struct_ipstat)(unsafe.Pointer(&data[0])) + + return NetstatMetrics{ + ipv4SendTotal: float64(ipStats.ips_localout), + ipv4RawSendTotal: float64(ipStats.ips_rawout), + ipv4RecvTotal: float64(ipStats.ips_total), + ipv4RecvFragmentsTotal: float64(ipStats.ips_fragments), + ipv4ForwardTotal: float64(ipStats.ips_forward), + ipv4FastForwardTotal: float64(ipStats.ips_fastforward), + ipv4DeliveredTotal: float64(ipStats.ips_delivered), + }, nil +} + func getData(queryString string, expectedSize int) ([]byte, error) { data, err := sysctlRaw(queryString) if err != nil { @@ -120,12 +180,21 @@ func (c *netStatCollector) Update(ch chan<- prometheus.Metric) error { return err } + ipv4Stats, err := NewIPv4Stat().GetData() + if err != nil { + return err + } + allStats := make(map[string]float64) for k, v := range tcpStats { allStats[k] = v } + for k, v := range ipv4Stats { + allStats[k] = v + } + for metricKey, metricData := range counterMetrics { ch <- prometheus.MustNewConstMetric( metricData, @@ -148,6 +217,19 @@ func getFreeBSDDataMock(sysctl string) []byte { size := int(unsafe.Sizeof(C.struct_tcpstat{})) return unsafe.Slice((*byte)(unsafe.Pointer(&tcpStats)), size) + } else if sysctl == "net.inet.ip.stats" { + ipStats := C.struct_ipstat{ + ips_localout: 1234, + ips_rawout: 1235, + ips_total: 1236, + ips_fragments: 1237, + ips_forward: 1238, + ips_fastforward: 1239, + ips_delivered: 1240, + } + size := int(unsafe.Sizeof(C.struct_ipstat{})) + + return unsafe.Slice((*byte)(unsafe.Pointer(&ipStats)), size) } return make([]byte, 0, 0) diff --git a/collector/netstat_freebsd_test.go b/collector/netstat_freebsd_test.go index 26ac371ef3..a6b3e44196 100644 --- a/collector/netstat_freebsd_test.go +++ b/collector/netstat_freebsd_test.go @@ -62,6 +62,36 @@ func TestGetTCPMetrics(t *testing.T) { } } +func TestGetIPv4Metrics(t *testing.T) { + testSetup() + + ipv4Data, err := NewIPv4Stat().GetData() + if err != nil { + t.Fatal("unexpected error:", err) + } + + sndTotal := ipv4Data[ipv4SendTotal] + rcvTotal := ipv4Data[ipv4RecvTotal] + forwardTotal := ipv4Data[ipv4ForwardTotal] + deliveredTotal := ipv4Data[ipv4DeliveredTotal] + + if got, want := sndTotal, float64(1234); got != want { + t.Errorf("unexpected sndTotal value: want %f, got %f", want, got) + } + + if got, want := rcvTotal, float64(1236); got != want { + t.Errorf("unexpected rcvTotal value: want %f, got %f", want, got) + } + + if got, want := forwardTotal, float64(1238); got != want { + t.Errorf("unexpected forwardTotal value: want %f, got %f", want, got) + } + + if got, want := deliveredTotal, float64(1240); got != want { + t.Errorf("unexpected deliveredTotal value: want %f, got %f", want, got) + } +} + func TestNetStatCollectorUpdate(t *testing.T) { ch := make(chan prometheus.Metric, len(counterMetrics)) collector := &netStatCollector{ From cbd8cc0eb19d10d2a6a661c61ecea154f07ecd13 Mon Sep 17 00:00:00 2001 From: Danilo Egea Gondolfo Date: Sun, 27 Apr 2025 14:26:37 +0100 Subject: [PATCH 3/5] netstat_freebsd: add support for some IPv6 metrics Metrics added: - ip6_transmit_packets_total - ip6_transmit_raw_packets_total - ip6_receive_packets_total - ip6_receive_fragments_total - ip6_forward_total - ip6_delivered_total Signed-off-by: Danilo Egea Gondolfo --- collector/netstat_freebsd.go | 75 +++++++++++++++++++++++++++++++ collector/netstat_freebsd_test.go | 30 +++++++++++++ 2 files changed, 105 insertions(+) diff --git a/collector/netstat_freebsd.go b/collector/netstat_freebsd.go index da8ef9b098..c367178514 100644 --- a/collector/netstat_freebsd.go +++ b/collector/netstat_freebsd.go @@ -34,6 +34,7 @@ import ( #include #include #include +#include */ import "C" @@ -48,6 +49,12 @@ var ( ipv4ForwardTotal = "bsdNetstatIPv4ForwardTotal" ipv4FastForwardTotal = "bsdNetstatIPv4FastForwardTotal" ipv4DeliveredTotal = "bsdNetstatIPv4DeliveredTotal" + ipv6SendTotal = "bsdNetstatIPv6SendPacketsTotal" + ipv6RawSendTotal = "bsdNetstatIPv6RawSendPacketsTotal" + ipv6RecvTotal = "bsdNetstatIPv6RecvPacketsTotal" + ipv6RecvFragmentsTotal = "bsdNetstatIPv6RecvFragmentsTotal" + ipv6ForwardTotal = "bsdNetstatIPv6ForwardTotal" + ipv6DeliveredTotal = "bsdNetstatIPv6DeliveredTotal" counterMetrics = map[string]*prometheus.Desc{ // TCP stats @@ -80,6 +87,26 @@ var ( ipv4DeliveredTotal: prometheus.NewDesc( prometheus.BuildFQName(namespace, "netstat", "ip4_delivered_total"), "IPv4 packets delivered to the upper layer (packets for this host)", nil, nil), + + // IPv6 stats + ipv6SendTotal: prometheus.NewDesc( + prometheus.BuildFQName(namespace, "netstat", "ip6_transmit_packets_total"), + "IPv6 packets sent from this host", nil, nil), + ipv6RawSendTotal: prometheus.NewDesc( + prometheus.BuildFQName(namespace, "netstat", "ip6_transmit_raw_packets_total"), + "IPv6 raw packets generated", nil, nil), + ipv6RecvTotal: prometheus.NewDesc( + prometheus.BuildFQName(namespace, "netstat", "ip6_receive_packets_total"), + "IPv6 packets received", nil, nil), + ipv6RecvFragmentsTotal: prometheus.NewDesc( + prometheus.BuildFQName(namespace, "netstat", "ip6_receive_fragments_total"), + "IPv6 fragments received", nil, nil), + ipv6ForwardTotal: prometheus.NewDesc( + prometheus.BuildFQName(namespace, "netstat", "ip6_forward_total"), + "IPv6 packets forwarded", nil, nil), + ipv6DeliveredTotal: prometheus.NewDesc( + prometheus.BuildFQName(namespace, "netstat", "ip6_delivered_total"), + "IPv6 packets delivered to the upper layer (packets for this host)", nil, nil), } ) @@ -141,6 +168,33 @@ func (netstatMetric *NetstatIPv4Data) GetData() (NetstatMetrics, error) { }, nil } +type NetstatIPv6Data NetstatData + +func NewIPv6Stat() *NetstatIPv6Data { + return &NetstatIPv6Data{ + structSize: int(unsafe.Sizeof(C.struct_ipstat{})), + sysctl: "net.inet6.ip6.stats", + } +} + +func (netstatMetric *NetstatIPv6Data) GetData() (NetstatMetrics, error) { + data, err := getData(netstatMetric.sysctl, netstatMetric.structSize) + if err != nil { + return nil, err + } + + ipStats := *(*C.struct_ip6stat)(unsafe.Pointer(&data[0])) + + return NetstatMetrics{ + ipv6SendTotal: float64(ipStats.ip6s_localout), + ipv6RawSendTotal: float64(ipStats.ip6s_rawout), + ipv6RecvTotal: float64(ipStats.ip6s_total), + ipv6RecvFragmentsTotal: float64(ipStats.ip6s_fragments), + ipv6ForwardTotal: float64(ipStats.ip6s_forward), + ipv6DeliveredTotal: float64(ipStats.ip6s_delivered), + }, nil +} + func getData(queryString string, expectedSize int) ([]byte, error) { data, err := sysctlRaw(queryString) if err != nil { @@ -185,6 +239,11 @@ func (c *netStatCollector) Update(ch chan<- prometheus.Metric) error { return err } + ipv6Stats, err := NewIPv6Stat().GetData() + if err != nil { + return err + } + allStats := make(map[string]float64) for k, v := range tcpStats { @@ -195,6 +254,10 @@ func (c *netStatCollector) Update(ch chan<- prometheus.Metric) error { allStats[k] = v } + for k, v := range ipv6Stats { + allStats[k] = v + } + for metricKey, metricData := range counterMetrics { ch <- prometheus.MustNewConstMetric( metricData, @@ -229,6 +292,18 @@ func getFreeBSDDataMock(sysctl string) []byte { } size := int(unsafe.Sizeof(C.struct_ipstat{})) + return unsafe.Slice((*byte)(unsafe.Pointer(&ipStats)), size) + } else if sysctl == "net.inet6.ip6.stats" { + ipStats := C.struct_ip6stat{ + ip6s_localout: 1234, + ip6s_rawout: 1235, + ip6s_total: 1236, + ip6s_fragments: 1237, + ip6s_forward: 1238, + ip6s_delivered: 1240, + } + size := int(unsafe.Sizeof(C.struct_ip6stat{})) + return unsafe.Slice((*byte)(unsafe.Pointer(&ipStats)), size) } diff --git a/collector/netstat_freebsd_test.go b/collector/netstat_freebsd_test.go index a6b3e44196..fb70b0530f 100644 --- a/collector/netstat_freebsd_test.go +++ b/collector/netstat_freebsd_test.go @@ -92,6 +92,36 @@ func TestGetIPv4Metrics(t *testing.T) { } } +func TestGetIPv6Metrics(t *testing.T) { + testSetup() + + ipv6Data, err := NewIPv6Stat().GetData() + if err != nil { + t.Fatal("unexpected error:", err) + } + + sndTotal := ipv6Data[ipv6SendTotal] + rcvTotal := ipv6Data[ipv6RecvTotal] + forwardTotal := ipv6Data[ipv6ForwardTotal] + deliveredTotal := ipv6Data[ipv6DeliveredTotal] + + if got, want := sndTotal, float64(1234); got != want { + t.Errorf("unexpected sndTotal value: want %f, got %f", want, got) + } + + if got, want := rcvTotal, float64(1236); got != want { + t.Errorf("unexpected rcvTotal value: want %f, got %f", want, got) + } + + if got, want := forwardTotal, float64(1238); got != want { + t.Errorf("unexpected forwardTotal value: want %f, got %f", want, got) + } + + if got, want := deliveredTotal, float64(1240); got != want { + t.Errorf("unexpected deliveredTotal value: want %f, got %f", want, got) + } +} + func TestNetStatCollectorUpdate(t *testing.T) { ch := make(chan prometheus.Metric, len(counterMetrics)) collector := &netStatCollector{ From 2db27ff2fa2a796537754bab3d8fae95d53f0912 Mon Sep 17 00:00:00 2001 From: Danilo Egea Gondolfo Date: Sun, 27 Apr 2025 14:30:06 +0100 Subject: [PATCH 4/5] netstat_freebsd: add support for some UDP metrics Metrics added: - udp_transmit_packets_total - udp_receive_packets_total Signed-off-by: Danilo Egea Gondolfo --- collector/netstat_freebsd.go | 51 +++++++++++++++++++++++++++++++ collector/netstat_freebsd_test.go | 20 ++++++++++++ 2 files changed, 71 insertions(+) diff --git a/collector/netstat_freebsd.go b/collector/netstat_freebsd.go index c367178514..903e97d254 100644 --- a/collector/netstat_freebsd.go +++ b/collector/netstat_freebsd.go @@ -33,6 +33,7 @@ import ( #include #include #include +#include #include #include */ @@ -42,6 +43,8 @@ var ( sysctlRaw = unix.SysctlRaw tcpSendTotal = "bsdNetstatTcpSendPacketsTotal" tcpRecvTotal = "bsdNetstatTcpRecvPacketsTotal" + udpSendTotal = "bsdNetstatUdpSendPacketsTotal" + udpRecvTotal = "bsdNetstatUdpRecvPacketsTotal" ipv4SendTotal = "bsdNetstatIPv4SendPacketsTotal" ipv4RawSendTotal = "bsdNetstatIPv4RawSendPacketsTotal" ipv4RecvTotal = "bsdNetstatIPv4RecvPacketsTotal" @@ -65,6 +68,14 @@ var ( prometheus.BuildFQName(namespace, "netstat", "tcp_receive_packets_total"), "TCP packets received", nil, nil), + // UDP stats + udpSendTotal: prometheus.NewDesc( + prometheus.BuildFQName(namespace, "netstat", "udp_transmit_packets_total"), + "UDP packets sent", nil, nil), + udpRecvTotal: prometheus.NewDesc( + prometheus.BuildFQName(namespace, "netstat", "udp_receive_packets_total"), + "UDP packets received", nil, nil), + // IPv4 stats ipv4SendTotal: prometheus.NewDesc( prometheus.BuildFQName(namespace, "netstat", "ip4_transmit_packets_total"), @@ -140,6 +151,29 @@ func (netstatMetric *NetstatTCPData) GetData() (NetstatMetrics, error) { }, nil } +type NetstatUDPData NetstatData + +func NewUDPStat() *NetstatUDPData { + return &NetstatUDPData{ + structSize: int(unsafe.Sizeof(C.struct_udpstat{})), + sysctl: "net.inet.udp.stats", + } +} + +func (netstatMetric *NetstatUDPData) GetData() (NetstatMetrics, error) { + data, err := getData(netstatMetric.sysctl, netstatMetric.structSize) + if err != nil { + return nil, err + } + + udpStats := *(*C.struct_udpstat)(unsafe.Pointer(&data[0])) + + return NetstatMetrics{ + udpSendTotal: float64(udpStats.udps_opackets), + udpRecvTotal: float64(udpStats.udps_ipackets), + }, nil +} + type NetstatIPv4Data NetstatData func NewIPv4Stat() *NetstatIPv4Data { @@ -234,6 +268,11 @@ func (c *netStatCollector) Update(ch chan<- prometheus.Metric) error { return err } + udpStats, err := NewUDPStat().GetData() + if err != nil { + return err + } + ipv4Stats, err := NewIPv4Stat().GetData() if err != nil { return err @@ -250,6 +289,10 @@ func (c *netStatCollector) Update(ch chan<- prometheus.Metric) error { allStats[k] = v } + for k, v := range udpStats { + allStats[k] = v + } + for k, v := range ipv4Stats { allStats[k] = v } @@ -280,6 +323,14 @@ func getFreeBSDDataMock(sysctl string) []byte { size := int(unsafe.Sizeof(C.struct_tcpstat{})) return unsafe.Slice((*byte)(unsafe.Pointer(&tcpStats)), size) + } else if sysctl == "net.inet.udp.stats" { + udpStats := C.struct_udpstat{ + udps_opackets: 1234, + udps_ipackets: 4321, + } + size := int(unsafe.Sizeof(C.struct_udpstat{})) + + return unsafe.Slice((*byte)(unsafe.Pointer(&udpStats)), size) } else if sysctl == "net.inet.ip.stats" { ipStats := C.struct_ipstat{ ips_localout: 1234, diff --git a/collector/netstat_freebsd_test.go b/collector/netstat_freebsd_test.go index fb70b0530f..3d00f3deab 100644 --- a/collector/netstat_freebsd_test.go +++ b/collector/netstat_freebsd_test.go @@ -62,6 +62,26 @@ func TestGetTCPMetrics(t *testing.T) { } } +func TestGetUDPMetrics(t *testing.T) { + testSetup() + + udpData, err := NewUDPStat().GetData() + if err != nil { + t.Fatal("unexpected error:", err) + } + + sndTotal := udpData[udpSendTotal] + rcvTotal := udpData[udpRecvTotal] + + if got, want := sndTotal, float64(1234); got != want { + t.Errorf("unexpected sndTotal value: want %f, got %f", want, got) + } + + if got, want := rcvTotal, float64(4321); got != want { + t.Errorf("unexpected rcvTotal value: want %f, got %f", want, got) + } +} + func TestGetIPv4Metrics(t *testing.T) { testSetup() From 4bb3f0315debbae7a8efc1d2690a6ccc35a31d29 Mon Sep 17 00:00:00 2001 From: Danilo Egea Gondolfo Date: Sun, 27 Apr 2025 17:22:00 +0100 Subject: [PATCH 5/5] netstat_freebsd: add support for TCP state metrics Metric added (gauge): node_netstat_tcp_connections{state="CLOSED"} node_netstat_tcp_connections{state="CLOSE_WAIT"} node_netstat_tcp_connections{state="CLOSING"} node_netstat_tcp_connections{state="ESTABLISHED"} node_netstat_tcp_connections{state="FIN_WAIT_1"} node_netstat_tcp_connections{state="FIN_WAIT_2"} node_netstat_tcp_connections{state="LAST_ACK"} node_netstat_tcp_connections{state="LISTEN"} node_netstat_tcp_connections{state="SYN_RCVD"} node_netstat_tcp_connections{state="SYN_SENT"} node_netstat_tcp_connections{state="TIME_WAIT"} Signed-off-by: Danilo Egea Gondolfo --- collector/netstat_freebsd.go | 54 +++++++++++++++++++++++++++++++ collector/netstat_freebsd_test.go | 30 ++++++++++++++--- 2 files changed, 80 insertions(+), 4 deletions(-) diff --git a/collector/netstat_freebsd.go b/collector/netstat_freebsd.go index 903e97d254..39ac46b8df 100644 --- a/collector/netstat_freebsd.go +++ b/collector/netstat_freebsd.go @@ -17,6 +17,7 @@ package collector import ( + "encoding/binary" "errors" "fmt" "log/slog" @@ -59,6 +60,16 @@ var ( ipv6ForwardTotal = "bsdNetstatIPv6ForwardTotal" ipv6DeliveredTotal = "bsdNetstatIPv6DeliveredTotal" + tcpStates = []string{ + "CLOSED", "LISTEN", "SYN_SENT", "SYN_RCVD", + "ESTABLISHED", "CLOSE_WAIT", "FIN_WAIT_1", "CLOSING", + "LAST_ACK", "FIN_WAIT_2", "TIME_WAIT", + } + + tcpStatesMetric = prometheus.NewDesc( + prometheus.BuildFQName(namespace, "netstat", "tcp_connections"), + "Number of TCP connections per state", []string{"state"}, nil) + counterMetrics = map[string]*prometheus.Desc{ // TCP stats tcpSendTotal: prometheus.NewDesc( @@ -242,6 +253,30 @@ func getData(queryString string, expectedSize int) ([]byte, error) { return data, nil } +func getTCPStates() ([]uint64, error) { + + // This sysctl returns an array of uint64 + data, err := sysctlRaw("net.inet.tcp.states") + + if err != nil { + return nil, err + } + + if len(data)/8 != len(tcpStates) { + return nil, fmt.Errorf("invalid TCP states data: expected %d entries, found %d", len(tcpStates), len(data)/8) + } + + states := make([]uint64, 0) + + offset := 0 + for range len(tcpStates) { + s := data[offset : offset+8] + offset += 8 + states = append(states, binary.NativeEndian.Uint64(s)) + } + return states, nil +} + type netStatCollector struct { netStatMetric *prometheus.Desc } @@ -309,6 +344,15 @@ func (c *netStatCollector) Update(ch chan<- prometheus.Metric) error { ) } + tcpConnsPerStates, err := getTCPStates() + + if err != nil { + return err + } + + for i, value := range tcpConnsPerStates { + ch <- prometheus.MustNewConstMetric(tcpStatesMetric, prometheus.GaugeValue, float64(value), tcpStates[i]) + } return nil } @@ -323,6 +367,16 @@ func getFreeBSDDataMock(sysctl string) []byte { size := int(unsafe.Sizeof(C.struct_tcpstat{})) return unsafe.Slice((*byte)(unsafe.Pointer(&tcpStats)), size) + } else if sysctl == "net.inet.tcp.states" { + tcpStatesSlice := make([]byte, 0, len(tcpStates)*8) + tcpStatesValues := []uint64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11} + + for _, value := range tcpStatesValues { + tcpStatesSlice = binary.NativeEndian.AppendUint64(tcpStatesSlice, value) + } + + return tcpStatesSlice + } else if sysctl == "net.inet.udp.stats" { udpStats := C.struct_udpstat{ udps_opackets: 1234, diff --git a/collector/netstat_freebsd_test.go b/collector/netstat_freebsd_test.go index 3d00f3deab..a5e4266363 100644 --- a/collector/netstat_freebsd_test.go +++ b/collector/netstat_freebsd_test.go @@ -62,6 +62,24 @@ func TestGetTCPMetrics(t *testing.T) { } } +func TestGetTCPStatesMetrics(t *testing.T) { + testSetup() + + tcpData, err := getTCPStates() + if err != nil { + t.Fatal("unexpected error:", err) + } + + expected := []uint64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11} + + for i, value := range tcpData { + if got, want := float64(value), float64(expected[i]); got != want { + t.Errorf("unexpected %s value: want %f, got %f", tcpStates[i], want, got) + } + } + +} + func TestGetUDPMetrics(t *testing.T) { testSetup() @@ -143,20 +161,24 @@ func TestGetIPv6Metrics(t *testing.T) { } func TestNetStatCollectorUpdate(t *testing.T) { - ch := make(chan prometheus.Metric, len(counterMetrics)) collector := &netStatCollector{ netStatMetric: prometheus.NewDesc("netstat_metric", "NetStat Metric", nil, nil), } + + totalMetrics := len(counterMetrics) + len(tcpStates) + + ch := make(chan prometheus.Metric, totalMetrics) + err := collector.Update(ch) if err != nil { t.Fatal("unexpected error:", err) } - if got, want := len(ch), len(counterMetrics); got != want { - t.Errorf("metric count mismatch: want %d, got %d", want, got) + if got, want := len(ch), totalMetrics; got != want { + t.Fatalf("metric count mismatch: want %d, got %d", want, got) } - for range len(counterMetrics) { + for range totalMetrics { <-ch } }