Sulu Http Cache Bundle Laravel Package

Technical Evaluation

Architecture Fit

• Purpose Alignment: The alengo/sulu-http-cache-bundle targets HTTP caching optimizations for Sulu CMS (Symfony-based) by:
  • Stripping tracking query parameters (e.g., ?utm_source) to avoid cache pollution.
  • Managing CTA/marketing-attribution cookies at the reverse-proxy layer (e.g., Varnish, Nginx) to reduce payload size and improve cache efficiency.
• Symfony/Sulu Compatibility: Built for Symfony 6.4+ (based on last release date 2026), leveraging Symfony’s HTTP cache layer (HttpCacheStore). Fits seamlessly into Sulu’s architecture, which is Symfony-based.
• Cache Layer Integration: Works with Symfony’s HTTP cache (e.g., HttpCache middleware) and reverse proxies (Varnish/Nginx). Requires minimal changes to existing caching strategies.
• Key Use Cases:
  • Performance: Reduces cache invalidation noise from tracking params.
  • Marketing Analytics: Preserves attribution cookies without bloating responses.
  • Edge Caching: Enables proxy-level cookie handling for faster responses.

Integration Feasibility

• Low Coupling: Bundle is self-contained (no DB changes, minimal config). Integrates via Symfony’s event system (kernel.request, kernel.response).
• Dependencies:
  • Requires Symfony 6.4+ (check Sulu version compatibility).
  • Assumes reverse proxy (Varnish/Nginx) for cookie handling at the edge.
  • No hard dependencies on Sulu-specific features (could work in vanilla Symfony).
• Configuration Overhead:
  • Minimal: Define sulu_http_cache in config/packages/ and configure proxy rules.
  • Example:

    sulu_http_cache:
        tracking_params: ['utm_source', 'utm_medium']  # Strip these
        proxy_cookies: ['_ga', 'marketing_attribution']  # Handle at proxy
    

• Testing: Unit/integration tests would focus on:
  • Query param stripping in responses.
  • Cookie header manipulation.
  • Proxy-level cookie injection (mock Varnish/Nginx).

Technical Risk

Key Questions

1. Proxy Requirements:
   • Is the target environment using Varnish/Nginx? If not, can cookies be handled at the app layer?
2. Tracking Param Scope:
   • Are all tracking params known upfront, or is dynamic detection needed?
3. Cache Strategy:
   • How does this interact with Sulu’s ESI/HTTP cache? Could stripped params affect fragment caching?
4. Cookie Sensitivity:
   • Are marketing cookies PII? Ensure compliance with GDPR/CCPA.
5. Fallback Mechanism:
   • What happens if the proxy fails to handle cookies? (Graceful degradation?)
6. Monitoring:
   • How will cache hit/miss rates be tracked post-deployment?

Integration Approach

Stack Fit

• Primary Stack:
  • Sulu CMS (Symfony 6.4+).
  • Reverse Proxy: Varnish (recommended) or Nginx with proxy_cache.
  • HTTP Cache: Symfony’s HttpCache or Varnish cache.
• Secondary Stack:
  • Vanilla Symfony apps (if Sulu-specific features aren’t needed).
  • Not a fit for:
    • Non-Symfony apps (e.g., Laravel, Node.js).
    • Environments without a reverse proxy (cookie handling falls back to app layer).

Migration Path

1. Pre-requisites:
   • Upgrade to Symfony 6.4+ (if not already).
   • Ensure Varnish/Nginx is configured for HTTP caching.
2. Bundle Installation:

   composer require alengo/sulu-http-cache-bundle
   

3. Configuration:
   • Add bundle to config/bundles.php.
   • Configure sulu_http_cache in config/packages/sulu_http_cache.yaml.
4. Proxy Rules:
   • Update Varnish/Nginx to:
     • Strip tracking params from cached responses.
     • Inject marketing cookies into requests/responses.
   • Example Varnish VCL snippet:

     sub vcl_deliver {
         if (obj.http.X-Sulu-Cache-Stripped) {
             unset beresp.http.Set-Cookie;  // Let bundle handle cookies
         }
     }
     

5. Testing:
   • Unit: Test SuluHttpCacheEventSubscriber for param stripping.
   • Integration: Verify proxy behavior with tools like curl or varnishlog.
   • E2E: Check Sulu admin panel and frontend cache consistency.

Compatibility

• Symfony: Confirmed for 6.4+ (check Sulu’s Symfony version).
• Sulu: Tested with Sulu’s HTTP cache layer (no conflicts reported).
• Proxies:
  • Varnish: Requires VCL adjustments (see above).
  • Nginx: Use proxy_cache_key and add_header directives.
• CDNs: May need similar cookie-stripping logic if not using Varnish.

Sequencing

1. Phase 1: Bundle installation + basic config (no proxy changes).
   • Validate query param stripping works in-app.
2. Phase 2: Proxy integration.
   • Deploy Varnish/Nginx rules incrementally (A/B test if possible).
3. Phase 3: Marketing cookie handling.
   • Test cookie injection without breaking existing sessions.
4. Phase 4: Monitoring.
   • Track cache hit rates, cookie handling errors, and performance.

Operational Impact

Maintenance

• Bundle Updates:
  • Low effort: MIT license allows forks if upstream stalls.
  • Monitor for Symfony 7+ compatibility.
• Configuration Drift:
  • Tracking params/cookies may need updates (e.g., new UTM params).
  • Document changes in README or wiki.
• Dependency Risks:
  • Only Symfony core dependencies (no external libraries).

Support

• Debugging:
  • Log SuluHttpCacheEvents for troubleshooting (e.g., kernel.response).
  • Proxy logs (varnishlog, Nginx error logs) for edge issues.
• Common Issues:
  • Cookie Conflicts: Ensure marketing cookies don’t override auth sessions.
  • Cache Stampedes: Monitor if stripped params affect cache invalidation.
• Support Channels:
  • Limited community (0 stars/dependents); rely on:
    • GitHub issues.
    • Symfony/Sulu Slack/Discord groups.

Scaling

• Performance:
  • Expected: Reduced cache invalidations → higher hit rates.
  • Edge Cases:
    • High traffic: Proxy may become bottleneck (scale Varnish/Nginx).
    • Dynamic cookies: App-layer fallback increases payload size.
• Horizontal Scaling:
  • Stateless design; scales with Symfony/Sulu.
  • Proxy must handle cookie injection at scale (test with load tools like wrk).
• Cost:
  • No additional infrastructure costs (uses existing proxy/cache).

Failure Modes

Ramp-Up

• Team Skills:
  • Required: Symfony event listeners, Varnish/Nginx basics.
  • Nice-to-have: HTTP caching deep dive (e.g., Cache-Control headers).
• Onboarding:
  1. Workshop: 1-hour session on:
     • Symfony event system.
     • Proxy-level caching.
  2. Docs: Add to internal wiki with:
     • Config examples.
     • Proxy VCL/Nginx snippets.
     • Troubleshooting checklist.
  3. Training:
     • Hands-on lab: Deploy to staging with mock tracking params.
• Knowledge Transfer:
  • Assign a proxy caching SME to review VCL