fixup! Further pursue of perfection.

memory_leak_fixes.go

@@ -7,14 +7,21 @@ import (
 	"time"
 )
 
-// LazyBackgroundTask wraps BackgroundTask to start only when needed
+// LazyBackgroundTask wraps BackgroundTask to provide delayed initialization.
+// This prevents memory leaks from unnecessary background tasks by starting
+// them only when actually needed, reducing resource usage in idle scenarios.
 type LazyBackgroundTask struct {
+	// BackgroundTask is the underlying task implementation
 	*BackgroundTask
-	started   bool
+	// started tracks whether the task has been activated
+	started bool
+	// startOnce ensures single initialization
 	startOnce sync.Once
 }
 
-// NewLazyBackgroundTask creates a background task that doesn't start immediately
+// NewLazyBackgroundTask creates a background task that doesn't start immediately.
+// The task will only start when explicitly activated, preventing unnecessary
+// resource usage for tasks that may never be needed.
 func NewLazyBackgroundTask(name string, interval time.Duration, taskFunc func(), logger *Logger, wg ...*sync.WaitGroup) *LazyBackgroundTask {
 	return &LazyBackgroundTask{
 		BackgroundTask: NewBackgroundTask(name, interval, taskFunc, logger, wg...),
@@ -22,7 +29,8 @@ func NewLazyBackgroundTask(name string, interval time.Duration, taskFunc func(),
 	}
 }
 
-// StartIfNeeded starts the task only if it hasn't been started yet
+// StartIfNeeded starts the background task only if it hasn't been started yet.
+// Uses sync.Once to ensure thread-safe single initialization.
 func (lt *LazyBackgroundTask) StartIfNeeded() {
 	lt.startOnce.Do(func() {
 		if !lt.started {
@@ -32,19 +40,22 @@ func (lt *LazyBackgroundTask) StartIfNeeded() {
 	})
 }
 
-// Stop stops the task if it was started
+// Stop stops the background task if it was started.
+// Resets the start state to allow potential future re-initialization.
 func (lt *LazyBackgroundTask) Stop() {
 	if lt.started {
 		lt.BackgroundTask.Stop()
 		lt.started = false
-		lt.startOnce = sync.Once{} // Reset for potential restart
+		lt.startOnce = sync.Once{}
 	}
 }
 
-// NewLazyCacheWithLogger creates a cache that doesn't start cleanup until first use
+// NewLazyCacheWithLogger creates a cache that doesn't start cleanup until first use.
+// This reduces memory overhead by avoiding unnecessary cleanup goroutines
+// for caches that may remain empty or be used infrequently.
 func NewLazyCacheWithLogger(logger *Logger) *Cache {
 	if logger == nil {
-		logger = newNoOpLogger()
+		logger = GetSingletonNoOpLogger()
 	}
 
 	c := &Cache{
@@ -52,19 +63,21 @@ func NewLazyCacheWithLogger(logger *Logger) *Cache {
 		order:               list.New(),
 		elems:               make(map[string]*list.Element, DefaultMaxSize),
 		maxSize:             DefaultMaxSize,
-		autoCleanupInterval: 10 * time.Minute, // Increased from 5 minutes
+		autoCleanupInterval: 10 * time.Minute,
 		logger:              logger,
 	}
-	// Don't start cleanup immediately - it will be started on first use
 	return c
 }
 
-// NewLazyCache creates a cache that doesn't start cleanup immediately
+// NewLazyCache creates a cache with delayed cleanup initialization.
+// Uses the default no-op logger and defers cleanup task creation.
 func NewLazyCache() *Cache {
 	return NewLazyCacheWithLogger(nil)
 }
 
-// CleanupIdleConnections periodically closes idle HTTP connections
+// CleanupIdleConnections periodically closes idle HTTP connections to prevent memory leaks.
+// Runs in a background goroutine and can be stopped via the stop channel.
+// This is crucial for long-running applications to prevent connection pool exhaustion.
 func CleanupIdleConnections(client *http.Client, interval time.Duration, stopChan <-chan struct{}) {
 	ticker := time.NewTicker(interval)
 	defer ticker.Stop()
@@ -76,7 +89,6 @@ func CleanupIdleConnections(client *http.Client, interval time.Duration, stopCha
 				transport.CloseIdleConnections()
 			}
 		case <-stopChan:
-			// Final cleanup
 			if transport, ok := client.Transport.(*http.Transport); ok {
 				transport.CloseIdleConnections()
 			}
@@ -85,22 +97,21 @@ func CleanupIdleConnections(client *http.Client, interval time.Duration, stopCha
 	}
 }
 
-// OptimizedMiddlewareConfig provides configuration for memory-optimized middleware
+// OptimizedMiddlewareConfig provides configuration options for memory-optimized middleware.
+// These settings help reduce memory usage and prevent leaks in resource-constrained environments.
 type OptimizedMiddlewareConfig struct {
-	// DelayBackgroundTasks delays starting background tasks until first request
+	// DelayBackgroundTasks defers starting background tasks until needed
 	DelayBackgroundTasks bool
-
-	// ReducedCleanupIntervals uses longer intervals for cleanup tasks
+	// ReducedCleanupIntervals uses longer intervals to reduce CPU/memory overhead
 	ReducedCleanupIntervals bool
-
-	// AggressiveConnectionCleanup closes idle connections more aggressively
+	// AggressiveConnectionCleanup closes idle connections more frequently
 	AggressiveConnectionCleanup bool
-
-	// MinimalCacheSize uses smaller default cache sizes
+	// MinimalCacheSize uses smaller cache limits to reduce memory footprint
 	MinimalCacheSize bool
 }
 
-// DefaultOptimizedConfig returns a configuration optimized for low memory usage
+// DefaultOptimizedConfig returns a configuration optimized for low memory usage.
+// All optimization features are enabled to minimize memory footprint and prevent leaks.
 func DefaultOptimizedConfig() *OptimizedMiddlewareConfig {
 	return &OptimizedMiddlewareConfig{
 		DelayBackgroundTasks:        true,