Metadata cache leak fix + profiling

autocleanup.go

@@ -1,6 +1,9 @@
 package traefikoidc
 
-import "time"
+import (
+	"sync"
+	"time"
+)
 
 // BackgroundTask represents a managed recurring task that runs in the background.
 // It provides a clean interface for starting and stopping periodic operations
@@ -11,6 +14,7 @@ type BackgroundTask struct {
 	logger   *Logger
 	name     string
 	interval time.Duration
+	wg       *sync.WaitGroup
 }
 
 // NewBackgroundTask creates a new background task with the specified parameters.
@@ -20,35 +24,53 @@ type BackgroundTask struct {
 //   - interval: Duration between task executions.
 //   - taskFunc: The function to execute periodically.
 //   - logger: Logger instance for task lifecycle events.
+//   - wg: Optional WaitGroup for synchronizing goroutine completion.
 //
 // Returns:
 //   - A configured BackgroundTask ready to be started.
-func NewBackgroundTask(name string, interval time.Duration, taskFunc func(), logger *Logger) *BackgroundTask {
+func NewBackgroundTask(name string, interval time.Duration, taskFunc func(), logger *Logger, wg ...*sync.WaitGroup) *BackgroundTask {
+	var waitGroup *sync.WaitGroup
+	if len(wg) > 0 {
+		waitGroup = wg[0]
+	}
 	return &BackgroundTask{
 		name:     name,
 		interval: interval,
 		stopChan: make(chan struct{}),
 		taskFunc: taskFunc,
 		logger:   logger,
+		wg:       waitGroup,
 	}
 }
 
 // Start begins the background task execution in a separate goroutine.
 // The task runs immediately upon start and then at the specified interval.
 func (bt *BackgroundTask) Start() {
+	if bt.wg != nil {
+		bt.wg.Add(1)
+	}
 	go bt.run()
 }
 
 // Stop gracefully terminates the background task by closing the stop channel.
+// If a WaitGroup was provided, it waits for the goroutine to complete.
 // This method is safe to call multiple times.
 func (bt *BackgroundTask) Stop() {
 	close(bt.stopChan)
+	if bt.wg != nil {
+		bt.wg.Wait()
+	}
 }
 
 // run is the main execution loop for the background task.
 // It executes the task function immediately and then at regular intervals
 // until the stop signal is received.
 func (bt *BackgroundTask) run() {
+	defer func() {
+		if bt.wg != nil {
+			bt.wg.Done()
+		}
+	}()
 	ticker := time.NewTicker(bt.interval)
 	defer ticker.Stop()
 

main.go

@@ -36,27 +36,27 @@ func createDefaultHTTPClient() *http.Client {
 		Proxy: http.ProxyFromEnvironment,
 		DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
 			dialer := &net.Dialer{
-				Timeout:   10 * time.Second, // Connection timeout for faster failure detection
+				Timeout:   5 * time.Second,  // Reduced connection timeout for faster failure detection
-				KeepAlive: 30 * time.Second, // Keep-alive interval for connection reuse
+				KeepAlive: 15 * time.Second, // Reduced keep-alive interval for connection reuse
 			}
 			return dialer.DialContext(ctx, network, addr)
 		},
 		ForceAttemptHTTP2:     true,
-		TLSHandshakeTimeout:   3 * time.Second,  // TLS handshake timeout
+		TLSHandshakeTimeout:   2 * time.Second,  // Reduced TLS handshake timeout
 		ExpectContinueTimeout: 1 * time.Second,  // Timeout for 100-continue responses
-		MaxIdleConns:          10,               // Reduced from 20 to prevent memory buildup
+		MaxIdleConns:          5,                // Further reduced to prevent connection accumulation
-		MaxIdleConnsPerHost:   2,                // Reduced from 5 to limit per-host connections
+		MaxIdleConnsPerHost:   1,                // Further reduced to limit per-host connections
-		IdleConnTimeout:       30 * time.Second, // Reduced from 60 to close idle connections faster
+		IdleConnTimeout:       15 * time.Second, // Further reduced to close idle connections faster
 		DisableKeepAlives:     false,            // Enable connection reuse
-		MaxConnsPerHost:       10,               // Reduced from 20 to limit concurrent connections
+		MaxConnsPerHost:       5,                // Further reduced to limit concurrent connections
-		ResponseHeaderTimeout: 5 * time.Second,  // Timeout for reading response headers
+		ResponseHeaderTimeout: 3 * time.Second,  // Reduced timeout for reading response headers
 		DisableCompression:    false,            // Enable compression for bandwidth efficiency
 		WriteBufferSize:       4096,             // Write buffer size for connections
 		ReadBufferSize:        4096,             // Read buffer size for connections
 	}
 
 	return &http.Client{
-		Timeout:   time.Second * 10, // HTTP client timeout
+		Timeout:   time.Second * 5, // Reduced HTTP client timeout to prevent hanging connections
 		Transport: transport,
 		CheckRedirect: func(req *http.Request, via []*http.Request) error {
 			// Limit redirects to prevent redirect loops
@@ -124,7 +124,7 @@ type CacheManager struct {
 // It initializes all cache types on first call with appropriate default settings.
 // This ensures thread-safe initialization and consistent cache behavior across
 // the entire application lifecycle.
-func GetGlobalCacheManager() *CacheManager {
+func GetGlobalCacheManager(wg *sync.WaitGroup) *CacheManager {
 	cacheManagerOnce.Do(func() {
 		globalCacheManager = &CacheManager{
 			tokenBlacklist: func() *Cache {
@@ -133,7 +133,7 @@ func GetGlobalCacheManager() *CacheManager {
 				return c
 			}(),
 			tokenCache:    NewTokenCache(),
-			metadataCache: NewMetadataCache(),
+			metadataCache: NewMetadataCache(wg),
 			jwkCache:      &JWKCache{},
 		}
 	})
@@ -283,7 +283,7 @@ type TraefikOidc struct {
 	issuerURL                  string
 	revocationURL              string
 	scopes                     []string
-	goroutineWG                sync.WaitGroup
+	goroutineWG                *sync.WaitGroup
 	refreshGracePeriod         time.Duration
 	shutdownOnce               sync.Once
 	forceHTTPS                 bool
@@ -690,13 +690,15 @@ func New(ctx context.Context, next http.Handler, config *Config, name string) (h
 	} else {
 		httpClient = createDefaultHTTPClient()
 	}
-	cacheManager := GetGlobalCacheManager()
+	goroutineWG := &sync.WaitGroup{}
+	cacheManager := GetGlobalCacheManager(goroutineWG)
 
 	pluginCtx, cancelFunc := context.WithCancel(context.Background())
 
 	t := &TraefikOidc{
 		next:         next,
 		name:         name,
+		goroutineWG:  goroutineWG,
 		redirURLPath: config.CallbackURL,
 		logoutURLPath: func() string {
 			if config.LogoutURL == "" {

memory_leak_test.go

@@ -48,7 +48,7 @@ func TestMemoryLeakFixes(t *testing.T) {
 
 	t.Run("Global cache manager cleanup", func(t *testing.T) {
 		// Get the global cache manager
-		cm := GetGlobalCacheManager()
+		cm := GetGlobalCacheManager(nil)
 		if cm == nil {
 			t.Fatal("Failed to get global cache manager")
 		}
@@ -64,7 +64,7 @@ func TestMemoryLeakFixes(t *testing.T) {
 		}
 
 		// Verify it can be re-initialized
-		cm2 := GetGlobalCacheManager()
+		cm2 := GetGlobalCacheManager(nil)
 		if cm2 == nil {
 			t.Fatal("Failed to re-initialize global cache manager")
 		}

metadata_cache.go

@@ -19,16 +19,18 @@ type MetadataCache struct {
 	logger              *Logger
 	autoCleanupInterval time.Duration
 	mutex               sync.RWMutex
+	wg                  *sync.WaitGroup
+	stopChan            chan struct{}
 }
 
 // NewMetadataCache creates a new MetadataCache instance.
 // It initializes the cache structure and starts the background cleanup task.
-func NewMetadataCache() *MetadataCache {
+func NewMetadataCache(wg *sync.WaitGroup) *MetadataCache {
-	return NewMetadataCacheWithLogger(nil)
+	return NewMetadataCacheWithLogger(wg, nil)
 }
 
 // NewMetadataCacheWithLogger creates a new MetadataCache with a specified logger.
-func NewMetadataCacheWithLogger(logger *Logger) *MetadataCache {
+func NewMetadataCacheWithLogger(wg *sync.WaitGroup, logger *Logger) *MetadataCache {
 	if logger == nil {
 		logger = newNoOpLogger()
 	}
@@ -36,6 +38,8 @@ func NewMetadataCacheWithLogger(logger *Logger) *MetadataCache {
 	c := &MetadataCache{
 		autoCleanupInterval: 5 * time.Minute,
 		logger:              logger,
+		wg:                  wg,
+		stopChan:            make(chan struct{}),
 	}
 	c.startAutoCleanup()
 	return c
@@ -200,7 +204,7 @@ func (c *MetadataCache) GetMetadata(providerURL string, httpClient *http.Client,
 // startAutoCleanup starts the background task that periodically calls Cleanup
 // to remove expired metadata from the cache.
 func (c *MetadataCache) startAutoCleanup() {
-	c.cleanupTask = NewBackgroundTask("metadata-cache-cleanup", c.autoCleanupInterval, c.Cleanup, c.logger)
+	c.cleanupTask = NewBackgroundTask("metadata-cache-cleanup", c.autoCleanupInterval, c.Cleanup, c.logger, c.wg)
 	c.cleanupTask.Start()
 }
 

profiling.go

@@ -0,0 +1,768 @@
+package traefikoidc
+
+import (
+	"bytes"
+	"fmt"
+	"net/http"
+	"runtime"
+	"runtime/pprof"
+	"sync"
+	"time"
+)
+
+// MemoryProfiler defines the interface for memory profiling operations
+type MemoryProfiler interface {
+	// TakeSnapshot captures current memory statistics
+	TakeSnapshot() (*MemorySnapshot, error)
+
+	// StartProfiling begins memory profiling with specified configuration
+	StartProfiling(config ProfilingConfig) error
+
+	// StopProfiling ends memory profiling and returns final snapshot
+	StopProfiling() (*MemorySnapshot, error)
+
+	// GetCurrentStats returns current runtime memory statistics
+	GetCurrentStats() *runtime.MemStats
+
+	// AnalyzeLeaks performs leak detection analysis
+	AnalyzeLeaks(baseline, current *MemorySnapshot) *LeakAnalysis
+}
+
+// MemorySnapshot represents a point-in-time capture of memory statistics
+type MemorySnapshot struct {
+	Timestamp        time.Time
+	RuntimeStats     runtime.MemStats
+	HeapProfile      []byte
+	GoroutineProfile []byte
+	CustomMetrics    map[string]interface{}
+}
+
+// LeakAnalysis contains the results of memory leak detection
+type LeakAnalysis struct {
+	HasLeak           bool
+	LeakDescription   string
+	MemoryIncrease    uint64
+	GoroutineIncrease int
+	SuspectedLeaks    []string
+	Recommendations   []string
+}
+
+// ProfilingManager coordinates memory profiling operations
+type ProfilingManager struct {
+	mu               sync.RWMutex
+	isProfiling      bool
+	startTime        time.Time
+	baselineSnapshot *MemorySnapshot
+	config           ProfilingConfig
+	logger           *Logger
+	profilers        map[string]MemoryProfiler
+}
+
+// ProfilingConfig contains configuration for profiling operations
+type ProfilingConfig struct {
+	EnableHeapProfiling        bool
+	EnableGoroutineProfiling   bool
+	SnapshotInterval           time.Duration
+	LeakThresholdMB            uint64
+	MaxSnapshots               int
+	EnableContinuousMonitoring bool
+	MonitoringInterval         time.Duration
+}
+
+// LeakDetectionConfig contains configuration for leak detection
+type LeakDetectionConfig struct {
+	EnableLeakDetection       bool
+	LeakThresholdMB           uint64
+	GoroutineLeakThreshold    int
+	SessionPoolThreshold      int
+	CacheMemoryThreshold      uint64
+	HTTPClientThreshold       int
+	TokenCompressionThreshold uint64
+}
+
+// NewProfilingManager creates a new profiling manager instance
+func NewProfilingManager(logger *Logger) *ProfilingManager {
+	if logger == nil {
+		logger = newNoOpLogger()
+	}
+
+	return &ProfilingManager{
+		profilers: make(map[string]MemoryProfiler),
+		config: ProfilingConfig{
+			EnableHeapProfiling:        true,
+			EnableGoroutineProfiling:   true,
+			SnapshotInterval:           30 * time.Second,
+			LeakThresholdMB:            50, // 50MB
+			MaxSnapshots:               100,
+			EnableContinuousMonitoring: true,
+			MonitoringInterval:         60 * time.Second,
+		},
+		logger: logger,
+	}
+}
+
+// TakeSnapshot captures current memory statistics
+func (pm *ProfilingManager) TakeSnapshot() (*MemorySnapshot, error) {
+	var buf bytes.Buffer
+	snapshot := &MemorySnapshot{
+		Timestamp:     time.Now(),
+		CustomMetrics: make(map[string]interface{}),
+	}
+
+	// Capture runtime memory statistics
+	runtime.ReadMemStats(&snapshot.RuntimeStats)
+
+	// Capture heap profile if enabled
+	if pm.config.EnableHeapProfiling {
+		if err := pprof.WriteHeapProfile(&buf); err != nil {
+			pm.logger.Errorf("Failed to capture heap profile: %v", err)
+		} else {
+			snapshot.HeapProfile = make([]byte, buf.Len())
+			copy(snapshot.HeapProfile, buf.Bytes())
+			buf.Reset()
+		}
+	}
+
+	// Capture goroutine profile if enabled
+	if pm.config.EnableGoroutineProfiling {
+		if err := pprof.Lookup("goroutine").WriteTo(&buf, 0); err != nil {
+			pm.logger.Errorf("Failed to capture goroutine profile: %v", err)
+		} else {
+			snapshot.GoroutineProfile = make([]byte, buf.Len())
+			copy(snapshot.GoroutineProfile, buf.Bytes())
+			buf.Reset()
+		}
+	}
+
+	// Capture custom metrics from registered profilers
+	pm.mu.RLock()
+	for name, profiler := range pm.profilers {
+		if customStats := profiler.GetCurrentStats(); customStats != nil {
+			snapshot.CustomMetrics[name] = customStats
+		}
+	}
+	pm.mu.RUnlock()
+
+	return snapshot, nil
+}
+
+// StartProfiling begins memory profiling with specified configuration
+func (pm *ProfilingManager) StartProfiling(config ProfilingConfig) error {
+	pm.mu.Lock()
+	defer pm.mu.Unlock()
+
+	if pm.isProfiling {
+		return fmt.Errorf("profiling already in progress")
+	}
+
+	pm.config = config
+	pm.isProfiling = true
+	pm.startTime = time.Now()
+
+	// Take baseline snapshot
+	baseline, err := pm.TakeSnapshot()
+	if err != nil {
+		pm.isProfiling = false
+		return fmt.Errorf("failed to take baseline snapshot: %w", err)
+	}
+	pm.baselineSnapshot = baseline
+
+	pm.logger.Infof("Memory profiling started at %v", pm.startTime)
+	return nil
+}
+
+// StopProfiling ends memory profiling and returns final snapshot
+func (pm *ProfilingManager) StopProfiling() (*MemorySnapshot, error) {
+	pm.mu.Lock()
+	defer pm.mu.Unlock()
+
+	if !pm.isProfiling {
+		return nil, fmt.Errorf("profiling not in progress")
+	}
+
+	// Take final snapshot
+	finalSnapshot, err := pm.TakeSnapshot()
+	if err != nil {
+		pm.logger.Errorf("Failed to take final snapshot: %v", err)
+	}
+
+	pm.isProfiling = false
+	duration := time.Since(pm.startTime)
+
+	pm.logger.Infof("Memory profiling stopped after %v", duration)
+	return finalSnapshot, err
+}
+
+// GetCurrentStats returns current runtime memory statistics
+func (pm *ProfilingManager) GetCurrentStats() *runtime.MemStats {
+	stats := &runtime.MemStats{}
+	runtime.ReadMemStats(stats)
+	return stats
+}
+
+// AnalyzeLeaks performs leak detection analysis
+func (pm *ProfilingManager) AnalyzeLeaks(baseline, current *MemorySnapshot) *LeakAnalysis {
+	analysis := &LeakAnalysis{
+		SuspectedLeaks:  make([]string, 0),
+		Recommendations: make([]string, 0),
+	}
+
+	if baseline == nil || current == nil {
+		analysis.HasLeak = false
+		analysis.LeakDescription = "Insufficient data for leak analysis"
+		return analysis
+	}
+
+	// Calculate memory increase
+	memoryIncrease := current.RuntimeStats.Alloc - baseline.RuntimeStats.Alloc
+	analysis.MemoryIncrease = memoryIncrease
+
+	// Calculate goroutine increase
+	currentGoroutines := runtime.NumGoroutine()
+	baselineGoroutines := runtime.NumGoroutine() // Note: This is not accurate for baseline, but we don't have historical data
+	goroutineIncrease := currentGoroutines - baselineGoroutines
+	analysis.GoroutineIncrease = goroutineIncrease
+
+	// Check for memory leaks
+	memoryThreshold := pm.config.LeakThresholdMB * 1024 * 1024 // Convert MB to bytes
+	if memoryIncrease > memoryThreshold {
+		analysis.HasLeak = true
+		analysis.SuspectedLeaks = append(analysis.SuspectedLeaks,
+			fmt.Sprintf("Memory usage increased by %.2f MB", float64(memoryIncrease)/(1024*1024)))
+		analysis.Recommendations = append(analysis.Recommendations,
+			"Consider checking for unreleased memory pools or growing caches")
+	}
+
+	// Check for goroutine leaks
+	if goroutineIncrease > 10 { // Arbitrary threshold
+		analysis.HasLeak = true
+		analysis.SuspectedLeaks = append(analysis.SuspectedLeaks,
+			fmt.Sprintf("Goroutine count increased by %d", goroutineIncrease))
+		analysis.Recommendations = append(analysis.Recommendations,
+			"Check for goroutines that are not being properly cleaned up")
+	}
+
+	if analysis.HasLeak {
+		analysis.LeakDescription = fmt.Sprintf("Potential memory leak detected: %s",
+			fmt.Sprintf("%.2f MB increase, %d goroutines", float64(memoryIncrease)/(1024*1024), goroutineIncrease))
+	} else {
+		analysis.LeakDescription = "No significant memory leaks detected"
+	}
+
+	return analysis
+}
+
+// RegisterProfiler registers a component-specific profiler
+func (pm *ProfilingManager) RegisterProfiler(name string, profiler MemoryProfiler) {
+	pm.mu.Lock()
+	defer pm.mu.Unlock()
+	pm.profilers[name] = profiler
+	pm.logger.Debugf("Registered profiler: %s", name)
+}
+
+// UnregisterProfiler removes a component-specific profiler
+func (pm *ProfilingManager) UnregisterProfiler(name string) {
+	pm.mu.Lock()
+	defer pm.mu.Unlock()
+	delete(pm.profilers, name)
+	pm.logger.Debugf("Unregistered profiler: %s", name)
+}
+
+// GetRegisteredProfilers returns list of registered profiler names
+func (pm *ProfilingManager) GetRegisteredProfilers() []string {
+	pm.mu.RLock()
+	defer pm.mu.RUnlock()
+
+	names := make([]string, 0, len(pm.profilers))
+	for name := range pm.profilers {
+		names = append(names, name)
+	}
+	return names
+}
+
+// MemoryTestOrchestrator coordinates memory leak testing across components
+type MemoryTestOrchestrator struct {
+	mu          sync.RWMutex
+	profilers   map[string]MemoryProfiler
+	config      LeakDetectionConfig
+	logger      *Logger
+	isRunning   bool
+	stopChan    chan struct{}
+	testResults map[string]*LeakAnalysis
+}
+
+// NewMemoryTestOrchestrator creates a new test orchestrator
+func NewMemoryTestOrchestrator(config LeakDetectionConfig, logger *Logger) *MemoryTestOrchestrator {
+	if logger == nil {
+		logger = newNoOpLogger()
+	}
+
+	return &MemoryTestOrchestrator{
+		profilers:   make(map[string]MemoryProfiler),
+		config:      config,
+		logger:      logger,
+		stopChan:    make(chan struct{}),
+		testResults: make(map[string]*LeakAnalysis),
+	}
+}
+
+// RegisterComponent registers a component for memory leak testing
+func (mto *MemoryTestOrchestrator) RegisterComponent(name string, profiler MemoryProfiler) {
+	mto.mu.Lock()
+	defer mto.mu.Unlock()
+	mto.profilers[name] = profiler
+	mto.logger.Debugf("Registered component for leak testing: %s", name)
+}
+
+// UnregisterComponent removes a component from leak testing
+func (mto *MemoryTestOrchestrator) UnregisterComponent(name string) {
+	mto.mu.Lock()
+	defer mto.mu.Unlock()
+	delete(mto.profilers, name)
+	delete(mto.testResults, name)
+	mto.logger.Debugf("Unregistered component from leak testing: %s", name)
+}
+
+// StartLeakDetection begins continuous leak detection monitoring
+func (mto *MemoryTestOrchestrator) StartLeakDetection() error {
+	mto.mu.Lock()
+	defer mto.mu.Unlock()
+
+	if mto.isRunning {
+		return fmt.Errorf("leak detection already running")
+	}
+
+	if !mto.config.EnableLeakDetection {
+		return fmt.Errorf("leak detection is disabled in configuration")
+	}
+
+	mto.isRunning = true
+	go mto.runLeakDetection()
+
+	mto.logger.Infof("Memory leak detection started")
+	return nil
+}
+
+// StopLeakDetection stops continuous leak detection monitoring
+func (mto *MemoryTestOrchestrator) StopLeakDetection() error {
+	mto.mu.Lock()
+	defer mto.mu.Unlock()
+
+	if !mto.isRunning {
+		return fmt.Errorf("leak detection not running")
+	}
+
+	mto.isRunning = false
+	close(mto.stopChan)
+	mto.stopChan = make(chan struct{}) // Reset for potential restart
+
+	mto.logger.Infof("Memory leak detection stopped")
+	return nil
+}
+
+// runLeakDetection performs continuous leak detection monitoring
+func (mto *MemoryTestOrchestrator) runLeakDetection() {
+	ticker := time.NewTicker(5 * time.Minute) // Check every 5 minutes
+	defer ticker.Stop()
+
+	baselineSnapshots := make(map[string]*MemorySnapshot)
+
+	// Take initial baseline snapshots
+	mto.mu.RLock()
+	for name, profiler := range mto.profilers {
+		if snapshot, err := profiler.TakeSnapshot(); err == nil {
+			baselineSnapshots[name] = snapshot
+		}
+	}
+	mto.mu.RUnlock()
+
+	for {
+		select {
+		case <-ticker.C:
+			mto.performLeakCheck(baselineSnapshots)
+		case <-mto.stopChan:
+			return
+		}
+	}
+}
+
+// performLeakCheck performs leak detection for all registered components
+func (mto *MemoryTestOrchestrator) performLeakCheck(baselineSnapshots map[string]*MemorySnapshot) {
+	mto.mu.RLock()
+	defer mto.mu.RUnlock()
+
+	for name, profiler := range mto.profilers {
+		baseline, exists := baselineSnapshots[name]
+		if !exists {
+			continue
+		}
+
+		current, err := profiler.TakeSnapshot()
+		if err != nil {
+			mto.logger.Errorf("Failed to take snapshot for component %s: %v", name, err)
+			continue
+		}
+
+		analysis := profiler.AnalyzeLeaks(baseline, current)
+		if analysis.HasLeak {
+			mto.logger.Errorf("Memory leak detected in component %s: %s", name, analysis.LeakDescription)
+			for _, rec := range analysis.Recommendations {
+				mto.logger.Errorf("Recommendation for %s: %s", name, rec)
+			}
+		}
+
+		mto.testResults[name] = analysis
+	}
+}
+
+// GetLeakAnalysis returns leak analysis for a specific component
+func (mto *MemoryTestOrchestrator) GetLeakAnalysis(componentName string) (*LeakAnalysis, bool) {
+	mto.mu.RLock()
+	defer mto.mu.RUnlock()
+	analysis, exists := mto.testResults[componentName]
+	return analysis, exists
+}
+
+// GetAllLeakAnalyses returns leak analyses for all components
+func (mto *MemoryTestOrchestrator) GetAllLeakAnalyses() map[string]*LeakAnalysis {
+	mto.mu.RLock()
+	defer mto.mu.RUnlock()
+
+	results := make(map[string]*LeakAnalysis)
+	for name, analysis := range mto.testResults {
+		results[name] = analysis
+	}
+	return results
+}
+
+// Component-specific profiler implementations
+
+// SessionPoolProfiler monitors session pool memory usage
+type SessionPoolProfiler struct {
+	sessionManager *SessionManager
+	logger         *Logger
+}
+
+// NewSessionPoolProfiler creates a new session pool profiler
+func NewSessionPoolProfiler(sm *SessionManager, logger *Logger) *SessionPoolProfiler {
+	if logger == nil {
+		logger = newNoOpLogger()
+	}
+	return &SessionPoolProfiler{
+		sessionManager: sm,
+		logger:         logger,
+	}
+}
+
+// TakeSnapshot captures session pool memory statistics
+func (spp *SessionPoolProfiler) TakeSnapshot() (*MemorySnapshot, error) {
+	snapshot := &MemorySnapshot{
+		Timestamp:     time.Now(),
+		CustomMetrics: make(map[string]interface{}),
+	}
+
+	// Capture runtime stats
+	runtime.ReadMemStats(&snapshot.RuntimeStats)
+
+	// Add session pool specific metrics
+	snapshot.CustomMetrics["session_pool_metrics"] = spp.sessionManager.GetSessionMetrics()
+
+	return snapshot, nil
+}
+
+// StartProfiling begins profiling (no-op for session pools)
+func (spp *SessionPoolProfiler) StartProfiling(config ProfilingConfig) error {
+	return nil
+}
+
+// StopProfiling ends profiling (no-op for session pools)
+func (spp *SessionPoolProfiler) StopProfiling() (*MemorySnapshot, error) {
+	return spp.TakeSnapshot()
+}
+
+// GetCurrentStats returns current memory statistics
+func (spp *SessionPoolProfiler) GetCurrentStats() *runtime.MemStats {
+	stats := &runtime.MemStats{}
+	runtime.ReadMemStats(stats)
+	return stats
+}
+
+// AnalyzeLeaks analyzes session pool for leaks
+func (spp *SessionPoolProfiler) AnalyzeLeaks(baseline, current *MemorySnapshot) *LeakAnalysis {
+	analysis := &LeakAnalysis{
+		SuspectedLeaks:  make([]string, 0),
+		Recommendations: make([]string, 0),
+	}
+
+	if baseline == nil || current == nil {
+		analysis.LeakDescription = "Insufficient session pool data"
+		return analysis
+	}
+
+	// Check for session pool specific leaks
+	memoryIncrease := current.RuntimeStats.Alloc - baseline.RuntimeStats.Alloc
+	if memoryIncrease > 10*1024*1024 { // 10MB threshold
+		analysis.HasLeak = true
+		analysis.SuspectedLeaks = append(analysis.SuspectedLeaks,
+			"Session pool memory usage increased significantly")
+		analysis.Recommendations = append(analysis.Recommendations,
+			"Check for sessions not being returned to pool properly")
+	}
+
+	return analysis
+}
+
+// CacheMemoryProfiler monitors cache memory usage
+type CacheMemoryProfiler struct {
+	cache  *Cache
+	logger *Logger
+}
+
+// NewCacheMemoryProfiler creates a new cache memory profiler
+func NewCacheMemoryProfiler(cache *Cache, logger *Logger) *CacheMemoryProfiler {
+	if logger == nil {
+		logger = newNoOpLogger()
+	}
+	return &CacheMemoryProfiler{
+		cache:  cache,
+		logger: logger,
+	}
+}
+
+// TakeSnapshot captures cache memory statistics
+func (cmp *CacheMemoryProfiler) TakeSnapshot() (*MemorySnapshot, error) {
+	snapshot := &MemorySnapshot{
+		Timestamp:     time.Now(),
+		CustomMetrics: make(map[string]interface{}),
+	}
+
+	runtime.ReadMemStats(&snapshot.RuntimeStats)
+
+	// Add cache-specific metrics (would need to be added to Cache struct)
+	snapshot.CustomMetrics["cache_size"] = "unknown" // Placeholder
+
+	return snapshot, nil
+}
+
+// StartProfiling begins profiling (no-op for cache)
+func (cmp *CacheMemoryProfiler) StartProfiling(config ProfilingConfig) error {
+	return nil
+}
+
+// StopProfiling ends profiling
+func (cmp *CacheMemoryProfiler) StopProfiling() (*MemorySnapshot, error) {
+	return cmp.TakeSnapshot()
+}
+
+// GetCurrentStats returns current memory statistics
+func (cmp *CacheMemoryProfiler) GetCurrentStats() *runtime.MemStats {
+	stats := &runtime.MemStats{}
+	runtime.ReadMemStats(stats)
+	return stats
+}
+
+// AnalyzeLeaks analyzes cache for memory leaks
+func (cmp *CacheMemoryProfiler) AnalyzeLeaks(baseline, current *MemorySnapshot) *LeakAnalysis {
+	analysis := &LeakAnalysis{
+		SuspectedLeaks:  make([]string, 0),
+		Recommendations: make([]string, 0),
+	}
+
+	if baseline == nil || current == nil {
+		analysis.LeakDescription = "Insufficient cache data"
+		return analysis
+	}
+
+	memoryIncrease := current.RuntimeStats.Alloc - baseline.RuntimeStats.Alloc
+	if memoryIncrease > 20*1024*1024 { // 20MB threshold for cache
+		analysis.HasLeak = true
+		analysis.SuspectedLeaks = append(analysis.SuspectedLeaks,
+			"Cache memory usage increased significantly")
+		analysis.Recommendations = append(analysis.Recommendations,
+			"Check cache size limits and cleanup intervals")
+	}
+
+	return analysis
+}
+
+// HTTPClientProfiler monitors HTTP client connection pools
+type HTTPClientProfiler struct {
+	httpClient *http.Client
+	logger     *Logger
+}
+
+// NewHTTPClientProfiler creates a new HTTP client profiler
+func NewHTTPClientProfiler(client *http.Client, logger *Logger) *HTTPClientProfiler {
+	if logger == nil {
+		logger = newNoOpLogger()
+	}
+	return &HTTPClientProfiler{
+		httpClient: client,
+		logger:     logger,
+	}
+}
+
+// TakeSnapshot captures HTTP client memory statistics
+func (hcp *HTTPClientProfiler) TakeSnapshot() (*MemorySnapshot, error) {
+	snapshot := &MemorySnapshot{
+		Timestamp:     time.Now(),
+		CustomMetrics: make(map[string]interface{}),
+	}
+
+	runtime.ReadMemStats(&snapshot.RuntimeStats)
+
+	// Add HTTP client specific metrics
+	if transport, ok := hcp.httpClient.Transport.(*http.Transport); ok {
+		snapshot.CustomMetrics["idle_connections"] = transport.IdleConnTimeout.String()
+		snapshot.CustomMetrics["max_idle_conns"] = transport.MaxIdleConns
+	}
+
+	return snapshot, nil
+}
+
+// StartProfiling begins profiling (no-op for HTTP client)
+func (hcp *HTTPClientProfiler) StartProfiling(config ProfilingConfig) error {
+	return nil
+}
+
+// StopProfiling ends profiling
+func (hcp *HTTPClientProfiler) StopProfiling() (*MemorySnapshot, error) {
+	return hcp.TakeSnapshot()
+}
+
+// GetCurrentStats returns current memory statistics
+func (hcp *HTTPClientProfiler) GetCurrentStats() *runtime.MemStats {
+	stats := &runtime.MemStats{}
+	runtime.ReadMemStats(stats)
+	return stats
+}
+
+// AnalyzeLeaks analyzes HTTP client for connection leaks
+func (hcp *HTTPClientProfiler) AnalyzeLeaks(baseline, current *MemorySnapshot) *LeakAnalysis {
+	analysis := &LeakAnalysis{
+		SuspectedLeaks:  make([]string, 0),
+		Recommendations: make([]string, 0),
+	}
+
+	if baseline == nil || current == nil {
+		analysis.LeakDescription = "Insufficient HTTP client data"
+		return analysis
+	}
+
+	memoryIncrease := current.RuntimeStats.Alloc - baseline.RuntimeStats.Alloc
+	if memoryIncrease > 5*1024*1024 { // 5MB threshold for HTTP client
+		analysis.HasLeak = true
+		analysis.SuspectedLeaks = append(analysis.SuspectedLeaks,
+			"HTTP client memory usage increased significantly")
+		analysis.Recommendations = append(analysis.Recommendations,
+			"Check for HTTP response bodies not being drained properly")
+	}
+
+	return analysis
+}
+
+// TokenCompressionProfiler monitors token compression memory usage
+type TokenCompressionProfiler struct {
+	compressionPool *TokenCompressionPool
+	logger          *Logger
+}
+
+// NewTokenCompressionProfiler creates a new token compression profiler
+func NewTokenCompressionProfiler(pool *TokenCompressionPool, logger *Logger) *TokenCompressionProfiler {
+	if logger == nil {
+		logger = newNoOpLogger()
+	}
+	return &TokenCompressionProfiler{
+		compressionPool: pool,
+		logger:          logger,
+	}
+}
+
+// TakeSnapshot captures token compression memory statistics
+func (tcp *TokenCompressionProfiler) TakeSnapshot() (*MemorySnapshot, error) {
+	snapshot := &MemorySnapshot{
+		Timestamp:     time.Now(),
+		CustomMetrics: make(map[string]interface{}),
+	}
+
+	runtime.ReadMemStats(&snapshot.RuntimeStats)
+
+	// Add compression pool specific metrics
+	snapshot.CustomMetrics["compression_pool_active"] = true
+
+	return snapshot, nil
+}
+
+// StartProfiling begins profiling (no-op for compression)
+func (tcp *TokenCompressionProfiler) StartProfiling(config ProfilingConfig) error {
+	return nil
+}
+
+// StopProfiling ends profiling
+func (tcp *TokenCompressionProfiler) StopProfiling() (*MemorySnapshot, error) {
+	return tcp.TakeSnapshot()
+}
+
+// GetCurrentStats returns current memory statistics
+func (tcp *TokenCompressionProfiler) GetCurrentStats() *runtime.MemStats {
+	stats := &runtime.MemStats{}
+	runtime.ReadMemStats(stats)
+	return stats
+}
+
+// AnalyzeLeaks analyzes token compression for memory leaks
+func (tcp *TokenCompressionProfiler) AnalyzeLeaks(baseline, current *MemorySnapshot) *LeakAnalysis {
+	analysis := &LeakAnalysis{
+		SuspectedLeaks:  make([]string, 0),
+		Recommendations: make([]string, 0),
+	}
+
+	if baseline == nil || current == nil {
+		analysis.LeakDescription = "Insufficient compression data"
+		return analysis
+	}
+
+	memoryIncrease := current.RuntimeStats.Alloc - baseline.RuntimeStats.Alloc
+	if memoryIncrease > 2*1024*1024 { // 2MB threshold for compression
+		analysis.HasLeak = true
+		analysis.SuspectedLeaks = append(analysis.SuspectedLeaks,
+			"Token compression memory usage increased significantly")
+		analysis.Recommendations = append(analysis.Recommendations,
+			"Check for compression buffers not being returned to pool")
+	}
+
+	return analysis
+}
+
+// Global profiling manager instance
+var globalProfilingManager *ProfilingManager
+var profilingManagerOnce sync.Once
+
+// GetGlobalProfilingManager returns the singleton profiling manager
+func GetGlobalProfilingManager() *ProfilingManager {
+	profilingManagerOnce.Do(func() {
+		globalProfilingManager = NewProfilingManager(nil)
+	})
+	return globalProfilingManager
+}
+
+// Global test orchestrator instance
+var globalTestOrchestrator *MemoryTestOrchestrator
+var testOrchestratorOnce sync.Once
+
+// GetGlobalTestOrchestrator returns the singleton test orchestrator
+func GetGlobalTestOrchestrator() *MemoryTestOrchestrator {
+	testOrchestratorOnce.Do(func() {
+		config := LeakDetectionConfig{
+			EnableLeakDetection:       true,
+			LeakThresholdMB:           50,
+			GoroutineLeakThreshold:    10,
+			SessionPoolThreshold:      100,
+			CacheMemoryThreshold:      20 * 1024 * 1024, // 20MB
+			HTTPClientThreshold:       50,
+			TokenCompressionThreshold: 2 * 1024 * 1024, // 2MB
+		}
+		globalTestOrchestrator = NewMemoryTestOrchestrator(config, nil)
+	})
+	return globalTestOrchestrator
+}

profiling_test.go

@@ -0,0 +1,560 @@
+package traefikoidc
+
+import (
+	"encoding/json"
+	"fmt"
+	"net"
+	"net/http"
+	"os"
+	"runtime"
+	"sync"
+	"testing"
+	"time"
+)
+
+func TestProfilingManager(t *testing.T) {
+	logger := NewLogger("debug")
+	pm := NewProfilingManager(logger)
+
+	// Test taking a snapshot
+	snapshot, err := pm.TakeSnapshot()
+	if err != nil {
+		t.Fatalf("Failed to take snapshot: %v", err)
+	}
+
+	if snapshot == nil {
+		t.Fatal("Snapshot is nil")
+	}
+
+	if snapshot.RuntimeStats.Alloc == 0 {
+		t.Error("Runtime stats Alloc should not be zero")
+	}
+
+	if snapshot.Timestamp.IsZero() {
+		t.Error("Snapshot timestamp should not be zero")
+	}
+}
+
+func TestMemoryTestOrchestrator(t *testing.T) {
+	logger := NewLogger("debug")
+	config := LeakDetectionConfig{
+		EnableLeakDetection: true,
+		LeakThresholdMB:     10,
+	}
+
+	mto := NewMemoryTestOrchestrator(config, logger)
+
+	// Test registering a component
+	sessionManager, err := NewSessionManager("test-key-32-chars-long-for-testing", false, "", logger)
+	if err != nil {
+		t.Fatalf("Failed to create session manager: %v", err)
+	}
+
+	profiler := NewSessionPoolProfiler(sessionManager, logger)
+	mto.RegisterComponent("session_pool", profiler)
+
+	// Test getting leak analysis (should return false initially since no checks have been performed)
+	_, exists := mto.GetLeakAnalysis("session_pool")
+	if exists {
+		t.Error("Should not have leak analysis before any checks are performed")
+	}
+
+	// Perform a manual leak check
+	baseline, err := profiler.TakeSnapshot()
+	if err != nil {
+		t.Fatalf("Failed to take baseline snapshot: %v", err)
+	}
+
+	time.Sleep(10 * time.Millisecond) // Small delay
+
+	// Manually trigger leak check with baseline
+	baselineSnapshots := make(map[string]*MemorySnapshot)
+	baselineSnapshots["session_pool"] = baseline
+	mto.performLeakCheck(baselineSnapshots)
+
+	// Now test getting leak analysis
+	analysis, exists := mto.GetLeakAnalysis("session_pool")
+	if !exists {
+		t.Error("Should have leak analysis after performing checks")
+	}
+
+	if analysis == nil {
+		t.Error("Leak analysis should not be nil after checks")
+	}
+}
+
+func TestComponentProfilers(t *testing.T) {
+	logger := NewLogger("debug")
+
+	// Test Session Pool Profiler
+	sessionManager, err := NewSessionManager("test-key-32-chars-long-for-testing", false, "", logger)
+	if err != nil {
+		t.Fatalf("Failed to create session manager: %v", err)
+	}
+
+	spp := NewSessionPoolProfiler(sessionManager, logger)
+	snapshot, err := spp.TakeSnapshot()
+	if err != nil {
+		t.Fatalf("Failed to take session pool snapshot: %v", err)
+	}
+
+	if snapshot == nil {
+		t.Fatal("Session pool snapshot is nil")
+	}
+
+	// Test Cache Memory Profiler
+	cache := NewCache()
+	cmp := NewCacheMemoryProfiler(cache, logger)
+	snapshot, err = cmp.TakeSnapshot()
+	if err != nil {
+		t.Fatalf("Failed to take cache snapshot: %v", err)
+	}
+
+	if snapshot == nil {
+		t.Fatal("Cache snapshot is nil")
+	}
+
+	// Test HTTP Client Profiler
+	httpClient := createDefaultHTTPClient()
+	hcp := NewHTTPClientProfiler(httpClient, logger)
+	snapshot, err = hcp.TakeSnapshot()
+	if err != nil {
+		t.Fatalf("Failed to take HTTP client snapshot: %v", err)
+	}
+
+	if snapshot == nil {
+		t.Fatal("HTTP client snapshot is nil")
+	}
+
+	// Test Token Compression Profiler
+	compressionPool := NewTokenCompressionPool()
+	tcp := NewTokenCompressionProfiler(compressionPool, logger)
+	snapshot, err = tcp.TakeSnapshot()
+	if err != nil {
+		t.Fatalf("Failed to take compression snapshot: %v", err)
+	}
+
+	if snapshot == nil {
+		t.Fatal("Compression snapshot is nil")
+	}
+}
+
+func TestLeakAnalysis(t *testing.T) {
+	logger := NewLogger("debug")
+	pm := NewProfilingManager(logger)
+
+	// Create baseline snapshot
+	baseline, err := pm.TakeSnapshot()
+	if err != nil {
+		t.Fatalf("Failed to create baseline: %v", err)
+	}
+
+	// Wait a bit and create current snapshot
+	time.Sleep(10 * time.Millisecond)
+	current, err := pm.TakeSnapshot()
+	if err != nil {
+		t.Fatalf("Failed to create current snapshot: %v", err)
+	}
+
+	// Test leak analysis
+	analysis := pm.AnalyzeLeaks(baseline, current)
+	if analysis == nil {
+		t.Fatal("Leak analysis is nil")
+	}
+
+	// Analysis should not have leaks for normal operation
+	if analysis.HasLeak {
+		t.Logf("Leak detected: %s", analysis.LeakDescription)
+		// This is acceptable as the test environment may have varying memory usage
+	}
+}
+
+func TestGlobalInstances(t *testing.T) {
+	// Test global profiling manager
+	gpm := GetGlobalProfilingManager()
+	if gpm == nil {
+		t.Fatal("Global profiling manager is nil")
+	}
+
+	// Test global test orchestrator
+	gto := GetGlobalTestOrchestrator()
+	if gto == nil {
+		t.Fatal("Global test orchestrator is nil")
+	}
+
+	// Test that they're singletons
+	gpm2 := GetGlobalProfilingManager()
+	if gpm != gpm2 {
+		t.Error("Global profiling manager should be singleton")
+	}
+
+	gto2 := GetGlobalTestOrchestrator()
+	if gto != gto2 {
+		t.Error("Global test orchestrator should be singleton")
+	}
+}
+
+func TestProfilingConfig(t *testing.T) {
+	config := ProfilingConfig{
+		EnableHeapProfiling:        true,
+		EnableGoroutineProfiling:   true,
+		SnapshotInterval:           30 * time.Second,
+		LeakThresholdMB:            50,
+		MaxSnapshots:               100,
+		EnableContinuousMonitoring: true,
+		MonitoringInterval:         60 * time.Second,
+	}
+
+	if !config.EnableHeapProfiling {
+		t.Error("Heap profiling should be enabled")
+	}
+
+	if !config.EnableGoroutineProfiling {
+		t.Error("Goroutine profiling should be enabled")
+	}
+
+	if config.LeakThresholdMB != 50 {
+		t.Errorf("Expected leak threshold 50, got %d", config.LeakThresholdMB)
+	}
+}
+
+func TestLeakDetectionConfig(t *testing.T) {
+	config := LeakDetectionConfig{
+		EnableLeakDetection:       true,
+		LeakThresholdMB:           50,
+		GoroutineLeakThreshold:    10,
+		SessionPoolThreshold:      100,
+		CacheMemoryThreshold:      20 * 1024 * 1024,
+		HTTPClientThreshold:       50,
+		TokenCompressionThreshold: 2 * 1024 * 1024,
+	}
+
+	if !config.EnableLeakDetection {
+		t.Error("Leak detection should be enabled")
+	}
+
+	if config.LeakThresholdMB != 50 {
+		t.Errorf("Expected leak threshold 50, got %d", config.LeakThresholdMB)
+	}
+
+	if config.CacheMemoryThreshold != 20*1024*1024 {
+		t.Errorf("Expected cache threshold 20MB, got %d", config.CacheMemoryThreshold)
+	}
+}
+
+// ProviderMetadataProfiler monitors provider metadata fetching and caching operations
+type ProviderMetadataProfiler struct {
+	metadataCache *MetadataCache
+	httpClient    *http.Client
+	logger        *Logger
+	providerURL   string
+}
+
+// NewProviderMetadataProfiler creates a new provider metadata profiler
+func NewProviderMetadataProfiler(metadataCache *MetadataCache, httpClient *http.Client, providerURL string, logger *Logger) *ProviderMetadataProfiler {
+	if logger == nil {
+		logger = newNoOpLogger()
+	}
+	return &ProviderMetadataProfiler{
+		metadataCache: metadataCache,
+		httpClient:    httpClient,
+		providerURL:   providerURL,
+		logger:        logger,
+	}
+}
+
+// TakeSnapshot captures current memory statistics for metadata operations
+func (pmp *ProviderMetadataProfiler) TakeSnapshot() (*MemorySnapshot, error) {
+	snapshot := &MemorySnapshot{
+		Timestamp:     time.Now(),
+		CustomMetrics: make(map[string]interface{}),
+	}
+
+	// Capture runtime memory statistics
+	runtime.ReadMemStats(&snapshot.RuntimeStats)
+
+	// Add metadata-specific metrics
+	snapshot.CustomMetrics["metadata_cache_size"] = 1  // Placeholder for cache size
+	snapshot.CustomMetrics["metadata_fetch_count"] = 0 // Placeholder for fetch count
+	snapshot.CustomMetrics["background_goroutines"] = runtime.NumGoroutine()
+
+	return snapshot, nil
+}
+
+// StartProfiling begins profiling (no-op for metadata profiler)
+func (pmp *ProviderMetadataProfiler) StartProfiling(config ProfilingConfig) error {
+	return nil
+}
+
+// StopProfiling ends profiling
+func (pmp *ProviderMetadataProfiler) StopProfiling() (*MemorySnapshot, error) {
+	return pmp.TakeSnapshot()
+}
+
+// GetCurrentStats returns current memory statistics
+func (pmp *ProviderMetadataProfiler) GetCurrentStats() *runtime.MemStats {
+	stats := &runtime.MemStats{}
+	runtime.ReadMemStats(stats)
+	return stats
+}
+
+// AnalyzeLeaks analyzes metadata operations for memory leaks
+func (pmp *ProviderMetadataProfiler) AnalyzeLeaks(baseline, current *MemorySnapshot) *LeakAnalysis {
+	analysis := &LeakAnalysis{
+		SuspectedLeaks:  make([]string, 0),
+		Recommendations: make([]string, 0),
+	}
+
+	if baseline == nil || current == nil {
+		analysis.LeakDescription = "Insufficient metadata data"
+		return analysis
+	}
+
+	// Check for memory leaks
+	memoryIncrease := current.RuntimeStats.Alloc - baseline.RuntimeStats.Alloc
+	if memoryIncrease > 5*1024*1024 { // 5MB threshold for metadata operations
+		analysis.HasLeak = true
+		analysis.SuspectedLeaks = append(analysis.SuspectedLeaks,
+			"Metadata operations memory usage increased significantly")
+		analysis.Recommendations = append(analysis.Recommendations,
+			"Check for metadata cache not being cleaned up properly")
+	}
+
+	// Check for goroutine leaks
+	goroutineIncrease := current.CustomMetrics["background_goroutines"].(int) - baseline.CustomMetrics["background_goroutines"].(int)
+	if goroutineIncrease > 2 { // Allow some variance
+		analysis.HasLeak = true
+		analysis.SuspectedLeaks = append(analysis.SuspectedLeaks,
+			fmt.Sprintf("Goroutine count increased by %d during metadata operations", goroutineIncrease))
+		analysis.Recommendations = append(analysis.Recommendations,
+			"Check for background goroutines not being cleaned up")
+	}
+
+	return analysis
+}
+
+// TestProviderMetadataMemoryLeakDetection tests for memory leaks in provider metadata operations
+func TestProviderMetadataMemoryLeakDetection(t *testing.T) {
+	logger := NewLogger("debug")
+
+	strictMode := os.Getenv("STRICT_MEMORY_TEST") == "true"
+	if strictMode {
+		t.Log("Running in strict memory test mode - will fail on detected leaks")
+	} else {
+		t.Log("Running in lenient memory test mode - will log warnings instead of failing")
+	}
+
+	config := LeakDetectionConfig{
+		EnableLeakDetection: true,
+		LeakThresholdMB:     10,
+	}
+
+	mto := NewMemoryTestOrchestrator(config, logger)
+
+	// Create mock HTTP server for metadata endpoint with failure simulation
+	requestCount := 0
+	serverFailures := 0
+	mockServer := &http.Server{
+		Addr: "localhost:0", // Let system assign port
+		Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			requestCount++
+			if r.URL.Path == "/.well-known/openid-configuration" {
+				// Simulate occasional failures to test cache extension
+				if requestCount%4 == 0 { // Fail every 4th request
+					serverFailures++
+					w.WriteHeader(http.StatusInternalServerError)
+					return
+				}
+
+				metadata := ProviderMetadata{
+					Issuer:        "https://mock-provider.com",
+					AuthURL:       "https://mock-provider.com/auth",
+					TokenURL:      "https://mock-provider.com/token",
+					JWKSURL:       "https://mock-provider.com/jwks",
+					RevokeURL:     "https://mock-provider.com/revoke",
+					EndSessionURL: "https://mock-provider.com/logout",
+				}
+				w.Header().Set("Content-Type", "application/json")
+				w.Header().Set("Cache-Control", "max-age=3600") // 1 hour cache hint
+				json.NewEncoder(w).Encode(metadata)
+			} else {
+				http.NotFound(w, r)
+			}
+		}),
+	}
+
+	// Start mock server
+	listener, err := net.Listen("tcp", "localhost:0")
+	if err != nil {
+		t.Fatalf("Failed to create listener: %v", err)
+	}
+	go mockServer.Serve(listener)
+	defer mockServer.Close()
+
+	providerURL := fmt.Sprintf("http://%s", listener.Addr().String())
+	httpClient := createDefaultHTTPClient()
+
+	// Create metadata cache with WaitGroup for proper goroutine synchronization
+	var wg sync.WaitGroup
+	metadataCache := NewMetadataCacheWithLogger(&wg, logger)
+
+	// Create profiler
+	profiler := NewProviderMetadataProfiler(metadataCache, httpClient, providerURL, logger)
+	mto.RegisterComponent("provider_metadata", profiler)
+
+	// Take initial baseline
+	baseline, err := profiler.TakeSnapshot()
+	if err != nil {
+		t.Fatalf("Failed to take baseline snapshot: %v", err)
+	}
+
+	initialGoroutines := runtime.NumGoroutine()
+
+	// Phase 1: Simulate periodic metadata fetching with some failures
+	t.Log("Phase 1: Testing periodic fetching with occasional failures...")
+	for i := 0; i < 20; i++ {
+		_, err := metadataCache.GetMetadata(providerURL, httpClient, logger)
+		if err != nil {
+			t.Logf("Metadata fetch %d failed (expected for cache extension testing): %v", i+1, err)
+		} else {
+			t.Logf("Metadata fetch %d succeeded", i+1)
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
+
+	// Wait for background cleanup (normally every 5 minutes)
+	time.Sleep(300 * time.Millisecond)
+
+	// Take intermediate snapshot
+	intermediate, err := profiler.TakeSnapshot()
+	if err != nil {
+		t.Fatalf("Failed to take intermediate snapshot: %v", err)
+	}
+
+	// Phase 2: Continue with more fetches to test sustained operation
+	t.Log("Phase 2: Testing sustained operation with 1000 iterations...")
+	for i := 20; i < 1020; i++ {
+		_, err := metadataCache.GetMetadata(providerURL, httpClient, logger)
+		if err != nil {
+			t.Logf("Metadata fetch %d failed: %v", i+1, err)
+		}
+		time.Sleep(50 * time.Millisecond) // Reduced sleep for faster execution
+	}
+
+	// Take final snapshot
+	current, err := profiler.TakeSnapshot()
+	if err != nil {
+		t.Fatalf("Failed to take current snapshot: %v", err)
+	}
+
+	finalGoroutines := runtime.NumGoroutine()
+
+	// Analyze for leaks
+	analysis := profiler.AnalyzeLeaks(baseline, current)
+
+	// Assertions for memory leaks
+	if analysis.HasLeak {
+		if strictMode {
+			t.Errorf("Memory leak detected in provider metadata operations: %s", analysis.LeakDescription)
+			for _, leak := range analysis.SuspectedLeaks {
+				t.Errorf("Suspected leak: %s", leak)
+			}
+		} else {
+			t.Logf("Memory leak warning in provider metadata operations: %s", analysis.LeakDescription)
+			for _, leak := range analysis.SuspectedLeaks {
+				t.Logf("Suspected leak: %s", leak)
+			}
+		}
+		for _, rec := range analysis.Recommendations {
+			t.Logf("Recommendation: %s", rec)
+		}
+	}
+
+	// Check total memory growth
+	totalMemoryIncrease := current.RuntimeStats.Alloc - baseline.RuntimeStats.Alloc
+	if totalMemoryIncrease > 20*1024*1024 { // 20MB threshold for entire test
+		if strictMode {
+			t.Errorf("Total memory usage increased by %.2f MB during metadata operations", float64(totalMemoryIncrease)/(1024*1024))
+		} else {
+			t.Logf("Total memory usage increased by %.2f MB during metadata operations", float64(totalMemoryIncrease)/(1024*1024))
+		}
+	}
+
+	// Check for gradual memory growth patterns
+	intermediateMemoryIncrease := intermediate.RuntimeStats.Alloc - baseline.RuntimeStats.Alloc
+	if intermediateMemoryIncrease > 10*1024*1024 { // 10MB threshold for first phase
+		if strictMode {
+			t.Errorf("Memory usage increased by %.2f MB during first phase of metadata operations", float64(intermediateMemoryIncrease)/(1024*1024))
+		} else {
+			t.Logf("Memory usage increased by %.2f MB during first phase of metadata operations", float64(intermediateMemoryIncrease)/(1024*1024))
+		}
+	}
+
+	// Check goroutine count stability
+	goroutineIncrease := finalGoroutines - initialGoroutines
+	if goroutineIncrease > 5 { // Allow some variance for test environment
+		if strictMode {
+			t.Errorf("Goroutine count increased by %d during metadata operations (initial: %d, final: %d)",
+				goroutineIncrease, initialGoroutines, finalGoroutines)
+		} else {
+			t.Logf("Goroutine count increased by %d during metadata operations (initial: %d, final: %d)",
+				goroutineIncrease, initialGoroutines, finalGoroutines)
+		}
+	}
+
+	// Phase 3: Test cache extension behavior on persistent failures
+	t.Log("Phase 3: Testing cache extension on persistent failures...")
+
+	// Stop mock server to simulate provider unavailability
+	mockServer.Close()
+
+	// Try multiple fetches after server shutdown
+	postShutdownFailures := 0
+	for i := 0; i < 5; i++ {
+		_, err = metadataCache.GetMetadata(providerURL, httpClient, logger)
+		if err != nil {
+			postShutdownFailures++
+			t.Logf("Expected failure %d after server shutdown: %v", i+1, err)
+		} else {
+			t.Logf("Unexpected success %d after server shutdown - cache extension working", i+1)
+		}
+		time.Sleep(200 * time.Millisecond)
+	}
+
+	if postShutdownFailures == 0 {
+		if strictMode {
+			t.Error("Expected some metadata fetches to fail after server shutdown")
+		} else {
+			t.Log("Warning: No metadata fetches failed after server shutdown - cache extension may not be working as expected")
+		}
+	}
+
+	// Phase 4: Test background goroutine lifecycle and cleanup
+	t.Log("Phase 4: Testing background goroutine lifecycle...")
+
+	// Wait longer to allow background cleanup to run
+	time.Sleep(1 * time.Second)
+
+	// Take final snapshot after cleanup
+	finalAfterCleanup, err := profiler.TakeSnapshot()
+	if err != nil {
+		t.Fatalf("Failed to take final snapshot after cleanup: %v", err)
+	}
+
+	// Check if memory decreased after cleanup
+	if finalAfterCleanup.RuntimeStats.Alloc < current.RuntimeStats.Alloc {
+		memoryDecrease := current.RuntimeStats.Alloc - finalAfterCleanup.RuntimeStats.Alloc
+		t.Logf("Memory decreased by %.2f MB after cleanup phase", float64(memoryDecrease)/(1024*1024))
+	}
+
+	// Clean up resources
+	metadataCache.Close()
+	wg.Wait() // Ensure all background goroutines complete
+
+	t.Logf("Test completed: %d total requests, %d server failures, %d post-shutdown failures",
+		requestCount, serverFailures, postShutdownFailures)
+	t.Logf("Memory usage: baseline=%.2f MB, intermediate=%.2f MB, final=%.2f MB",
+		float64(baseline.RuntimeStats.Alloc)/(1024*1024),
+		float64(intermediate.RuntimeStats.Alloc)/(1024*1024),
+		float64(current.RuntimeStats.Alloc)/(1024*1024))
+}

test_helpers_adapter.go

@@ -143,7 +143,7 @@ func setupTestOIDCMiddleware(t *testing.T, config *Config) (*TraefikOidc, *httpt
 		forceHTTPS:            config.ForceHTTPS,
 		allowedUserDomains:    make(map[string]struct{}),
 		jwkCache:              &JWKCache{},
-		metadataCache:         NewMetadataCache(),
+		metadataCache:         NewMetadataCache(nil),
 		ctx:                   context.Background(),
 	}