Zeta Cache Bundle Laravel Package

Technical Evaluation

Architecture Fit

• Pros:
  • Hierarchical caching (stacks) aligns well with Symfony’s layered architecture (e.g., APC/Memcache + filesystem fallback).
  • Tag-based invalidation enables granular cache control, useful for feature flags, A/B testing, or dynamic content.
  • LFU/LRU strategies optimize memory usage for read-heavy workloads (e.g., API responses, static assets).
  • DevMode simplifies debugging by auto-invalidating cached items during development.
• Cons:
  • Symfony 2.x only: Incompatible with modern Symfony (5.x/6.x) due to symfony/symfony:>=2.1,<3.0-dev.
  • Zeta Components’ retirement: No active maintenance risks long-term stability (e.g., PHP 8.x compatibility).
  • Overhead: Stacked caches may introduce latency if misconfigured (e.g., deep fallbacks).

Integration Feasibility

• Symfony 2.x Projects:
  • High: Direct drop-in for legacy apps (e.g., eZ Publish 5, custom Symfony2 apps).
  • Low for New Projects: Requires polyfills or forks to work with Symfony 3+ (e.g., symfony/cache compatibility layer).
• Key Features:
  • Cache Stacks: Requires careful tuning of freeRate and storage limits to avoid thrashing.
  • Tag Invalidation: Needs integration with Symfony’s CacheWarmer or event listeners (e.g., kernel.terminate).
  • CLI Tools: Useful for ops but may conflict with Symfony’s cache:clear commands.

Technical Risk

• Critical:
  • Deprecated Dependencies: zetacomponents/cache is unmaintained; may break with PHP 7.4+ or Symfony updates.
  • Race Conditions: "Dog Pile" protection is storage-specific; requires testing under high concurrency.
• Moderate:
  • Configuration Complexity: Stacked caches need tuning (e.g., ezcCacheStorageFileApcArray paths, LRU limits).
  • Documentation Gaps: Broken links in Zeta’s docs; bundle’s index.rst may lack details.
• Mitigation:
  • Fork and Modernize: Rewrite for Symfony 5+ using Psr\Cache\CacheItemPoolInterface (e.g., leverage symfony/cache).
  • Isolation: Use as a standalone cache layer (e.g., for non-Symfony services) to reduce risk.

Key Questions

1. Why Symfony 2.x?
   • Is this for maintaining legacy systems, or is there a plan to upgrade Symfony?
   • If upgrading, what’s the migration path for cache dependencies?
2. Performance Trade-offs:
   • How will stacked caches (e.g., APC + Memcache) impact latency vs. hit rates?
   • Are there benchmarks for LFU/LRU under expected load?
3. Maintenance Plan:
   • Who will handle security updates (e.g., if Zeta Components has CVEs)?
   • Is there a fallback plan if the bundle becomes unmaintainable?
4. Alternatives:
   • Could symfony/cache + predis/php-apcu achieve similar goals with less risk?
   • Is hierarchical caching necessary, or would a simpler tag-based cache (e.g., stash) suffice?

Integration Approach

Stack Fit

• Symfony 2.x:
  • Native Integration: Replaces or supplements Symfony’s Cache component (e.g., symfony/cache).
  • Use Cases:
    • Multi-layer caching: Combine APC (fast, small) + Memcache (distributed) + FS (persistent).
    • Tag-based invalidation: Replace CacheWarmer for dynamic content (e.g., user-specific caches).
    • DevOps: CLI tools for cache management (e.g., app/console aw:zeta-cache:clear --tags=feature_x).
• Symfony 3+/Modern PHP:
  • Partial Integration: Use Zeta Cache as a standalone library (e.g., for non-Symfony services).
  • Polyfill: Requires wrapping Zeta’s API in Psr\Cache interfaces (e.g., CacheItemPoolInterface).
  • Alternatives: Prefer symfony/cache + cache-adapter for PSR-6 compliance.

Migration Path

Compatibility

• Symfony 2.x:
  • High: Designed for Symfony 2.1–2.8; may need composer.json tweaks for newer 2.x.
  • Breaking Changes: None expected, but test with ezcCacheStorage* classes.
• PHP Versions:
  • Supported: PHP 5.3–5.6 (Zeta’s original target). PHP 7.x may require patches.
  • Workarounds: Use php7.4-apcu or php-redis as drop-in replacements for storages.
• Dependencies:
  • APC: Deprecated in PHP 7.4+; replace with apcu.
  • Memcache: Use memcached extension (binary protocol) for PHP 7.x.
  • Filesystem: Ensure ezcCacheStorageFileApcArray paths are writable and configurable.

Sequencing

1. Phase 1: Evaluation
   • Benchmark Zeta Cache vs. symfony/cache + predis for target use cases.
   • Validate tag invalidation performance (e.g., 10K items with 100 tags).
2. Phase 2: Core Integration
   • Replace Cache component with AwZetaCacheBundle in AppKernel.
   • Configure stacks in config.yml (e.g., apc → memcache → fs).
3. Phase 3: Invalidation
   • Implement event listeners for tag-based clearing (e.g., user.delete → clear user_* tags).
   • Test DevMode to ensure cached items auto-invalidate.
4. Phase 4: CLI/Ops
   • Deploy cache management commands (e.g., aw:zeta-cache:clear --tags=promo_banner).
   • Integrate with CI/CD for cache warm-up/clear.
5. Phase 5: Monitoring
   • Track cache hit/miss ratios, LRU/LFU evictions, and storage limits.
   • Alert on high eviction rates (indicates misconfigured freeRate).

Operational Impact

Maintenance

• Pros:
  • Centralized Configuration: All cache stacks defined in config.yml (easy to audit).
  • CLI Tools: Reduce manual cache clearing (e.g., app/console aw:zeta-cache:reset --all).
  • DevMode: Eliminates "clear cache" steps during development.
• Cons:
  • Unmaintained Codebase: No patches for PHP 8.x/Symfony 5+; requires internal maintenance.
  • Complexity: Stacked caches need monitoring (e.g., ezcCacheStorageApc memory usage).
  • Dependency Risk: Zeta Components’ retirement may introduce security/bug risks.

Support

• Internal:
  • Training: Document stack configurations, tagging strategies, and CLI usage.
  • Runbooks: Define procedures for cache corruption (e.g., fs storage filesystem issues).
• External:
  • Limited: No community support; rely on Zeta’s archived docs or forks.
  • Workarounds: Maintain a fork with PHP 8.x patches if critical.

Scaling

• Horizontal Scaling:
  • Memcache/Redis: Supported via ezcCacheStorageMemcache; ensure consistent hashing.
  • APC: Not distributed; use only for local caching (e.g., per-webserver).
  • Filesystem: Avoid for distributed setups (use ezcCacheStorageMemcache instead).
• Vertical Scaling:
  • LRU/LFU Tuning: Adjust freeRate to balance memory usage vs. hit rate.
  • Storage Limits: Monitor ezcCacheStorage*