cgroups2/Stats: split out reading cpu, memory, memory events (#1)

As outlined in the PR, usage_usec, user_usec, and system_use may
always exist, but in situations where the files parsed do not
exist, we shouldn't have to try to assign values (which would always
be 0).

Split out parsing of these to separate functions, so make this more
transparent.

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>

Author: thaJeztah

cgroup2/manager.go

@@ -560,36 +560,73 @@ func (c *Manager) MoveTo(destination *Manager) error {
 
 func (c *Manager) Stat() (*stats.Metrics, error) {
 	var metrics stats.Metrics
+	var err error
 
+	metrics.Pids = &stats.PidsStat{
+		Current: getStatFileContentUint64(filepath.Join(c.path, "pids.current")),
+		Limit:   getStatFileContentUint64(filepath.Join(c.path, "pids.max")),
+	}
+
+	metrics.CPU, err = readCPUStats(c.path)
+	if err != nil {
+		return nil, err
+	}
+
+	metrics.Memory, err = readMemoryStats(c.path)
+	if err != nil {
+		return nil, err
+	}
+
+	metrics.MemoryEvents, err = readMemoryEvents(c.path)
+	if err != nil {
+		return nil, err
+	}
+
+	metrics.Io = &stats.IOStat{
+		Usage: readIoStats(c.path),
+		PSI:   getStatPSIFromFile(filepath.Join(c.path, "io.pressure")),
+	}
+
+	metrics.Rdma = &stats.RdmaStat{
+		Current: rdmaStats(filepath.Join(c.path, "rdma.current")),
+		Limit:   rdmaStats(filepath.Join(c.path, "rdma.max")),
+	}
+
+	metrics.Hugetlb = readHugeTlbStats(c.path)
+
+	return &metrics, nil
+}
+
+func readCPUStats(cgroupPath string) (*stats.CPUStat, error) {
 	cpuStat := make(map[string]uint64)
-	if err := readKVStatsFile(c.path, "cpu.stat", cpuStat); err != nil {
-		if !os.IsNotExist(err) {
-			return nil, err
+	if err := readKVStatsFile(cgroupPath, "cpu.stat", cpuStat); err != nil {
+		if os.IsNotExist(err) {
+			return &stats.CPUStat{}, nil
 		}
+		return nil, err
 	}
-	metrics.CPU = &stats.CPUStat{
+	return &stats.CPUStat{
 		UsageUsec:     cpuStat["usage_usec"],
 		UserUsec:      cpuStat["user_usec"],
 		SystemUsec:    cpuStat["system_usec"],
 		NrPeriods:     cpuStat["nr_periods"],
 		NrThrottled:   cpuStat["nr_throttled"],
 		ThrottledUsec: cpuStat["throttled_usec"],
-		PSI:           getStatPSIFromFile(filepath.Join(c.path, "cpu.pressure")),
-	}
-	if nr_bursts, ok := cpuStat["nr_bursts"]; ok {
-		metrics.CPU.NrBursts = nr_bursts
-	}
-	if burst_usec, ok := cpuStat["burst_usec"]; ok {
-		metrics.CPU.BurstUsec = burst_usec
-	}
+		NrBursts:      cpuStat["nr_bursts"],
+		BurstUsec:     cpuStat["burst_usec"],
+		PSI:           getStatPSIFromFile(filepath.Join(cgroupPath, "cpu.pressure")),
+	}, nil
+}
 
+func readMemoryStats(cgroupPath string) (*stats.MemoryStat, error) {
 	memoryStat := make(map[string]uint64, 40)
-	if err := readKVStatsFile(c.path, "memory.stat", memoryStat); err != nil {
-		if !os.IsNotExist(err) {
-			return nil, err
+	if err := readKVStatsFile(cgroupPath, "memory.stat", memoryStat); err != nil {
+		if os.IsNotExist(err) {
+			return &stats.MemoryStat{}, nil
 		}
+		return nil, err
 	}
-	metrics.Memory = &stats.MemoryStat{
+	return &stats.MemoryStat{
 		Anon:                  memoryStat["anon"],
 		File:                  memoryStat["file"],
 		KernelStack:           memoryStat["kernel_stack"],
@@ -621,41 +658,33 @@ func (c *Manager) Stat() (*stats.Metrics, error) {
 		Pglazyfreed:           memoryStat["pglazyfreed"],
 		ThpFaultAlloc:         memoryStat["thp_fault_alloc"],
 		ThpCollapseAlloc:      memoryStat["thp_collapse_alloc"],
-		Usage:                 getStatFileContentUint64(filepath.Join(c.path, "memory.current")),
-		UsageLimit:            getStatFileContentUint64(filepath.Join(c.path, "memory.max")),
-		MaxUsage:              getStatFileContentUint64(filepath.Join(c.path, "memory.peak")),
-		SwapUsage:             getStatFileContentUint64(filepath.Join(c.path, "memory.swap.current")),
-		SwapLimit:             getStatFileContentUint64(filepath.Join(c.path, "memory.swap.max")),
-		SwapMaxUsage:          getStatFileContentUint64(filepath.Join(c.path, "memory.swap.peak")),
-		PSI:                   getStatPSIFromFile(filepath.Join(c.path, "memory.pressure")),
-	}
+		Usage:                 getStatFileContentUint64(filepath.Join(cgroupPath, "memory.current")),
+		UsageLimit:            getStatFileContentUint64(filepath.Join(cgroupPath, "memory.max")),
+		MaxUsage:              getStatFileContentUint64(filepath.Join(cgroupPath, "memory.peak")),
+		SwapUsage:             getStatFileContentUint64(filepath.Join(cgroupPath, "memory.swap.current")),
+		SwapLimit:             getStatFileContentUint64(filepath.Join(cgroupPath, "memory.swap.max")),
+		SwapMaxUsage:          getStatFileContentUint64(filepath.Join(cgroupPath, "memory.swap.peak")),
+		PSI:                   getStatPSIFromFile(filepath.Join(cgroupPath, "memory.pressure")),
+	}, nil
+}
 
+func readMemoryEvents(cgroupPath string) (*stats.MemoryEvents, error) {
 	memoryEvents := make(map[string]uint64)
-	if err := readKVStatsFile(c.path, "memory.events", memoryEvents); err != nil {
+	if err := readKVStatsFile(cgroupPath, "memory.events", memoryEvents); err != nil {
 		if !os.IsNotExist(err) {
 			return nil, err
 		}
 	}
-	if len(memoryEvents) > 0 {
-		metrics.MemoryEvents = &stats.MemoryEvents{
-			Low:     memoryEvents["low"],
-			High:    memoryEvents["high"],
-			Max:     memoryEvents["max"],
-			Oom:     memoryEvents["oom"],
-			OomKill: memoryEvents["oom_kill"],
-		}
-	}
-	metrics.Io = &stats.IOStat{
-		Usage: readIoStats(c.path),
-		PSI:   getStatPSIFromFile(filepath.Join(c.path, "io.pressure")),
-	}
-	metrics.Rdma = &stats.RdmaStat{
-		Current: rdmaStats(filepath.Join(c.path, "rdma.current")),
-		Limit:   rdmaStats(filepath.Join(c.path, "rdma.max")),
+	if len(memoryEvents) == 0 {
+		return nil, nil
 	}
-	metrics.Hugetlb = readHugeTlbStats(c.path)
-
-	return &metrics, nil
+	return &stats.MemoryEvents{
+		Low:     memoryEvents["low"],
+		High:    memoryEvents["high"],
+		Max:     memoryEvents["max"],
+		Oom:     memoryEvents["oom"],
+		OomKill: memoryEvents["oom_kill"],
+	}, nil
 }
 
 func readKVStatsFile(path string, file string, out map[string]uint64) error {