mirror of
https://github.com/kubernetes/node-problem-detector.git
synced 2026-03-02 17:50:34 +00:00
318 lines
9.5 KiB
Go
318 lines
9.5 KiB
Go
/*
|
|
Copyright 2020 The Kubernetes Authors All rights reserved.
|
|
|
|
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.
|
|
*/
|
|
|
|
package systemstatsmonitor
|
|
|
|
import (
|
|
"github.com/golang/glog"
|
|
"github.com/prometheus/procfs"
|
|
ssmtypes "k8s.io/node-problem-detector/pkg/systemstatsmonitor/types"
|
|
"k8s.io/node-problem-detector/pkg/util/metrics"
|
|
)
|
|
|
|
type netCollector struct {
|
|
mNetDevRxBytes *metrics.Int64Metric
|
|
mNetDevRxPackets *metrics.Int64Metric
|
|
mNetDevRxErrors *metrics.Int64Metric
|
|
mNetDevRxDropped *metrics.Int64Metric
|
|
mNetDevRxFifo *metrics.Int64Metric
|
|
mNetDevRxFrame *metrics.Int64Metric
|
|
mNetDevRxCompressed *metrics.Int64Metric
|
|
mNetDevRxMulticast *metrics.Int64Metric
|
|
mNetDevTxBytes *metrics.Int64Metric
|
|
mNetDevTxPackets *metrics.Int64Metric
|
|
mNetDevTxErrors *metrics.Int64Metric
|
|
mNetDevTxDropped *metrics.Int64Metric
|
|
mNetDevTxFifo *metrics.Int64Metric
|
|
mNetDevTxCollisions *metrics.Int64Metric
|
|
mNetDevTxCarrier *metrics.Int64Metric
|
|
mNetDevTxCompressed *metrics.Int64Metric
|
|
|
|
config *ssmtypes.NetStatsConfig
|
|
}
|
|
|
|
func NewNetCollectorOrDie(netConfig *ssmtypes.NetStatsConfig) *netCollector {
|
|
nc := netCollector{config: netConfig}
|
|
|
|
var err error
|
|
|
|
nc.mNetDevRxBytes, err = metrics.NewInt64Metric(
|
|
metrics.NetDevRxBytes,
|
|
netConfig.MetricsConfigs[string(metrics.NetDevRxBytes)].DisplayName,
|
|
"Cumulative count of bytes received.",
|
|
"Byte",
|
|
metrics.Sum,
|
|
[]string{interfaceNameLabel})
|
|
if err != nil {
|
|
glog.Fatalf("Error initializing metric for %q: %v", metrics.NetDevRxBytes, err)
|
|
}
|
|
|
|
nc.mNetDevRxPackets, err = metrics.NewInt64Metric(
|
|
metrics.NetDevRxPackets,
|
|
netConfig.MetricsConfigs[string(metrics.NetDevRxPackets)].DisplayName,
|
|
"Cumulative count of packets received.",
|
|
"1",
|
|
metrics.Sum,
|
|
[]string{interfaceNameLabel})
|
|
if err != nil {
|
|
glog.Fatalf("Error initializing metric for %q: %v", metrics.NetDevRxPackets, err)
|
|
}
|
|
|
|
nc.mNetDevRxErrors, err = metrics.NewInt64Metric(
|
|
metrics.NetDevRxErrors,
|
|
netConfig.MetricsConfigs[string(metrics.NetDevRxErrors)].DisplayName,
|
|
"Cumulative count of receive errors encountered.",
|
|
"1",
|
|
metrics.Sum,
|
|
[]string{interfaceNameLabel})
|
|
if err != nil {
|
|
glog.Fatalf("Error initializing metric for %q: %v", metrics.NetDevRxErrors, err)
|
|
}
|
|
|
|
nc.mNetDevRxDropped, err = metrics.NewInt64Metric(
|
|
metrics.NetDevRxDropped,
|
|
netConfig.MetricsConfigs[string(metrics.NetDevRxDropped)].DisplayName,
|
|
"Cumulative count of packets dropped while receiving.",
|
|
"1",
|
|
metrics.Sum,
|
|
[]string{interfaceNameLabel})
|
|
if err != nil {
|
|
glog.Fatalf("Error initializing metric for %q: %v", metrics.NetDevRxDropped, err)
|
|
}
|
|
|
|
nc.mNetDevRxFifo, err = metrics.NewInt64Metric(
|
|
metrics.NetDevRxFifo,
|
|
netConfig.MetricsConfigs[string(metrics.NetDevRxFifo)].DisplayName,
|
|
"Cumulative count of FIFO buffer errors.",
|
|
"1",
|
|
metrics.Sum,
|
|
[]string{interfaceNameLabel})
|
|
if err != nil {
|
|
glog.Fatalf("Error initializing metric for %q: %v", metrics.NetDevRxFifo, err)
|
|
}
|
|
|
|
nc.mNetDevRxFrame, err = metrics.NewInt64Metric(
|
|
metrics.NetDevRxFrame,
|
|
netConfig.MetricsConfigs[string(metrics.NetDevRxFrame)].DisplayName,
|
|
"Cumulative count of packet framing errors.",
|
|
"1",
|
|
metrics.Sum,
|
|
[]string{interfaceNameLabel})
|
|
if err != nil {
|
|
glog.Fatalf("Error initializing metric for %q: %v", metrics.NetDevRxFrame, err)
|
|
}
|
|
|
|
nc.mNetDevRxCompressed, err = metrics.NewInt64Metric(
|
|
metrics.NetDevRxCompressed,
|
|
netConfig.MetricsConfigs[string(metrics.NetDevRxCompressed)].DisplayName,
|
|
"Cumulative count of compressed packets received by the device driver.",
|
|
"1",
|
|
metrics.Sum,
|
|
[]string{interfaceNameLabel})
|
|
if err != nil {
|
|
glog.Fatalf("Error initializing metric for %q: %v", metrics.NetDevRxCompressed, err)
|
|
}
|
|
|
|
nc.mNetDevRxMulticast, err = metrics.NewInt64Metric(
|
|
metrics.NetDevRxMulticast,
|
|
netConfig.MetricsConfigs[string(metrics.NetDevRxMulticast)].DisplayName,
|
|
"Cumulative count of multicast frames received by the device driver.",
|
|
"1",
|
|
metrics.Sum,
|
|
[]string{interfaceNameLabel})
|
|
if err != nil {
|
|
glog.Fatalf("Error initializing metric for %q: %v", metrics.NetDevRxMulticast, err)
|
|
}
|
|
|
|
nc.mNetDevTxBytes, err = metrics.NewInt64Metric(
|
|
metrics.NetDevTxBytes,
|
|
netConfig.MetricsConfigs[string(metrics.NetDevTxBytes)].DisplayName,
|
|
"Cumulative count of bytes transmitted.",
|
|
"Byte",
|
|
metrics.Sum,
|
|
[]string{interfaceNameLabel})
|
|
if err != nil {
|
|
glog.Fatalf("Error initializing metric for %q: %v", metrics.NetDevTxBytes, err)
|
|
}
|
|
|
|
nc.mNetDevTxPackets, err = metrics.NewInt64Metric(
|
|
metrics.NetDevTxPackets,
|
|
netConfig.MetricsConfigs[string(metrics.NetDevTxPackets)].DisplayName,
|
|
"Cumulative count of packets transmitted.",
|
|
"1",
|
|
metrics.Sum,
|
|
[]string{interfaceNameLabel})
|
|
if err != nil {
|
|
glog.Fatalf("Error initializing metric for %q: %v", metrics.NetDevTxPackets, err)
|
|
}
|
|
|
|
nc.mNetDevTxErrors, err = metrics.NewInt64Metric(
|
|
metrics.NetDevTxErrors,
|
|
netConfig.MetricsConfigs[string(metrics.NetDevTxErrors)].DisplayName,
|
|
"Cumulative count of transmit errors encountered.",
|
|
"1",
|
|
metrics.Sum,
|
|
[]string{interfaceNameLabel})
|
|
if err != nil {
|
|
glog.Fatalf("Error initializing metric for %q: %v", metrics.NetDevTxErrors, err)
|
|
}
|
|
|
|
nc.mNetDevTxDropped, err = metrics.NewInt64Metric(
|
|
metrics.NetDevTxDropped,
|
|
netConfig.MetricsConfigs[string(metrics.NetDevTxDropped)].DisplayName,
|
|
"Cumulative count of packets dropped while transmitting.",
|
|
"1",
|
|
metrics.Sum,
|
|
[]string{interfaceNameLabel})
|
|
if err != nil {
|
|
glog.Fatalf("Error initializing metric for %q: %v", metrics.NetDevTxDropped, err)
|
|
}
|
|
|
|
nc.mNetDevTxFifo, err = metrics.NewInt64Metric(
|
|
metrics.NetDevTxFifo,
|
|
netConfig.MetricsConfigs[string(metrics.NetDevTxFifo)].DisplayName,
|
|
"Cumulative count of FIFO buffer errors.",
|
|
"1",
|
|
metrics.Sum,
|
|
[]string{interfaceNameLabel})
|
|
if err != nil {
|
|
glog.Fatalf("Error initializing metric for %q: %v", metrics.NetDevTxFifo, err)
|
|
}
|
|
|
|
nc.mNetDevTxCollisions, err = metrics.NewInt64Metric(
|
|
metrics.NetDevTxCollisions,
|
|
netConfig.MetricsConfigs[string(metrics.NetDevTxCollisions)].DisplayName,
|
|
"Cumulative count of collisions detected on the interface.",
|
|
"1",
|
|
metrics.Sum,
|
|
[]string{interfaceNameLabel})
|
|
if err != nil {
|
|
glog.Fatalf("Error initializing metric for %q: %v", metrics.NetDevTxCollisions, err)
|
|
}
|
|
|
|
nc.mNetDevTxCarrier, err = metrics.NewInt64Metric(
|
|
metrics.NetDevTxCarrier,
|
|
netConfig.MetricsConfigs[string(metrics.NetDevTxCarrier)].DisplayName,
|
|
"Cumulative count of carrier losses detected by the device driver.",
|
|
"1",
|
|
metrics.Sum,
|
|
[]string{interfaceNameLabel})
|
|
if err != nil {
|
|
glog.Fatalf("Error initializing metric for %q: %v", metrics.NetDevTxCarrier, err)
|
|
}
|
|
|
|
nc.mNetDevTxCompressed, err = metrics.NewInt64Metric(
|
|
metrics.NetDevTxCompressed,
|
|
netConfig.MetricsConfigs[string(metrics.NetDevTxCompressed)].DisplayName,
|
|
"Cumulative count of compressed packets transmitted by the device driver.",
|
|
"1",
|
|
metrics.Sum,
|
|
[]string{interfaceNameLabel})
|
|
if err != nil {
|
|
glog.Fatalf("Error initializing metric for %q: %v", metrics.NetDevTxCompressed, err)
|
|
}
|
|
|
|
return &nc
|
|
}
|
|
|
|
func (nc *netCollector) recordNetDev() {
|
|
if nc.mNetDevRxBytes == nil {
|
|
return
|
|
}
|
|
if nc.mNetDevRxPackets == nil {
|
|
return
|
|
}
|
|
if nc.mNetDevRxErrors == nil {
|
|
return
|
|
}
|
|
if nc.mNetDevRxDropped == nil {
|
|
return
|
|
}
|
|
if nc.mNetDevRxFifo == nil {
|
|
return
|
|
}
|
|
if nc.mNetDevRxFrame == nil {
|
|
return
|
|
}
|
|
if nc.mNetDevRxCompressed == nil {
|
|
return
|
|
}
|
|
if nc.mNetDevRxMulticast == nil {
|
|
return
|
|
}
|
|
if nc.mNetDevTxBytes == nil {
|
|
return
|
|
}
|
|
if nc.mNetDevTxPackets == nil {
|
|
return
|
|
}
|
|
if nc.mNetDevTxErrors == nil {
|
|
return
|
|
}
|
|
if nc.mNetDevTxDropped == nil {
|
|
return
|
|
}
|
|
if nc.mNetDevTxFifo == nil {
|
|
return
|
|
}
|
|
if nc.mNetDevTxCollisions == nil {
|
|
return
|
|
}
|
|
if nc.mNetDevTxCarrier == nil {
|
|
return
|
|
}
|
|
if nc.mNetDevTxCompressed == nil {
|
|
return
|
|
}
|
|
|
|
fs, err := procfs.NewFS("/proc")
|
|
stats, err := fs.NetDev()
|
|
if err != nil {
|
|
glog.Errorf("Failed to retrieve net dev stat: %v", err)
|
|
return
|
|
}
|
|
|
|
for iface, ifaceStats := range stats {
|
|
tags := map[string]string{}
|
|
tags[interfaceNameLabel] = iface
|
|
|
|
nc.mNetDevRxBytes.Record(tags, int64(ifaceStats.RxBytes))
|
|
nc.mNetDevRxPackets.Record(tags, int64(ifaceStats.RxPackets))
|
|
nc.mNetDevRxErrors.Record(tags, int64(ifaceStats.RxErrors))
|
|
nc.mNetDevRxDropped.Record(tags, int64(ifaceStats.RxDropped))
|
|
nc.mNetDevRxFifo.Record(tags, int64(ifaceStats.RxFIFO))
|
|
nc.mNetDevRxFrame.Record(tags, int64(ifaceStats.RxFrame))
|
|
nc.mNetDevRxCompressed.Record(tags, int64(ifaceStats.RxCompressed))
|
|
nc.mNetDevRxMulticast.Record(tags, int64(ifaceStats.RxMulticast))
|
|
nc.mNetDevTxBytes.Record(tags, int64(ifaceStats.TxBytes))
|
|
nc.mNetDevTxPackets.Record(tags, int64(ifaceStats.TxPackets))
|
|
nc.mNetDevTxErrors.Record(tags, int64(ifaceStats.TxErrors))
|
|
nc.mNetDevTxDropped.Record(tags, int64(ifaceStats.TxDropped))
|
|
nc.mNetDevTxFifo.Record(tags, int64(ifaceStats.TxFIFO))
|
|
nc.mNetDevTxCollisions.Record(tags, int64(ifaceStats.TxCollisions))
|
|
nc.mNetDevTxCarrier.Record(tags, int64(ifaceStats.TxCarrier))
|
|
nc.mNetDevTxCompressed.Record(tags, int64(ifaceStats.TxCompressed))
|
|
}
|
|
}
|
|
|
|
func (nc *netCollector) collect() {
|
|
if nc == nil {
|
|
return
|
|
}
|
|
|
|
nc.recordNetDev()
|
|
}
|