Add cleanupExpiredManagedKeys method to SmartCache for managing expired keys and update ClearCommand to report on expired keys cleaned. Enhance performance metrics with configurable thresholds for warnings.

iazaran · iazaran · commit 19abdfb774af · 2025-09-27T23:45:38.000+04:00
diff --git a/src/Console/Commands/ClearCommand.php b/src/Console/Commands/ClearCommand.php
@@ -100,6 +100,23 @@ protected function clearAllKeys(SmartCache $cache): int
         
         $this->info("Clearing {$count} SmartCache managed items...");
         
+        // Clean up expired keys first and report
+        $expiredCleaned = $cache->cleanupExpiredManagedKeys();
+        if ($expiredCleaned > 0) {
+            $this->info("Cleaned up {$expiredCleaned} expired keys from tracking list.");
+        }
+        
+        // Get updated key count after cleanup
+        $keys = $cache->getManagedKeys();
+        $actualCount = count($keys);
+        
+        if ($actualCount === 0) {
+            $this->info('All managed keys were expired and have been cleaned up.');
+            return 0;
+        }
+        
+        $this->info("Clearing {$actualCount} active SmartCache managed items...");
+        
         $success = $cache->clear();
         
         if ($success) {
@@ -113,6 +130,7 @@ protected function clearAllKeys(SmartCache $cache): int
             return 0;
         } else {
             $this->error('Some SmartCache items could not be cleared.');
+            $this->comment('This may be due to cache driver limitations or permission issues.');
             return 1;
         }
     }
diff --git a/src/Contracts/SmartCache.php b/src/Contracts/SmartCache.php
@@ -88,6 +88,21 @@ public function clear(): bool;
      */
     public function getManagedKeys(): array;
 
+    /**
+     * Clean up expired keys from managed keys tracking.
+     *
+     * @return int Number of expired keys removed
+     */
+    public function cleanupExpiredManagedKeys(): int;
+
+    /**
+     * Check if a specific feature is available.
+     *
+     * @param string $feature The feature name to check
+     * @return bool
+     */
+    public function hasFeature(string $feature): bool;
+
     /**
      * Tag cache entries for organized invalidation.
      *
diff --git a/src/Facades/SmartCache.php b/src/Facades/SmartCache.php
@@ -33,6 +33,8 @@
  * @method static array getPerformanceMetrics()
  * @method static void resetPerformanceMetrics()
  * @method static array analyzePerformance()
+ * @method static int cleanupExpiredManagedKeys()
+ * @method static bool hasFeature(string $feature)
  * 
  * @see \SmartCache\SmartCache
  */
