mudhorn/node_exporter
1
0
Fork 0
mirror of https://github.com/prometheus/node_exporter.git synced 2025-08-20 18:33:52 -07:00
Code Issues Actions Packages Projects Releases Wiki Activity

Update prometheus/common

Browse source
This commit is contained in:
Sam DeHaan 2025-02-13 12:59:48 -05:00
parent e1b5fa2aed
commit c55b81403e
119 changed files with 622 additions and 690 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
collector/arp_linux.go
View file

@ -19,9 +19,9 @@ package collector
import (
"errors"
"fmt"
"log/slog"
"net"
"github.com/go-kit/log"
"github.com/jsimonetti/rtnetlink"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs"
@ -32,7 +32,7 @@ type arpCollector struct {
fs procfs.FS
deviceFilter deviceFilter
entries *prometheus.Desc
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -41,7 +41,7 @@ func init() {
}
// NewARPCollector returns a new Collector exposing ARP stats.
func NewARPCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewARPCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
fs, err := procfs.NewFS(*config.Path.ProcPath)
if err != nil {
return nil, fmt.Errorf("failed to open procfs: %w", err)

6
collector/bcache_linux.go
View file

@ -18,8 +18,8 @@ package collector
import (
"fmt"
"log/slog"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs/bcache"
)
@ -32,13 +32,13 @@ func init() {
// A bcacheCollector is a Collector which gathers metrics from Linux bcache.
type bcacheCollector struct {
fs bcache.FS
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
// NewBcacheCollector returns a newly allocated bcacheCollector.
// It exposes a number of Linux bcache statistics.
func NewBcacheCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewBcacheCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
fs, err := bcache.NewFS(*config.Path.SysPath)
if err != nil {
return nil, fmt.Errorf("failed to open sysfs: %w", err)

9
collector/bonding_linux.go
View file

@ -19,18 +19,17 @@ package collector
import (
"errors"
"fmt"
"log/slog"
"os"
"path/filepath"
"strings"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
)
type bondingCollector struct {
slaves, active typedDesc
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -40,7 +39,7 @@ func init() {
// NewBondingCollector returns a newly allocated bondingCollector.
// It exposes the number of configured and active slave of linux bonding interfaces.
func NewBondingCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewBondingCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &bondingCollector{
slaves: typedDesc{prometheus.NewDesc(
prometheus.BuildFQName(namespace, "bonding", "slaves"),
@ -63,7 +62,7 @@ func (c *bondingCollector) Update(ch chan<- prometheus.Metric) error {
bondingStats, err := readBondingStats(statusfile)
if err != nil {
if errors.Is(err, os.ErrNotExist) {
level.Debug(c.logger).Log("msg", "Not collecting bonding, file does not exist", "file", statusfile)
c.logger.Debug("Not collecting bonding, file does not exist", "file", statusfile)
return ErrNoData
}
return err

7
collector/boot_time_bsd.go
View file

@ -18,13 +18,14 @@
package collector
import (
"github.com/go-kit/log"
"log/slog"
"github.com/prometheus/client_golang/prometheus"
"golang.org/x/sys/unix"
)
type bootTimeCollector struct {
logger log.Logger
logger *slog.Logger
}
func init() {
@ -32,7 +33,7 @@ func init() {
}
// newBootTimeCollector returns a new Collector exposing system boot time on BSD systems.
func newBootTimeCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func newBootTimeCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &bootTimeCollector{
logger: logger,
}, nil

7
collector/boot_time_solaris.go
View file

@ -17,21 +17,22 @@
package collector
import (
"github.com/go-kit/log"
"log/slog"
"github.com/illumos/go-kstat"
"github.com/prometheus/client_golang/prometheus"
)
type bootTimeCollector struct {
boottime typedDesc
logger log.Logger
logger *slog.Logger
}
func init() {
registerCollector("boottime", defaultEnabled, newBootTimeCollector)
}
func newBootTimeCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func newBootTimeCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &bootTimeCollector{
boottime: typedDesc{
prometheus.NewDesc(

23
collector/btrfs_linux.go
View file

@ -18,13 +18,12 @@ package collector
import (
"fmt"
"log/slog"
"path"
"strings"
"syscall"
dennwc "github.com/dennwc/btrfs"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs/btrfs"
)
@ -32,7 +31,7 @@ import (
// A btrfsCollector is a Collector which gathers metrics from Btrfs filesystems.
type btrfsCollector struct {
fs btrfs.FS
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -41,7 +40,7 @@ func init() {
}
// NewBtrfsCollector returns a new Collector exposing Btrfs statistics.
func NewBtrfsCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewBtrfsCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
fs, err := btrfs.NewFS(*config.Path.SysPath)
if err != nil {
return nil, fmt.Errorf("failed to open sysfs: %w", err)
@ -64,9 +63,7 @@ func (c *btrfsCollector) Update(ch chan<- prometheus.Metric) error {
ioctlStatsMap, err := c.getIoctlStats()
if err != nil {
level.Debug(c.logger).Log(
"msg", "Error querying btrfs device stats with ioctl",
"err", err)
c.logger.Debug("Error querying btrfs device stats with ioctl", "err", err)
ioctlStatsMap = make(map[string]*btrfsIoctlFsStats)
}
@ -131,8 +128,8 @@ func (c *btrfsCollector) getIoctlStats() (map[string]*btrfsIoctlFsStats, error)
if err != nil {
// Failed to open this mount point, maybe we didn't have permission
// maybe we'll find another mount point for this FS later.
level.Debug(c.logger).Log(
"msg", "Error inspecting btrfs mountpoint",
c.logger.Debug(
"Error inspecting btrfs mountpoint",
"mountPoint", mountPath,
"err", err)
continue
@ -143,8 +140,8 @@ func (c *btrfsCollector) getIoctlStats() (map[string]*btrfsIoctlFsStats, error)
if err != nil {
// Failed to get the FS info for some reason,
// perhaps it'll work with a different mount point
level.Debug(c.logger).Log(
"msg", "Error querying btrfs filesystem",
c.logger.Debug(
"Error querying btrfs filesystem",
"mountPoint", mountPath,
"err", err)
continue
@ -158,8 +155,8 @@ func (c *btrfsCollector) getIoctlStats() (map[string]*btrfsIoctlFsStats, error)
deviceStats, err := c.getIoctlDeviceStats(fs, &fsInfo)
if err != nil {
level.Debug(c.logger).Log(
"msg", "Error querying btrfs device stats",
c.logger.Debug(
"Error querying btrfs device stats",
"mountPoint", mountPath,
"err", err)
continue

9
collector/buddyinfo.go
View file

@ -18,10 +18,9 @@ package collector
import (
"fmt"
"log/slog"
"strconv"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs"
)
@ -33,7 +32,7 @@ const (
type buddyinfoCollector struct {
fs procfs.FS
desc *prometheus.Desc
logger log.Logger
logger *slog.Logger
}
func init() {
@ -41,7 +40,7 @@ func init() {
}
// NewBuddyinfoCollector returns a new Collector exposing buddyinfo stats.
func NewBuddyinfoCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewBuddyinfoCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
desc := prometheus.NewDesc(
prometheus.BuildFQName(namespace, buddyInfoSubsystem, "blocks"),
"Count of free blocks according to size.",
@ -62,7 +61,7 @@ func (c *buddyinfoCollector) Update(ch chan<- prometheus.Metric) error {
return fmt.Errorf("couldn't get buddyinfo: %w", err)
}
level.Debug(c.logger).Log("msg", "Set node_buddy", "buddyInfo", buddyInfo)
c.logger.Debug("Set node_buddy", "buddyInfo", buddyInfo)
for _, entry := range buddyInfo {
for size, value := range entry.Sizes {
ch <- prometheus.MustNewConstMetric(

6
collector/cgroups_linux.go
View file

@ -18,8 +18,8 @@ package collector
import (
"fmt"
"log/slog"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs"
)
@ -30,7 +30,7 @@ type cgroupSummaryCollector struct {
fs procfs.FS
cgroups *prometheus.Desc
enabled *prometheus.Desc
logger log.Logger
logger *slog.Logger
}
func init() {
@ -38,7 +38,7 @@ func init() {
}
// NewCgroupSummaryCollector returns a new Collector exposing a summary of cgroups.
func NewCgroupSummaryCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewCgroupSummaryCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
fs, err := procfs.NewFS(*config.Path.ProcPath)
if err != nil {
return nil, fmt.Errorf("failed to open procfs: %w", err)

21
collector/collector.go
View file

@ -17,12 +17,11 @@ package collector
import (
"errors"
"fmt"
"log/slog"
"sync"
"time"
"github.com/alecthomas/kingpin/v2"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
)
@ -50,7 +49,7 @@ const (
)
var (
factories = make(map[string]func(config *NodeCollectorConfig, logger log.Logger) (Collector, error))
factories = make(map[string]func(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error))
initiatedCollectorsMtx = sync.Mutex{}
initiatedCollectors = make(map[string]Collector)
collectorStateGlobal = make(map[string]bool)
@ -79,7 +78,7 @@ func GetAvailableCollectors() []string {
return availableCollectors
}
func registerCollector(collector string, isDefaultEnabled bool, factory func(config *NodeCollectorConfig, logger log.Logger) (Collector, error)) {
func registerCollector(collector string, isDefaultEnabled bool, factory func(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error)) {
var helpDefaultState string
if isDefaultEnabled {
helpDefaultState = "enabled"
@ -102,7 +101,7 @@ func registerCollector(collector string, isDefaultEnabled bool, factory func(con
// NodeCollector implements the prometheus.Collector interface.
type NodeCollector struct {
Collectors map[string]Collector
logger log.Logger
logger *slog.Logger
}
// DisableDefaultCollectors sets the collector state to false for all collectors which
@ -128,7 +127,7 @@ func collectorFlagAction(collector string) func(ctx *kingpin.ParseContext) error
}
// NewNodeCollector creates a new NodeCollector.
func NewNodeCollector(config *NodeCollectorConfig, logger log.Logger, filters ...string) (*NodeCollector, error) {
func NewNodeCollector(config *NodeCollectorConfig, logger *slog.Logger, filters ...string) (*NodeCollector, error) {
f := make(map[string]bool)
for _, filter := range filters {
enabled, exist := config.Collectors[filter]
@ -151,7 +150,7 @@ func NewNodeCollector(config *NodeCollectorConfig, logger log.Logger, filters ..
if collector, ok := initiatedCollectors[key]; ok && config.AllowCachingOfCollectors {
collectors[key] = collector
} else {
collector, err := factories[key](config, log.With(logger, "collector", key))
collector, err := factories[key](config, logger.With("collector", key))
if err != nil {
return nil, err
}
@ -181,7 +180,7 @@ func (n NodeCollector) Collect(ch chan<- prometheus.Metric) {
wg.Wait()
}
func execute(name string, c Collector, ch chan<- prometheus.Metric, logger log.Logger) {
func execute(name string, c Collector, ch chan<- prometheus.Metric, logger *slog.Logger) {
begin := time.Now()
err := c.Update(ch)
duration := time.Since(begin)
@ -189,13 +188,13 @@ func execute(name string, c Collector, ch chan<- prometheus.Metric, logger log.L
if err != nil {
if IsNoDataError(err) {
level.Debug(logger).Log("msg", "collector returned no data", "name", name, "duration_seconds", duration.Seconds(), "err", err)
logger.Debug("collector returned no data", "name", name, "duration_seconds", duration.Seconds(), "err", err)
} else {
level.Error(logger).Log("msg", "collector failed", "name", name, "duration_seconds", duration.Seconds(), "err", err)
logger.Error("collector failed", "name", name, "duration_seconds", duration.Seconds(), "err", err)
}
success = 0
} else {
level.Debug(logger).Log("msg", "collector succeeded", "name", name, "duration_seconds", duration.Seconds())
logger.Debug("collector succeeded", "name", name, "duration_seconds", duration.Seconds())
success = 1
}
ch <- prometheus.MustNewConstMetric(scrapeDurationDesc, prometheus.GaugeValue, duration.Seconds(), name)

9
collector/conntrack_linux.go
View file

@ -19,10 +19,9 @@ package collector
import (
"errors"
"fmt"
"log/slog"
"os"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs"
)
@ -38,7 +37,7 @@ type conntrackCollector struct {
drop *prometheus.Desc
earlyDrop *prometheus.Desc
searchRestart *prometheus.Desc
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -58,7 +57,7 @@ func init() {
}
// NewConntrackCollector returns a new Collector exposing conntrack stats.
func NewConntrackCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewConntrackCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &conntrackCollector{
current: prometheus.NewDesc(
prometheus.BuildFQName(namespace, "", "nf_conntrack_entries"),
@ -156,7 +155,7 @@ func (c *conntrackCollector) Update(ch chan<- prometheus.Metric) error {
func (c *conntrackCollector) handleErr(err error) error {
if errors.Is(err, os.ErrNotExist) {
level.Debug(c.logger).Log("msg", "conntrack probably not loaded")
c.logger.Debug("conntrack probably not loaded")
return ErrNoData
}
return fmt.Errorf("failed to retrieve conntrack stats: %w", err)

6
collector/cpu_darwin.go
View file

@ -23,10 +23,10 @@ import (
"bytes"
"encoding/binary"
"fmt"
"log/slog"
"strconv"
"unsafe"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
)
@ -53,7 +53,7 @@ const ClocksPerSec = float64(C.CLK_TCK)
type statCollector struct {
cpu *prometheus.Desc
logger log.Logger
logger *slog.Logger
}
func init() {
@ -61,7 +61,7 @@ func init() {
}
// NewCPUCollector returns a new Collector exposing CPU stats.
func NewCPUCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewCPUCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &statCollector{
cpu: nodeCPUSecondsDesc,
logger: logger,

6
collector/cpu_dragonfly.go
View file

@ -18,10 +18,10 @@ package collector
import (
"errors"
"log/slog"
"strconv"
"unsafe"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
)
@ -78,7 +78,7 @@ const maxCPUTimesLen = C.MAXCPU * C.CPUSTATES
type statCollector struct {
cpu *prometheus.Desc
logger log.Logger
logger *slog.Logger
}
func init() {
@ -86,7 +86,7 @@ func init() {
}
// NewStatCollector returns a new Collector exposing CPU stats.
func NewStatCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewStatCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &statCollector{
cpu: nodeCPUSecondsDesc,
logger: logger,

11
collector/cpu_freebsd.go
View file

@ -18,12 +18,11 @@ package collector
import (
"fmt"
"log/slog"
"math"
"strconv"
"unsafe"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"golang.org/x/sys/unix"
)
@ -85,7 +84,7 @@ func getCPUTimes() ([]cputime, error) {
type statCollector struct {
cpu typedDesc
temp typedDesc
logger log.Logger
logger *slog.Logger
}
func init() {
@ -93,7 +92,7 @@ func init() {
}
// NewStatCollector returns a new Collector exposing CPU stats.
func NewStatCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewStatCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &statCollector{
cpu: typedDesc{nodeCPUSecondsDesc, prometheus.CounterValue},
temp: typedDesc{prometheus.NewDesc(
@ -134,11 +133,11 @@ func (c *statCollector) Update(ch chan<- prometheus.Metric) error {
if err != nil {
if err == unix.ENOENT {
// No temperature information for this CPU
level.Debug(c.logger).Log("msg", "no temperature information for CPU", "cpu", cpu)
c.logger.Debug("no temperature information for CPU", "cpu", cpu)
} else {
// Unexpected error
ch <- c.temp.mustNewConstMetric(math.NaN(), lcpu)
level.Error(c.logger).Log("msg", "failed to query CPU temperature for CPU", "cpu", cpu, "err", err)
c.logger.Error("failed to query CPU temperature for CPU", "cpu", cpu, "err", err)
}
continue
}

41
collector/cpu_linux.go
View file

@ -18,14 +18,13 @@ package collector
import (
"fmt"
"log/slog"
"os"
"path/filepath"
"regexp"
"strconv"
"sync"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs"
"github.com/prometheus/procfs/sysfs"
@ -44,7 +43,7 @@ type cpuCollector struct {
cpuCoreThrottle *prometheus.Desc
cpuPackageThrottle *prometheus.Desc
cpuIsolated *prometheus.Desc
logger log.Logger
logger *slog.Logger
cpuStats map[int64]procfs.CPUStat
cpuStatsMutex sync.Mutex
isolatedCpus []uint16
@ -67,7 +66,7 @@ func init() {
}
// NewCPUCollector returns a new Collector exposing kernel/system statistics.
func NewCPUCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewCPUCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
fs, err := procfs.NewFS(*config.Path.ProcPath)
if err != nil {
return nil, fmt.Errorf("failed to open procfs: %w", err)
@ -83,7 +82,7 @@ func NewCPUCollector(config *NodeCollectorConfig, logger log.Logger) (Collector,
if !os.IsNotExist(err) {
return nil, fmt.Errorf("Unable to get isolated cpus: %w", err)
}
level.Debug(logger).Log("msg", "Could not open isolated file", "error", err)
logger.Debug("Could not open isolated file", "error", err)
}
c := &cpuCollector{
@ -144,7 +143,7 @@ func NewCPUCollector(config *NodeCollectorConfig, logger log.Logger) (Collector,
func (c *cpuCollector) compileIncludeFlags(flagsIncludeFlag, bugsIncludeFlag *string) error {
if (*flagsIncludeFlag != "" || *bugsIncludeFlag != "") && !*c.config.CPU.EnableCPUInfo {
*c.config.CPU.EnableCPUInfo = true
level.Info(c.logger).Log("msg", "--collector.cpu.info has been set to `true` because you set the following flags, like --collector.cpu.info.flags-include and --collector.cpu.info.bugs-include")
c.logger.Info("--collector.cpu.info has been set to `true` because you set the following flags, like --collector.cpu.info.flags-include and --collector.cpu.info.bugs-include")
}
var err error
@ -265,12 +264,12 @@ func (c *cpuCollector) updateThermalThrottle(config *NodeCollectorConfig, ch cha
// topology/physical_package_id
if physicalPackageID, err = readUintFromFile(filepath.Join(cpu, "topology", "physical_package_id")); err != nil {
level.Debug(c.logger).Log("msg", "CPU is missing physical_package_id", "cpu", cpu)
c.logger.Debug("CPU is missing physical_package_id", "cpu", cpu)
continue
}
// topology/core_id
if coreID, err = readUintFromFile(filepath.Join(cpu, "topology", "core_id")); err != nil {
level.Debug(c.logger).Log("msg", "CPU is missing core_id", "cpu", cpu)
c.logger.Debug("CPU is missing core_id", "cpu", cpu)
continue
}
@ -288,7 +287,7 @@ func (c *cpuCollector) updateThermalThrottle(config *NodeCollectorConfig, ch cha
if coreThrottleCount, err := readUintFromFile(filepath.Join(cpu, "thermal_throttle", "core_throttle_count")); err == nil {
packageCoreThrottles[physicalPackageID][coreID] = coreThrottleCount
} else {
level.Debug(c.logger).Log("msg", "CPU is missing core_throttle_count", "cpu", cpu)
c.logger.Debug("CPU is missing core_throttle_count", "cpu", cpu)
}
}
@ -298,7 +297,7 @@ func (c *cpuCollector) updateThermalThrottle(config *NodeCollectorConfig, ch cha
if packageThrottleCount, err := readUintFromFile(filepath.Join(cpu, "thermal_throttle", "package_throttle_count")); err == nil {
packageThrottles[physicalPackageID] = packageThrottleCount
} else {
level.Debug(c.logger).Log("msg", "CPU is missing package_throttle_count", "cpu", cpu)
c.logger.Debug("CPU is missing package_throttle_count", "cpu", cpu)
}
}
}
@ -376,68 +375,68 @@ func (c *cpuCollector) updateCPUStats(newStats map[int64]procfs.CPUStat) {
// If idle jumps backwards by more than X seconds, assume we had a hotplug event and reset the stats for this CPU.
if (cpuStats.Idle - n.Idle) >= jumpBackSeconds {
level.Debug(c.logger).Log("msg", jumpBackDebugMessage, "cpu", i, "old_value", cpuStats.Idle, "new_value", n.Idle)
c.logger.Debug(jumpBackDebugMessage, "cpu", i, "old_value", cpuStats.Idle, "new_value", n.Idle)
cpuStats = procfs.CPUStat{}
}
if n.Idle >= cpuStats.Idle {
cpuStats.Idle = n.Idle
} else {
level.Debug(c.logger).Log("msg", "CPU Idle counter jumped backwards", "cpu", i, "old_value", cpuStats.Idle, "new_value", n.Idle)
c.logger.Debug("CPU Idle counter jumped backwards", "cpu", i, "old_value", cpuStats.Idle, "new_value", n.Idle)
}
if n.User >= cpuStats.User {
cpuStats.User = n.User
} else {
level.Debug(c.logger).Log("msg", "CPU User counter jumped backwards", "cpu", i, "old_value", cpuStats.User, "new_value", n.User)
c.logger.Debug("CPU User counter jumped backwards", "cpu", i, "old_value", cpuStats.User, "new_value", n.User)
}
if n.Nice >= cpuStats.Nice {
cpuStats.Nice = n.Nice
} else {
level.Debug(c.logger).Log("msg", "CPU Nice counter jumped backwards", "cpu", i, "old_value", cpuStats.Nice, "new_value", n.Nice)
c.logger.Debug("CPU Nice counter jumped backwards", "cpu", i, "old_value", cpuStats.Nice, "new_value", n.Nice)
}
if n.System >= cpuStats.System {
cpuStats.System = n.System
} else {
level.Debug(c.logger).Log("msg", "CPU System counter jumped backwards", "cpu", i, "old_value", cpuStats.System, "new_value", n.System)
c.logger.Debug("CPU System counter jumped backwards", "cpu", i, "old_value", cpuStats.System, "new_value", n.System)
}
if n.Iowait >= cpuStats.Iowait {
cpuStats.Iowait = n.Iowait
} else {
level.Debug(c.logger).Log("msg", "CPU Iowait counter jumped backwards", "cpu", i, "old_value", cpuStats.Iowait, "new_value", n.Iowait)
c.logger.Debug("CPU Iowait counter jumped backwards", "cpu", i, "old_value", cpuStats.Iowait, "new_value", n.Iowait)
}
if n.IRQ >= cpuStats.IRQ {
cpuStats.IRQ = n.IRQ
} else {
level.Debug(c.logger).Log("msg", "CPU IRQ counter jumped backwards", "cpu", i, "old_value", cpuStats.IRQ, "new_value", n.IRQ)
c.logger.Debug("CPU IRQ counter jumped backwards", "cpu", i, "old_value", cpuStats.IRQ, "new_value", n.IRQ)
}
if n.SoftIRQ >= cpuStats.SoftIRQ {
cpuStats.SoftIRQ = n.SoftIRQ
} else {
level.Debug(c.logger).Log("msg", "CPU SoftIRQ counter jumped backwards", "cpu", i, "old_value", cpuStats.SoftIRQ, "new_value", n.SoftIRQ)
c.logger.Debug("CPU SoftIRQ counter jumped backwards", "cpu", i, "old_value", cpuStats.SoftIRQ, "new_value", n.SoftIRQ)
}
if n.Steal >= cpuStats.Steal {
cpuStats.Steal = n.Steal
} else {
level.Debug(c.logger).Log("msg", "CPU Steal counter jumped backwards", "cpu", i, "old_value", cpuStats.Steal, "new_value", n.Steal)
c.logger.Debug("CPU Steal counter jumped backwards", "cpu", i, "old_value", cpuStats.Steal, "new_value", n.Steal)
}
if n.Guest >= cpuStats.Guest {
cpuStats.Guest = n.Guest
} else {
level.Debug(c.logger).Log("msg", "CPU Guest counter jumped backwards", "cpu", i, "old_value", cpuStats.Guest, "new_value", n.Guest)
c.logger.Debug("CPU Guest counter jumped backwards", "cpu", i, "old_value", cpuStats.Guest, "new_value", n.Guest)
}
if n.GuestNice >= cpuStats.GuestNice {
cpuStats.GuestNice = n.GuestNice
} else {
level.Debug(c.logger).Log("msg", "CPU GuestNice counter jumped backwards", "cpu", i, "old_value", cpuStats.GuestNice, "new_value", n.GuestNice)
c.logger.Debug("CPU GuestNice counter jumped backwards", "cpu", i, "old_value", cpuStats.GuestNice, "new_value", n.GuestNice)
}
c.cpuStats[i] = cpuStats

3
collector/cpu_linux_test.go
View file

@ -20,7 +20,6 @@ import (
"reflect"
"testing"
"github.com/go-kit/log"
"github.com/prometheus/procfs"
)
@ -35,7 +34,7 @@ func makeTestCPUCollector(s map[int64]procfs.CPUStat) *cpuCollector {
dup := make(map[int64]procfs.CPUStat, len(s))
copyStats(dup, s)
return &cpuCollector{
logger: log.NewNopLogger(),
logger: promspromslog.NewNopLogger(),
cpuStats: dup,
}
}

9
collector/cpu_netbsd.go
View file

@ -18,6 +18,7 @@ package collector
import (
"errors"
"log/slog"
"math"
"regexp"
"sort"
@ -25,8 +26,6 @@ import (
"strings"
"unsafe"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"golang.org/x/sys/unix"
@ -214,7 +213,7 @@ func getCPUTimes() ([]cputime, error) {
type statCollector struct {
cpu typedDesc
temp typedDesc
logger log.Logger
logger *slog.Logger
p PathConfig
}
@ -223,7 +222,7 @@ func init() {
}
// NewStatCollector returns a new Collector exposing CPU stats.
func NewStatCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewStatCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &statCollector{
cpu: typedDesc{nodeCPUSecondsDesc, prometheus.CounterValue},
temp: typedDesc{prometheus.NewDesc(
@ -271,7 +270,7 @@ func (c *statCollector) Update(ch chan<- prometheus.Metric) error {
if temp, ok := cpuTemperatures[cpu]; ok {
ch <- c.temp.mustNewConstMetric(temp, lcpu)
} else {
level.Debug(c.logger).Log("msg", "no temperature information for CPU", "cpu", cpu)
c.logger.Debug("no temperature information for CPU", "cpu", cpu)
ch <- c.temp.mustNewConstMetric(math.NaN(), lcpu)
}
}

6
collector/cpu_openbsd.go
View file

@ -17,10 +17,10 @@
package collector
import (
"log/slog"
"strconv"
"unsafe"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
"golang.org/x/sys/unix"
)
@ -45,14 +45,14 @@ const (
type cpuCollector struct {
cpu typedDesc
logger log.Logger
logger *slog.Logger
}
func init() {
registerCollector("cpu", defaultEnabled, NewCPUCollector)
}
func NewCPUCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewCPUCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &cpuCollector{
cpu: typedDesc{nodeCPUSecondsDesc, prometheus.CounterValue},
logger: logger,

6
collector/cpu_solaris.go
View file

@ -17,9 +17,9 @@
package collector
import (
"log/slog"
"strconv"
"github.com/go-kit/log"
"github.com/illumos/go-kstat"
"github.com/prometheus/client_golang/prometheus"
)
@ -29,14 +29,14 @@ import "C"
type cpuCollector struct {
cpu typedDesc
logger log.Logger
logger *slog.Logger
}
func init() {
registerCollector("cpu", defaultEnabled, NewCpuCollector)
}
func NewCpuCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewCpuCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &cpuCollector{
cpu: typedDesc{nodeCPUSecondsDesc, prometheus.CounterValue},
logger: logger,

4
collector/cpu_vulnerabilities_linux.go
View file

@ -15,8 +15,8 @@ package collector
import (
"fmt"
"log/slog"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs/sysfs"
)
@ -42,7 +42,7 @@ func init() {
registerCollector(cpuVulerabilitiesCollector, defaultDisabled, NewVulnerabilitySysfsCollector)
}
func NewVulnerabilitySysfsCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewVulnerabilitySysfsCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &cpuVulnerabilitiesCollector{config}, nil
}

6
collector/cpufreq_linux.go
View file

@ -18,16 +18,16 @@ package collector
import (
"fmt"
"log/slog"
"strings"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs/sysfs"
)
type cpuFreqCollector struct {
fs sysfs.FS
logger log.Logger
logger *slog.Logger
}
func init() {
@ -35,7 +35,7 @@ func init() {
}
// NewCPUFreqCollector returns a new Collector exposing kernel/system statistics.
func NewCPUFreqCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewCPUFreqCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
fs, err := sysfs.NewFS(*config.Path.SysPath)
if err != nil {
return nil, fmt.Errorf("failed to open sysfs: %w", err)

6
collector/cpufreq_solaris.go
View file

@ -18,9 +18,9 @@ package collector
import (
"fmt"
"log/slog"
"strconv"
"github.com/go-kit/log"
"github.com/illumos/go-kstat"
"github.com/prometheus/client_golang/prometheus"
)
@ -29,14 +29,14 @@ import (
import "C"
type cpuFreqCollector struct {
logger log.Logger
logger *slog.Logger
}
func init() {
registerCollector("cpufreq", defaultEnabled, NewCPUFreqCollector)
}
func NewCpuFreqCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewCpuFreqCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &cpuFreqCollector{
logger: logger,
}, nil

6
collector/devstat_dragonfly.go
View file

@ -19,8 +19,8 @@ package collector
import (
"errors"
"fmt"
"log/slog"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
)
@ -98,7 +98,7 @@ type devstatCollector struct {
bytesDesc *prometheus.Desc
transfersDesc *prometheus.Desc
blocksDesc *prometheus.Desc
logger log.Logger
logger *slog.Logger
}
func init() {
@ -106,7 +106,7 @@ func init() {
}
// NewDevstatCollector returns a new Collector exposing Device stats.
func NewDevstatCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewDevstatCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &devstatCollector{
bytesDesc: prometheus.NewDesc(
prometheus.BuildFQName(namespace, devstatSubsystem, "bytes_total"),

6
collector/devstat_freebsd.go
View file

@ -19,10 +19,10 @@ package collector
import (
"errors"
"fmt"
"log/slog"
"sync"
"unsafe"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
)
@ -43,7 +43,7 @@ type devstatCollector struct {
duration typedDesc
busyTime typedDesc
blocks typedDesc
logger log.Logger
logger *slog.Logger
}
func init() {
@ -51,7 +51,7 @@ func init() {
}
// NewDevstatCollector returns a new Collector exposing Device stats.
func NewDevstatCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewDevstatCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &devstatCollector{
devinfo: &C.struct_devinfo{},
bytes: typedDesc{prometheus.NewDesc(

11
collector/diskstats_common.go
View file

@ -19,9 +19,8 @@ package collector
import (
"errors"
"log/slog"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
)
@ -77,10 +76,10 @@ var (
)
)
func newDiskstatsDeviceFilter(config DiskstatsDeviceFilterConfig, logger log.Logger) (deviceFilter, error) {
func newDiskstatsDeviceFilter(config DiskstatsDeviceFilterConfig, logger *slog.Logger) (deviceFilter, error) {
if *config.OldDeviceExclude != "" {
if !config.DeviceExcludeSet {
level.Warn(logger).Log("msg", "--collector.diskstats.ignored-devices is DEPRECATED and will be removed in 2.0.0, use --collector.diskstats.device-exclude")
logger.Warn("--collector.diskstats.ignored-devices is DEPRECATED and will be removed in 2.0.0, use --collector.diskstats.device-exclude")
*config.DeviceExclude = *config.OldDeviceExclude
} else {
return deviceFilter{}, errors.New("--collector.diskstats.ignored-devices and --collector.diskstats.device-exclude are mutually exclusive")
@ -92,11 +91,11 @@ func newDiskstatsDeviceFilter(config DiskstatsDeviceFilterConfig, logger log.Log
}
if *config.DeviceExclude != "" {
level.Info(logger).Log("msg", "Parsed flag --collector.diskstats.device-exclude", "flag", *config.DeviceExclude)
logger.Info("Parsed flag --collector.diskstats.device-exclude", "flag", *config.DeviceExclude)
}
if *config.DeviceInclude != "" {
level.Info(logger).Log("msg", "Parsed Flag --collector.diskstats.device-include", "flag", *config.DeviceInclude)
logger.Info("Parsed Flag --collector.diskstats.device-include", "flag", *config.DeviceInclude)
}
if !config.DeviceExcludeSet { // use default exclude devices if flag is not set

6
collector/diskstats_darwin.go
View file

@ -18,8 +18,8 @@ package collector
import (
"fmt"
"log/slog"
"github.com/go-kit/log"
"github.com/lufia/iostat"
"github.com/prometheus/client_golang/prometheus"
)
@ -35,7 +35,7 @@ type diskstatsCollector struct {
descs []typedDescFunc
deviceFilter deviceFilter
logger log.Logger
logger *slog.Logger
}
func init() {
@ -43,7 +43,7 @@ func init() {
}
// NewDiskstatsCollector returns a new Collector exposing disk device stats.
func NewDiskstatsCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewDiskstatsCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
var diskLabelNames = []string{"device"}
deviceFilter, err := newDiskstatsDeviceFilter(config.DiskstatsDeviceFilter, logger)

15
collector/diskstats_linux.go
View file

@ -19,12 +19,11 @@ package collector
import (
"bufio"
"fmt"
"log/slog"
"os"
"strconv"
"strings"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs/blockdevice"
)
@ -85,7 +84,7 @@ type diskstatsCollector struct {
filesystemInfoDesc typedFactorDesc
deviceMapperInfoDesc typedFactorDesc
ataDescs map[string]typedFactorDesc
logger log.Logger
logger *slog.Logger
getUdevDeviceProperties func(*NodeCollectorConfig, uint32, uint32) (udevInfo, error)
config *NodeCollectorConfig
}
@ -96,7 +95,7 @@ func init() {
// NewDiskstatsCollector returns a new Collector exposing disk device stats.
// Docs from https://www.kernel.org/doc/Documentation/iostats.txt
func NewDiskstatsCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewDiskstatsCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
var diskLabelNames = []string{"device"}
fs, err := blockdevice.NewFS(*config.Path.ProcPath, *config.Path.SysPath)
if err != nil {
@ -264,7 +263,7 @@ func NewDiskstatsCollector(config *NodeCollectorConfig, logger log.Logger) (Coll
// Only enable getting device properties from udev if the directory is readable.
if stat, err := os.Stat(*config.Path.UdevDataPath); err != nil || !stat.IsDir() {
level.Error(logger).Log("msg", "Failed to open directory, disabling udev device properties", "path", *config.Path.UdevDataPath)
logger.Error("Failed to open directory, disabling udev device properties", "path", *config.Path.UdevDataPath)
} else {
collector.getUdevDeviceProperties = getUdevDeviceProperties
}
@ -286,7 +285,7 @@ func (c *diskstatsCollector) Update(ch chan<- prometheus.Metric) error {
info, err := getUdevDeviceProperties(c.config, stats.MajorNumber, stats.MinorNumber)
if err != nil {
level.Debug(c.logger).Log("msg", "Failed to parse udev info", "err", err)
c.logger.Debug("Failed to parse udev info", "err", err)
}
// This is usually the serial printed on the disk label.
@ -357,14 +356,14 @@ func (c *diskstatsCollector) Update(ch chan<- prometheus.Metric) error {
for attr, desc := range c.ataDescs {
str, ok := info[attr]
if !ok {
level.Debug(c.logger).Log("msg", "Udev attribute does not exist", "attribute", attr)
c.logger.Debug("Udev attribute does not exist", "attribute", attr)
continue
}
if value, err := strconv.ParseFloat(str, 64); err == nil {
ch <- desc.mustNewConstMetric(value, dev)
} else {
level.Error(c.logger).Log("msg", "Failed to parse ATA value", "err", err)
c.logger.Error("Failed to parse ATA value", "err", err)
}
}
}

11
collector/diskstats_linux_test.go
View file

@ -18,13 +18,13 @@ package collector
import (
"fmt"
"os"
"log/slog"
"strings"
"testing"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/client_golang/prometheus/testutil"
"github.com/prometheus/common/promslog"
)
type testDiskStatsCollector struct {
@ -39,7 +39,7 @@ func (c testDiskStatsCollector) Describe(ch chan<- *prometheus.Desc) {
prometheus.DescribeByCollect(c, ch)
}
func NewTestDiskStatsCollector(config *NodeCollectorConfig, logger log.Logger) (prometheus.Collector, error) {
func NewTestDiskStatsCollector(config *NodeCollectorConfig, logger *slog.Logger) (prometheus.Collector, error) {
dsc, err := NewDiskstatsCollector(config, logger)
if err != nil {
return testDiskStatsCollector{}, err
@ -331,12 +331,11 @@ node_disk_written_bytes_total{device="sr0"} 0
node_disk_written_bytes_total{device="vda"} 1.0938236928e+11
`
logger := log.NewLogfmtLogger(os.Stderr)
collector, err := NewDiskstatsCollector(config, logger)
collector, err := NewDiskstatsCollector(config, promslog.NewNopLogger())
if err != nil {
panic(err)
}
c, err := NewTestDiskStatsCollector(config, logger)
c, err := NewTestDiskStatsCollector(config, promslog.NewNopLogger())
if err != nil {
t.Fatal(err)
}

6
collector/diskstats_openbsd.go
View file

@ -18,9 +18,9 @@ package collector
import (
"fmt"
"log/slog"
"unsafe"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
"golang.org/x/sys/unix"
)
@ -41,7 +41,7 @@ type diskstatsCollector struct {
time typedDesc
deviceFilter deviceFilter
logger log.Logger
logger *slog.Logger
}
func init() {
@ -49,7 +49,7 @@ func init() {
}
// NewDiskstatsCollector returns a new Collector exposing disk device stats.
func NewDiskstatsCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewDiskstatsCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
deviceFilter, err := newDiskstatsDeviceFilter(config.DiskstatsDeviceFilter, logger)
if err != nil {
return nil, fmt.Errorf("failed to parse device filter flags: %w", err)

6
collector/diskstats_openbsd_amd64.go
View file

@ -18,9 +18,9 @@ package collector
import (
"fmt"
"log/slog"
"unsafe"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
"golang.org/x/sys/unix"
)
@ -52,7 +52,7 @@ type diskstatsCollector struct {
time typedDesc
deviceFilter deviceFilter
logger log.Logger
logger *slog.Logger
}
func init() {
@ -60,7 +60,7 @@ func init() {
}
// NewDiskstatsCollector returns a new Collector exposing disk device stats.
func NewDiskstatsCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewDiskstatsCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
deviceFilter, err := newDiskstatsDeviceFilter(config.DiskstatsDeviceFilter, logger)
if err != nil {
return nil, fmt.Errorf("failed to parse device filter flags: %w", err)

7
collector/dmi.go
View file

@ -19,11 +19,10 @@ package collector
import (
"errors"
"fmt"
"log/slog"
"os"
"strings"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs/sysfs"
)
@ -38,7 +37,7 @@ func init() {
}
// NewDMICollector returns a new Collector exposing DMI information.
func NewDMICollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewDMICollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
fs, err := sysfs.NewFS(*config.Path.SysPath)
if err != nil {
return nil, fmt.Errorf("failed to open sysfs: %w", err)
@ -47,7 +46,7 @@ func NewDMICollector(config *NodeCollectorConfig, logger log.Logger) (Collector,
dmi, err := fs.DMIClass()
if err != nil {
if errors.Is(err, os.ErrNotExist) {
level.Debug(logger).Log("msg", "Platform does not support Desktop Management Interface (DMI) information", "err", err)
logger.Debug("Platform does not support Desktop Management Interface (DMI) information", "err", err)
dmi = &sysfs.DMIClass{}
} else {
return nil, fmt.Errorf("failed to read Desktop Management Interface (DMI) information: %w", err)

13
collector/drbd_linux.go
View file

@ -20,12 +20,11 @@ import (
"bufio"
"errors"
"fmt"
"log/slog"
"os"
"strconv"
"strings"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
)
@ -79,7 +78,7 @@ type drbdCollector struct {
numerical map[string]drbdNumericalMetric
stringPair map[string]drbdStringPairMetric
connected *prometheus.Desc
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -87,7 +86,7 @@ func init() {
registerCollector("drbd", defaultDisabled, newDRBDCollector)
}
func newDRBDCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func newDRBDCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &drbdCollector{
numerical: map[string]drbdNumericalMetric{
"ns": newDRBDNumericalMetric(
@ -193,7 +192,7 @@ func (c *drbdCollector) Update(ch chan<- prometheus.Metric) error {
file, err := os.Open(statsFile)
if err != nil {
if errors.Is(err, os.ErrNotExist) {
level.Debug(c.logger).Log("msg", "stats file does not exist, skipping", "file", statsFile, "err", err)
c.logger.Debug("stats file does not exist, skipping", "file", statsFile, "err", err)
return ErrNoData
}
@ -210,7 +209,7 @@ func (c *drbdCollector) Update(ch chan<- prometheus.Metric) error {
kv := strings.Split(field, ":")
if len(kv) != 2 {
level.Debug(c.logger).Log("msg", "skipping invalid key:value pair", "field", field)
c.logger.Debug("skipping invalid key:value pair", "field", field)
continue
}
@ -276,7 +275,7 @@ func (c *drbdCollector) Update(ch chan<- prometheus.Metric) error {
continue
}
level.Debug(c.logger).Log("msg", "unhandled key-value pair", "key", kv[0], "value", kv[1])
c.logger.Debug("unhandled key-value pair", "key", kv[0], "value", kv[1])
}
return scanner.Err()

6
collector/drm_linux.go
View file

@ -18,8 +18,8 @@ package collector
import (
"fmt"
"log/slog"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs/sysfs"
)
@ -30,7 +30,7 @@ const (
type drmCollector struct {
fs sysfs.FS
logger log.Logger
logger *slog.Logger
CardInfo *prometheus.Desc
GPUBusyPercent *prometheus.Desc
MemoryGTTSize *prometheus.Desc
@ -46,7 +46,7 @@ func init() {
}
// NewDrmCollector returns a new Collector exposing /sys/class/drm/card?/device stats.
func NewDrmCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewDrmCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
fs, err := sysfs.NewFS(*config.Path.SysPath)
if err != nil {
return nil, fmt.Errorf("failed to open sysfs: %w", err)

6
collector/edac_linux.go
View file

@ -18,10 +18,10 @@ package collector
import (
"fmt"
"log/slog"
"path/filepath"
"regexp"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
)
@ -39,7 +39,7 @@ type edacCollector struct {
ueCount *prometheus.Desc
csRowCECount *prometheus.Desc
csRowUECount *prometheus.Desc
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -48,7 +48,7 @@ func init() {
}
// NewEdacCollector returns a new Collector exposing edac stats.
func NewEdacCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewEdacCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &edacCollector{
ceCount: prometheus.NewDesc(
prometheus.BuildFQName(namespace, edacSubsystem, "correctable_errors_total"),

6
collector/entropy_linux.go
View file

@ -18,8 +18,8 @@ package collector
import (
"fmt"
"log/slog"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs"
)
@ -28,7 +28,7 @@ type entropyCollector struct {
fs procfs.FS
entropyAvail *prometheus.Desc
entropyPoolSize *prometheus.Desc
logger log.Logger
logger *slog.Logger
}
func init() {
@ -36,7 +36,7 @@ func init() {
}
// NewEntropyCollector returns a new Collector exposing entropy stats.
func NewEntropyCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewEntropyCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
fs, err := procfs.NewFS(*config.Path.ProcPath)
if err != nil {
return nil, fmt.Errorf("failed to open procfs: %w", err)

31
collector/ethtool_linux.go
View file

@ -23,6 +23,7 @@ package collector
import (
"errors"
"fmt"
"log/slog"
"os"
"regexp"
"sort"
@ -30,8 +31,6 @@ import (
"sync"
"syscall"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs/sysfs"
"github.com/safchain/ethtool"
@ -75,13 +74,13 @@ type ethtoolCollector struct {
deviceFilter deviceFilter
infoDesc *prometheus.Desc
metricsPattern *regexp.Regexp
logger log.Logger
logger *slog.Logger
}
// makeEthtoolCollector is the internal constructor for EthtoolCollector.
// This allows NewEthtoolTestCollector to override its .ethtool interface
// for testing.
func makeEthtoolCollector(config *NodeCollectorConfig, logger log.Logger) (*ethtoolCollector, error) {
func makeEthtoolCollector(config *NodeCollectorConfig, logger *slog.Logger) (*ethtoolCollector, error) {
fs, err := sysfs.NewFS(*config.Path.SysPath)
if err != nil {
return nil, fmt.Errorf("failed to open sysfs: %w", err)
@ -209,7 +208,7 @@ func buildEthtoolFQName(metric string) string {
}
// NewEthtoolCollector returns a new Collector exposing ethtool stats.
func NewEthtoolCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewEthtoolCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return makeEthtoolCollector(config, logger)
}
@ -362,7 +361,7 @@ 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)
c.logger.Debug("Could not read netclass file", "err", err)
return ErrNoData
}
return fmt.Errorf("could not get net class info: %w", err)
@ -391,12 +390,12 @@ func (c *ethtoolCollector) Update(ch chan<- prometheus.Metric) error {
} 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))
c.logger.Debug("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))
c.logger.Error("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)
c.logger.Error("ethtool link info error", "err", err, "device", device)
}
}
@ -408,12 +407,12 @@ func (c *ethtoolCollector) Update(ch chan<- prometheus.Metric) error {
} 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))
c.logger.Debug("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))
c.logger.Error("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)
c.logger.Error("ethtool driver info error", "err", err, "device", device)
}
}
@ -424,12 +423,12 @@ func (c *ethtoolCollector) Update(ch chan<- prometheus.Metric) error {
if err != nil {
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))
c.logger.Debug("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))
c.logger.Error("ethtool stats error", "err", err, "device", device, "errno", uint(errno))
}
} else {
level.Error(c.logger).Log("msg", "ethtool stats error", "err", err, "device", device)
c.logger.Error("ethtool stats error", "err", err, "device", device)
}
}
@ -447,7 +446,7 @@ func (c *ethtoolCollector) Update(ch chan<- prometheus.Metric) error {
metricFQName := buildEthtoolFQName(metric)
existingMetric, exists := metricFQNames[metricFQName]
if exists {
level.Debug(c.logger).Log("msg", "dropping duplicate metric name", "device", device,
c.logger.Debug("dropping duplicate metric name", "device", device,
"metricFQName", metricFQName, "metric1", existingMetric, "metric2", metric)
// Keep the metric as "deleted" in the dict in case there are 3 duplicates.
metricFQNames[metricFQName] = ""

12
collector/ethtool_linux_test.go
View file

@ -19,6 +19,7 @@ package collector
import (
"bufio"
"fmt"
"log/slog"
"os"
"path/filepath"
"strconv"
@ -26,9 +27,9 @@ import (
"syscall"
"testing"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/client_golang/prometheus/testutil"
"github.com/prometheus/common/promslog"
"github.com/safchain/ethtool"
"golang.org/x/sys/unix"
)
@ -49,7 +50,7 @@ func (c testEthtoolCollector) Describe(ch chan<- *prometheus.Desc) {
prometheus.DescribeByCollect(c, ch)
}
func NewTestEthtoolCollector(config *NodeCollectorConfig, logger log.Logger) (prometheus.Collector, error) {
func NewTestEthtoolCollector(config *NodeCollectorConfig, logger *slog.Logger) (prometheus.Collector, error) {
dsc, err := NewEthtoolTestCollector(config, logger)
if err != nil {
return testEthtoolCollector{}, err
@ -255,7 +256,7 @@ func (e *EthtoolFixture) LinkInfo(intf string) (ethtool.EthtoolCmd, error) {
return res, err
}
func NewEthtoolTestCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewEthtoolTestCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
collector, err := makeEthtoolCollector(config, logger)
collector.ethtool = &EthtoolFixture{
fixturePath: "fixtures/ethtool/",
@ -378,12 +379,11 @@ node_network_supported_speed_bytes{device="eth0",duplex="half",mode="10baseT"} 1
sysPath := "fixtures/sys"
config.Path.SysPath = &sysPath
logger := log.NewLogfmtLogger(os.Stderr)
collector, err := NewEthtoolTestCollector(config, logger)
collector, err := NewEthtoolTestCollector(config, promslog.NewNopLogger())
if err != nil {
panic(err)
}
c, err := NewTestEthtoolCollector(config, logger)
c, err := NewTestEthtoolCollector(config, promslog.NewNopLogger())
if err != nil {
t.Fatal(err)
}

7
collector/exec_bsd.go
View file

@ -18,13 +18,14 @@
package collector
import (
"github.com/go-kit/log"
"log/slog"
"github.com/prometheus/client_golang/prometheus"
)
type execCollector struct {
sysctls []bsdSysctl
logger log.Logger
logger *slog.Logger
}
func init() {
@ -32,7 +33,7 @@ func init() {
}
// NewExecCollector returns a new Collector exposing system execution statistics.
func NewExecCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewExecCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
// From sys/vm/vm_meter.c:
// All are of type CTLTYPE_UINT.
//

9
collector/fibrechannel_linux.go
View file

@ -18,10 +18,9 @@ package collector
import (
"fmt"
"log/slog"
"os"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs/sysfs"
)
@ -31,7 +30,7 @@ const maxUint64 = ^uint64(0)
type fibrechannelCollector struct {
fs sysfs.FS
metricDescs map[string]*prometheus.Desc
logger log.Logger
logger *slog.Logger
subsystem string
}
@ -40,7 +39,7 @@ func init() {
}
// NewFibreChannelCollector returns a new Collector exposing FibreChannel stats.
func NewFibreChannelCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewFibreChannelCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
var i fibrechannelCollector
var err error
@ -110,7 +109,7 @@ func (c *fibrechannelCollector) Update(ch chan<- prometheus.Metric) error {
hosts, err := c.fs.FibreChannelClass()
if err != nil {
if os.IsNotExist(err) {
level.Debug(c.logger).Log("msg", "fibrechannel statistics not found, skipping")
c.logger.Debug("fibrechannel statistics not found, skipping")
return ErrNoData
}
return fmt.Errorf("error obtaining FibreChannel class info: %s", err)

6
collector/filefd_linux.go
View file

@ -20,10 +20,10 @@ import (
"bytes"
"fmt"
"io"
"log/slog"
"os"
"strconv"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
)
@ -32,7 +32,7 @@ const (
)
type fileFDStatCollector struct {
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -41,7 +41,7 @@ func init() {
}
// NewFileFDStatCollector returns a new Collector exposing file-nr stats.
func NewFileFDStatCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewFileFDStatCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &fileFDStatCollector{logger, config}, nil
}

6
collector/filesystem_bsd.go
View file

@ -20,8 +20,6 @@ package collector
import (
"errors"
"unsafe"
"github.com/go-kit/log/level"
)
/*
@ -51,14 +49,14 @@ func (c *filesystemCollector) GetStats(p PathConfig) (stats []filesystemStats, e
for i := 0; i < int(count); i++ {
mountpoint := C.GoString(&mnt[i].f_mntonname[0])
if c.excludedMountPointsPattern.MatchString(mountpoint) {
level.Debug(c.logger).Log("msg", "Ignoring mount point", "mountpoint", mountpoint)
c.logger.Debug("Ignoring mount point", "mountpoint", mountpoint)
continue
}
device := C.GoString(&mnt[i].f_mntfromname[0])
fstype := C.GoString(&mnt[i].f_fstypename[0])
if c.excludedFSTypesPattern.MatchString(fstype) {
level.Debug(c.logger).Log("msg", "Ignoring fs type", "type", fstype)
c.logger.Debug("Ignoring fs type", "type", fstype)
continue
}

18
collector/filesystem_common.go
View file

@ -19,10 +19,10 @@ package collector
import (
"errors"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"log/slog"
"regexp"
"github.com/prometheus/client_golang/prometheus"
)
// Arch-dependent implementation must define:
@ -41,7 +41,7 @@ type filesystemCollector struct {
sizeDesc, freeDesc, availDesc *prometheus.Desc
filesDesc, filesFreeDesc *prometheus.Desc
roDesc, deviceErrorDesc *prometheus.Desc
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -61,10 +61,10 @@ func init() {
}
// NewFilesystemCollector returns a new Collector exposing filesystems stats.
func NewFilesystemCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewFilesystemCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
if *config.Filesystem.OldMountPointsExcluded != "" {
if !config.Filesystem.MountPointsExcludeSet {
level.Warn(logger).Log("msg", "--collector.filesystem.ignored-mount-points is DEPRECATED and will be removed in 2.0.0, use --collector.filesystem.mount-points-exclude")
logger.Warn("--collector.filesystem.ignored-mount-points is DEPRECATED and will be removed in 2.0.0, use --collector.filesystem.mount-points-exclude")
*config.Filesystem.MountPointsExclude = *config.Filesystem.OldMountPointsExcluded
} else {
return nil, errors.New("--collector.filesystem.ignored-mount-points and --collector.filesystem.mount-points-exclude are mutually exclusive")
@ -72,7 +72,7 @@ func NewFilesystemCollector(config *NodeCollectorConfig, logger log.Logger) (Col
}
if *config.Filesystem.MountPointsExclude != "" {
level.Info(logger).Log("msg", "Parsed flag --collector.filesystem.mount-points-exclude", "flag", *config.Filesystem.MountPointsExclude)
logger.Info("Parsed flag --collector.filesystem.mount-points-exclude", "flag", *config.Filesystem.MountPointsExclude)
}
if !config.Filesystem.MountPointsExcludeSet { // use default mount points if flag is not set
@ -82,7 +82,7 @@ func NewFilesystemCollector(config *NodeCollectorConfig, logger log.Logger) (Col
if *config.Filesystem.OldFSTypesExcluded != "" {
if !config.Filesystem.FSTypesExcludeSet {
level.Warn(logger).Log("msg", "--collector.filesystem.ignored-fs-types is DEPRECATED and will be removed in 2.0.0, use --collector.filesystem.fs-types-exclude")
logger.Warn("--collector.filesystem.ignored-fs-types is DEPRECATED and will be removed in 2.0.0, use --collector.filesystem.fs-types-exclude")
*config.Filesystem.FSTypesExclude = *config.Filesystem.OldFSTypesExcluded
} else {
return nil, errors.New("--collector.filesystem.ignored-fs-types and --collector.filesystem.fs-types-exclude are mutually exclusive")
@ -90,7 +90,7 @@ func NewFilesystemCollector(config *NodeCollectorConfig, logger log.Logger) (Col
}
if *config.Filesystem.FSTypesExclude != "" {
level.Info(logger).Log("msg", "Parsed flag --collector.filesystem.fs-types-exclude", "flag", *config.Filesystem.FSTypesExclude)
logger.Info("Parsed flag --collector.filesystem.fs-types-exclude", "flag", *config.Filesystem.FSTypesExclude)
}
if !config.Filesystem.FSTypesExcludeSet { // use default fs types if flag is not set

7
collector/filesystem_freebsd.go
View file

@ -17,7 +17,6 @@
package collector
import (
"github.com/go-kit/log/level"
"golang.org/x/sys/unix"
)
@ -41,19 +40,19 @@ func (c *filesystemCollector) GetStats(_ PathConfig) ([]filesystemStats, error)
for _, fs := range buf {
mountpoint := unix.ByteSliceToString(fs.Mntonname[:])
if c.excludedMountPointsPattern.MatchString(mountpoint) {
level.Debug(c.logger).Log("msg", "Ignoring mount point", "mountpoint", mountpoint)
c.logger.Debug("Ignoring mount point", "mountpoint", mountpoint)
continue
}
device := unix.ByteSliceToString(fs.Mntfromname[:])
fstype := unix.ByteSliceToString(fs.Fstypename[:])
if c.excludedFSTypesPattern.MatchString(fstype) {
level.Debug(c.logger).Log("msg", "Ignoring fs type", "type", fstype)
c.logger.Debug("Ignoring fs type", "type", fstype)
continue
}
if (fs.Flags & unix.MNT_IGNORE) != 0 {
level.Debug(c.logger).Log("msg", "Ignoring mount flagged as ignore", "mountpoint", mountpoint)
c.logger.Debug("Ignoring mount flagged as ignore", "mountpoint", mountpoint)
continue
}

21
collector/filesystem_linux.go
View file

@ -21,13 +21,12 @@ import (
"errors"
"fmt"
"io"
"log/slog"
"os"
"strings"
"sync"
"time"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"golang.org/x/sys/unix"
)
@ -68,11 +67,11 @@ func (c *filesystemCollector) GetStats(_ PathConfig) ([]filesystemStats, error)
go func() {
for _, labels := range mps {
if c.excludedMountPointsPattern.MatchString(labels.mountPoint) {
level.Debug(c.logger).Log("msg", "Ignoring mount point", "mountpoint", labels.mountPoint)
c.logger.Debug("Ignoring mount point", "mountpoint", labels.mountPoint)
continue
}
if c.excludedFSTypesPattern.MatchString(labels.fsType) {
level.Debug(c.logger).Log("msg", "Ignoring fs", "type", labels.fsType)
c.logger.Debug("Ignoring fs", "type", labels.fsType)
continue
}
@ -82,7 +81,7 @@ func (c *filesystemCollector) GetStats(_ PathConfig) ([]filesystemStats, error)
labels: labels,
deviceError: 1,
})
level.Debug(c.logger).Log("msg", "Mount point is in an unresponsive state", "mountpoint", labels.mountPoint)
c.logger.Debug("Mount point is in an unresponsive state", "mountpoint", labels.mountPoint)
stuckMountsMtx.Unlock()
continue
}
@ -120,13 +119,13 @@ func (c *filesystemCollector) processStat(labels filesystemLabels) filesystemSta
// If the mount has been marked as stuck, unmark it and log it's recovery.
if _, ok := stuckMounts[labels.mountPoint]; ok {
level.Debug(c.logger).Log("msg", "Mount point has recovered, monitoring will resume", "mountpoint", labels.mountPoint)
c.logger.Debug("Mount point has recovered, monitoring will resume", "mountpoint", labels.mountPoint)
delete(stuckMounts, labels.mountPoint)
}
stuckMountsMtx.Unlock()
if err != nil {
level.Debug(c.logger).Log("msg", "Error on statfs() system call", "rootfs", c.config.Path.rootfsFilePath(labels.mountPoint), "err", err)
c.logger.Debug("Error on statfs() system call", "rootfs", c.config.Path.rootfsFilePath(labels.mountPoint), "err", err)
return filesystemStats{
labels: labels,
deviceError: 1,
@ -148,7 +147,7 @@ func (c *filesystemCollector) processStat(labels filesystemLabels) filesystemSta
// stuckMountWatcher listens on the given success channel and if the channel closes
// then the watcher does nothing. If instead the timeout is reached, the
// mount point that is being watched is marked as stuck.
func stuckMountWatcher(mountTimeout *time.Duration, mountPoint string, success chan struct{}, logger log.Logger) {
func stuckMountWatcher(mountTimeout *time.Duration, mountPoint string, success chan struct{}, logger *slog.Logger) {
mountCheckTimer := time.NewTimer(*mountTimeout)
defer mountCheckTimer.Stop()
select {
@ -161,18 +160,18 @@ func stuckMountWatcher(mountTimeout *time.Duration, mountPoint string, success c
case <-success:
// Success came in just after the timeout was reached, don't label the mount as stuck
default:
level.Debug(logger).Log("msg", "Mount point timed out, it is being labeled as stuck and will not be monitored", "mountpoint", mountPoint)
logger.Debug("Mount point timed out, it is being labeled as stuck and will not be monitored", "mountpoint", mountPoint)
stuckMounts[mountPoint] = struct{}{}
}
stuckMountsMtx.Unlock()
}
}
func mountPointDetails(config *NodeCollectorConfig, logger log.Logger) ([]filesystemLabels, error) {
func mountPointDetails(config *NodeCollectorConfig, logger *slog.Logger) ([]filesystemLabels, error) {
file, err := os.Open(config.Path.procFilePath("1/mounts"))
if errors.Is(err, os.ErrNotExist) {
// Fallback to `/proc/mounts` if `/proc/1/mounts` is missing due hidepid.
level.Debug(logger).Log("msg", "Reading root mounts failed, falling back to system mounts", "err", err)
logger.Debug("Reading root mounts failed, falling back to system mounts", "err", err)
file, err = os.Open(config.Path.procFilePath("mounts"))
}
if err != nil {

8
collector/filesystem_linux_test.go
View file

@ -20,7 +20,7 @@ import (
"strings"
"testing"
"github.com/go-kit/log"
"github.com/prometheus/common/promslog"
)
func Test_parseFilesystemLabelsError(t *testing.T) {
@ -82,7 +82,7 @@ func TestMountPointDetails(t *testing.T) {
"/var/lib/kubelet/plugins/kubernetes.io/vsphere-volume/mounts/[vsanDatastore] bafb9e5a-8856-7e6c-699c-801844e77a4a/kubernetes-dynamic-pvc-3eba5bba-48a3-11e8-89ab-005056b92113.vmdk": "",
}
filesystems, err := mountPointDetails(config, log.NewNopLogger())
filesystems, err := mountPointDetails(config, promslog.NewNopLogger())
if err != nil {
t.Log(err)
}
@ -103,7 +103,7 @@ func TestMountsFallback(t *testing.T) {
"/": "",
}
filesystems, err := mountPointDetails(config, log.NewNopLogger())
filesystems, err := mountPointDetails(config, promslog.NewNopLogger())
if err != nil {
t.Log(err)
}
@ -133,7 +133,7 @@ func TestPathRootfs(t *testing.T) {
"/sys/fs/cgroup": "",
}
filesystems, err := mountPointDetails(config, log.NewNopLogger())
filesystems, err := mountPointDetails(config, promslog.NewNopLogger())
if err != nil {
t.Log(err)
}

5
collector/filesystem_openbsd.go
View file

@ -17,7 +17,6 @@
package collector
import (
"github.com/go-kit/log/level"
"golang.org/x/sys/unix"
)
@ -43,14 +42,14 @@ func (c *filesystemCollector) GetStats(_ PathConfig) (stats []filesystemStats, e
for _, v := range mnt {
mountpoint := unix.ByteSliceToString(v.F_mntonname[:])
if c.excludedMountPointsPattern.MatchString(mountpoint) {
level.Debug(c.logger).Log("msg", "Ignoring mount point", "mountpoint", mountpoint)
c.logger.Debug("Ignoring mount point", "mountpoint", mountpoint)
continue
}
device := unix.ByteSliceToString(v.F_mntfromname[:])
fstype := unix.ByteSliceToString(v.F_fstypename[:])
if c.excludedFSTypesPattern.MatchString(fstype) {
level.Debug(c.logger).Log("msg", "Ignoring fs type", "type", fstype)
c.logger.Debug("Ignoring fs type", "type", fstype)
continue
}

11
collector/hwmon_linux.go
View file

@ -18,14 +18,13 @@ package collector
import (
"errors"
"log/slog"
"os"
"path/filepath"
"regexp"
"strconv"
"strings"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"golang.org/x/sys/unix"
)
@ -48,13 +47,13 @@ func init() {
type hwMonCollector struct {
deviceFilter deviceFilter
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
// NewHwMonCollector returns a new Collector exposing /sys/class/hwmon stats
// (similar to lm-sensors).
func NewHwMonCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewHwMonCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &hwMonCollector{
logger: logger,
@ -162,7 +161,7 @@ func (c *hwMonCollector) updateHwmon(ch chan<- prometheus.Metric, dir string) er
}
if c.deviceFilter.ignored(hwmonName) {
level.Debug(c.logger).Log("msg", "ignoring hwmon chip", "chip", hwmonName)
c.logger.Debug("ignoring hwmon chip", "chip", hwmonName)
return nil
}
@ -435,7 +434,7 @@ func (c *hwMonCollector) Update(ch chan<- prometheus.Metric) error {
hwmonFiles, err := os.ReadDir(hwmonPathName)
if err != nil {
if errors.Is(err, os.ErrNotExist) {
level.Debug(c.logger).Log("msg", "hwmon collector metrics are not available for this system")
c.logger.Debug("hwmon collector metrics are not available for this system")
return ErrNoData
}

9
collector/infiniband_linux.go
View file

@ -19,11 +19,10 @@ package collector
import (
"errors"
"fmt"
"log/slog"
"os"
"strconv"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs/sysfs"
)
@ -31,7 +30,7 @@ import (
type infinibandCollector struct {
fs sysfs.FS
metricDescs map[string]*prometheus.Desc
logger log.Logger
logger *slog.Logger
subsystem string
}
@ -40,7 +39,7 @@ func init() {
}
// NewInfiniBandCollector returns a new Collector exposing InfiniBand stats.
func NewInfiniBandCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewInfiniBandCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
var i infinibandCollector
var err error
@ -116,7 +115,7 @@ func (c *infinibandCollector) Update(ch chan<- prometheus.Metric) error {
devices, err := c.fs.InfiniBandClass()
if err != nil {
if errors.Is(err, os.ErrNotExist) {
level.Debug(c.logger).Log("msg", "infiniband statistics not found, skipping")
c.logger.Debug("infiniband statistics not found, skipping")
return ErrNoData
}
return fmt.Errorf("error obtaining InfiniBand class info: %w", err)

7
collector/interrupts_common.go
View file

@ -18,13 +18,14 @@
package collector
import (
"github.com/go-kit/log"
"log/slog"
"github.com/prometheus/client_golang/prometheus"
)
type interruptsCollector struct {
desc typedDesc
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -33,7 +34,7 @@ func init() {
}
// NewInterruptsCollector returns a new Collector exposing interrupts stats.
func NewInterruptsCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewInterruptsCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &interruptsCollector{
desc: typedDesc{prometheus.NewDesc(
namespace+"_interrupts_total",

11
collector/ipvs_linux.go
View file

@ -19,13 +19,12 @@ package collector
import (
"errors"
"fmt"
"log/slog"
"os"
"sort"
"strconv"
"strings"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs"
)
@ -36,7 +35,7 @@ type ipvsCollector struct {
backendLabels []string
backendConnectionsActive, backendConnectionsInact, backendWeight typedDesc
connections, incomingPackets, outgoingPackets, incomingBytes, outgoingBytes typedDesc
logger log.Logger
logger *slog.Logger
}
type ipvsBackendStatus struct {
@ -71,11 +70,11 @@ func init() {
// NewIPVSCollector sets up a new collector for IPVS metrics. It accepts the
// "procfs" config parameter to override the default proc location (/proc).
func NewIPVSCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewIPVSCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return newIPVSCollector(config, logger)
}
func newIPVSCollector(config *NodeCollectorConfig, logger log.Logger) (*ipvsCollector, error) {
func newIPVSCollector(config *NodeCollectorConfig, logger *slog.Logger) (*ipvsCollector, error) {
var (
c ipvsCollector
err error
@ -146,7 +145,7 @@ func (c *ipvsCollector) Update(ch chan<- prometheus.Metric) error {
if err != nil {
// Cannot access ipvs metrics, report no error.
if errors.Is(err, os.ErrNotExist) {
level.Debug(c.logger).Log("msg", "ipvs collector metrics are not available for this system")
c.logger.Debug("ipvs collector metrics are not available for this system")
return ErrNoData
}
return fmt.Errorf("could not get IPVS stats: %w", err)

7
collector/ipvs_linux_test.go
View file

@ -25,10 +25,9 @@ import (
"strings"
"testing"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/client_golang/prometheus/promhttp"
"github.com/prometheus/common/promslog"
)
func TestIPVSCollector(t *testing.T) {
@ -114,7 +113,7 @@ func TestIPVSCollector(t *testing.T) {
config.IPVS.LabelsSet = true
config.IPVS.Labels = &test.labels
}
collector, err := newIPVSCollector(config, log.NewNopLogger())
collector, err := newIPVSCollector(config, promslog.NewNopLogger())
if err != nil {
if test.err == nil {
t.Fatal(err)
@ -183,7 +182,7 @@ func TestIPVSCollectorResponse(t *testing.T) {
config.IPVS.LabelsSet = true
config.IPVS.Labels = &test.labels
}
collector, err := NewIPVSCollector(config, log.NewNopLogger())
collector, err := NewIPVSCollector(config, promslog.NewNopLogger())
if err != nil {
t.Fatal(err)
}

6
collector/ksmd_linux.go
View file

@ -18,9 +18,9 @@ package collector
import (
"fmt"
"log/slog"
"path/filepath"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
)
@ -31,7 +31,7 @@ var (
type ksmdCollector struct {
metricDescs map[string]*prometheus.Desc
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -51,7 +51,7 @@ func getCanonicalMetricName(filename string) string {
}
// NewKsmdCollector returns a new Collector exposing kernel/system statistics.
func NewKsmdCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewKsmdCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
subsystem := "ksmd"
descs := make(map[string]*prometheus.Desc)

6
collector/lnstat_linux.go
View file

@ -18,15 +18,15 @@ package collector
import (
"fmt"
"log/slog"
"strconv"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs"
)
type lnstatCollector struct {
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -34,7 +34,7 @@ func init() {
registerCollector("lnstat", defaultDisabled, NewLnstatCollector)
}
func NewLnstatCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewLnstatCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &lnstatCollector{logger, config}, nil
}

9
collector/loadavg.go
View file

@ -19,15 +19,14 @@ package collector
import (
"fmt"
"log/slog"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
)
type loadavgCollector struct {
metric []typedDesc
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -36,7 +35,7 @@ func init() {
}
// NewLoadavgCollector returns a new Collector exposing load average stats.
func NewLoadavgCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewLoadavgCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &loadavgCollector{
metric: []typedDesc{
{prometheus.NewDesc(namespace+"_load1", "1m load average.", nil, nil), prometheus.GaugeValue},
@ -54,7 +53,7 @@ func (c *loadavgCollector) Update(ch chan<- prometheus.Metric) error {
return fmt.Errorf("couldn't get load: %w", err)
}
for i, load := range loads {
level.Debug(c.logger).Log("msg", "return load", "index", i, "load", load)
c.logger.Debug("return load", "index", i, "load", load)
ch <- c.metric[i].mustNewConstMetric(load)
}
return err

6
collector/logind_linux.go
View file

@ -18,10 +18,10 @@ package collector
import (
"fmt"
"log/slog"
"os"
"strconv"
"github.com/go-kit/log"
"github.com/godbus/dbus/v5"
"github.com/prometheus/client_golang/prometheus"
)
@ -46,7 +46,7 @@ var (
)
type logindCollector struct {
logger log.Logger
logger *slog.Logger
}
type logindDbus struct {
@ -86,7 +86,7 @@ func init() {
}
// NewLogindCollector returns a new Collector exposing logind statistics.
func NewLogindCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewLogindCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &logindCollector{logger}, nil
}

11
collector/mdadm_linux.go
View file

@ -19,16 +19,15 @@ package collector
import (
"errors"
"fmt"
"log/slog"
"os"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs"
)
type mdadmCollector struct {
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -37,7 +36,7 @@ func init() {
}
// NewMdadmCollector returns a new Collector exposing raid statistics.
func NewMdadmCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewMdadmCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &mdadmCollector{logger, config}, nil
}
@ -113,7 +112,7 @@ func (c *mdadmCollector) Update(ch chan<- prometheus.Metric) error {
if err != nil {
if errors.Is(err, os.ErrNotExist) {
level.Debug(c.logger).Log("msg", "Not collecting mdstat, file does not exist", "file", *c.config.Path.ProcPath)
c.logger.Debug("Not collecting mdstat, file does not exist", "file", *c.config.Path.ProcPath)
return ErrNoData
}
@ -121,7 +120,7 @@ func (c *mdadmCollector) Update(ch chan<- prometheus.Metric) error {
}
for _, mdStat := range mdStats {
level.Debug(c.logger).Log("msg", "collecting metrics for device", "device", mdStat.Name)
c.logger.Debug("collecting metrics for device", "device", mdStat.Name)
stateVals := make(map[string]float64)
stateVals[mdStat.ActivityState] = 1

9
collector/meminfo.go
View file

@ -19,10 +19,9 @@ package collector
import (
"fmt"
"log/slog"
"strings"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
)
@ -31,7 +30,7 @@ const (
)
type meminfoCollector struct {
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -40,7 +39,7 @@ func init() {
}
// NewMeminfoCollector returns a new Collector exposing memory stats.
func NewMeminfoCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewMeminfoCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &meminfoCollector{logger, config}, nil
}
@ -52,7 +51,7 @@ func (c *meminfoCollector) Update(ch chan<- prometheus.Metric) error {
if err != nil {
return fmt.Errorf("couldn't get meminfo: %w", err)
}
level.Debug(c.logger).Log("msg", "Set node_mem", "memInfo", memInfo)
c.logger.Debug("Set node_mem", "memInfo", memInfo)
for k, v := range memInfo {
if strings.HasSuffix(k, "_total") {
metricType = prometheus.CounterValue

6
collector/meminfo_numa_linux.go
View file

@ -20,13 +20,13 @@ import (
"bufio"
"fmt"
"io"
"log/slog"
"os"
"path/filepath"
"regexp"
"strconv"
"strings"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
)
@ -45,7 +45,7 @@ type meminfoMetric struct {
type meminfoNumaCollector struct {
metricDescs map[string]*prometheus.Desc
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -54,7 +54,7 @@ func init() {
}
// NewMeminfoNumaCollector returns a new Collector exposing memory stats.
func NewMeminfoNumaCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewMeminfoNumaCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &meminfoNumaCollector{
metricDescs: map[string]*prometheus.Desc{},
logger: logger,

6
collector/memory_bsd.go
View file

@ -19,8 +19,8 @@ package collector
import (
"fmt"
"log/slog"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
"golang.org/x/sys/unix"
)
@ -33,7 +33,7 @@ type memoryCollector struct {
pageSize uint64
sysctls []bsdSysctl
kvm kvm
logger log.Logger
logger *slog.Logger
}
func init() {
@ -41,7 +41,7 @@ func init() {
}
// NewMemoryCollector returns a new Collector exposing memory stats.
func NewMemoryCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewMemoryCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
tmp32, err := unix.SysctlUint32("vm.stats.vm.v_page_size")
if err != nil {
return nil, fmt.Errorf("sysctl(vm.stats.vm.v_page_size) failed: %w", err)

9
collector/mountstats_linux.go
View file

@ -18,9 +18,8 @@ package collector
import (
"fmt"
"log/slog"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs"
)
@ -96,7 +95,7 @@ type mountStatsCollector struct {
proc procfs.Proc
logger log.Logger
logger *slog.Logger
}
// used to uniquely identify an NFS mount to prevent duplicates
@ -111,7 +110,7 @@ func init() {
}
// NewMountStatsCollector returns a new Collector exposing NFS statistics.
func NewMountStatsCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewMountStatsCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
fs, err := procfs.NewFS(*config.Path.ProcPath)
if err != nil {
return nil, fmt.Errorf("failed to open procfs: %w", err)
@ -541,7 +540,7 @@ func (c *mountStatsCollector) Update(ch chan<- prometheus.Metric) error {
deviceIdentifier := nfsDeviceIdentifier{m.Device, stats.Transport.Protocol, mountAddress}
i := deviceList[deviceIdentifier]
if i {
level.Debug(c.logger).Log("msg", "Skipping duplicate device entry", "device", deviceIdentifier)
c.logger.Debug("Skipping duplicate device entry", "device", deviceIdentifier)
continue
}

9
collector/netclass_linux.go
View file

@ -19,12 +19,11 @@ package collector
import (
"errors"
"fmt"
"log/slog"
"net"
"os"
"regexp"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs/sysfs"
)
@ -34,7 +33,7 @@ type netClassCollector struct {
subsystem string
ignoredDevicesPattern *regexp.Regexp
metricDescs map[string]*prometheus.Desc
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -43,7 +42,7 @@ func init() {
}
// NewNetClassCollector returns a new Collector exposing network class stats.
func NewNetClassCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewNetClassCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
fs, err := sysfs.NewFS(*config.Path.SysPath)
if err != nil {
return nil, fmt.Errorf("failed to open sysfs: %w", err)
@ -70,7 +69,7 @@ func (c *netClassCollector) netClassSysfsUpdate(ch chan<- prometheus.Metric) err
netClass, err := c.getNetClassInfo()
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)
c.logger.Debug("Could not read netclass file", "err", err)
return ErrNoData
}
return fmt.Errorf("could not get net class info: %w", err)

3
collector/netclass_rtnl_linux.go
View file

@ -22,7 +22,6 @@ import (
"io/fs"
"path/filepath"
"github.com/go-kit/log/level"
"github.com/jsimonetti/rtnetlink"
"github.com/mdlayher/ethtool"
"github.com/prometheus/client_golang/prometheus"
@ -43,7 +42,7 @@ func (c *netClassCollector) netClassRTNLUpdate(ch chan<- prometheus.Metric) erro
if !errors.Is(errors.Unwrap(err), fs.ErrNotExist) {
return fmt.Errorf("could not get link modes: %w", err)
}
level.Info(c.logger).Log("msg", "ETHTOOL netlink interface unavailable, duplex and linkspeed are not scraped.")
c.logger.Info("ETHTOOL netlink interface unavailable, duplex and linkspeed are not scraped.")
} else {
for _, lm := range lms {
if c.ignoredDevicesPattern.MatchString(lm.Interface.Name) {

8
collector/netdev_bsd.go
View file

@ -19,9 +19,7 @@ package collector
import (
"errors"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"log/slog"
)
/*
@ -34,7 +32,7 @@ import (
*/
import "C"
func getNetDevStats(_ *NodeCollectorConfig, _ *bool, filter *deviceFilter, logger log.Logger) (netDevStats, error) {
func getNetDevStats(_ *NodeCollectorConfig, _ *bool, filter *deviceFilter, logger *slog.Logger) (netDevStats, error) {
netDev := netDevStats{}
var ifap, ifa *C.struct_ifaddrs
@ -50,7 +48,7 @@ func getNetDevStats(_ *NodeCollectorConfig, _ *bool, filter *deviceFilter, logge
dev := C.GoString(ifa.ifa_name)
if filter.ignored(dev) {
level.Debug(logger).Log("msg", "Ignoring device", "device", dev)
logger.Debug("Ignoring device", "device", dev)
continue
}

15
collector/netdev_common.go
View file

@ -20,12 +20,11 @@ package collector
import (
"errors"
"fmt"
"log/slog"
"net"
"strconv"
"sync"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
)
@ -34,7 +33,7 @@ type netDevCollector struct {
deviceFilter deviceFilter
metricDescsMutex sync.Mutex
metricDescs map[string]*prometheus.Desc
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -45,10 +44,10 @@ func init() {
}
// NewNetDevCollector returns a new Collector exposing network device stats.
func NewNetDevCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewNetDevCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
if *config.NetDev.OldDeviceInclude != "" {
if *config.NetDev.DeviceInclude == "" {
level.Warn(logger).Log("msg", "--collector.netdev.device-whitelist is DEPRECATED and will be removed in 2.0.0, use --collector.netdev.device-include")
logger.Warn("--collector.netdev.device-whitelist is DEPRECATED and will be removed in 2.0.0, use --collector.netdev.device-include")
*config.NetDev.DeviceInclude = *config.NetDev.OldDeviceInclude
} else {
return nil, errors.New("--collector.netdev.device-whitelist and --collector.netdev.device-include are mutually exclusive")
@ -57,7 +56,7 @@ func NewNetDevCollector(config *NodeCollectorConfig, logger log.Logger) (Collect
if *config.NetDev.OldDeviceExclude != "" {
if *config.NetDev.DeviceExclude == "" {
level.Warn(logger).Log("msg", "--collector.netdev.device-blacklist is DEPRECATED and will be removed in 2.0.0, use --collector.netdev.device-exclude")
logger.Warn("--collector.netdev.device-blacklist is DEPRECATED and will be removed in 2.0.0, use --collector.netdev.device-exclude")
*config.NetDev.DeviceExclude = *config.NetDev.OldDeviceExclude
} else {
return nil, errors.New("--collector.netdev.device-blacklist and --collector.netdev.device-exclude are mutually exclusive")
@ -69,11 +68,11 @@ func NewNetDevCollector(config *NodeCollectorConfig, logger log.Logger) (Collect
}
if *config.NetDev.DeviceExclude != "" {
level.Info(logger).Log("msg", "Parsed flag --collector.netdev.device-exclude", "flag", *config.NetDev.DeviceExclude)
logger.Info("Parsed flag --collector.netdev.device-exclude", "flag", *config.NetDev.DeviceExclude)
}
if *config.NetDev.DeviceInclude != "" {
level.Info(logger).Log("msg", "Parsed Flag --collector.netdev.device-include", "flag", *config.NetDev.DeviceInclude)
logger.Info("Parsed Flag --collector.netdev.device-include", "flag", *config.NetDev.DeviceInclude)
}
return &netDevCollector{

9
collector/netdev_darwin.go
View file

@ -20,14 +20,13 @@ import (
"bytes"
"encoding/binary"
"fmt"
"log/slog"
"net"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"golang.org/x/sys/unix"
)
func getNetDevStats(_ *NodeCollectorConfig, _ *bool, filter *deviceFilter, logger log.Logger) (netDevStats, error) {
func getNetDevStats(_ *NodeCollectorConfig, _ *bool, filter *deviceFilter, logger *slog.Logger) (netDevStats, error) {
netDev := netDevStats{}
ifs, err := net.Interfaces()
@ -37,13 +36,13 @@ func getNetDevStats(_ *NodeCollectorConfig, _ *bool, filter *deviceFilter, logge
for _, iface := range ifs {
if filter.ignored(iface.Name) {
level.Debug(logger).Log("msg", "Ignoring device", "device", iface.Name)
logger.Debug("Ignoring device", "device", iface.Name)
continue
}
ifaceData, err := getIfaceData(iface.Index)
if err != nil {
level.Debug(logger).Log("msg", "failed to load data for interface", "device", iface.Name, "err", err)
logger.Debug("failed to load data for interface", "device", iface.Name, "err", err)
continue
}

19
collector/netdev_linux.go
View file

@ -18,21 +18,20 @@ package collector
import (
"fmt"
"log/slog"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/jsimonetti/rtnetlink"
"github.com/prometheus/procfs"
)
func getNetDevStats(config *NodeCollectorConfig, netDevNetlink *bool, filter *deviceFilter, logger log.Logger) (netDevStats, error) {
func getNetDevStats(config *NodeCollectorConfig, netDevNetlink *bool, filter *deviceFilter, logger *slog.Logger) (netDevStats, error) {
if *netDevNetlink {
return netlinkStats(filter, logger)
}
return procNetDevStats(config, filter, logger)
}
func netlinkStats(filter *deviceFilter, logger log.Logger) (netDevStats, error) {
func netlinkStats(filter *deviceFilter, logger *slog.Logger) (netDevStats, error) {
conn, err := rtnetlink.Dial(nil)
if err != nil {
return nil, err
@ -47,12 +46,12 @@ func netlinkStats(filter *deviceFilter, logger log.Logger) (netDevStats, error)
return parseNetlinkStats(links, filter, logger), nil
}
func parseNetlinkStats(links []rtnetlink.LinkMessage, filter *deviceFilter, logger log.Logger) netDevStats {
func parseNetlinkStats(links []rtnetlink.LinkMessage, filter *deviceFilter, logger *slog.Logger) netDevStats {
metrics := netDevStats{}
for _, msg := range links {
if msg.Attributes == nil {
level.Debug(logger).Log("msg", "No netlink attributes, skipping")
logger.Debug("No netlink attributes, skipping")
continue
}
name := msg.Attributes.Name
@ -88,13 +87,13 @@ func parseNetlinkStats(links []rtnetlink.LinkMessage, filter *deviceFilter, logg
}
if filter.ignored(name) {
level.Debug(logger).Log("msg", "Ignoring device", "device", name)
logger.Debug("Ignoring device", "device", name)
continue
}
// Make sure we don't panic when accessing `stats` attributes below.
if stats == nil {
level.Debug(logger).Log("msg", "No netlink stats, skipping")
logger.Debug("No netlink stats, skipping")
continue
}
@ -136,7 +135,7 @@ func parseNetlinkStats(links []rtnetlink.LinkMessage, filter *deviceFilter, logg
return metrics
}
func procNetDevStats(config *NodeCollectorConfig, filter *deviceFilter, logger log.Logger) (netDevStats, error) {
func procNetDevStats(config *NodeCollectorConfig, filter *deviceFilter, logger *slog.Logger) (netDevStats, error) {
metrics := netDevStats{}
fs, err := procfs.NewFS(*config.Path.ProcPath)
@ -153,7 +152,7 @@ func procNetDevStats(config *NodeCollectorConfig, filter *deviceFilter, logger l
name := stats.Name
if filter.ignored(name) {
level.Debug(logger).Log("msg", "Ignoring device", "device", name)
logger.Debug("Ignoring device", "device", name)
continue
}

13
collector/netdev_linux_test.go
View file

@ -19,9 +19,8 @@ package collector
import (
"testing"
"github.com/go-kit/log"
"github.com/jsimonetti/rtnetlink"
"github.com/prometheus/common/promslog"
)
var links = []rtnetlink.LinkMessage{
@ -166,7 +165,7 @@ var links = []rtnetlink.LinkMessage{
func TestNetDevStatsIgnore(t *testing.T) {
filter := newDeviceFilter("^veth", "")
netStats := parseNetlinkStats(links, &filter, log.NewNopLogger())
netStats := parseNetlinkStats(links, &filter, promslog.NewNopLogger())
if want, got := uint64(10437182923), netStats["wlan0"]["receive_bytes"]; want != got {
t.Errorf("want netstat wlan0 bytes %v, got %v", want, got)
@ -199,7 +198,7 @@ func TestNetDevStatsIgnore(t *testing.T) {
func TestNetDevStatsAccept(t *testing.T) {
filter := newDeviceFilter("", "^💩0$")
netStats := parseNetlinkStats(links, &filter, log.NewNopLogger())
netStats := parseNetlinkStats(links, &filter, promslog.NewNopLogger())
if want, got := 1, len(netStats); want != got {
t.Errorf("want count of devices to be %d, got %d", want, got)
@ -230,7 +229,7 @@ func TestNetDevLegacyMetricNames(t *testing.T) {
}
filter := newDeviceFilter("", "")
netStats := parseNetlinkStats(links, &filter, log.NewNopLogger())
netStats := parseNetlinkStats(links, &filter, promslog.NewNopLogger())
for dev, devStats := range netStats {
legacy(devStats)
@ -263,7 +262,7 @@ func TestNetDevLegacyMetricValues(t *testing.T) {
}
filter := newDeviceFilter("", "^enp0s0f0$")
netStats := parseNetlinkStats(links, &filter, log.NewNopLogger())
netStats := parseNetlinkStats(links, &filter, promslog.NewNopLogger())
metrics, ok := netStats["enp0s0f0"]
if !ok {
t.Error("expected stats for interface enp0s0f0")
@ -285,7 +284,7 @@ func TestNetDevLegacyMetricValues(t *testing.T) {
func TestNetDevMetricValues(t *testing.T) {
filter := newDeviceFilter("", "")
netStats := parseNetlinkStats(links, &filter, log.NewNopLogger())
netStats := parseNetlinkStats(links, &filter, promslog.NewNopLogger())
for _, msg := range links {
device := msg.Attributes.Name

8
collector/netdev_openbsd.go
View file

@ -18,9 +18,7 @@ package collector
import (
"errors"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"log/slog"
)
/*
@ -31,7 +29,7 @@ import (
*/
import "C"
func getNetDevStats(_ *NodeCollectorConfig, _ *bool, filter *deviceFilter, logger log.Logger) (netDevStats, error) {
func getNetDevStats(_ *NodeCollectorConfig, _ *bool, filter *deviceFilter, logger *slog.Logger) (netDevStats, error) {
netDev := netDevStats{}
var ifap, ifa *C.struct_ifaddrs
@ -47,7 +45,7 @@ func getNetDevStats(_ *NodeCollectorConfig, _ *bool, filter *deviceFilter, logge
dev := C.GoString(ifa.ifa_name)
if filter.ignored(dev) {
level.Debug(logger).Log("msg", "Ignoring device", "device", dev)
logger.Debug("Ignoring device", "device", dev)
continue
}

9
collector/netdev_openbsd_amd64.go
View file

@ -17,14 +17,13 @@
package collector
import (
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"log/slog"
"unsafe"
"golang.org/x/sys/unix"
"unsafe"
)
func getNetDevStats(_ *NodeCollectorConfig, _ *bool, filter *deviceFilter, logger log.Logger) (netDevStats, error) {
func getNetDevStats(_ *NodeCollectorConfig, _ *bool, filter *deviceFilter, logger *slog.Logger) (netDevStats, error) {
netDev := netDevStats{}
mib := [6]_C_int{unix.CTL_NET, unix.AF_ROUTE, 0, 0, unix.NET_RT_IFLIST, 0}
@ -54,7 +53,7 @@ func getNetDevStats(_ *NodeCollectorConfig, _ *bool, filter *deviceFilter, logge
data := ifm.Data
dev := int8ToString(dl.Data[:dl.Nlen])
if filter.ignored(dev) {
level.Debug(logger).Log("msg", "Ignoring device", "device", dev)
logger.Debug("Ignoring device", "device", dev)
continue
}

6
collector/netisr_freebsd.go
View file

@ -18,14 +18,14 @@ package collector
import (
"fmt"
"log/slog"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
)
type netisrCollector struct {
sysctls []bsdSysctl
logger log.Logger
logger *slog.Logger
}
const (
@ -36,7 +36,7 @@ func init() {
registerCollector("netisr", defaultEnabled, NewNetisrCollector)
}
func NewNetisrCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewNetisrCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &netisrCollector{
sysctls: []bsdSysctl{
{

6
collector/netstat_linux.go
View file

@ -21,12 +21,12 @@ import (
"errors"
"fmt"
"io"
"log/slog"
"os"
"regexp"
"strconv"
"strings"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
)
@ -36,7 +36,7 @@ const (
type netStatCollector struct {
fieldPattern *regexp.Regexp
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -46,7 +46,7 @@ func init() {
// NewNetStatCollector takes and returns
// a new Collector exposing network stats.
func NewNetStatCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewNetStatCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
pattern := regexp.MustCompile(*config.NetStat.Fields)
return &netStatCollector{
fieldPattern: pattern,

6
collector/network_route_linux.go
View file

@ -18,12 +18,12 @@ package collector
import (
"fmt"
"log/slog"
"net"
"strconv"
"golang.org/x/sys/unix"
"github.com/go-kit/log"
"github.com/jsimonetti/rtnetlink"
"github.com/prometheus/client_golang/prometheus"
)
@ -31,7 +31,7 @@ import (
type networkRouteCollector struct {
routeInfoDesc *prometheus.Desc
routesDesc *prometheus.Desc
logger log.Logger
logger *slog.Logger
}
func init() {
@ -39,7 +39,7 @@ func init() {
}
// NewNetworkRouteCollector returns a new Collector exposing systemd statistics.
func NewNetworkRouteCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewNetworkRouteCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
const subsystem = "network"
routeInfoDesc := prometheus.NewDesc(

9
collector/nfs_linux.go
View file

@ -19,11 +19,10 @@ package collector
import (
"errors"
"fmt"
"log/slog"
"os"
"reflect"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs/nfs"
)
@ -40,7 +39,7 @@ type nfsCollector struct {
nfsRPCRetransmissionsDesc *prometheus.Desc
nfsRPCAuthenticationRefreshesDesc *prometheus.Desc
nfsProceduresDesc *prometheus.Desc
logger log.Logger
logger *slog.Logger
}
func init() {
@ -48,7 +47,7 @@ func init() {
}
// NewNfsCollector returns a new Collector exposing NFS statistics.
func NewNfsCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewNfsCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
fs, err := nfs.NewFS(*config.Path.ProcPath)
if err != nil {
return nil, fmt.Errorf("failed to open procfs: %w", err)
@ -100,7 +99,7 @@ func (c *nfsCollector) Update(ch chan<- prometheus.Metric) error {
stats, err := c.fs.ClientRPCStats()
if err != nil {
if errors.Is(err, os.ErrNotExist) {
level.Debug(c.logger).Log("msg", "Not collecting NFS metrics", "err", err)
c.logger.Debug("Not collecting NFS metrics", "err", err)
return ErrNoData
}
return fmt.Errorf("failed to retrieve nfs stats: %w", err)

9
collector/nfsd_linux.go
View file

@ -19,10 +19,9 @@ package collector
import (
"errors"
"fmt"
"log/slog"
"os"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs/nfs"
)
@ -32,7 +31,7 @@ import (
type nfsdCollector struct {
fs nfs.FS
requestsDesc *prometheus.Desc
logger log.Logger
logger *slog.Logger
}
func init() {
@ -44,7 +43,7 @@ const (
)
// NewNFSdCollector returns a new Collector exposing /proc/net/rpc/nfsd statistics.
func NewNFSdCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewNFSdCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
fs, err := nfs.NewFS(*config.Path.ProcPath)
if err != nil {
return nil, fmt.Errorf("failed to open procfs: %w", err)
@ -66,7 +65,7 @@ func (c *nfsdCollector) Update(ch chan<- prometheus.Metric) error {
stats, err := c.fs.ServerRPCStats()
if err != nil {
if errors.Is(err, os.ErrNotExist) {
level.Debug(c.logger).Log("msg", "Not collecting NFSd metrics", "err", err)
c.logger.Debug("Not collecting NFSd metrics", "err", err)
return ErrNoData
}
return fmt.Errorf("failed to retrieve nfsd stats: %w", err)

9
collector/ntp.go
View file

@ -18,13 +18,12 @@ package collector
import (
"fmt"
"log/slog"
"net"
"sync"
"time"
"github.com/beevik/ntp"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
)
@ -40,7 +39,7 @@ var (
type ntpCollector struct {
stratum, leap, rtt, offset, reftime, rootDelay, rootDispersion, sanity typedDesc
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -52,7 +51,7 @@ func init() {
// Default definition of "local" is:
// - collector.ntp.server address is a loopback address (or collector.ntp.server-is-mine flag is turned on)
// - the server is reachable with outgoin IP_TTL = 1
func NewNtpCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewNtpCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
ipaddr := net.ParseIP(*config.NTP.Server)
if !*config.NTP.ServerIsLocal && (ipaddr == nil || !ipaddr.IsLoopback()) {
return nil, fmt.Errorf("only IP address of local NTP server is valid for --collector.ntp.server")
@ -70,7 +69,7 @@ func NewNtpCollector(config *NodeCollectorConfig, logger log.Logger) (Collector,
return nil, fmt.Errorf("invalid NTP port number %d; must be between 1 and 65535 inclusive", *config.NTP.ServerPort)
}
level.Warn(logger).Log("msg", "This collector is deprecated and will be removed in the next major version release.")
logger.Warn("This collector is deprecated and will be removed in the next major version release.")
return &ntpCollector{
stratum: typedDesc{prometheus.NewDesc(
prometheus.BuildFQName(namespace, ntpSubsystem, "stratum"),

9
collector/nvme_linux.go
View file

@ -19,17 +19,16 @@ package collector
import (
"errors"
"fmt"
"log/slog"
"os"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs/sysfs"
)
type nvmeCollector struct {
fs sysfs.FS
logger log.Logger
logger *slog.Logger
}
func init() {
@ -37,7 +36,7 @@ func init() {
}
// NewNVMeCollector returns a new Collector exposing NVMe stats.
func NewNVMeCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewNVMeCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
fs, err := sysfs.NewFS(*config.Path.SysPath)
if err != nil {
return nil, fmt.Errorf("failed to open sysfs: %w", err)
@ -53,7 +52,7 @@ func (c *nvmeCollector) Update(ch chan<- prometheus.Metric) error {
devices, err := c.fs.NVMeClass()
if err != nil {
if errors.Is(err, os.ErrNotExist) {
level.Debug(c.logger).Log("msg", "nvme statistics not found, skipping")
c.logger.Debug("nvme statistics not found, skipping")
return ErrNoData
}
return fmt.Errorf("error obtaining NVMe class info: %w", err)

11
collector/os_release.go
View file

@ -17,6 +17,7 @@ import (
"encoding/xml"
"errors"
"io"
"log/slog"
"os"
"regexp"
"strconv"
@ -24,8 +25,6 @@ import (
"sync"
"time"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
envparse "github.com/hashicorp/go-envparse"
"github.com/prometheus/client_golang/prometheus"
)
@ -57,7 +56,7 @@ type osRelease struct {
type osReleaseCollector struct {
infoDesc *prometheus.Desc
logger log.Logger
logger *slog.Logger
os *osRelease
osFilename string // file name of cached release information
osMtime time.Time // mtime of cached release file
@ -82,7 +81,7 @@ func init() {
}
// NewOSCollector returns a new Collector exposing os-release information.
func NewOSCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewOSCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &osReleaseCollector{
logger: logger,
infoDesc: prometheus.NewDesc(
@ -145,7 +144,7 @@ func (c *osReleaseCollector) UpdateStruct(path string) error {
c.osMutex.Lock()
defer c.osMutex.Unlock()
level.Debug(c.logger).Log("msg", "file modification time has changed",
c.logger.Debug("file modification time has changed",
"file", path, "old_value", c.osMtime, "new_value", t)
c.osFilename = path
c.osMtime = t
@ -182,7 +181,7 @@ func (c *osReleaseCollector) Update(ch chan<- prometheus.Metric) error {
}
if errors.Is(err, os.ErrNotExist) {
if i >= (len(c.osReleaseFilenames) - 1) {
level.Debug(c.logger).Log("msg", "no os-release file found", "files", strings.Join(c.osReleaseFilenames, ","))
c.logger.Debug("no os-release file found", "files", strings.Join(c.osReleaseFilenames, ","))
return ErrNoData
}
continue

4
collector/os_release_test.go
View file

@ -19,7 +19,7 @@ import (
"strings"
"testing"
"github.com/go-kit/log"
"github.com/prometheus/common/promslog"
)
const debianBullseye string = `PRETTY_NAME="Debian GNU/Linux 11 (bullseye)"
@ -87,7 +87,7 @@ func TestUpdateStruct(t *testing.T) {
}
wantedVersion := 20.04
collector, err := NewOSCollector(&NodeCollectorConfig{}, log.NewNopLogger())
collector, err := NewOSCollector(&NodeCollectorConfig{}, promslog.NewNopLogger())
if err != nil {
t.Fatal(err)
}

13
collector/perf_linux.go
View file

@ -18,12 +18,11 @@ package collector
import (
"fmt"
"log/slog"
"runtime"
"strconv"
"strings"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/hodgesds/perf-utils"
"github.com/prometheus/client_golang/prometheus"
"golang.org/x/sys/unix"
@ -177,7 +176,7 @@ type perfCollector struct {
perfSwProfilers map[int]*perf.SoftwareProfiler
perfCacheProfilers map[int]*perf.CacheProfiler
desc map[string]*prometheus.Desc
logger log.Logger
logger *slog.Logger
tracepointCollector *perfTracepointCollector
}
@ -187,7 +186,7 @@ type perfTracepointCollector struct {
// collection order is the sorted configured collection order of the profiler.
collectionOrder []string
logger log.Logger
logger *slog.Logger
profilers map[int]perf.GroupProfiler
}
@ -206,7 +205,7 @@ func (c *perfTracepointCollector) updateCPU(cpu int, ch chan<- prometheus.Metric
profiler := c.profilers[cpu]
p := &perf.GroupProfileValue{}
if err := profiler.Profile(p); err != nil {
level.Error(c.logger).Log("msg", "Failed to collect tracepoint profile", "err", err)
c.logger.Error("Failed to collect tracepoint profile", "err", err)
return err
}
@ -228,7 +227,7 @@ func (c *perfTracepointCollector) updateCPU(cpu int, ch chan<- prometheus.Metric
// newPerfTracepointCollector returns a configured perfTracepointCollector.
func newPerfTracepointCollector(
logger log.Logger,
logger *slog.Logger,
tracepointsFlag []string,
cpus []int,
) (*perfTracepointCollector, error) {
@ -289,7 +288,7 @@ func newPerfTracepointCollector(
// NewPerfCollector returns a new perf based collector, it creates a profiler
// per CPU.
func NewPerfCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewPerfCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
collector := &perfCollector{
perfHwProfilers: map[int]*perf.HardwareProfiler{},
perfSwProfilers: map[int]*perf.SoftwareProfiler{},

6
collector/perf_linux_test.go
View file

@ -23,8 +23,8 @@ import (
"strings"
"testing"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/common/promslog"
)
func canTestPerf(t *testing.T) {
@ -44,7 +44,7 @@ func canTestPerf(t *testing.T) {
func TestPerfCollector(t *testing.T) {
canTestPerf(t)
collector, err := NewPerfCollector(&NodeCollectorConfig{}, log.NewNopLogger())
collector, err := NewPerfCollector(&NodeCollectorConfig{}, promslog.NewNopLogger())
if err != nil {
t.Fatal(err)
}
@ -99,7 +99,7 @@ func TestPerfCollectorStride(t *testing.T) {
}
}
config.Perf.CPUs = &test.flag
collector, err := NewPerfCollector(config, log.NewNopLogger())
collector, err := NewPerfCollector(config, promslog.NewNopLogger())
if err != nil {
t.Fatal(err)
}

6
collector/powersupplyclass.go
View file

@ -18,9 +18,9 @@
package collector
import (
"log/slog"
"regexp"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
)
@ -28,7 +28,7 @@ type powerSupplyClassCollector struct {
subsystem string
ignoredPattern *regexp.Regexp
metricDescs map[string]*prometheus.Desc
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -36,7 +36,7 @@ func init() {
registerCollector("powersupplyclass", defaultEnabled, NewPowerSupplyClassCollector)
}
func NewPowerSupplyClassCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewPowerSupplyClassCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
pattern := regexp.MustCompile(*config.PowerSupplyClass.IgnoredPowerSupplies)
return &powerSupplyClassCollector{
subsystem: "power_supply",

15
collector/pressure_linux.go
View file

@ -19,11 +19,10 @@ package collector
import (
"errors"
"fmt"
"log/slog"
"os"
"syscall"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs"
)
@ -41,7 +40,7 @@ type pressureStatsCollector struct {
fs procfs.FS
logger log.Logger
logger *slog.Logger
}
func init() {
@ -49,7 +48,7 @@ func init() {
}
// NewPressureStatsCollector returns a Collector exposing pressure stall information
func NewPressureStatsCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewPressureStatsCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
fs, err := procfs.NewFS(*config.Path.ProcPath)
if err != nil {
return nil, fmt.Errorf("failed to open procfs: %w", err)
@ -89,15 +88,15 @@ func NewPressureStatsCollector(config *NodeCollectorConfig, logger log.Logger) (
// Update calls procfs.NewPSIStatsForResource for the different resources and updates the values
func (c *pressureStatsCollector) Update(ch chan<- prometheus.Metric) error {
for _, res := range psiResources {
level.Debug(c.logger).Log("msg", "collecting statistics for resource", "resource", res)
c.logger.Debug("collecting statistics for resource", "resource", res)
vals, err := c.fs.PSIStatsForResource(res)
if err != nil {
if errors.Is(err, os.ErrNotExist) {
level.Debug(c.logger).Log("msg", "pressure information is unavailable, you need a Linux kernel >= 4.20 and/or CONFIG_PSI enabled for your kernel")
c.logger.Debug("pressure information is unavailable, you need a Linux kernel >= 4.20 and/or CONFIG_PSI enabled for your kernel")
return ErrNoData
}
if errors.Is(err, syscall.ENOTSUP) {
level.Debug(c.logger).Log("msg", "pressure information is disabled, add psi=1 kernel command line to enable it")
c.logger.Debug("pressure information is disabled, add psi=1 kernel command line to enable it")
return ErrNoData
}
return fmt.Errorf("failed to retrieve pressure stats: %w", err)
@ -112,7 +111,7 @@ func (c *pressureStatsCollector) Update(ch chan<- prometheus.Metric) error {
ch <- prometheus.MustNewConstMetric(c.mem, prometheus.CounterValue, float64(vals.Some.Total)/1000.0/1000.0)
ch <- prometheus.MustNewConstMetric(c.memFull, prometheus.CounterValue, float64(vals.Full.Total)/1000.0/1000.0)
default:
level.Debug(c.logger).Log("msg", "did not account for resource", "resource", res)
c.logger.Debug("did not account for resource", "resource", res)
}
}

21
collector/processes_linux.go
View file

@ -19,14 +19,13 @@ package collector
import (
"errors"
"fmt"
"log/slog"
"os"
"path"
"strconv"
"strings"
"syscall"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs"
)
@ -39,7 +38,7 @@ type processCollector struct {
procsState *prometheus.Desc
pidUsed *prometheus.Desc
pidMax *prometheus.Desc
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -48,7 +47,7 @@ func init() {
}
// NewProcessStatCollector returns a new Collector exposing process data read from the proc filesystem.
func NewProcessStatCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewProcessStatCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
fs, err := procfs.NewFS(*config.Path.ProcPath)
if err != nil {
return nil, fmt.Errorf("failed to open procfs: %w", err)
@ -132,10 +131,10 @@ func (c *processCollector) getAllocatedThreads() (int, map[string]int32, int, ma
if err != nil {
// PIDs can vanish between getting the list and getting stats.
if c.isIgnoredError(err) {
level.Debug(c.logger).Log("msg", "file not found when retrieving stats for pid", "pid", pid.PID, "err", err)
c.logger.Debug("file not found when retrieving stats for pid", "pid", pid.PID, "err", err)
continue
}
level.Debug(c.logger).Log("msg", "error reading stat for pid", "pid", pid.PID, "err", err)
c.logger.Debug("error reading stat for pid", "pid", pid.PID, "err", err)
return 0, nil, 0, nil, fmt.Errorf("error reading stat for pid %d: %w", pid.PID, err)
}
pids++
@ -153,17 +152,17 @@ func (c *processCollector) getThreadStates(pid int, pidStat procfs.ProcStat, thr
fs, err := procfs.NewFS(c.config.Path.procFilePath(path.Join(strconv.Itoa(pid), "task")))
if err != nil {
if c.isIgnoredError(err) {
level.Debug(c.logger).Log("msg", "file not found when retrieving tasks for pid", "pid", pid, "err", err)
c.logger.Debug("file not found when retrieving tasks for pid", "pid", pid, "err", err)
return nil
}
level.Debug(c.logger).Log("msg", "error reading tasks for pid", "pid", pid, "err", err)
c.logger.Debug("error reading tasks for pid", "pid", pid, "err", err)
return fmt.Errorf("error reading task for pid %d: %w", pid, err)
}
t, err := fs.AllProcs()
if err != nil {
if c.isIgnoredError(err) {
level.Debug(c.logger).Log("msg", "file not found when retrieving tasks for pid", "pid", pid, "err", err)
c.logger.Debug("file not found when retrieving tasks for pid", "pid", pid, "err", err)
return nil
}
return fmt.Errorf("unable to list all threads for pid: %d %w", pid, err)
@ -177,10 +176,10 @@ func (c *processCollector) getThreadStates(pid int, pidStat procfs.ProcStat, thr
threadStat, err := thread.Stat()
if err != nil {
if c.isIgnoredError(err) {
level.Debug(c.logger).Log("msg", "file not found when retrieving stats for thread", "pid", pid, "threadId", thread.PID, "err", err)
c.logger.Debug("file not found when retrieving stats for thread", "pid", pid, "threadId", thread.PID, "err", err)
continue
}
level.Debug(c.logger).Log("msg", "error reading stat for thread", "pid", pid, "threadId", thread.PID, "err", err)
c.logger.Debug("error reading stat for thread", "pid", pid, "threadId", thread.PID, "err", err)
return fmt.Errorf("error reading stat for pid:%d thread:%d err:%w", pid, thread.PID, err)
}
threadStates[threadStat.State]++

4
collector/processes_linux_test.go
View file

@ -19,7 +19,7 @@ package collector
import (
"testing"
"github.com/go-kit/log"
"github.com/prometheus/common/promslog"
"github.com/prometheus/procfs"
)
@ -33,7 +33,7 @@ func TestReadProcessStatus(t *testing.T) {
if err != nil {
t.Errorf("failed to open procfs: %v", err)
}
c := processCollector{fs: fs, logger: log.NewNopLogger(), config: config}
c := processCollector{fs: fs, logger: promslog.NewNopLogger(), config: config}
pids, states, threads, _, err := c.getAllocatedThreads()
if err != nil {
t.Fatalf("Cannot retrieve data from procfs getAllocatedThreads function: %v ", err)

11
collector/qdisc_linux.go
View file

@ -19,17 +19,16 @@ package collector
import (
"encoding/json"
"fmt"
"log/slog"
"os"
"path/filepath"
"github.com/ema/qdisc"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
)
type qdiscStatCollector struct {
logger log.Logger
logger *slog.Logger
deviceFilter deviceFilter
bytes typedDesc
packets typedDesc
@ -46,10 +45,10 @@ func init() {
}
// NewQdiscStatCollector returns a new Collector exposing queuing discipline statistics.
func NewQdiscStatCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewQdiscStatCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
if *config.Qdisc.OldDeviceInclude != "" {
if *config.Qdisc.DeviceInclude == "" {
level.Warn(logger).Log("msg", "--collector.qdisk.device-include is DEPRECATED and will be removed in 2.0.0, use --collector.qdisc.device-include")
logger.Warn("--collector.qdisk.device-include is DEPRECATED and will be removed in 2.0.0, use --collector.qdisc.device-include")
*config.Qdisc.DeviceInclude = *config.Qdisc.OldDeviceInclude
} else {
return nil, fmt.Errorf("--collector.qdisk.device-include and --collector.qdisc.device-include are mutually exclusive")
@ -58,7 +57,7 @@ func NewQdiscStatCollector(config *NodeCollectorConfig, logger log.Logger) (Coll
if *config.Qdisc.OldDeviceExclude != "" {
if *config.Qdisc.DeviceExclude == "" {
level.Warn(logger).Log("msg", "--collector.qdisk.device-exclude is DEPRECATED and will be removed in 2.0.0, use --collector.qdisc.device-exclude")
logger.Warn("--collector.qdisk.device-exclude is DEPRECATED and will be removed in 2.0.0, use --collector.qdisc.device-exclude")
*config.Qdisc.DeviceExclude = *config.Qdisc.OldDeviceExclude
} else {
return nil, fmt.Errorf("--collector.qdisk.device-exclude and --collector.qdisc.device-exclude are mutually exclusive")

13
collector/rapl_linux.go
View file

@ -19,11 +19,10 @@ package collector
import (
"errors"
"fmt"
"log/slog"
"os"
"strconv"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs/sysfs"
)
@ -32,7 +31,7 @@ const raplCollectorSubsystem = "rapl"
type raplCollector struct {
fs sysfs.FS
logger log.Logger
logger *slog.Logger
joulesMetricDesc *prometheus.Desc
config *NodeCollectorConfig
@ -43,7 +42,7 @@ func init() {
}
// NewRaplCollector returns a new Collector exposing RAPL metrics.
func NewRaplCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewRaplCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
fs, err := sysfs.NewFS(*config.Path.SysPath)
if err != nil {
@ -71,11 +70,11 @@ func (c *raplCollector) Update(ch chan<- prometheus.Metric) error {
zones, err := sysfs.GetRaplZones(c.fs)
if err != nil {
if errors.Is(err, os.ErrNotExist) {
level.Debug(c.logger).Log("msg", "Platform doesn't have powercap files present", "err", err)
c.logger.Debug("Platform doesn't have powercap files present", "err", err)
return ErrNoData
}
if errors.Is(err, os.ErrPermission) {
level.Debug(c.logger).Log("msg", "Can't access powercap files", "err", err)
c.logger.Debug("Can't access powercap files", "err", err)
return ErrNoData
}
return fmt.Errorf("failed to retrieve rapl stats: %w", err)
@ -85,7 +84,7 @@ func (c *raplCollector) Update(ch chan<- prometheus.Metric) error {
microJoules, err := rz.GetEnergyMicrojoules()
if err != nil {
if errors.Is(err, os.ErrPermission) {
level.Debug(c.logger).Log("msg", "Can't access energy_uj file", "zone", rz, "err", err)
c.logger.Debug("Can't access energy_uj file", "zone", rz, "err", err)
return ErrNoData
}
return err

14
collector/runit.go
View file

@ -17,8 +17,8 @@
package collector
import (
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"log/slog"
"github.com/prometheus-community/go-runit/runit"
"github.com/prometheus/client_golang/prometheus"
)
@ -28,7 +28,7 @@ type runitCollector struct {
stateDesired typedDesc
stateNormal typedDesc
stateTimestamp typedDesc
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -37,14 +37,14 @@ func init() {
}
// NewRunitCollector returns a new Collector exposing runit statistics.
func NewRunitCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewRunitCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
var (
subsystem = "service"
constLabels = prometheus.Labels{"supervisor": "runit"}
labelNames = []string{"service"}
)
level.Warn(logger).Log("msg", "This collector is deprecated and will be removed in the next major version release.")
logger.Warn("This collector is deprecated and will be removed in the next major version release.")
return &runitCollector{
state: typedDesc{prometheus.NewDesc(
@ -81,11 +81,11 @@ func (c *runitCollector) Update(ch chan<- prometheus.Metric) error {
for _, service := range services {
status, err := service.Status()
if err != nil {
level.Debug(c.logger).Log("msg", "Couldn't get status", "service", service.Name, "err", err)
c.logger.Debug("Couldn't get status", "service", service.Name, "err", err)
continue
}
level.Debug(c.logger).Log("msg", "duration", "service", service.Name, "status", status.State, "pid", status.Pid, "duration_seconds", status.Duration)
c.logger.Debug("duration", "service", service.Name, "status", status.State, "pid", status.Pid, "duration_seconds", status.Duration)
ch <- c.state.mustNewConstMetric(float64(status.State), service.Name)
ch <- c.stateDesired.mustNewConstMetric(float64(status.Want), service.Name)
ch <- c.stateTimestamp.mustNewConstMetric(float64(status.Timestamp.Unix()), service.Name)

9
collector/schedstat_linux.go
View file

@ -19,10 +19,9 @@ package collector
import (
"errors"
"fmt"
"log/slog"
"os"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs"
)
@ -53,7 +52,7 @@ var (
)
// NewSchedstatCollector returns a new Collector exposing task scheduler statistics
func NewSchedstatCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewSchedstatCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
fs, err := procfs.NewFS(*config.Path.ProcPath)
if err != nil {
return nil, fmt.Errorf("failed to open procfs: %w", err)
@ -64,7 +63,7 @@ func NewSchedstatCollector(config *NodeCollectorConfig, logger log.Logger) (Coll
type schedstatCollector struct {
fs procfs.FS
logger log.Logger
logger *slog.Logger
}
func init() {
@ -75,7 +74,7 @@ func (c *schedstatCollector) Update(ch chan<- prometheus.Metric) error {
stats, err := c.fs.Schedstat()
if err != nil {
if errors.Is(err, os.ErrNotExist) {
level.Debug(c.logger).Log("msg", "schedstat file does not exist")
c.logger.Debug("schedstat file does not exist")
return ErrNoData
}
return err

7
collector/selinux_linux.go
View file

@ -17,7 +17,8 @@
package collector
import (
"github.com/go-kit/log"
"log/slog"
"github.com/opencontainers/selinux/go-selinux"
"github.com/prometheus/client_golang/prometheus"
)
@ -26,7 +27,7 @@ type selinuxCollector struct {
configMode *prometheus.Desc
currentMode *prometheus.Desc
enabled *prometheus.Desc
logger log.Logger
logger *slog.Logger
}
func init() {
@ -34,7 +35,7 @@ func init() {
}
// NewSelinuxCollector returns a new Collector exposing SELinux statistics.
func NewSelinuxCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewSelinuxCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
const subsystem = "selinux"
return &selinuxCollector{

6
collector/slabinfo_linux.go
View file

@ -18,15 +18,15 @@ package collector
import (
"fmt"
"log/slog"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs"
)
type slabinfoCollector struct {
fs procfs.FS
logger log.Logger
logger *slog.Logger
subsystem string
labels []string
}
@ -35,7 +35,7 @@ func init() {
registerCollector("slabinfo", defaultDisabled, NewSlabinfoCollector)
}
func NewSlabinfoCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewSlabinfoCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
fs, err := procfs.NewFS(*config.Path.ProcPath)
if err != nil {
return nil, fmt.Errorf("failed to open procfs: %w", err)

11
collector/sockstat_linux.go
View file

@ -19,10 +19,9 @@ package collector
import (
"errors"
"fmt"
"log/slog"
"os"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs"
)
@ -35,7 +34,7 @@ const (
var pageSize = os.Getpagesize()
type sockStatCollector struct {
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -44,7 +43,7 @@ func init() {
}
// NewSockStatCollector returns a new Collector exposing socket stats.
func NewSockStatCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewSockStatCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &sockStatCollector{logger, config}, nil
}
@ -59,7 +58,7 @@ func (c *sockStatCollector) Update(ch chan<- prometheus.Metric) error {
switch {
case err == nil:
case errors.Is(err, os.ErrNotExist):
level.Debug(c.logger).Log("msg", "IPv4 sockstat statistics not found, skipping")
c.logger.Debug("IPv4 sockstat statistics not found, skipping")
default:
return fmt.Errorf("failed to get IPv4 sockstat data: %w", err)
}
@ -68,7 +67,7 @@ func (c *sockStatCollector) Update(ch chan<- prometheus.Metric) error {
switch {
case err == nil:
case errors.Is(err, os.ErrNotExist):
level.Debug(c.logger).Log("msg", "IPv6 sockstat statistics not found, skipping")
c.logger.Debug("IPv6 sockstat statistics not found, skipping")
default:
return fmt.Errorf("failed to get IPv6 sockstat data: %w", err)
}

6
collector/softirqs_common.go
View file

@ -18,8 +18,8 @@ package collector
import (
"fmt"
"log/slog"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs"
)
@ -27,7 +27,7 @@ import (
type softirqsCollector struct {
fs procfs.FS
desc typedDesc
logger log.Logger
logger *slog.Logger
}
func init() {
@ -35,7 +35,7 @@ func init() {
}
// NewSoftirqsCollector returns a new Collector exposing softirq stats.
func NewSoftirqsCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewSoftirqsCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
desc := typedDesc{prometheus.NewDesc(
namespace+"_softirqs_functions_total",
"Softirq counts per CPU.",

6
collector/softnet_linux.go
View file

@ -18,9 +18,9 @@ package collector
import (
"fmt"
"log/slog"
"strconv"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs"
)
@ -34,7 +34,7 @@ type softnetCollector struct {
receivedRps *prometheus.Desc
flowLimitCount *prometheus.Desc
softnetBacklogLen *prometheus.Desc
logger log.Logger
logger *slog.Logger
}
const (
@ -46,7 +46,7 @@ func init() {
}
// NewSoftnetCollector returns a new Collector exposing softnet metrics.
func NewSoftnetCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewSoftnetCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
fs, err := procfs.NewFS(*config.Path.ProcPath)
if err != nil {
return nil, fmt.Errorf("failed to open procfs: %w", err)

6
collector/stat_linux.go
View file

@ -18,8 +18,8 @@ package collector
import (
"fmt"
"log/slog"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs"
)
@ -33,7 +33,7 @@ type statCollector struct {
procsRunning *prometheus.Desc
procsBlocked *prometheus.Desc
softIRQ *prometheus.Desc
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -42,7 +42,7 @@ func init() {
}
// NewStatCollector returns a new Collector exposing kernel/system statistics.
func NewStatCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewStatCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
fs, err := procfs.NewFS(*config.Path.ProcPath)
if err != nil {
return nil, fmt.Errorf("failed to open procfs: %w", err)

11
collector/supervisord.go
View file

@ -19,13 +19,12 @@ package collector
import (
"context"
"fmt"
"log/slog"
"net"
"net/http"
"net/url"
"time"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/mattn/go-xmlrpc"
"github.com/prometheus/client_golang/prometheus"
)
@ -39,7 +38,7 @@ type supervisordCollector struct {
stateDesc *prometheus.Desc
exitStatusDesc *prometheus.Desc
startTimeDesc *prometheus.Desc
logger log.Logger
logger *slog.Logger
}
func init() {
@ -47,7 +46,7 @@ func init() {
}
// NewSupervisordCollector returns a new Collector exposing supervisord statistics.
func NewSupervisordCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewSupervisordCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
var (
subsystem = "supervisord"
labelNames = []string{"name", "group"}
@ -67,7 +66,7 @@ func NewSupervisordCollector(config *NodeCollectorConfig, logger log.Logger) (Co
xrpc = xmlrpc.NewClient(*config.Supervisord.URL)
}
level.Warn(logger).Log("msg", "This collector is deprecated and will be removed in the next major version release.")
logger.Warn("This collector is deprecated and will be removed in the next major version release.")
return &supervisordCollector{
upDesc: prometheus.NewDesc(
@ -172,7 +171,7 @@ func (c *supervisordCollector) Update(ch chan<- prometheus.Metric) error {
} else {
ch <- prometheus.MustNewConstMetric(c.upDesc, prometheus.GaugeValue, 0, labels...)
}
level.Debug(c.logger).Log("msg", "process info", "group", info.Group, "name", info.Name, "state", info.StateName, "pid", info.PID)
c.logger.Debug("process info", "group", info.Group, "name", info.Name, "state", info.StateName, "pid", info.PID)
}
return nil

6
collector/sysctl_linux.go
View file

@ -15,10 +15,10 @@ package collector
import (
"fmt"
"log/slog"
"strconv"
"strings"
"github.com/go-kit/log"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs"
)
@ -29,7 +29,7 @@ var (
type sysctlCollector struct {
fs procfs.FS
logger log.Logger
logger *slog.Logger
sysctls []*sysctl
}
@ -37,7 +37,7 @@ func init() {
registerCollector("sysctl", defaultDisabled, NewSysctlCollector)
}
func NewSysctlCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewSysctlCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
fs, err := procfs.NewFS(*config.Path.ProcPath)
if err != nil {
return nil, fmt.Errorf("failed to open sysfs: %w", err)

65
collector/systemd_linux.go
View file

@ -20,6 +20,7 @@ import (
"context"
"errors"
"fmt"
"log/slog"
"math"
"regexp"
"strconv"
@ -28,8 +29,6 @@ import (
"time"
"github.com/coreos/go-systemd/v22/dbus"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
)
@ -60,7 +59,7 @@ type systemdCollector struct {
// Use regexps for more flexability than device_filter.go allows
systemdUnitIncludePattern *regexp.Regexp
systemdUnitExcludePattern *regexp.Regexp
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -71,7 +70,7 @@ func init() {
}
// NewSystemdCollector returns a new Collector exposing systemd statistics.
func NewSystemdCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewSystemdCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
const subsystem = "systemd"
unitDesc := prometheus.NewDesc(
@ -119,7 +118,7 @@ func NewSystemdCollector(config *NodeCollectorConfig, logger log.Logger) (Collec
if *config.Systemd.OldUnitExclude != "" {
if !config.Systemd.UnitExcludeSet {
level.Warn(logger).Log("msg", "--collector.systemd.unit-blacklist is DEPRECATED and will be removed in 2.0.0, use --collector.systemd.unit-exclude")
logger.Warn("--collector.systemd.unit-blacklist is DEPRECATED and will be removed in 2.0.0, use --collector.systemd.unit-exclude")
*config.Systemd.UnitExclude = *config.Systemd.OldUnitExclude
} else {
return nil, errors.New("--collector.systemd.unit-blacklist and --collector.systemd.unit-exclude are mutually exclusive")
@ -127,15 +126,15 @@ func NewSystemdCollector(config *NodeCollectorConfig, logger log.Logger) (Collec
}
if *config.Systemd.OldUnitInclude != "" {
if !config.Systemd.UnitIncludeSet {
level.Warn(logger).Log("msg", "--collector.systemd.unit-whitelist is DEPRECATED and will be removed in 2.0.0, use --collector.systemd.unit-include")
logger.Warn("--collector.systemd.unit-whitelist is DEPRECATED and will be removed in 2.0.0, use --collector.systemd.unit-include")
*config.Systemd.UnitInclude = *config.Systemd.OldUnitInclude
} else {
return nil, errors.New("--collector.systemd.unit-whitelist and --collector.systemd.unit-include are mutually exclusive")
}
}
level.Info(logger).Log("msg", "Parsed flag --collector.systemd.unit-include", "flag", *config.Systemd.UnitInclude)
logger.Info("Parsed flag --collector.systemd.unit-include", "flag", *config.Systemd.UnitInclude)
systemdUnitIncludePattern := regexp.MustCompile(fmt.Sprintf("^(?:%s)$", *config.Systemd.UnitInclude))
level.Info(logger).Log("msg", "Parsed flag --collector.systemd.unit-exclude", "flag", *config.Systemd.UnitExclude)
logger.Info("Parsed flag --collector.systemd.unit-exclude", "flag", *config.Systemd.UnitExclude)
systemdUnitExcludePattern := regexp.MustCompile(fmt.Sprintf("^(?:%s)$", *config.Systemd.UnitExclude))
return &systemdCollector{
@ -170,7 +169,7 @@ func (c *systemdCollector) Update(ch chan<- prometheus.Metric) error {
systemdVersion, systemdVersionFull := c.getSystemdVersion(conn)
if systemdVersion < minSystemdVersionSystemState {
level.Debug(c.logger).Log("msg", "Detected systemd version is lower than minimum, some systemd state and timer metrics will not be available", "current", systemdVersion, "minimum", minSystemdVersionSystemState)
c.logger.Debug("Detected systemd version is lower than minimum, some systemd state and timer metrics will not be available", "current", systemdVersion, "minimum", minSystemdVersionSystemState)
}
ch <- prometheus.MustNewConstMetric(
c.systemdVersionDesc,
@ -183,16 +182,16 @@ func (c *systemdCollector) Update(ch chan<- prometheus.Metric) error {
if err != nil {
return fmt.Errorf("couldn't get units: %w", err)
}
level.Debug(c.logger).Log("msg", "getAllUnits took", "duration_seconds", time.Since(begin).Seconds())
c.logger.Debug("getAllUnits took", "duration_seconds", time.Since(begin).Seconds())
begin = time.Now()
summary := summarizeUnits(allUnits)
c.collectSummaryMetrics(ch, summary)
level.Debug(c.logger).Log("msg", "collectSummaryMetrics took", "duration_seconds", time.Since(begin).Seconds())
c.logger.Debug("collectSummaryMetrics took", "duration_seconds", time.Since(begin).Seconds())
begin = time.Now()
units := filterUnits(allUnits, c.systemdUnitIncludePattern, c.systemdUnitExcludePattern, c.logger)
level.Debug(c.logger).Log("msg", "filterUnits took", "duration_seconds", time.Since(begin).Seconds())
c.logger.Debug("filterUnits took", "duration_seconds", time.Since(begin).Seconds())
var wg sync.WaitGroup
defer wg.Wait()
@ -202,7 +201,7 @@ func (c *systemdCollector) Update(ch chan<- prometheus.Metric) error {
defer wg.Done()
begin = time.Now()
c.collectUnitStatusMetrics(conn, ch, units)
level.Debug(c.logger).Log("msg", "collectUnitStatusMetrics took", "duration_seconds", time.Since(begin).Seconds())
c.logger.Debug("collectUnitStatusMetrics took", "duration_seconds", time.Since(begin).Seconds())
}()
if *c.config.Systemd.EnableStartTimeMetrics {
@ -211,7 +210,7 @@ func (c *systemdCollector) Update(ch chan<- prometheus.Metric) error {
defer wg.Done()
begin = time.Now()
c.collectUnitStartTimeMetrics(conn, ch, units)
level.Debug(c.logger).Log("msg", "collectUnitStartTimeMetrics took", "duration_seconds", time.Since(begin).Seconds())
c.logger.Debug("collectUnitStartTimeMetrics took", "duration_seconds", time.Since(begin).Seconds())
}()
}
@ -221,7 +220,7 @@ func (c *systemdCollector) Update(ch chan<- prometheus.Metric) error {
defer wg.Done()
begin = time.Now()
c.collectUnitTasksMetrics(conn, ch, units)
level.Debug(c.logger).Log("msg", "collectUnitTasksMetrics took", "duration_seconds", time.Since(begin).Seconds())
c.logger.Debug("collectUnitTasksMetrics took", "duration_seconds", time.Since(begin).Seconds())
}()
}
@ -231,7 +230,7 @@ func (c *systemdCollector) Update(ch chan<- prometheus.Metric) error {
defer wg.Done()
begin = time.Now()
c.collectTimers(conn, ch, units)
level.Debug(c.logger).Log("msg", "collectTimers took", "duration_seconds", time.Since(begin).Seconds())
c.logger.Debug("collectTimers took", "duration_seconds", time.Since(begin).Seconds())
}()
}
@ -240,13 +239,13 @@ func (c *systemdCollector) Update(ch chan<- prometheus.Metric) error {
defer wg.Done()
begin = time.Now()
c.collectSockets(conn, ch, units)
level.Debug(c.logger).Log("msg", "collectSockets took", "duration_seconds", time.Since(begin).Seconds())
c.logger.Debug("collectSockets took", "duration_seconds", time.Since(begin).Seconds())
}()
if systemdVersion >= minSystemdVersionSystemState {
begin = time.Now()
err = c.collectSystemState(conn, ch)
level.Debug(c.logger).Log("msg", "collectSystemState took", "duration_seconds", time.Since(begin).Seconds())
c.logger.Debug("collectSystemState took", "duration_seconds", time.Since(begin).Seconds())
}
return err
@ -258,14 +257,14 @@ func (c *systemdCollector) collectUnitStatusMetrics(conn *dbus.Conn, ch chan<- p
if strings.HasSuffix(unit.Name, ".service") {
serviceTypeProperty, err := conn.GetUnitTypePropertyContext(context.TODO(), unit.Name, "Service", "Type")
if err != nil {
level.Debug(c.logger).Log("msg", "couldn't get unit type", "unit", unit.Name, "err", err)
c.logger.Debug("couldn't get unit type", "unit", unit.Name, "err", err)
} else {
serviceType = serviceTypeProperty.Value.Value().(string)
}
} else if strings.HasSuffix(unit.Name, ".mount") {
serviceTypeProperty, err := conn.GetUnitTypePropertyContext(context.TODO(), unit.Name, "Mount", "Type")
if err != nil {
level.Debug(c.logger).Log("msg", "couldn't get unit type", "unit", unit.Name, "err", err)
c.logger.Debug("couldn't get unit type", "unit", unit.Name, "err", err)
} else {
serviceType = serviceTypeProperty.Value.Value().(string)
}
@ -283,7 +282,7 @@ func (c *systemdCollector) collectUnitStatusMetrics(conn *dbus.Conn, ch chan<- p
// NRestarts wasn't added until systemd 235.
restartsCount, err := conn.GetUnitTypePropertyContext(context.TODO(), unit.Name, "Service", "NRestarts")
if err != nil {
level.Debug(c.logger).Log("msg", "couldn't get unit NRestarts", "unit", unit.Name, "err", err)
c.logger.Debug("couldn't get unit NRestarts", "unit", unit.Name, "err", err)
} else {
ch <- prometheus.MustNewConstMetric(
c.nRestartsDesc, prometheus.CounterValue,
@ -301,7 +300,7 @@ func (c *systemdCollector) collectSockets(conn *dbus.Conn, ch chan<- prometheus.
acceptedConnectionCount, err := conn.GetUnitTypePropertyContext(context.TODO(), unit.Name, "Socket", "NAccepted")
if err != nil {
level.Debug(c.logger).Log("msg", "couldn't get unit NAccepted", "unit", unit.Name, "err", err)
c.logger.Debug("couldn't get unit NAccepted", "unit", unit.Name, "err", err)
continue
}
ch <- prometheus.MustNewConstMetric(
@ -310,7 +309,7 @@ func (c *systemdCollector) collectSockets(conn *dbus.Conn, ch chan<- prometheus.
currentConnectionCount, err := conn.GetUnitTypePropertyContext(context.TODO(), unit.Name, "Socket", "NConnections")
if err != nil {
level.Debug(c.logger).Log("msg", "couldn't get unit NConnections", "unit", unit.Name, "err", err)
c.logger.Debug("couldn't get unit NConnections", "unit", unit.Name, "err", err)
continue
}
ch <- prometheus.MustNewConstMetric(
@ -336,7 +335,7 @@ func (c *systemdCollector) collectUnitStartTimeMetrics(conn *dbus.Conn, ch chan<
} else {
timestampValue, err := conn.GetUnitPropertyContext(context.TODO(), unit.Name, "ActiveEnterTimestamp")
if err != nil {
level.Debug(c.logger).Log("msg", "couldn't get unit StartTimeUsec", "unit", unit.Name, "err", err)
c.logger.Debug("couldn't get unit StartTimeUsec", "unit", unit.Name, "err", err)
continue
}
startTimeUsec = timestampValue.Value.Value().(uint64)
@ -354,7 +353,7 @@ func (c *systemdCollector) collectUnitTasksMetrics(conn *dbus.Conn, ch chan<- pr
if strings.HasSuffix(unit.Name, ".service") {
tasksCurrentCount, err := conn.GetUnitTypePropertyContext(context.TODO(), unit.Name, "Service", "TasksCurrent")
if err != nil {
level.Debug(c.logger).Log("msg", "couldn't get unit TasksCurrent", "unit", unit.Name, "err", err)
c.logger.Debug("couldn't get unit TasksCurrent", "unit", unit.Name, "err", err)
} else {
val = tasksCurrentCount.Value.Value().(uint64)
// Don't set if tasksCurrent if dbus reports MaxUint64.
@ -366,7 +365,7 @@ func (c *systemdCollector) collectUnitTasksMetrics(conn *dbus.Conn, ch chan<- pr
}
tasksMaxCount, err := conn.GetUnitTypePropertyContext(context.TODO(), unit.Name, "Service", "TasksMax")
if err != nil {
level.Debug(c.logger).Log("msg", "couldn't get unit TasksMax", "unit", unit.Name, "err", err)
c.logger.Debug("couldn't get unit TasksMax", "unit", unit.Name, "err", err)
} else {
val = tasksMaxCount.Value.Value().(uint64)
// Don't set if tasksMax if dbus reports MaxUint64.
@ -388,7 +387,7 @@ func (c *systemdCollector) collectTimers(conn *dbus.Conn, ch chan<- prometheus.M
lastTriggerValue, err := conn.GetUnitTypePropertyContext(context.TODO(), unit.Name, "Timer", "LastTriggerUSec")
if err != nil {
level.Debug(c.logger).Log("msg", "couldn't get unit LastTriggerUSec", "unit", unit.Name, "err", err)
c.logger.Debug("couldn't get unit LastTriggerUSec", "unit", unit.Name, "err", err)
continue
}
@ -460,14 +459,14 @@ func summarizeUnits(units []unit) map[string]float64 {
return summarized
}
func filterUnits(units []unit, includePattern, excludePattern *regexp.Regexp, logger log.Logger) []unit {
func filterUnits(units []unit, includePattern, excludePattern *regexp.Regexp, logger *slog.Logger) []unit {
filtered := make([]unit, 0, len(units))
for _, unit := range units {
if includePattern.MatchString(unit.Name) && !excludePattern.MatchString(unit.Name) && unit.LoadState == "loaded" {
level.Debug(logger).Log("msg", "Adding unit", "unit", unit.Name)
logger.Debug("Adding unit", "unit", unit.Name)
filtered = append(filtered, unit)
} else {
level.Debug(logger).Log("msg", "Ignoring unit", "unit", unit.Name)
logger.Debug("Ignoring unit", "unit", unit.Name)
}
}
@ -477,15 +476,15 @@ func filterUnits(units []unit, includePattern, excludePattern *regexp.Regexp, lo
func (c *systemdCollector) getSystemdVersion(conn *dbus.Conn) (float64, string) {
version, err := conn.GetManagerProperty("Version")
if err != nil {
level.Debug(c.logger).Log("msg", "Unable to get systemd version property, defaulting to 0")
c.logger.Debug("Unable to get systemd version property, defaulting to 0")
return 0, ""
}
version = strings.TrimPrefix(strings.TrimSuffix(version, `"`), `"`)
level.Debug(c.logger).Log("msg", "Got systemd version", "version", version)
c.logger.Debug("Got systemd version", "version", version)
parsedVersion := systemdVersionRE.FindString(version)
v, err := strconv.ParseFloat(parsedVersion, 64)
if err != nil {
level.Debug(c.logger).Log("msg", "Got invalid systemd version", "version", version)
c.logger.Debug("Got invalid systemd version", "version", version)
return 0, ""
}
return v, version

6
collector/systemd_linux_test.go
View file

@ -21,7 +21,7 @@ import (
"testing"
"github.com/coreos/go-systemd/v22/dbus"
"github.com/go-kit/log"
"github.com/prometheus/common/promslog"
)
// Creates mock UnitLists
@ -94,7 +94,7 @@ func TestSystemdIgnoreFilter(t *testing.T) {
fixtures := getUnitListFixtures()
includePattern := regexp.MustCompile("^foo$")
excludePattern := regexp.MustCompile("^bar$")
filtered := filterUnits(fixtures[0], includePattern, excludePattern, log.NewNopLogger())
filtered := filterUnits(fixtures[0], includePattern, excludePattern, promslog.NewNopLogger())
for _, unit := range filtered {
if excludePattern.MatchString(unit.Name) || !includePattern.MatchString(unit.Name) {
t.Error(unit.Name, "should not be in the filtered list")
@ -102,7 +102,7 @@ func TestSystemdIgnoreFilter(t *testing.T) {
}
}
func TestSystemdIgnoreFilterDefaultKeepsAll(t *testing.T) {
logger := log.NewNopLogger()
logger := promslog.NewNopLogger()
defaultInclude := ".+"
defaultExclude := ".+\\.(automount|device|mount|scope|slice)"
config := &NodeCollectorConfig{Systemd: SystemdConfig{

11
collector/tapestats_linux.go
View file

@ -18,11 +18,10 @@ package collector
import (
"fmt"
"log/slog"
"os"
"regexp"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/procfs/sysfs"
)
@ -40,7 +39,7 @@ type tapestatsCollector struct {
writeTimeSeconds *prometheus.Desc
residualTotal *prometheus.Desc
fs sysfs.FS
logger log.Logger
logger *slog.Logger
}
func init() {
@ -49,7 +48,7 @@ func init() {
// NewTapestatsCollector returns a new Collector exposing tape device stats.
// Docs from https://www.kernel.org/doc/html/latest/scsi/st.html#sysfs-and-statistics-for-tape-devices
func NewTapestatsCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewTapestatsCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
var tapeLabelNames = []string{"device"}
fs, err := sysfs.NewFS(*config.Path.SysPath)
@ -121,7 +120,7 @@ func (c *tapestatsCollector) Update(ch chan<- prometheus.Metric) error {
tapes, err := c.fs.SCSITapeClass()
if err != nil {
if os.IsNotExist(err) {
level.Debug(c.logger).Log("msg", "scsi_tape stats not found, skipping")
c.logger.Debug("scsi_tape stats not found, skipping")
return ErrNoData
}
return fmt.Errorf("error obtaining SCSITape class info: %s", err)
@ -129,7 +128,7 @@ func (c *tapestatsCollector) Update(ch chan<- prometheus.Metric) error {
for _, tape := range tapes {
if c.ignoredDevicesPattern.MatchString(tape.Name) {
level.Debug(c.logger).Log("msg", "Ignoring device", "device", tape.Name)
c.logger.Debug("Ignoring device", "device", tape.Name)
continue
}
ch <- prometheus.MustNewConstMetric(c.ioNow, prometheus.GaugeValue, float64(tape.Counters.InFlight), tape.Name)

6
collector/tcpstat_linux.go
View file

@ -18,11 +18,11 @@ package collector
import (
"fmt"
"log/slog"
"os"
"syscall"
"unsafe"
"github.com/go-kit/log"
"github.com/mdlayher/netlink"
"github.com/prometheus/client_golang/prometheus"
)
@ -60,7 +60,7 @@ const (
type tcpStatCollector struct {
desc typedDesc
logger log.Logger
logger *slog.Logger
config *NodeCollectorConfig
}
@ -69,7 +69,7 @@ func init() {
}
// NewTCPStatCollector returns a new Collector exposing network stats.
func NewTCPStatCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewTCPStatCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
return &tcpStatCollector{
desc: typedDesc{prometheus.NewDesc(
prometheus.BuildFQName(namespace, "tcp", "connection_states"),

15
collector/textfile.go
View file

@ -18,14 +18,13 @@ package collector
import (
"fmt"
"log/slog"
"os"
"path/filepath"
"sort"
"strings"
"time"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
"github.com/prometheus/client_golang/prometheus"
dto "github.com/prometheus/client_model/go"
"github.com/prometheus/common/expfmt"
@ -44,7 +43,7 @@ type textFileCollector struct {
path string
// Only set for testing to get predictable output.
mtime *float64
logger log.Logger
logger *slog.Logger
}
func init() {
@ -53,7 +52,7 @@ func init() {
// NewTextFileCollector returns a new Collector exposing metrics read from files
// in the given textfile directory.
func NewTextFileCollector(config *NodeCollectorConfig, logger log.Logger) (Collector, error) {
func NewTextFileCollector(config *NodeCollectorConfig, logger *slog.Logger) (Collector, error) {
c := &textFileCollector{
path: *config.TextFile.Directory,
logger: logger,
@ -61,7 +60,7 @@ func NewTextFileCollector(config *NodeCollectorConfig, logger log.Logger) (Colle
return c, nil
}
func convertMetricFamily(metricFamily *dto.MetricFamily, ch chan<- prometheus.Metric, logger log.Logger) {
func convertMetricFamily(metricFamily *dto.MetricFamily, ch chan<- prometheus.Metric, logger *slog.Logger) {
var valType prometheus.ValueType
var val float64
@ -77,7 +76,7 @@ func convertMetricFamily(metricFamily *dto.MetricFamily, ch chan<- prometheus.Me
for _, metric := range metricFamily.Metric {
if metric.TimestampMs != nil {
level.Warn(logger).Log("msg", "Ignoring unsupported custom timestamp on textfile collector metric", "metric", metric)
logger.Warn("Ignoring unsupported custom timestamp on textfile collector metric", "metric", metric)
}
labels := metric.GetLabel()
@ -204,7 +203,7 @@ func (c *textFileCollector) Update(ch chan<- prometheus.Metric) error {
files, err := os.ReadDir(path)
if err != nil && path != "" {
errored = true
level.Error(c.logger).Log("msg", "failed to read textfile collector directory", "path", path, "err", err)
c.logger.Error("failed to read textfile collector directory", "path", path, "err", err)
}
for _, f := range files {
@ -222,7 +221,7 @@ func (c *textFileCollector) Update(ch chan<- prometheus.Metric) error {
if err != nil {
errored = true
level.Error(c.logger).Log("msg", "failed to collect textfile data", "file", f.Name(), "err", err)
c.logger.Error("failed to collect textfile data", "file", f.Name(), "err", err)
continue
}

Some files were not shown because too many files have changed in this diff Show more