update the metrics calculation

Signed-off-by: jason yang <[email protected]>

internal/cgroup/cgroup.go

@@ -40,7 +40,7 @@ func (c *CGroup) CreateStats() ([]parser.StatFunc, error) {
 	}
 
 	statManager := &parser.StatManager{Stats: stat}
-	statManager.WithCPU().WithMemory().WithMemorySwap().WithMemoryKernel().WithPid()
+	statManager.WithCPU().WithMemory().WithMemorySwap().WithPid()
 	return statManager.All(), nil
 }
 

internal/cgroup/cgroup_test.go

@@ -79,7 +79,7 @@ func TestCgroup(t *testing.T) {
 	funcs, err := cgroup.CreateStats()
 	require.NoError(t, err)
 	require.NotEmpty(t, funcs)
-	require.Len(t, funcs, 5)
+	require.Len(t, funcs, 4)
 
 	var buffer bytes.Buffer
 	_, err = cgroup.Marshal(&buffer)

internal/cgroup/parser/parser.go

@@ -5,6 +5,9 @@ package parser
 
 import (
 	"bytes"
+	"math"
+	"syscall"
+	"time"
 
 	"github.com/opencontainers/runc/libcontainer/cgroups"
 )
@@ -16,6 +19,9 @@ type Marshal interface {
 type StatManager struct {
 	funcs []StatFunc
 	*cgroups.Stats
+
+	// for cpu metric
+	prevTime, prevCPU uint64
 }
 
 func (s *StatManager) add(fc StatFunc) *StatManager {
@@ -25,25 +31,66 @@ func (s *StatManager) add(fc StatFunc) *StatManager {
 
 func (s *StatManager) WithCPU() *StatManager {
 	return s.add(func() (string, float64) {
-		return "cpu_usage", float64(s.CpuStats.CpuUsage.TotalUsage)
+		nowTime := time.Now()
+
+		curTime := uint64(nowTime.UnixNano())
+		curCPU := s.CpuStats.CpuUsage.TotalUsage
+
+		deltaCPU := float64(curCPU - s.prevCPU)
+		if s.prevTime == 0 {
+			// 500ms earlier by default
+			s.prevTime = uint64(nowTime.Truncate(500 * time.Millisecond).UnixNano())
+		}
+
+		deltaTime := float64(curTime - s.prevTime)
+		cpuPercent := (deltaCPU / deltaTime) * 100
+
+		// update the saved metrics
+		s.prevTime = curTime
+		s.prevCPU = curCPU
+		return "cpu_usage", float64(cpuPercent)
 	})
 }
 
 func (s *StatManager) WithMemory() *StatManager {
 	return s.add(func() (string, float64) {
-		return "memory_usage", float64(s.MemoryStats.Usage.Usage)
+		memUsage := s.MemoryStats.Usage.Usage
+		memLimit := s.MemoryStats.Usage.Limit
+		memPercent := 0.0
+
+		// If there is no limit, show system RAM instead of max uint64...
+		if memLimit == math.MaxUint64 {
+			in := &syscall.Sysinfo_t{}
+			err := syscall.Sysinfo(in)
+			if err == nil {
+				memLimit = uint64(in.Totalram) * uint64(in.Unit)
+			}
+		}
+		if memLimit != 0 {
+			memPercent = float64(memUsage) / float64(memLimit) * 100.0
+		}
+		return "memory_usage", float64(memPercent)
 	})
 }
 
 func (s *StatManager) WithMemorySwap() *StatManager {
 	return s.add(func() (string, float64) {
-		return "memory_swap_usage", float64(s.MemoryStats.SwapUsage.Usage)
-	})
-}
+		swapUsage := s.MemoryStats.SwapUsage.Usage
+		swapLimit := s.MemoryStats.SwapUsage.Limit
+		swapPercent := 0.0
 
-func (s *StatManager) WithMemoryKernel() *StatManager {
-	return s.add(func() (string, float64) {
-		return "memory_kernel_usage", float64(s.MemoryStats.KernelUsage.Usage)
+		// If there is no limit, show system RAM instead of max uint64...
+		if swapLimit == math.MaxUint64 {
+			in := &syscall.Sysinfo_t{}
+			err := syscall.Sysinfo(in)
+			if err == nil {
+				swapLimit = uint64(in.Totalswap) * uint64(in.Unit)
+			}
+		}
+		if swapLimit != 0 {
+			swapPercent = float64(swapUsage) / float64(swapLimit) * 100.0
+		}
+		return "memory_swap_usage", float64(swapPercent)
 	})
 }
 

internal/cgroup/parser/parser_test.go

@@ -15,5 +15,5 @@ func TestParser(t *testing.T) {
 	}
 
 	require.NotNil(t, mgr)
-	require.Len(t, mgr.WithCPU().WithMemory().WithMemorySwap().WithMemoryKernel().WithPid().All(), 5)
+	require.Len(t, mgr.WithCPU().WithMemory().WithMemorySwap().WithPid().All(), 4)
 }