diff --git a/src/Services/CacheInvalidationService.php b/src/Services/CacheInvalidationService.php
@@ -154,7 +154,7 @@ public function getCacheStatistics(): array
 
         // Analyze optimization usage
         foreach ($managedKeys as $key) {
-            $value = Cache::get($key);
+            $value = $this->smartCache->get($key);
             if (is_array($value)) {
                 if (isset($value['_sc_compressed'])) {
                     $stats['optimization_stats']['compressed']++;
@@ -182,19 +182,23 @@ public function healthCheckAndCleanup(): array
             'orphaned_chunks_cleaned' => 0,
             'broken_dependencies_fixed' => 0,
             'invalid_tags_removed' => 0,
+            'expired_keys_cleaned' => 0,
             'total_keys_checked' => 0,
         ];
 
         $managedKeys = $this->smartCache->getManagedKeys();
         $results['total_keys_checked'] = count($managedKeys);
 
+        // Clean up expired managed keys first
+        $results['expired_keys_cleaned'] = $this->smartCache->cleanupExpiredManagedKeys();
+
         // Check for orphaned chunks
         foreach ($managedKeys as $key) {
-            $value = Cache::get($key);
+            $value = $this->smartCache->get($key);
             if (is_array($value) && isset($value['_sc_chunked'])) {
                 $missingChunks = 0;
                 foreach ($value['chunk_keys'] as $chunkKey) {
-                    if (!Cache::has($chunkKey)) {
+                    if (!$this->smartCache->has($chunkKey)) {
                         $missingChunks++;
                     }
                 }
diff --git a/src/SmartCache.php b/src/SmartCache.php
@@ -256,6 +256,9 @@ public function clear(): bool
     {
         $success = true;
         
+        // Clean up expired keys first
+        $this->cleanupExpiredManagedKeys();
+        
         // Get all tracked keys
         $keys = $this->getManagedKeys();
         
@@ -405,6 +408,62 @@ public function getManagedKeys(): array
         return $this->managedKeys;
     }
 
+    /**
+     * Clean up expired keys from managed keys tracking.
+     *
+     * @return int Number of expired keys removed
+     */
+    public function cleanupExpiredManagedKeys(): int
+    {
+        $cleaned = 0;
+        $validKeys = [];
+        
+        foreach ($this->managedKeys as $key) {
+            if ($this->has($key)) {
+                $validKeys[] = $key;
+            } else {
+                $cleaned++;
+            }
+        }
+        
+        if ($cleaned > 0) {
+            $this->managedKeys = $validKeys;
+            $this->cache->forever('_sc_managed_keys', $this->managedKeys);
+        }
+        
+        return $cleaned;
+    }
+
+    /**
+     * Check if a specific feature is available.
+     *
+     * @param string $feature The feature name to check
+     * @return bool
+     */
+    public function hasFeature(string $feature): bool
+    {
+        $features = [
+            'tags' => method_exists($this, 'tags'),
+            'flushTags' => method_exists($this, 'flushTags'),
+            'dependsOn' => method_exists($this, 'dependsOn'),
+            'invalidate' => method_exists($this, 'invalidate'),
+            'flushPatterns' => method_exists($this, 'flushPatterns'),
+            'invalidateModel' => method_exists($this, 'invalidateModel'),
+            'swr' => method_exists($this, 'swr'),
+            'stale' => method_exists($this, 'stale'),
+            'refreshAhead' => method_exists($this, 'refreshAhead'),
+            'flexible' => method_exists($this, 'flexible'),
+            'getStatistics' => method_exists($this, 'getStatistics'),
+            'healthCheck' => method_exists($this, 'healthCheck'),
+            'getPerformanceMetrics' => method_exists($this, 'getPerformanceMetrics'),
+            'analyzePerformance' => method_exists($this, 'analyzePerformance'),
+            'getAvailableCommands' => method_exists($this, 'getAvailableCommands'),
+            'executeCommand' => method_exists($this, 'executeCommand'),
+        ];
+        
+        return $features[$feature] ?? false;
+    }
+
     /**
      * Determines the cache driver from the store instance.
      *
@@ -882,13 +941,30 @@ protected function executeClearCommand(array $parameters = []): array
                 ];
             }
             
+            // Clean up expired keys first
+            $expiredCleaned = $this->cleanupExpiredManagedKeys();
+            $keys = $this->getManagedKeys();
+            $actualCount = count($keys);
+            
+            if ($actualCount === 0) {
+                return [
+                    'success' => true,
+                    'message' => "All {$count} managed keys were expired and have been cleaned up.",
+                    'cleared_count' => $count,
+                    'expired_cleaned' => $expiredCleaned,
+                    'total_managed_keys' => $count
+                ];
+            }
+            
             $success = $this->clear();
             
             return [
                 'success' => $success,
-                'message' => $success ? "Cleared {$count} SmartCache managed keys." : 'Some keys could not be cleared.',
-                'cleared_count' => $success ? $count : 0,
-                'total_managed_keys' => $count
+                'message' => $success ? "Cleared {$actualCount} SmartCache managed keys." : 'Some keys could not be cleared.',
+                'cleared_count' => $success ? $actualCount : 0,
+                'expired_cleaned' => $expiredCleaned,
+                'total_managed_keys' => $count,
+                'active_keys_cleared' => $actualCount
             ];
         }
     }
@@ -1091,34 +1167,42 @@ public function analyzePerformance(): array
         $efficiency = $metrics['cache_efficiency'];
         $optimization = $metrics['optimization_impact'];
         
+        // Get warning thresholds from config
+        $hitRatioThreshold = $this->config->get('smart-cache.warnings.hit_ratio_threshold', 70);
+        $optimizationThreshold = $this->config->get('smart-cache.warnings.optimization_ratio_threshold', 20);
+        $slowWriteThreshold = $this->config->get('smart-cache.warnings.slow_write_threshold', 0.1);
+        
         // Hit ratio recommendations
-        if ($efficiency['hit_ratio'] < 70) {
+        if ($efficiency['hit_ratio'] < $hitRatioThreshold) {
             $recommendations[] = [
                 'type' => 'low_hit_ratio',
                 'severity' => 'warning',
-                'message' => 'Cache hit ratio is below 70%. Consider increasing TTL values or reviewing cache key strategies.',
-                'current_ratio' => $efficiency['hit_ratio']
+                'message' => "Cache hit ratio is below {$hitRatioThreshold}%. Consider increasing TTL values or reviewing cache key strategies.",
+                'current_ratio' => $efficiency['hit_ratio'],
+                'threshold' => $hitRatioThreshold
             ];
         }
         
         // Optimization recommendations
-        if ($optimization['optimization_ratio'] < 20 && $optimization['total_writes'] > 10) {
+        if ($optimization['optimization_ratio'] < $optimizationThreshold && $optimization['total_writes'] > 10) {
             $recommendations[] = [
                 'type' => 'low_optimization',
                 'severity' => 'info',
-                'message' => 'Few cache entries are being optimized. Consider adjusting compression/chunking thresholds.',
-                'current_ratio' => $optimization['optimization_ratio']
+                'message' => "Few cache entries are being optimized. Consider adjusting compression/chunking thresholds.",
+                'current_ratio' => $optimization['optimization_ratio'],
+                'threshold' => $optimizationThreshold
             ];
         }
         
         // Performance issues
         $writes = $metrics['metrics']['cache_write'] ?? [];
-        if (isset($writes['average_duration']) && $writes['average_duration'] > 0.1) {
+        if (isset($writes['average_duration']) && $writes['average_duration'] > $slowWriteThreshold) {
             $recommendations[] = [
                 'type' => 'slow_writes',
                 'severity' => 'warning',
-                'message' => 'Cache write operations are taking longer than 100ms on average.',
-                'average_duration' => round($writes['average_duration'] * 1000, 2) . 'ms'
+                'message' => "Cache write operations are taking longer than " . round($slowWriteThreshold * 1000) . "ms on average.",
+                'average_duration' => round($writes['average_duration'] * 1000, 2) . 'ms',
+                'threshold' => round($slowWriteThreshold * 1000) . 'ms'
             ];
         }
         

Original file line number	Diff line number	Diff line change
`@@ -33,6 +33,8 @@`
`33`	`33`	`* @method static array getPerformanceMetrics()`
`34`	`34`	`* @method static void resetPerformanceMetrics()`
`35`	`35`	`* @method static array analyzePerformance()`
	`36`	`+ * @method static int cleanupExpiredManagedKeys()`
	`37`	`+ * @method static bool hasFeature(string $feature)`
`36`	`38`	`*`
`37`	`39`	`* @see \SmartCache\SmartCache`
`38`	`40`	`*/`