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>

vendor/github.com/prometheus/procfs/.golangci.yml

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

vendor/github.com/prometheus/procfs/fixtures.ttar

@@ -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

vendor/github.com/prometheus/procfs/internal/util/valueparser.go

@@ -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

vendor/github.com/prometheus/procfs/meminfo.go

@@ -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
 }

vendor/github.com/prometheus/procfs/net_sockstat.go

@@ -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
+}

vendor/github.com/prometheus/procfs/net_unix.go

@@ -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 {

vendor/modules.txt

@@ -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