Bounded Cache Laravel Package

Technical Evaluation

Architecture Fit

• PSR-16 Compliance: The package’s adherence to PSR-16 ensures seamless integration with Laravel’s caching ecosystem, including the Cache facade, CacheManager, and third-party PSR-16-compliant backends (e.g., Redis, Memcached). This allows for backward compatibility with existing Laravel caching logic while adding bounded TTL constraints.
• Bounded TTL Enforcement: The core feature—enforcing maximum and minimum TTLs—addresses critical use cases like:
  • Stale Data Mitigation: Prevents indefinite caching of sensitive or volatile data (e.g., user sessions, feature flags).
  • Memory Management: Limits cache bloat in memory-constrained environments (e.g., shared hosting, serverless).
  • Compliance: Ensures regulatory requirements (e.g., GDPR data retention) are met via automated eviction.
• Laravel-Specific Advantages:
  • Cache Tags Integration: Works with Laravel’s cache:tags system, enabling tag-based invalidation while respecting TTL bounds.
  • Queue-Based Cache Invalidation: Compatible with Laravel’s cache:flush and cache:forget queues for distributed systems.
  • Event Hooks: Can be extended to emit custom events (e.g., BoundedCacheEvicted) for observability.

Integration Feasibility

• Minimal Code Changes: The package can be dropped into Laravel with zero core modifications by leveraging:
  • Cache Drivers: Extend Laravel’s CacheManager to include a bounded driver.
  • Facade Overrides: Use Laravel’s Cache::extend() to wrap existing stores.
  • Service Provider Decorators: Globally wrap the cache instance in AppServiceProvider.
• PSR-16 Backend Agnosticism: Supports any PSR-16-compliant store, including:
  • Redis/Memcached: For distributed caching with bounded evictions.
  • Database: For persistence-bound use cases (e.g., database driver).
  • File/Array: For lightweight, in-memory caching (e.g., dev environments).
• Configuration Granularity:
  • Per-Key Bounds: Override global minTTL/maxTTL for specific keys.
  • Dynamic TTLs: Adjust bounds at runtime (e.g., based on user roles or request context).

Technical Risk

• PHP Version Lock: Requires PHP 8.1–8.5 (as of v3.1). Risk Mitigation:
  • If using PHP 8.0, downgrade to v2.2.1 (supports PHP 8.0–8.4).
  • Laravel 10+ drops PHP 8.0 support, so this may not impact new projects.
• Eviction Race Conditions: Concurrent set()/evict() operations could lead to inconsistent states in high-traffic apps. Risk Mitigation:
  • Use atomic operations (e.g., Redis SET with NX flag) if underlying store supports it.
  • Implement retry logic for failed evictions.
• Underlying Store Limitations:
  • File-Based Caches: May hit disk I/O limits under heavy eviction loads.
  • Redis/Memcached: Native TTLs may conflict with bounded evictions (e.g., Redis EXPIRE vs. package eviction).
  • Database Stores: Eviction queries could impact DB performance.
• Laravel-Specific Edge Cases:
  • Cache Tags: Evicting tagged keys may not align with Laravel’s cache:tags invalidation.
  • Queue Jobs: Delayed evictions (e.g., via queues) could desync with bounded TTLs.
  • Cache Events: Existing listeners (e.g., CacheStoreEvent) may need updates for bounded evictions.

Key Questions

1. Use Case Validation:
   • Are bounded TTLs needed for all cached data, or only specific keys/tags?
   • How will eviction events be surfaced (e.g., logs, metrics, alerts)?
2. Performance Tradeoffs:
   • What is the acceptable latency overhead for bounded checks (e.g., 0.5–5ms)?
   • How will cache hit ratios change under bounded evictions?
3. Fallback Strategies:
   • Should eviction failures fall back to underlying store TTLs or trigger retries?
   • How will distributed cache invalidation (e.g., multi-AZ Redis) handle bounded evictions?
4. Monitoring and Alerts:
   • Are there SLOs for eviction latency (e.g., P99 < 100ms)?
   • How will eviction rates be monitored (e.g., Prometheus metrics)?
5. Testing Scope:
   • Should chaos testing be included (e.g., simulate cache store failures during eviction)?
   • Are there load tests for concurrent bounded operations?

Integration Approach

Stack Fit

• Laravel Integration Points:
  • Cache Facade: Extend Cache::store() to support bounded drivers.
  • CacheManager: Register BoundedCache as a custom driver in config/cache.php.
  • Service Container: Bind GrahamCampbell\BoundedCache\BoundedCache to cache or extend existing bindings.
  • Middleware: Use Cache::remember() with bounded stores for HTTP responses.
• PSR-16 Backend Compatibility:
  • Redis/Memcached: Wrap Predis\Client or Memcached with BoundedCache.
  • Database: Extend Illuminate\Cache\DatabaseStore to enforce bounds.
  • File/Array: Use as a drop-in replacement for file or array drivers.
• Event-Driven Extensions:
  • Emit custom events (e.g., BoundedCacheEvicted) via Laravel’s Events system.
  • Integrate with Laravel Horizon for queue-based eviction monitoring.

Migration Path

1. Phase 1: Local Testing (Dev/Staging)
   • Replace the file cache driver with BoundedCache:

     // config/cache.php
     'stores' => [
         'bounded' => [
             'driver' => 'bounded',
             'store' => 'file', // Underlying PSR-16 store
             'min_ttl' => 60,    // Optional: Default min TTL
             'max_ttl' => 3600, // Optional: Default max TTL
         ],
     ];
     

   • Test with non-critical endpoints (e.g., API rate limits, feature flags).
2. Phase 2: Driver Abstraction
   • Create a custom Laravel cache driver:

     // app/Providers/AppServiceProvider.php
     public function register()
     {
         Cache::extend('bounded', function ($app) {
             $store = Cache::store('redis'); // Underlying store
             return new BoundedCache($store, maxTTL: 300);
         });
     }
     

   • Configure in config/cache.php:

     'default' => env('CACHE_DRIVER', 'bounded'),
     

3. Phase 3: Global Wrapping (Production)
   • Decorate the default cache store to enforce bounds globally:

     // app/Providers/AppServiceProvider.php
     public function boot()
     {
         $app = $this->app;
         $app->resolving('cache', function ($cache, $app) {
             return new BoundedCache($cache, maxTTL: 3600);
         });
     }
     

   • Validate with load tests (e.g., 10K RPS) to measure eviction impact.
4. Phase 4: Observability and Alerts
   • Add logging for eviction events:

     // app/Providers/AppServiceProvider.php
     public function boot()
     {
         BoundedCache::evicting(function ($key) {
             Log::debug("Bounded eviction triggered for key: {$key}");
         });
     }
     

   • Integrate with Laravel Telescope or Prometheus for metrics.

Compatibility

• Laravel Versions: Compatible with Laravel 9+ (PHP 8.1+).
• PSR-16 Backends: Works with any PSR-16-compliant store, including:
  • predis/predis (Redis).
  • php-memcached (Memcached).
  • illuminate/cache (Database/File).
• Third-Party Packages: Compatible with packages using Cache facade (e.g., spatie/laravel-cache).
• Queue-Based Caching: Supports Laravel’s cache:flush and cache:forget queues.

Sequencing

1. Pre-Migration:
   • Audit