2021-04-29 11:05:29 -07:00
// Copyright 2021 The Prometheus Authors
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
2021-10-03 04:35:24 -07:00
//go:build !noethtool
2021-04-29 11:05:29 -07:00
// +build !noethtool
// The hard work of collecting data from the kernel via the ethtool interfaces is done by
// https://github.com/safchain/ethtool/
// by Sylvain Afchain. Used under the Apache license.
package collector
import (
"errors"
"fmt"
"os"
"regexp"
"sort"
2021-07-21 11:23:11 -07:00
"strings"
2022-02-11 06:06:39 -08:00
"sync"
2021-05-14 10:07:30 -07:00
"syscall"
2021-04-29 11:05:29 -07:00
2023-03-07 00:25:05 -08:00
"github.com/alecthomas/kingpin/v2"
2021-06-17 04:21:05 -07:00
"github.com/go-kit/log"
"github.com/go-kit/log/level"
2021-04-29 11:05:29 -07:00
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs/sysfs"
"github.com/safchain/ethtool"
2021-05-14 10:07:30 -07:00
"golang.org/x/sys/unix"
2021-04-29 11:05:29 -07:00
)
var (
2021-10-11 06:12:25 -07:00
ethtoolDeviceInclude = kingpin . Flag ( "collector.ethtool.device-include" , "Regexp of ethtool devices to include (mutually exclusive to device-exclude)." ) . String ( )
ethtoolDeviceExclude = kingpin . Flag ( "collector.ethtool.device-exclude" , "Regexp of ethtool devices to exclude (mutually exclusive to device-include)." ) . String ( )
2021-08-10 09:57:36 -07:00
ethtoolIncludedMetrics = kingpin . Flag ( "collector.ethtool.metrics-include" , "Regexp of ethtool stats to include." ) . Default ( ".*" ) . String ( )
2021-10-11 06:12:25 -07:00
ethtoolReceivedRegex = regexp . MustCompile ( ` (^|_)rx(_|$) ` )
ethtoolTransmitRegex = regexp . MustCompile ( ` (^|_)tx(_|$) ` )
2021-04-29 11:05:29 -07:00
)
2021-08-16 06:33:25 -07:00
type Ethtool interface {
DriverInfo ( string ) ( ethtool . DrvInfo , error )
2021-04-29 11:05:29 -07:00
Stats ( string ) ( map [ string ] uint64 , error )
2021-09-24 09:56:09 -07:00
LinkInfo ( string ) ( ethtool . EthtoolCmd , error )
2021-04-29 11:05:29 -07:00
}
2021-08-16 06:33:25 -07:00
type ethtoolLibrary struct {
ethtool * ethtool . Ethtool
2021-04-29 11:05:29 -07:00
}
2021-08-16 06:33:25 -07:00
func ( e * ethtoolLibrary ) DriverInfo ( intf string ) ( ethtool . DrvInfo , error ) {
return e . ethtool . DriverInfo ( intf )
}
func ( e * ethtoolLibrary ) Stats ( intf string ) ( map [ string ] uint64 , error ) {
return e . ethtool . Stats ( intf )
2021-04-29 11:05:29 -07:00
}
2021-09-24 09:56:09 -07:00
func ( e * ethtoolLibrary ) LinkInfo ( intf string ) ( ethtool . EthtoolCmd , error ) {
var ethtoolCmd ethtool . EthtoolCmd
_ , err := ethtoolCmd . CmdGet ( intf )
return ethtoolCmd , err
}
2021-04-29 11:05:29 -07:00
type ethtoolCollector struct {
2021-10-11 06:12:25 -07:00
fs sysfs . FS
entries map [ string ] * prometheus . Desc
2022-02-11 06:06:39 -08:00
entriesMutex sync . Mutex
2021-10-11 06:12:25 -07:00
ethtool Ethtool
2022-05-19 01:31:48 -07:00
deviceFilter deviceFilter
2021-10-11 06:12:25 -07:00
infoDesc * prometheus . Desc
metricsPattern * regexp . Regexp
logger log . Logger
2021-04-29 11:05:29 -07:00
}
// makeEthtoolCollector is the internal constructor for EthtoolCollector.
2021-08-16 06:33:25 -07:00
// This allows NewEthtoolTestCollector to override its .ethtool interface
2021-04-29 11:05:29 -07:00
// for testing.
func makeEthtoolCollector ( logger log . Logger ) ( * ethtoolCollector , error ) {
fs , err := sysfs . NewFS ( * sysPath )
if err != nil {
return nil , fmt . Errorf ( "failed to open sysfs: %w" , err )
}
2021-08-16 06:33:25 -07:00
e , err := ethtool . NewEthtool ( )
if err != nil {
return nil , fmt . Errorf ( "failed to initialize ethtool library: %w" , err )
}
2021-04-29 11:05:29 -07:00
// Pre-populate some common ethtool metrics.
return & ethtoolCollector {
2021-10-11 06:12:25 -07:00
fs : fs ,
ethtool : & ethtoolLibrary { e } ,
2022-05-19 01:31:48 -07:00
deviceFilter : newDeviceFilter ( * ethtoolDeviceExclude , * ethtoolDeviceInclude ) ,
2021-10-11 06:12:25 -07:00
metricsPattern : regexp . MustCompile ( * ethtoolIncludedMetrics ) ,
logger : logger ,
2021-04-29 11:05:29 -07:00
entries : map [ string ] * prometheus . Desc {
"rx_bytes" : prometheus . NewDesc (
2021-07-22 02:29:58 -07:00
prometheus . BuildFQName ( namespace , "ethtool" , "received_bytes_total" ) ,
2021-04-29 11:05:29 -07:00
"Network interface bytes received" ,
[ ] string { "device" } , nil ,
) ,
"rx_dropped" : prometheus . NewDesc (
2021-07-22 02:29:58 -07:00
prometheus . BuildFQName ( namespace , "ethtool" , "received_dropped_total" ) ,
2021-04-29 11:05:29 -07:00
"Number of received frames dropped" ,
[ ] string { "device" } , nil ,
) ,
"rx_errors" : prometheus . NewDesc (
2021-07-22 02:29:58 -07:00
prometheus . BuildFQName ( namespace , "ethtool" , "received_errors_total" ) ,
2021-04-29 11:05:29 -07:00
"Number of received frames with errors" ,
[ ] string { "device" } , nil ,
) ,
"rx_packets" : prometheus . NewDesc (
2021-07-22 02:29:58 -07:00
prometheus . BuildFQName ( namespace , "ethtool" , "received_packets_total" ) ,
2021-04-29 11:05:29 -07:00
"Network interface packets received" ,
[ ] string { "device" } , nil ,
) ,
"tx_bytes" : prometheus . NewDesc (
2021-07-22 02:29:58 -07:00
prometheus . BuildFQName ( namespace , "ethtool" , "transmitted_bytes_total" ) ,
2021-04-29 11:05:29 -07:00
"Network interface bytes sent" ,
[ ] string { "device" } , nil ,
) ,
"tx_errors" : prometheus . NewDesc (
2021-07-22 02:29:58 -07:00
prometheus . BuildFQName ( namespace , "ethtool" , "transmitted_errors_total" ) ,
2021-04-29 11:05:29 -07:00
"Number of sent frames with errors" ,
[ ] string { "device" } , nil ,
) ,
"tx_packets" : prometheus . NewDesc (
2021-07-22 02:29:58 -07:00
prometheus . BuildFQName ( namespace , "ethtool" , "transmitted_packets_total" ) ,
2021-04-29 11:05:29 -07:00
"Network interface packets sent" ,
[ ] string { "device" } , nil ,
) ,
2021-09-24 09:56:09 -07:00
// link info
"supported_port" : prometheus . NewDesc (
prometheus . BuildFQName ( namespace , "network" , "supported_port_info" ) ,
"Type of ports or PHYs supported by network device" ,
[ ] string { "device" , "type" } , nil ,
) ,
"supported_speed" : prometheus . NewDesc (
prometheus . BuildFQName ( namespace , "network" , "supported_speed_bytes" ) ,
"Combination of speeds and features supported by network device" ,
[ ] string { "device" , "duplex" , "mode" } , nil ,
) ,
"supported_autonegotiate" : prometheus . NewDesc (
prometheus . BuildFQName ( namespace , "network" , "autonegotiate_supported" ) ,
"If this port device supports autonegotiate" ,
[ ] string { "device" } , nil ,
) ,
"supported_pause" : prometheus . NewDesc (
prometheus . BuildFQName ( namespace , "network" , "pause_supported" ) ,
"If this port device supports pause frames" ,
[ ] string { "device" } , nil ,
) ,
"supported_asymmetricpause" : prometheus . NewDesc (
prometheus . BuildFQName ( namespace , "network" , "asymmetricpause_supported" ) ,
"If this port device supports asymmetric pause frames" ,
[ ] string { "device" } , nil ,
) ,
"advertised_speed" : prometheus . NewDesc (
prometheus . BuildFQName ( namespace , "network" , "advertised_speed_bytes" ) ,
"Combination of speeds and features offered by network device" ,
[ ] string { "device" , "duplex" , "mode" } , nil ,
) ,
"advertised_autonegotiate" : prometheus . NewDesc (
prometheus . BuildFQName ( namespace , "network" , "autonegotiate_advertised" ) ,
"If this port device offers autonegotiate" ,
[ ] string { "device" } , nil ,
) ,
"advertised_pause" : prometheus . NewDesc (
prometheus . BuildFQName ( namespace , "network" , "pause_advertised" ) ,
"If this port device offers pause capability" ,
[ ] string { "device" } , nil ,
) ,
"advertised_asymmetricpause" : prometheus . NewDesc (
prometheus . BuildFQName ( namespace , "network" , "asymmetricpause_advertised" ) ,
"If this port device offers asymmetric pause capability" ,
[ ] string { "device" } , nil ,
) ,
"autonegotiate" : prometheus . NewDesc (
prometheus . BuildFQName ( namespace , "network" , "autonegotiate" ) ,
"If this port is using autonegotiate" ,
[ ] string { "device" } , nil ,
) ,
2021-04-29 11:05:29 -07:00
} ,
2021-08-16 06:33:25 -07:00
infoDesc : prometheus . NewDesc (
prometheus . BuildFQName ( namespace , "ethtool" , "info" ) ,
"A metric with a constant '1' value labeled by bus_info, device, driver, expansion_rom_version, firmware_version, version." ,
[ ] string { "bus_info" , "device" , "driver" , "expansion_rom_version" , "firmware_version" , "version" } , nil ,
) ,
2021-04-29 11:05:29 -07:00
} , nil
}
func init ( ) {
registerCollector ( "ethtool" , defaultDisabled , NewEthtoolCollector )
}
2021-07-21 11:23:11 -07:00
// Generate the fully-qualified metric name for the ethool metric.
func buildEthtoolFQName ( metric string ) string {
metricName := strings . TrimLeft ( strings . ToLower ( SanitizeMetricName ( metric ) ) , "_" )
2021-10-11 06:12:25 -07:00
metricName = ethtoolReceivedRegex . ReplaceAllString ( metricName , "${1}received${2}" )
metricName = ethtoolTransmitRegex . ReplaceAllString ( metricName , "${1}transmitted${2}" )
2021-07-21 11:23:11 -07:00
return prometheus . BuildFQName ( namespace , "ethtool" , metricName )
}
2021-04-29 11:05:29 -07:00
// NewEthtoolCollector returns a new Collector exposing ethtool stats.
func NewEthtoolCollector ( logger log . Logger ) ( Collector , error ) {
return makeEthtoolCollector ( logger )
}
2021-09-24 09:56:09 -07:00
// updatePortCapabilities generates metrics for autonegotiate, pause and asymmetricpause.
// The bit offsets here correspond to ethtool_link_mode_bit_indices in linux/include/uapi/linux/ethtool.h
// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/uapi/linux/ethtool.h
func ( c * ethtoolCollector ) updatePortCapabilities ( ch chan <- prometheus . Metric , prefix string , device string , linkModes uint32 ) {
2021-10-18 11:16:10 -07:00
var (
autonegotiate = 0.0
pause = 0.0
asymmetricPause = 0.0
)
if linkModes & ( 1 << unix . ETHTOOL_LINK_MODE_Autoneg_BIT ) != 0 {
2021-09-24 09:56:09 -07:00
autonegotiate = 1.0
}
2021-10-18 11:16:10 -07:00
if linkModes & ( 1 << unix . ETHTOOL_LINK_MODE_Pause_BIT ) != 0 {
2021-09-24 09:56:09 -07:00
pause = 1.0
}
2021-10-18 11:16:10 -07:00
if linkModes & ( 1 << unix . ETHTOOL_LINK_MODE_Asym_Pause_BIT ) != 0 {
2021-09-24 09:56:09 -07:00
asymmetricPause = 1.0
}
2022-02-11 07:55:26 -08:00
ch <- prometheus . MustNewConstMetric ( c . entry ( fmt . Sprintf ( "%s_autonegotiate" , prefix ) ) , prometheus . GaugeValue , autonegotiate , device )
ch <- prometheus . MustNewConstMetric ( c . entry ( fmt . Sprintf ( "%s_pause" , prefix ) ) , prometheus . GaugeValue , pause , device )
ch <- prometheus . MustNewConstMetric ( c . entry ( fmt . Sprintf ( "%s_asymmetricpause" , prefix ) ) , prometheus . GaugeValue , asymmetricPause , device )
2021-09-24 09:56:09 -07:00
}
// updatePortInfo generates port type metrics to indicate if the network devices supports Twisted Pair, optical fiber, etc.
// The bit offsets here correspond to ethtool_link_mode_bit_indices in linux/include/uapi/linux/ethtool.h
// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/uapi/linux/ethtool.h
func ( c * ethtoolCollector ) updatePortInfo ( ch chan <- prometheus . Metric , device string , linkModes uint32 ) {
2021-10-18 11:16:10 -07:00
for name , bit := range map [ string ] int {
"TP" : unix . ETHTOOL_LINK_MODE_TP_BIT ,
"AUI" : unix . ETHTOOL_LINK_MODE_AUI_BIT ,
"MII" : unix . ETHTOOL_LINK_MODE_MII_BIT ,
"FIBRE" : unix . ETHTOOL_LINK_MODE_FIBRE_BIT ,
"BNC" : unix . ETHTOOL_LINK_MODE_BNC_BIT ,
"Backplane" : unix . ETHTOOL_LINK_MODE_Backplane_BIT ,
} {
if linkModes & ( 1 << bit ) != 0 {
2022-02-11 07:55:26 -08:00
ch <- prometheus . MustNewConstMetric ( c . entry ( "supported_port" ) , prometheus . GaugeValue , 1.0 , device , name )
2021-10-18 11:16:10 -07:00
}
2021-09-24 09:56:09 -07:00
}
}
// updateSpeeds generates metrics corresponding to the speeds and duplex modes supported or advertised by the network device.
// The bit offsets here correspond to ethtool_link_mode_bit_indices in linux/include/uapi/linux/ethtool.h
// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/uapi/linux/ethtool.h
func ( c * ethtoolCollector ) updateSpeeds ( ch chan <- prometheus . Metric , prefix string , device string , linkModes uint32 ) {
linkMode := fmt . Sprintf ( "%s_speed" , prefix )
2021-10-20 09:43:56 -07:00
const (
full = "full"
half = "half"
// This is in _bytes_ to match bytes-per-second speeds from netclass.
Mbps = 1000000.0 / 8.0
)
2021-09-24 09:56:09 -07:00
2021-10-20 09:43:56 -07:00
for bit , labels := range map [ int ] struct {
speed int
duplex string
phy string
} {
2023-06-18 00:01:53 -07:00
unix . ETHTOOL_LINK_MODE_10baseT_Half_BIT : { 10 , half , "T" } ,
unix . ETHTOOL_LINK_MODE_10baseT_Full_BIT : { 10 , full , "T" } ,
unix . ETHTOOL_LINK_MODE_100baseT_Half_BIT : { 100 , half , "T" } ,
unix . ETHTOOL_LINK_MODE_100baseT_Full_BIT : { 100 , full , "T" } ,
unix . ETHTOOL_LINK_MODE_1000baseT_Half_BIT : { 1000 , half , "T" } ,
unix . ETHTOOL_LINK_MODE_1000baseT_Full_BIT : { 1000 , full , "T" } ,
unix . ETHTOOL_LINK_MODE_10000baseT_Full_BIT : { 10000 , full , "T" } ,
unix . ETHTOOL_LINK_MODE_2500baseT_Full_BIT : { 2500 , full , "T" } ,
unix . ETHTOOL_LINK_MODE_1000baseKX_Full_BIT : { 1000 , full , "KX" } ,
unix . ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT : { 10000 , full , "KX4" } ,
unix . ETHTOOL_LINK_MODE_10000baseKR_Full_BIT : { 10000 , full , "KR" } ,
unix . ETHTOOL_LINK_MODE_10000baseR_FEC_BIT : { 10000 , full , "R_FEC" } ,
unix . ETHTOOL_LINK_MODE_20000baseMLD2_Full_BIT : { 20000 , full , "MLD2" } ,
unix . ETHTOOL_LINK_MODE_20000baseKR2_Full_BIT : { 20000 , full , "KR2" } ,
unix . ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT : { 40000 , full , "KR4" } ,
unix . ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT : { 40000 , full , "CR4" } ,
unix . ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT : { 40000 , full , "SR4" } ,
unix . ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT : { 40000 , full , "LR4" } ,
unix . ETHTOOL_LINK_MODE_56000baseKR4_Full_BIT : { 56000 , full , "KR4" } ,
unix . ETHTOOL_LINK_MODE_56000baseCR4_Full_BIT : { 56000 , full , "CR4" } ,
unix . ETHTOOL_LINK_MODE_56000baseSR4_Full_BIT : { 56000 , full , "SR4" } ,
unix . ETHTOOL_LINK_MODE_56000baseLR4_Full_BIT : { 56000 , full , "LR4" } ,
unix . ETHTOOL_LINK_MODE_25000baseCR_Full_BIT : { 25000 , full , "CR" } ,
unix . ETHTOOL_LINK_MODE_25000baseKR_Full_BIT : { 25000 , full , "KR" } ,
unix . ETHTOOL_LINK_MODE_25000baseSR_Full_BIT : { 25000 , full , "SR" } ,
unix . ETHTOOL_LINK_MODE_50000baseCR2_Full_BIT : { 50000 , full , "CR2" } ,
unix . ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT : { 50000 , full , "KR2" } ,
unix . ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT : { 100000 , full , "KR4" } ,
unix . ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT : { 100000 , full , "SR4" } ,
unix . ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT : { 100000 , full , "CR4" } ,
unix . ETHTOOL_LINK_MODE_100000baseLR4_ER4_Full_BIT : { 100000 , full , "R4_ER4" } ,
unix . ETHTOOL_LINK_MODE_50000baseSR2_Full_BIT : { 50000 , full , "SR2" } ,
unix . ETHTOOL_LINK_MODE_1000baseX_Full_BIT : { 1000 , full , "X" } ,
unix . ETHTOOL_LINK_MODE_10000baseCR_Full_BIT : { 10000 , full , "CR" } ,
unix . ETHTOOL_LINK_MODE_10000baseSR_Full_BIT : { 10000 , full , "SR" } ,
unix . ETHTOOL_LINK_MODE_10000baseLR_Full_BIT : { 10000 , full , "LR" } ,
unix . ETHTOOL_LINK_MODE_10000baseLRM_Full_BIT : { 10000 , full , "LRM" } ,
unix . ETHTOOL_LINK_MODE_10000baseER_Full_BIT : { 10000 , full , "ER" } ,
unix . ETHTOOL_LINK_MODE_5000baseT_Full_BIT : { 5000 , full , "T" } ,
unix . ETHTOOL_LINK_MODE_50000baseKR_Full_BIT : { 50000 , full , "KR" } ,
unix . ETHTOOL_LINK_MODE_50000baseSR_Full_BIT : { 50000 , full , "SR" } ,
unix . ETHTOOL_LINK_MODE_50000baseCR_Full_BIT : { 50000 , full , "CR" } ,
unix . ETHTOOL_LINK_MODE_50000baseLR_ER_FR_Full_BIT : { 50000 , full , "LR_ER_FR" } ,
unix . ETHTOOL_LINK_MODE_50000baseDR_Full_BIT : { 50000 , full , "DR" } ,
unix . ETHTOOL_LINK_MODE_100000baseKR2_Full_BIT : { 100000 , full , "KR2" } ,
unix . ETHTOOL_LINK_MODE_100000baseSR2_Full_BIT : { 100000 , full , "SR2" } ,
unix . ETHTOOL_LINK_MODE_100000baseCR2_Full_BIT : { 100000 , full , "CR2" } ,
unix . ETHTOOL_LINK_MODE_100000baseLR2_ER2_FR2_Full_BIT : { 100000 , full , "LR2_ER2_FR2" } ,
unix . ETHTOOL_LINK_MODE_100000baseDR2_Full_BIT : { 100000 , full , "DR2" } ,
unix . ETHTOOL_LINK_MODE_200000baseKR4_Full_BIT : { 200000 , full , "KR4" } ,
unix . ETHTOOL_LINK_MODE_200000baseSR4_Full_BIT : { 200000 , full , "SR4" } ,
unix . ETHTOOL_LINK_MODE_200000baseLR4_ER4_FR4_Full_BIT : { 200000 , full , "LR4_ER4_FR4" } ,
unix . ETHTOOL_LINK_MODE_200000baseDR4_Full_BIT : { 200000 , full , "DR4" } ,
unix . ETHTOOL_LINK_MODE_200000baseCR4_Full_BIT : { 200000 , full , "CR4" } ,
unix . ETHTOOL_LINK_MODE_100baseT1_Full_BIT : { 100 , full , "T1" } ,
unix . ETHTOOL_LINK_MODE_1000baseT1_Full_BIT : { 1000 , full , "T1" } ,
unix . ETHTOOL_LINK_MODE_400000baseKR8_Full_BIT : { 400000 , full , "KR8" } ,
unix . ETHTOOL_LINK_MODE_400000baseSR8_Full_BIT : { 400000 , full , "SR8" } ,
unix . ETHTOOL_LINK_MODE_400000baseLR8_ER8_FR8_Full_BIT : { 400000 , full , "LR8_ER8_FR8" } ,
unix . ETHTOOL_LINK_MODE_400000baseDR8_Full_BIT : { 400000 , full , "DR8" } ,
unix . ETHTOOL_LINK_MODE_400000baseCR8_Full_BIT : { 400000 , full , "CR8" } ,
unix . ETHTOOL_LINK_MODE_100000baseKR_Full_BIT : { 100000 , full , "KR" } ,
unix . ETHTOOL_LINK_MODE_100000baseSR_Full_BIT : { 100000 , full , "SR" } ,
unix . ETHTOOL_LINK_MODE_100000baseLR_ER_FR_Full_BIT : { 100000 , full , "LR_ER_FR" } ,
unix . ETHTOOL_LINK_MODE_100000baseCR_Full_BIT : { 100000 , full , "CR" } ,
unix . ETHTOOL_LINK_MODE_100000baseDR_Full_BIT : { 100000 , full , "DR" } ,
unix . ETHTOOL_LINK_MODE_200000baseKR2_Full_BIT : { 200000 , full , "KR2" } ,
unix . ETHTOOL_LINK_MODE_200000baseSR2_Full_BIT : { 200000 , full , "SR2" } ,
unix . ETHTOOL_LINK_MODE_200000baseLR2_ER2_FR2_Full_BIT : { 200000 , full , "LR2_ER2_FR2" } ,
unix . ETHTOOL_LINK_MODE_200000baseDR2_Full_BIT : { 200000 , full , "DR2" } ,
unix . ETHTOOL_LINK_MODE_200000baseCR2_Full_BIT : { 200000 , full , "CR2" } ,
unix . ETHTOOL_LINK_MODE_400000baseKR4_Full_BIT : { 400000 , full , "KR4" } ,
unix . ETHTOOL_LINK_MODE_400000baseSR4_Full_BIT : { 400000 , full , "SR4" } ,
unix . ETHTOOL_LINK_MODE_400000baseLR4_ER4_FR4_Full_BIT : { 400000 , full , "LR4_ER4_FR4" } ,
unix . ETHTOOL_LINK_MODE_400000baseDR4_Full_BIT : { 400000 , full , "DR4" } ,
unix . ETHTOOL_LINK_MODE_400000baseCR4_Full_BIT : { 400000 , full , "CR4" } ,
unix . ETHTOOL_LINK_MODE_100baseFX_Half_BIT : { 100 , half , "FX" } ,
unix . ETHTOOL_LINK_MODE_100baseFX_Full_BIT : { 100 , full , "FX" } ,
2021-10-20 09:43:56 -07:00
} {
if linkModes & ( 1 << bit ) != 0 {
2022-02-11 07:55:26 -08:00
ch <- prometheus . MustNewConstMetric ( c . entry ( linkMode ) , prometheus . GaugeValue ,
2021-10-20 09:43:56 -07:00
float64 ( labels . speed ) * Mbps , device , labels . duplex , fmt . Sprintf ( "%dbase%s" , labels . speed , labels . phy ) )
}
2021-09-24 09:56:09 -07:00
}
}
2021-04-29 11:05:29 -07:00
func ( c * ethtoolCollector ) Update ( ch chan <- prometheus . Metric ) error {
netClass , err := c . fs . NetClass ( )
if err != nil {
if errors . Is ( err , os . ErrNotExist ) || errors . Is ( err , os . ErrPermission ) {
level . Debug ( c . logger ) . Log ( "msg" , "Could not read netclass file" , "err" , err )
return ErrNoData
}
return fmt . Errorf ( "could not get net class info: %w" , err )
}
if len ( netClass ) == 0 {
return fmt . Errorf ( "no network devices found" )
}
for device := range netClass {
var stats map [ string ] uint64
var err error
2021-10-11 06:12:25 -07:00
if c . deviceFilter . ignored ( device ) {
2021-07-19 02:44:28 -07:00
continue
}
2021-09-24 09:56:09 -07:00
linkInfo , err := c . ethtool . LinkInfo ( device )
if err == nil {
c . updateSpeeds ( ch , "supported" , device , linkInfo . Supported )
c . updatePortInfo ( ch , device , linkInfo . Supported )
c . updatePortCapabilities ( ch , "supported" , device , linkInfo . Supported )
c . updateSpeeds ( ch , "advertised" , device , linkInfo . Advertising )
c . updatePortCapabilities ( ch , "advertised" , device , linkInfo . Advertising )
2022-02-11 07:55:26 -08:00
ch <- prometheus . MustNewConstMetric ( c . entry ( "autonegotiate" ) , prometheus . GaugeValue , float64 ( linkInfo . Autoneg ) , device )
2021-09-24 09:56:09 -07:00
} else {
if errno , ok := err . ( syscall . Errno ) ; ok {
if err == unix . EOPNOTSUPP {
level . Debug ( c . logger ) . Log ( "msg" , "ethtool link info error" , "err" , err , "device" , device , "errno" , uint ( errno ) )
} else if errno != 0 {
level . Error ( c . logger ) . Log ( "msg" , "ethtool link info error" , "err" , err , "device" , device , "errno" , uint ( errno ) )
}
} else {
level . Error ( c . logger ) . Log ( "msg" , "ethtool link info error" , "err" , err , "device" , device )
}
}
2021-08-16 06:33:25 -07:00
drvInfo , err := c . ethtool . DriverInfo ( device )
if err == nil {
ch <- prometheus . MustNewConstMetric ( c . infoDesc , prometheus . GaugeValue , 1.0 ,
drvInfo . BusInfo , device , drvInfo . Driver , drvInfo . EromVersion , drvInfo . FwVersion , drvInfo . Version )
} else {
if errno , ok := err . ( syscall . Errno ) ; ok {
if err == unix . EOPNOTSUPP {
level . Debug ( c . logger ) . Log ( "msg" , "ethtool driver info error" , "err" , err , "device" , device , "errno" , uint ( errno ) )
} else if errno != 0 {
level . Error ( c . logger ) . Log ( "msg" , "ethtool driver info error" , "err" , err , "device" , device , "errno" , uint ( errno ) )
}
} else {
level . Error ( c . logger ) . Log ( "msg" , "ethtool driver info error" , "err" , err , "device" , device )
}
}
stats , err = c . ethtool . Stats ( device )
2021-05-14 10:07:30 -07:00
// If Stats() returns EOPNOTSUPP it doesn't support ethtool stats. Log that only at Debug level.
// Otherwise log it at Error level.
2021-04-29 11:05:29 -07:00
if err != nil {
2021-05-14 10:07:30 -07:00
if errno , ok := err . ( syscall . Errno ) ; ok {
if err == unix . EOPNOTSUPP {
level . Debug ( c . logger ) . Log ( "msg" , "ethtool stats error" , "err" , err , "device" , device , "errno" , uint ( errno ) )
} else if errno != 0 {
level . Error ( c . logger ) . Log ( "msg" , "ethtool stats error" , "err" , err , "device" , device , "errno" , uint ( errno ) )
}
} else {
level . Error ( c . logger ) . Log ( "msg" , "ethtool stats error" , "err" , err , "device" , device )
}
}
if stats == nil || len ( stats ) < 1 {
// No stats returned; device does not support ethtool stats.
2021-04-29 11:05:29 -07:00
continue
}
2021-11-15 02:22:36 -08:00
// Sanitizing the metric names can lead to duplicate metric names. Therefore check for clashes beforehand.
metricFQNames := make ( map [ string ] string )
for metric := range stats {
2024-02-29 13:00:45 -08:00
metricName := SanitizeMetricName ( metric )
if ! c . metricsPattern . MatchString ( metricName ) {
2021-11-15 02:22:36 -08:00
continue
}
2024-02-29 13:00:45 -08:00
metricFQName := buildEthtoolFQName ( metricName )
2021-11-15 02:22:36 -08:00
existingMetric , exists := metricFQNames [ metricFQName ]
if exists {
level . Debug ( c . logger ) . Log ( "msg" , "dropping duplicate metric name" , "device" , device ,
2024-02-29 13:00:45 -08:00
"metricFQName" , metricFQName , "metric1" , existingMetric , "metric2" , metricName )
// Keep the metricName as "deleted" in the dict in case there are 3 duplicates.
2021-11-15 02:22:36 -08:00
metricFQNames [ metricFQName ] = ""
} else {
2024-02-29 13:00:45 -08:00
metricFQNames [ metricFQName ] = metricName
2021-11-15 02:22:36 -08:00
}
}
2021-04-29 11:05:29 -07:00
// Sort metric names so that the test fixtures will match up
2021-11-15 02:22:36 -08:00
keys := make ( [ ] string , 0 , len ( metricFQNames ) )
for k := range metricFQNames {
2021-04-29 11:05:29 -07:00
keys = append ( keys , k )
}
sort . Strings ( keys )
2021-11-15 02:22:36 -08:00
for _ , metricFQName := range keys {
metric := metricFQNames [ metricFQName ]
if metric == "" {
// Skip the "deleted" duplicate metrics
2021-08-10 09:57:36 -07:00
continue
}
2021-11-15 02:22:36 -08:00
2021-04-29 11:05:29 -07:00
val := stats [ metric ]
// Check to see if this metric exists; if not then create it and store it in c.entries.
2022-02-11 08:04:33 -08:00
entry := c . entryWithCreate ( metric , metricFQName )
2021-04-29 11:05:29 -07:00
ch <- prometheus . MustNewConstMetric (
entry , prometheus . UntypedValue , float64 ( val ) , device )
}
}
return nil
}
2022-02-11 06:06:39 -08:00
2022-02-11 08:04:33 -08:00
func ( c * ethtoolCollector ) entryWithCreate ( key , metricFQName string ) * prometheus . Desc {
2022-02-11 06:06:39 -08:00
c . entriesMutex . Lock ( )
defer c . entriesMutex . Unlock ( )
if _ , ok := c . entries [ key ] ; ! ok {
c . entries [ key ] = prometheus . NewDesc (
metricFQName ,
2022-02-11 06:58:10 -08:00
fmt . Sprintf ( "Network interface %s" , key ) ,
2022-02-11 06:06:39 -08:00
[ ] string { "device" } , nil ,
)
}
return c . entries [ key ]
}
2022-02-11 08:04:33 -08:00
2022-02-11 08:06:53 -08:00
func ( c * ethtoolCollector ) entry ( key string ) * prometheus . Desc {
2022-02-11 08:04:33 -08:00
c . entriesMutex . Lock ( )
defer c . entriesMutex . Unlock ( )
return c . entries [ key ]
}
