[memorylimiter] Add disable_gc configuration option

.chloggen/memorylimiter-disable-gc.yaml

@@ -0,0 +1,9 @@
+change_type: enhancement
+
+component: processor/memory_limiter
+
+note: Add `disable_gc` option to allow disabling forced garbage collection.
+
+issues: [15081]
+
+change_logs: [user]

internal/memorylimiter/config.go

@@ -37,6 +37,9 @@ type Config struct {
 	// GCs is a CPU-heavy operation and executing it too frequently may affect the recovery capabilities of the collector.
 	MinGCIntervalWhenHardLimited time.Duration `mapstructure:"min_gc_interval_when_hard_limited"`
 
+	// DisableGC disables forced garbage collection.
+	DisableGC bool `mapstructure:"disable_gc"`
+
 	// MemoryLimitMiB is the maximum amount of memory, in MiB, targeted to be
 	// allocated by the process.
 	MemoryLimitMiB uint32 `mapstructure:"limit_mib"`

internal/memorylimiter/config_test.go

@@ -24,6 +24,7 @@ func TestUnmarshalConfig(t *testing.T) {
 			CheckInterval:       5 * time.Second,
 			MemoryLimitMiB:      4000,
 			MemorySpikeLimitMiB: 500,
+			DisableGC:           true,
 		}, cfg)
 }
 

internal/memorylimiter/memorylimiter.go

@@ -46,6 +46,7 @@ type MemoryLimiter struct {
 	minGCIntervalWhenSoftLimited time.Duration
 	minGCIntervalWhenHardLimited time.Duration
 	lastGCDone                   time.Time
+	gcDisabled                   bool
 
 	// The functions to read the mem values and run GC are set as a reference to help with
 	// testing different values.
@@ -80,6 +81,7 @@ func NewMemoryLimiter(cfg *Config, logger *zap.Logger) (*MemoryLimiter, error) {
 		minGCIntervalWhenSoftLimited: cfg.MinGCIntervalWhenSoftLimited,
 		minGCIntervalWhenHardLimited: cfg.MinGCIntervalWhenHardLimited,
 		lastGCDone:                   time.Now(),
+		gcDisabled:                   cfg.DisableGC,
 		readMemStatsFn:               ReadMemStatsFn,
 		runGCFn:                      runtime.GC,
 		logger:                       logger,
@@ -186,7 +188,7 @@ func (ml *MemoryLimiter) CheckMemLimits() {
 	if ml.usageChecker.aboveHardLimit(ms) {
 		// We are above hard limit, do a GC if it wasn't done recently and see if
 		// it brings memory usage below the soft limit.
-		if time.Since(ml.lastGCDone) > ml.minGCIntervalWhenHardLimited {
+		if !ml.gcDisabled && time.Since(ml.lastGCDone) > ml.minGCIntervalWhenHardLimited {
 			ml.logger.Warn("Memory usage is above hard limit. Forcing a GC.", memstatToZapField(ms))
 			ms = ml.doGCandReadMemStats()
 			// Check the limit again to see if GC helped.
@@ -195,7 +197,7 @@ func (ml *MemoryLimiter) CheckMemLimits() {
 	} else {
 		// We are above soft limit, do a GC if it wasn't done recently and see if
 		// it brings memory usage below the soft limit.
-		if time.Since(ml.lastGCDone) > ml.minGCIntervalWhenSoftLimited {
+		if !ml.gcDisabled && time.Since(ml.lastGCDone) > ml.minGCIntervalWhenSoftLimited {
 			ml.logger.Info("Memory usage is above soft limit. Forcing a GC.", memstatToZapField(ms))
 			ms = ml.doGCandReadMemStats()
 			// Check the limit again to see if GC helped.

internal/memorylimiter/memorylimiter_test.go

@@ -196,6 +196,30 @@ func TestCallGCWhenSoftLimit(t *testing.T) {
 			memAllocMiB: [2]uint64{45, 55},
 			numGCs:      2,
 		},
+		{
+			name: "No GC when soft limited and GC disabled",
+			mlCfg: &Config{
+				CheckInterval:                1 * time.Minute,
+				MinGCIntervalWhenSoftLimited: 0,
+				MemoryLimitMiB:               50,
+				MemorySpikeLimitMiB:          10,
+				DisableGC:                    true,
+			},
+			memAllocMiB: [2]uint64{45, 45},
+			numGCs:      0,
+		},
+		{
+			name: "No GC when hard limited and GC disabled",
+			mlCfg: &Config{
+				CheckInterval:                1 * time.Minute,
+				MinGCIntervalWhenHardLimited: 0,
+				MemoryLimitMiB:               50,
+				MemorySpikeLimitMiB:          10,
+				DisableGC:                    true,
+			},
+			memAllocMiB: [2]uint64{55, 55},
+			numGCs:      0,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {

internal/memorylimiter/testdata/config.yaml

@@ -11,3 +11,6 @@ limit_mib: 4000
 
 # The maximum, in MiB, spike expected between the measurements of memory usage.
 spike_limit_mib: 500
+
+# When set to true, disables forced garbage collection.
+disable_gc: true

processor/memorylimiterprocessor/README.md

@@ -135,6 +135,8 @@ measurements of memory usage. The value must be less than `limit_percentage`.
 This option is used to calculate `spike_limit_mib` from the total available memory.
 For instance setting of 25% with the total memory of 1GiB will result in the spike limit of 250MiB.
 This option is intended to be used only with `limit_percentage`.
+- `disable_gc` (default = false): When set to true, disables forced garbage collection.
+The processor will still refuse data when memory limits are exceeded but will not trigger GC.
 
 Examples: