Refresh percentage memory limits

Problem: percentage memory limits are resolved once at startup, so in-place container resizes leave the memory limiter enforcing stale thresholds.

Solution: refresh cgroup-backed percentage thresholds on each memory check while retaining the previous thresholds when a refresh fails. Fixed MiB limits remain unchanged.

Validation: go test . in internal/memorylimiter; go test . in processor/memorylimiterprocessor

Signed-off-by: ADITYA CHAUHAN <125276621+hooiv@users.noreply.github.com>

Author: hooiv

internal/memorylimiter/memorylimiter.go

@@ -43,6 +43,13 @@ var (
 type MemoryLimiter struct {
 	usageChecker memUsageChecker
 
+	// Percentage-based limits are refreshed on each memory check so that
+	// in-place container resizes are reflected without changing fixed limits.
+	percentageBased       bool
+	memoryLimitPercentage uint64
+	memorySpikePercentage uint64
+	getMemoryFn           func() (uint64, error)
+
 	memCheckWait time.Duration
 
 	// mustRefuse is used to indicate when data should be refused.
@@ -113,6 +120,10 @@ func NewMemoryLimiter(cfg *Config, logger *zap.Logger) (*MemoryLimiter, error) {
 
 	return &MemoryLimiter{
 		usageChecker:                 *usageChecker,
+		percentageBased:              cfg.MemoryLimitMiB == 0,
+		memoryLimitPercentage:        uint64(cfg.MemoryLimitPercentage),
+		memorySpikePercentage:        uint64(cfg.MemorySpikePercentage),
+		getMemoryFn:                  GetMemoryFn,
 		memCheckWait:                 cfg.CheckInterval,
 		ticker:                       time.NewTicker(cfg.CheckInterval),
 		minGCIntervalWhenSoftLimited: cfg.MinGCIntervalWhenSoftLimited,
@@ -255,6 +266,7 @@ func (ml *MemoryLimiter) nextBackoffInterval(current, configMin, configMax time.
 
 // CheckMemLimits inspects current memory usage against threshold and toggles mustRefuse when threshold is exceeded
 func (ml *MemoryLimiter) CheckMemLimits() {
+	ml.refreshPercentageMemoryLimit()
 	ms := ml.readMemStats()
 
 	ml.logger.Debug("Currently used memory.", memstatToZapField(ms))
@@ -309,6 +321,20 @@ func (ml *MemoryLimiter) CheckMemLimits() {
 	ml.mustRefuse.Store(aboveSoftLimit)
 }
 
+func (ml *MemoryLimiter) refreshPercentageMemoryLimit() {
+	if !ml.percentageBased {
+		return
+	}
+
+	totalMemory, err := ml.getMemoryFn()
+	if err != nil {
+		ml.logger.Warn("Unable to refresh percentage memory limiter; retaining previous limits.", zap.Error(err))
+		return
+	}
+
+	ml.usageChecker = *newPercentageMemUsageChecker(totalMemory, ml.memoryLimitPercentage, ml.memorySpikePercentage)
+}
+
 type memUsageChecker struct {
 	memAllocLimit uint64
 	memSpikeLimit uint64

internal/memorylimiter/memorylimiter_test.go

@@ -5,6 +5,7 @@ package memorylimiter
 
 import (
 	"context"
+	"errors"
 	"runtime"
 	"testing"
 	"time"
@@ -107,6 +108,43 @@ func TestGetDecision(t *testing.T) {
 	})
 }
 
+func TestRefreshPercentageMemoryLimit(t *testing.T) {
+	var totalMemory uint64 = 100 * mibBytes
+	getMemory := func() (uint64, error) {
+		return totalMemory, nil
+	}
+	originalGetMemory := GetMemoryFn
+	GetMemoryFn = getMemory
+	t.Cleanup(func() { GetMemoryFn = originalGetMemory })
+
+	ml, err := NewMemoryLimiter(&Config{
+		CheckInterval:         time.Minute,
+		MemoryLimitPercentage: 80,
+		MemorySpikePercentage: 20,
+	}, zap.NewNop())
+	require.NoError(t, err)
+	assert.Equal(t, uint64(80*mibBytes), ml.usageChecker.memAllocLimit)
+	assert.Equal(t, uint64(20*mibBytes), ml.usageChecker.memSpikeLimit)
+
+	totalMemory = 200 * mibBytes
+	ml.refreshPercentageMemoryLimit()
+	assert.Equal(t, uint64(160*mibBytes), ml.usageChecker.memAllocLimit)
+	assert.Equal(t, uint64(40*mibBytes), ml.usageChecker.memSpikeLimit)
+}
+
+func TestRefreshPercentageMemoryLimitRetainsPreviousLimitOnError(t *testing.T) {
+	ml, err := NewMemoryLimiter(&Config{
+		CheckInterval:         time.Minute,
+		MemoryLimitPercentage: 80,
+		MemorySpikePercentage: 20,
+	}, zap.NewNop())
+	require.NoError(t, err)
+	previous := ml.usageChecker
+	ml.getMemoryFn = func() (uint64, error) { return 0, errors.New("cgroup unavailable") }
+	ml.refreshPercentageMemoryLimit()
+	assert.Equal(t, previous, ml.usageChecker)
+}
+
 func TestRefuseDecision(t *testing.T) {
 	decision1000Limit30Spike30 := newPercentageMemUsageChecker(1000, 60, 30)
 	decision1000Limit60Spike50 := newPercentageMemUsageChecker(1000, 60, 50)