RepoMirrors
/
node_exporter
mirror of https://github.com/prometheus/node_exporter
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

collector: reimplement sockstat collector with procfs (#1552) 

* collector: reimplement sockstat collector with procfs
* collector: handle sockstat IPv4 disabled, debug logging

Signed-off-by: Matt Layher <mdlayher@gmail.com>
This commit is contained in:
Matt Layher 2019-11-25 14:41:38 -05:00 committed by Ben Kochie
parent 3c2c4e7b3c
commit da6b66371f
15 changed files with 380 additions and 348 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@ -25,6 +25,7 @@
* [ENHANCEMENT] Report non-fatal collection errors in the exporter metric. #1439
* [ENHANCEMENT] Expose IPVS firewall mark as a label #1455
* [ENHANCEMENT] Add check for systemd version before attempting to query certain metrics. #1413
* [ENHANCEMENT] The sockstat collector now exposes IPv6 statistics in addition to the existing IPv4 support.
* [BUGFIX] Renamed label `state` to `name` on `node_systemd_service_restart_total`. #1393
* [BUGFIX] Fix netdev nil reference on Darwin #1414
* [BUGFIX] Strip path.rootfs from mountpoint labels #1421

20
collector/fixtures/e2e-output.txt
View File

@ -2575,15 +2575,27 @@ node_scrape_collector_success{collector="vmstat"} 1
node_scrape_collector_success{collector="wifi"} 1
node_scrape_collector_success{collector="xfs"} 1
node_scrape_collector_success{collector="zfs"} 1
# HELP node_sockstat_FRAG6_inuse Number of FRAG6 sockets in state inuse.
# TYPE node_sockstat_FRAG6_inuse gauge
node_sockstat_FRAG6_inuse 0
# HELP node_sockstat_FRAG6_memory Number of FRAG6 sockets in state memory.
# TYPE node_sockstat_FRAG6_memory gauge
node_sockstat_FRAG6_memory 0
# HELP node_sockstat_FRAG_inuse Number of FRAG sockets in state inuse.
# TYPE node_sockstat_FRAG_inuse gauge
node_sockstat_FRAG_inuse 0
# HELP node_sockstat_FRAG_memory Number of FRAG sockets in state memory.
# TYPE node_sockstat_FRAG_memory gauge
node_sockstat_FRAG_memory 0
# HELP node_sockstat_RAW6_inuse Number of RAW6 sockets in state inuse.
# TYPE node_sockstat_RAW6_inuse gauge
node_sockstat_RAW6_inuse 1
# HELP node_sockstat_RAW_inuse Number of RAW sockets in state inuse.
# TYPE node_sockstat_RAW_inuse gauge
node_sockstat_RAW_inuse 0
# HELP node_sockstat_TCP6_inuse Number of TCP6 sockets in state inuse.
# TYPE node_sockstat_TCP6_inuse gauge
node_sockstat_TCP6_inuse 17
# HELP node_sockstat_TCP_alloc Number of TCP sockets in state alloc.
# TYPE node_sockstat_TCP_alloc gauge
node_sockstat_TCP_alloc 17
@ -2602,6 +2614,12 @@ node_sockstat_TCP_orphan 0
# HELP node_sockstat_TCP_tw Number of TCP sockets in state tw.
# TYPE node_sockstat_TCP_tw gauge
node_sockstat_TCP_tw 4
# HELP node_sockstat_UDP6_inuse Number of UDP6 sockets in state inuse.
# TYPE node_sockstat_UDP6_inuse gauge
node_sockstat_UDP6_inuse 9
# HELP node_sockstat_UDPLITE6_inuse Number of UDPLITE6 sockets in state inuse.
# TYPE node_sockstat_UDPLITE6_inuse gauge
node_sockstat_UDPLITE6_inuse 0
# HELP node_sockstat_UDPLITE_inuse Number of UDPLITE sockets in state inuse.
# TYPE node_sockstat_UDPLITE_inuse gauge
node_sockstat_UDPLITE_inuse 0
@ -2614,7 +2632,7 @@ node_sockstat_UDP_mem 0
# HELP node_sockstat_UDP_mem_bytes Number of UDP sockets in state mem_bytes.
# TYPE node_sockstat_UDP_mem_bytes gauge
node_sockstat_UDP_mem_bytes 0
# HELP node_sockstat_sockets_used Number of sockets sockets in state used.
# HELP node_sockstat_sockets_used Number of IPv4 sockets in use.
# TYPE node_sockstat_sockets_used gauge
node_sockstat_sockets_used 229
# HELP node_textfile_mtime_seconds Unixtime mtime of textfiles successfully read.

5
collector/fixtures/proc/net/sockstat6 Normal file
View File

@ -0,0 +1,5 @@
TCP6: inuse 17
UDP6: inuse 9
UDPLITE6: inuse 0
RAW6: inuse 1
FRAG6: inuse 0 memory 0

5
collector/fixtures/proc/net/sockstat_rhe4
View File

@ -1,5 +0,0 @@
sockets: used 229
TCP: inuse 4 orphan 0 tw 4 alloc 17 mem 1
UDP: inuse 0
RAW: inuse 0
FRAG: inuse 0 memory 0

196
collector/sockstat_linux.go
View File

@ -16,14 +16,12 @@
package collector
import (
"bufio"
"fmt"
"io"
"os"
"strconv"
"strings"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/common/log"
"github.com/prometheus/procfs"
)
const (
@ -45,78 +43,138 @@ func NewSockStatCollector() (Collector, error) {
}
func (c *sockStatCollector) Update(ch chan<- prometheus.Metric) error {
sockStats, err := getSockStats(procFilePath("net/sockstat"))
fs, err := procfs.NewFS(*procPath)
if err != nil {
return fmt.Errorf("couldn't get sockstats: %s", err)
return fmt.Errorf("failed to open procfs: %v", err)
}
for protocol, protocolStats := range sockStats {
for name, value := range protocolStats {
v, err := strconv.ParseFloat(value, 64)
if err != nil {
return fmt.Errorf("invalid value %s in sockstats: %s", value, err)
// If IPv4 and/or IPv6 are disabled on this kernel, handle it gracefully.
stat4, err := fs.NetSockstat()
switch {
case err == nil:
case os.IsNotExist(err):
log.Debug("IPv4 sockstat statistics not found, skipping")
default:
return fmt.Errorf("failed to get IPv4 sockstat data: %v", err)
}
stat6, err := fs.NetSockstat6()
switch {
case err == nil:
case os.IsNotExist(err):
log.Debug("IPv6 sockstat statistics not found, skipping")
default:
return fmt.Errorf("failed to get IPv6 sockstat data: %v", err)
}
stats := []struct {
isIPv6 bool
stat *procfs.NetSockstat
}{
{
stat: stat4,
},
{
isIPv6: true,
stat: stat6,
},
}
for _, s := range stats {
c.update(ch, s.isIPv6, s.stat)
}
return nil
}
func (c *sockStatCollector) update(ch chan<- prometheus.Metric, isIPv6 bool, s *procfs.NetSockstat) {
if s == nil {
// IPv6 disabled or similar; nothing to do.
return
}
// If sockstat contains the number of used sockets, export it.
if !isIPv6 && s.Used != nil {
// TODO: this must be updated if sockstat6 ever exports this data.
ch <- prometheus.MustNewConstMetric(
prometheus.NewDesc(
prometheus.BuildFQName(namespace, sockStatSubsystem, "sockets_used"),
"Number of IPv4 sockets in use.",
nil,
nil,
),
prometheus.GaugeValue,
float64(*s.Used),
)
}
// A name and optional value for a sockstat metric.
type ssPair struct {
name string
v *int
}
// Previously these metric names were generated directly from the file output.
// In order to keep the same level of compatibility, we must map the fields
// to their correct names.
for _, p := range s.Protocols {
pairs := []ssPair{
{
name: "inuse",
v: &p.InUse,
},
{
name: "orphan",
v: p.Orphan,
},
{
name: "tw",
v: p.TW,
},
{
name: "alloc",
v: p.Alloc,
},
{
name: "mem",
v: p.Mem,
},
{
name: "memory",
v: p.Memory,
},
}
// Also export mem_bytes values for sockets which have a mem value
// stored in pages.
if p.Mem != nil {
v := *p.Mem * pageSize
pairs = append(pairs, ssPair{
name: "mem_bytes",
v: &v,
})
}
for _, pair := range pairs {
if pair.v == nil {
// This value is not set for this protocol; nothing to do.
continue
}
ch <- prometheus.MustNewConstMetric(
prometheus.NewDesc(
prometheus.BuildFQName(namespace, sockStatSubsystem, protocol+"_"+name),
fmt.Sprintf("Number of %s sockets in state %s.", protocol, name),
nil, nil,
prometheus.BuildFQName(
namespace,
sockStatSubsystem,
fmt.Sprintf("%s_%s", p.Protocol, pair.name),
),
fmt.Sprintf("Number of %s sockets in state %s.", p.Protocol, pair.name),
nil,
nil,
),
prometheus.GaugeValue, v,
prometheus.GaugeValue,
float64(*pair.v),
)
}
}
return err
}
func getSockStats(fileName string) (map[string]map[string]string, error) {
file, err := os.Open(fileName)
if err != nil {
return nil, err
}
defer file.Close()
return parseSockStats(file, fileName)
}
func parseSockStats(r io.Reader, fileName string) (map[string]map[string]string, error) {
var (
sockStat = map[string]map[string]string{}
scanner = bufio.NewScanner(r)
)
for scanner.Scan() {
line := strings.Split(scanner.Text(), " ")
// Remove trailing ':'.
protocol := line[0][:len(line[0])-1]
sockStat[protocol] = map[string]string{}
for i := 1; i < len(line) && i+1 < len(line); i++ {
sockStat[protocol][line[i]] = line[i+1]
i++
}
}
if err := scanner.Err(); err != nil {
return nil, err
}
// The mem metrics is the count of pages used. Multiply the mem metrics by
// the page size from the kernel to get the number of bytes used.
//
// Update the TCP mem from page count to bytes.
pageCount, err := strconv.Atoi(sockStat["TCP"]["mem"])
if err != nil {
return nil, fmt.Errorf("invalid value %s in sockstats: %s", sockStat["TCP"]["mem"], err)
}
sockStat["TCP"]["mem_bytes"] = strconv.Itoa(pageCount * pageSize)
// Update the UDP mem from page count to bytes.
if udpMem := sockStat["UDP"]["mem"]; udpMem != "" {
pageCount, err = strconv.Atoi(udpMem)
if err != nil {
return nil, fmt.Errorf("invalid value %s in sockstats: %s", sockStat["UDP"]["mem"], err)
}
sockStat["UDP"]["mem_bytes"] = strconv.Itoa(pageCount * pageSize)
}
return sockStat, nil
}

59
collector/sockstat_linux_test.go
View File

@ -1,59 +0,0 @@
// Copyright 2015 The Prometheus Authors
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package collector
import (
"os"
"strconv"
"testing"
)
func TestSockStats(t *testing.T) {
testSockStats(t, "fixtures/proc/net/sockstat")
testSockStats(t, "fixtures/proc/net/sockstat_rhe4")
}
func testSockStats(t *testing.T, fixture string) {
file, err := os.Open(fixture)
if err != nil {
t.Fatal(err)
}
defer file.Close()
sockStats, err := parseSockStats(file, fixture)
if err != nil {
t.Fatal(err)
}
if want, got := "229", sockStats["sockets"]["used"]; want != got {
t.Errorf("want sockstat sockets used %s, got %s", want, got)
}
if want, got := "4", sockStats["TCP"]["tw"]; want != got {
t.Errorf("want sockstat TCP tw %s, got %s", want, got)
}
if want, got := "17", sockStats["TCP"]["alloc"]; want != got {
t.Errorf("want sockstat TCP alloc %s, got %s", want, got)
}
// The test file has 1 for TCP mem, which is one page. So we should get the
// page size in bytes back from sockstat_linux. We get the page size from
// os here because this value can change from system to system. The value is
// 4096 by default from linux 2.4 onward.
if want, got := strconv.Itoa(os.Getpagesize()), sockStats["TCP"]["mem_bytes"]; want != got {
t.Errorf("want sockstat TCP mem_bytes %s, got %s", want, got)
}
}

2
go.mod
View File

@ -15,7 +15,7 @@ require (
github.com/prometheus/client_golang v1.0.0
github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90
github.com/prometheus/common v0.7.0
github.com/prometheus/procfs v0.0.7
github.com/prometheus/procfs v0.0.8
github.com/siebenmann/go-kstat v0.0.0-20160321171754-d34789b79745
github.com/soundcloud/go-runit v0.0.0-20150630195641-06ad41a06c4a
go.uber.org/atomic v1.3.2 // indirect

4
go.sum
View File

@ -85,8 +85,8 @@ github.com/prometheus/common v0.7.0/go.mod h1:DjGbpBbp5NYNiECxcL/VnbXCCaQpKd3tt2
github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
github.com/prometheus/procfs v0.0.2 h1:6LJUbpNm42llc4HRCuvApCSWB/WfhuNo9K98Q9sNGfs=
github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
github.com/prometheus/procfs v0.0.7 h1:RS5GAlMbnkWkhs4+bPocMTmGjYkuCY5djjqEDdXOhcQ=
github.com/prometheus/procfs v0.0.7/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
github.com/prometheus/procfs v0.0.8 h1:+fpWZdT24pJBiqJdAwYBjPSk+5YmQzYNPYzQsdzLkt8=
github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
github.com/siebenmann/go-kstat v0.0.0-20160321171754-d34789b79745 h1:IuH7WumZNax0D+rEqmy2TyhKCzrtMGqbZO0b8rO00JA=
github.com/siebenmann/go-kstat v0.0.0-20160321171754-d34789b79745/go.mod h1:G81aIFAMS9ECrwBYR9YxhlPjWgrItd+Kje78O6+uqm8=
github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=

2
vendor/github.com/prometheus/procfs/.golangci.yml generated vendored
View File

@ -1,6 +1,4 @@
# Run only staticcheck for now. Additional linters will be enabled one-by-one.
linters:
enable:
- staticcheck
- govet
disable-all: true

19
vendor/github.com/prometheus/procfs/fixtures.ttar generated vendored
View File

@ -1801,6 +1801,25 @@ proc4 2 2 10853
proc4ops 72 0 0 0 1098 2 0 0 0 0 8179 5896 0 0 0 0 5900 0 0 2 0 2 0 9609 0 2 150 1272 0 0 0 1236 0 0 0 0 3 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Mode: 644
# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Path: fixtures/proc/net/sockstat
Lines: 6
sockets: used 1602
TCP: inuse 35 orphan 0 tw 4 alloc 59 mem 22
UDP: inuse 12 mem 62
UDPLITE: inuse 0
RAW: inuse 0
FRAG: inuse 0 memory 0
Mode: 444
# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Path: fixtures/proc/net/sockstat6
Lines: 5
TCP6: inuse 17
UDP6: inuse 9
UDPLITE6: inuse 0
RAW6: inuse 1
FRAG6: inuse 0 memory 0
Mode: 444
# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Path: fixtures/proc/net/softnet_stat
Lines: 1
00015c73 00020e76 F0000769 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000

18
vendor/github.com/prometheus/procfs/internal/util/valueparser.go generated vendored
View File

@ -33,6 +33,9 @@ func NewValueParser(v string) *ValueParser {
return &ValueParser{v: v}
}
// Int interprets the underlying value as an int and returns that value.
func (vp *ValueParser) Int() int { return int(vp.int64()) }
// PInt64 interprets the underlying value as an int64 and returns a pointer to
// that value.
func (vp *ValueParser) PInt64() *int64 {
@ -40,16 +43,27 @@ func (vp *ValueParser) PInt64() *int64 {
return nil
}
v := vp.int64()
return &v
}
// int64 interprets the underlying value as an int64 and returns that value.
// TODO: export if/when necessary.
func (vp *ValueParser) int64() int64 {
if vp.err != nil {
return 0
}
// A base value of zero makes ParseInt infer the correct base using the
// string's prefix, if any.
const base = 0
v, err := strconv.ParseInt(vp.v, base, 64)
if err != nil {
vp.err = err
return nil
return 0
}
return &v
return v
}
// PUInt64 interprets the underlying value as an uint64 and returns a pointer to

228
vendor/github.com/prometheus/procfs/meminfo.go generated vendored
View File

@ -16,6 +16,8 @@ package procfs
import (
"bufio"
"bytes"
"fmt"
"io"
"strconv"
"strings"
@ -143,311 +145,133 @@ type Meminfo struct {
// Meminfo returns an information about current kernel/system memory statistics.
// See https://www.kernel.org/doc/Documentation/filesystems/proc.txt
func (fs FS) Meminfo() (Meminfo, error) {
data, err := util.ReadFileNoStat(fs.proc.Path("meminfo"))
b, err := util.ReadFileNoStat(fs.proc.Path("meminfo"))
if err != nil {
return Meminfo{}, err
}
return parseMemInfo(data)
m, err := parseMemInfo(bytes.NewReader(b))
if err != nil {
return Meminfo{}, fmt.Errorf("failed to parse meminfo: %v", err)
}
return *m, nil
}
func parseMemInfo(info []byte) (m Meminfo, err error) {
scanner := bufio.NewScanner(bytes.NewReader(info))
func parseMemInfo(r io.Reader) (*Meminfo, error) {
var m Meminfo
s := bufio.NewScanner(r)
for s.Scan() {
// Each line has at least a name and value; we ignore the unit.
fields := strings.Fields(s.Text())
if len(fields) < 2 {
return nil, fmt.Errorf("malformed meminfo line: %q", s.Text())
}
var line string
for scanner.Scan() {
line = scanner.Text()
v, err := strconv.ParseUint(fields[1], 0, 64)
if err != nil {
return nil, err
}
field := strings.Fields(line)
switch field[0] {
switch fields[0] {
case "MemTotal:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.MemTotal = v
case "MemFree:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.MemFree = v
case "MemAvailable:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.MemAvailable = v
case "Buffers:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.Buffers = v
case "Cached:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.Cached = v
case "SwapCached:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.SwapCached = v
case "Active:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.Active = v
case "Inactive:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.Inactive = v
case "Active(anon):":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.ActiveAnon = v
case "Inactive(anon):":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.InactiveAnon = v
case "Active(file):":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.ActiveFile = v
case "Inactive(file):":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.InactiveFile = v
case "Unevictable:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.Unevictable = v
case "Mlocked:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.Mlocked = v
case "SwapTotal:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.SwapTotal = v
case "SwapFree:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.SwapFree = v
case "Dirty:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.Dirty = v
case "Writeback:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.Writeback = v
case "AnonPages:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.AnonPages = v
case "Mapped:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.Mapped = v
case "Shmem:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.Shmem = v
case "Slab:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.Slab = v
case "SReclaimable:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.SReclaimable = v
case "SUnreclaim:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.SUnreclaim = v
case "KernelStack:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.KernelStack = v
case "PageTables:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.PageTables = v
case "NFS_Unstable:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.NFSUnstable = v
case "Bounce:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.Bounce = v
case "WritebackTmp:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.WritebackTmp = v
case "CommitLimit:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.CommitLimit = v
case "Committed_AS:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.CommittedAS = v
case "VmallocTotal:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.VmallocTotal = v
case "VmallocUsed:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.VmallocUsed = v
case "VmallocChunk:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.VmallocChunk = v
case "HardwareCorrupted:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.HardwareCorrupted = v
case "AnonHugePages:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.AnonHugePages = v
case "ShmemHugePages:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.ShmemHugePages = v
case "ShmemPmdMapped:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.ShmemPmdMapped = v
case "CmaTotal:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.CmaTotal = v
case "CmaFree:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.CmaFree = v
case "HugePages_Total:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.HugePagesTotal = v
case "HugePages_Free:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.HugePagesFree = v
case "HugePages_Rsvd:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.HugePagesRsvd = v
case "HugePages_Surp:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.HugePagesSurp = v
case "Hugepagesize:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.Hugepagesize = v
case "DirectMap4k:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.DirectMap4k = v
case "DirectMap2M:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.DirectMap2M = v
case "DirectMap1G:":
v, err := strconv.ParseUint(field[1], 0, 64)
if err != nil {
return Meminfo{}, err
}
m.DirectMap1G = v
}
}
return m, nil
return &m, nil
}

163
vendor/github.com/prometheus/procfs/net_sockstat.go generated vendored Normal file
View File

@ -0,0 +1,163 @@
// Copyright 2019 The Prometheus Authors
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package procfs
import (
"bufio"
"bytes"
"errors"
"fmt"
"io"
"strings"
"github.com/prometheus/procfs/internal/util"
)
// A NetSockstat contains the output of /proc/net/sockstat{,6} for IPv4 or IPv6,
// respectively.
type NetSockstat struct {
// Used is non-nil for IPv4 sockstat results, but nil for IPv6.
Used *int
Protocols []NetSockstatProtocol
}
// A NetSockstatProtocol contains statistics about a given socket protocol.
// Pointer fields indicate that the value may or may not be present on any
// given protocol.
type NetSockstatProtocol struct {
Protocol string
InUse int
Orphan *int
TW *int
Alloc *int
Mem *int
Memory *int
}
// NetSockstat retrieves IPv4 socket statistics.
func (fs FS) NetSockstat() (*NetSockstat, error) {
return readSockstat(fs.proc.Path("net", "sockstat"))
}
// NetSockstat6 retrieves IPv6 socket statistics.
//
// If IPv6 is disabled on this kernel, the returned error can be checked with
// os.IsNotExist.
func (fs FS) NetSockstat6() (*NetSockstat, error) {
return readSockstat(fs.proc.Path("net", "sockstat6"))
}
// readSockstat opens and parses a NetSockstat from the input file.
func readSockstat(name string) (*NetSockstat, error) {
// This file is small and can be read with one syscall.
b, err := util.ReadFileNoStat(name)
if err != nil {
// Do not wrap this error so the caller can detect os.IsNotExist and
// similar conditions.
return nil, err
}
stat, err := parseSockstat(bytes.NewReader(b))
if err != nil {
return nil, fmt.Errorf("failed to read sockstats from %q: %v", name, err)
}
return stat, nil
}
// parseSockstat reads the contents of a sockstat file and parses a NetSockstat.
func parseSockstat(r io.Reader) (*NetSockstat, error) {
var stat NetSockstat
s := bufio.NewScanner(r)
for s.Scan() {
// Expect a minimum of a protocol and one key/value pair.
fields := strings.Split(s.Text(), " ")
if len(fields) < 3 {
return nil, fmt.Errorf("malformed sockstat line: %q", s.Text())
}
// The remaining fields are key/value pairs.
kvs, err := parseSockstatKVs(fields[1:])
if err != nil {
return nil, fmt.Errorf("error parsing sockstat key/value pairs from %q: %v", s.Text(), err)
}
// The first field is the protocol. We must trim its colon suffix.
proto := strings.TrimSuffix(fields[0], ":")
switch proto {
case "sockets":
// Special case: IPv4 has a sockets "used" key/value pair that we
// embed at the top level of the structure.
used := kvs["used"]
stat.Used = &used
default:
// Parse all other lines as individual protocols.
nsp := parseSockstatProtocol(kvs)
nsp.Protocol = proto
stat.Protocols = append(stat.Protocols, nsp)
}
}
if err := s.Err(); err != nil {
return nil, err
}
return &stat, nil
}
// parseSockstatKVs parses a string slice into a map of key/value pairs.
func parseSockstatKVs(kvs []string) (map[string]int, error) {
if len(kvs)%2 != 0 {
return nil, errors.New("odd number of fields in key/value pairs")
}
// Iterate two values at a time to gather key/value pairs.
out := make(map[string]int, len(kvs)/2)
for i := 0; i < len(kvs); i += 2 {
vp := util.NewValueParser(kvs[i+1])
out[kvs[i]] = vp.Int()
if err := vp.Err(); err != nil {
return nil, err
}
}
return out, nil
}
// parseSockstatProtocol parses a NetSockstatProtocol from the input kvs map.
func parseSockstatProtocol(kvs map[string]int) NetSockstatProtocol {
var nsp NetSockstatProtocol
for k, v := range kvs {
// Capture the range variable to ensure we get unique pointers for
// each of the optional fields.
v := v
switch k {
case "inuse":
nsp.InUse = v
case "orphan":
nsp.Orphan = &v
case "tw":
nsp.TW = &v
case "alloc":
nsp.Alloc = &v
case "mem":
nsp.Mem = &v
case "memory":
nsp.Memory = &v
}
}
return nsp
}

4
vendor/github.com/prometheus/procfs/net_unix.go generated vendored
View File

@ -207,10 +207,6 @@ func (u NetUnix) parseUsers(hexStr string) (uint64, error) {
return strconv.ParseUint(hexStr, 16, 32)
}
func (u NetUnix) parseProtocol(hexStr string) (uint64, error) {
return strconv.ParseUint(hexStr, 16, 32)
}
func (u NetUnix) parseType(hexStr string) (NetUnixType, error) {
typ, err := strconv.ParseUint(hexStr, 16, 16)
if err != nil {

2
vendor/modules.txt vendored
View File

@ -47,7 +47,7 @@ github.com/prometheus/common/internal/bitbucket.org/ww/goautoneg
github.com/prometheus/common/log
github.com/prometheus/common/model
github.com/prometheus/common/version
# github.com/prometheus/procfs v0.0.7
# github.com/prometheus/procfs v0.0.8
github.com/prometheus/procfs
github.com/prometheus/procfs/bcache
github.com/prometheus/procfs/internal/fs