fix: solve node memory zero values

internal/collector/cgroup_node_metrics_collector_linux.go

@@ -174,12 +174,29 @@ func (c *cgroupNodeMetricsCollector) resolveNodeName(nodes []*corev1.Node) (stri
 
 // readNodeMemoryUsage helper
 func readNodeMemoryUsage(logger *slog.Logger, memPath string) int64 {
+	// 1. Try cgroup first
 	val, err := readCgroupMemory(logger, memPath)
+	if err == nil && val > 0 {
+		if val > 9223372036854775807 { // MaxInt64
+			return 9223372036854775807
+		}
+		return int64(val)
+	}
+
+	// 2. Fallback to /proc/meminfo
+	// This is often necessary in containers where /sys/fs/cgroup/memory may not reflect the node's
+	// full usage or permissions are restricted.
+	if logger != nil && logger.Enabled(context.Background(), slog.LevelDebug) {
+		logger.Debug("cgroup memory read failed or zero; falling back to /proc/meminfo", slog.Any("error", err))
+	}
+
+	memInfo, err := readProcMemInfo("/proc/meminfo")
 	if err != nil {
+		if logger != nil {
+			logger.Warn("failed to read node memory from both cgroup and /proc/meminfo", slog.String("error", err.Error()))
+		}
 		return 0
 	}
-	if val > 9223372036854775807 { // MaxInt64
-		return 9223372036854775807
-	}
-	return int64(val)
+
+	return memInfo
 }

internal/collector/cgroup_node_metrics_test.go

@@ -0,0 +1,65 @@
+package collector
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestReadProcMemInfo(t *testing.T) {
+	// Create a temporary file mimicking /proc/meminfo
+	tmpDir := t.TempDir()
+	memInfoFile := filepath.Join(tmpDir, "meminfo")
+
+	content := `MemTotal:       16306544 kB
+MemFree:         4354264 kB
+MemAvailable:    8992348 kB
+Buffers:          345124 kB
+Cached:          4567232 kB
+SwapCached:            0 kB
+`
+	if err := os.WriteFile(memInfoFile, []byte(content), 0o644); err != nil {
+		t.Fatalf("failed to write meminfo mock: %v", err)
+	}
+
+	// Test Case 1: Standard MemAvailable present
+	usage, err := readProcMemInfo(memInfoFile)
+	if err != nil {
+		t.Fatalf("readProcMemInfo failed: %v", err)
+	}
+
+	// Expected: Total (16306544) - Available (8992348) = 7314196 kB
+	// In bytes: 7314196 * 1024 = 7,489,736,704
+	expectedKB := int64(16306544 - 8992348)
+	expectedBytes := expectedKB * 1024
+
+	if usage != expectedBytes {
+		t.Errorf("expected usage %d bytes, got %d", expectedBytes, usage)
+	}
+
+	// Test Case 2: No MemAvailable (older kernels)
+	oldContent := `MemTotal:       16306544 kB
+MemFree:         4354264 kB
+Buffers:          345124 kB
+Cached:          4567232 kB
+`
+	memInfoFileOld := filepath.Join(tmpDir, "meminfo_old")
+	if err := os.WriteFile(memInfoFileOld, []byte(oldContent), 0o644); err != nil {
+		t.Fatalf("failed to write meminfo old mock: %v", err)
+	}
+
+	usageOld, err := readProcMemInfo(memInfoFileOld)
+	if err != nil {
+		t.Fatalf("readProcMemInfo (old) failed: %v", err)
+	}
+
+	// Expected: Total - Free - Buffers - Cached
+	// 16306544 - 4354264 - 345124 - 4567232 = 7039924 kB
+	// 7039924 * 1024 = 7,208,882,176
+	expectedKBOld := int64(16306544 - 4354264 - 345124 - 4567232)
+	expectedBytesOld := expectedKBOld * 1024
+
+	if usageOld != expectedBytesOld {
+		t.Errorf("expected usage (old) %d bytes, got %d", expectedBytesOld, usageOld)
+	}
+}

internal/collector/node_memory.go

@@ -0,0 +1,64 @@
+package collector
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+)
+
+// readProcMemInfo parses /proc/meminfo to calculate used memory (Total - Available)
+// This function is kept platform-independent for easier testing, although /proc/meminfo is Linux-specific.
+func readProcMemInfo(path string) (int64, error) {
+	data, err := os.ReadFile(path) // #nosec G304
+	if err != nil {
+		return 0, err
+	}
+
+	var memTotal, memAvailable, memFree, buffers, cached uint64
+	var foundTotal, foundAvailable bool
+
+	lines := strings.Split(string(data), "\n")
+	for _, line := range lines {
+		fields := strings.Fields(line)
+		if len(fields) < 2 {
+			continue
+		}
+		key := strings.TrimSuffix(fields[0], ":")
+		val, err := strconv.ParseUint(fields[1], 10, 64)
+		if err != nil {
+			continue
+		}
+		// /proc/meminfo values are in kB
+		valBytes := val * 1024
+
+		switch key {
+		case "MemTotal":
+			memTotal = valBytes
+			foundTotal = true
+		case "MemAvailable":
+			memAvailable = valBytes
+			foundAvailable = true
+		case "MemFree":
+			memFree = valBytes
+		case "Buffers":
+			buffers = valBytes
+		case "Cached":
+			cached = valBytes
+		}
+	}
+
+	if !foundTotal {
+		return 0, fmt.Errorf("MemTotal not found in %s", path)
+	}
+
+	// Ideally use MemAvailable (kernels 3.14+)
+	if foundAvailable {
+		// Used = Total - Available
+		return int64(memTotal - memAvailable), nil
+	}
+
+	// Fallback for older kernels: Used = Total - Free - Buffers - Cached
+	used := memTotal - memFree - buffers - cached
+	return int64(used), nil
+}