HTTP Caching: Strategies for Faster Web Applications

# Simulating a multi-tier cache
import time
import random
from functools import lru_cache

class MultiTierCache:
    def __init__(self):
        self.browser_cache = {}    # Tier 1: Browser
        self.cdn_cache = {}        # Tier 2: CDN edge
        self.origin_cache = {}     # Tier 3: Application

    def get(self, url, ttl_browser=300, ttl_cdn=600, ttl_origin=60):
        now = time.time()
        cache_key = url

        # Tier 1: Browser cache
        if cache_key in self.browser_cache:
            entry = self.browser_cache[cache_key]
            if now - entry['time'] < ttl_browser:
                self._log_hit("Browser", url)
                return entry['data']

        # Tier 2: CDN cache
        if cache_key in self.cdn_cache:
            entry = self.cdn_cache[cache_key]
            if now - entry['time'] < ttl_cdn:
                self.browser_cache[cache_key] = entry  # Populate browser cache
                self._log_hit("CDN", url)
                return entry['data']

        # Tier 3: Origin (always serves fresh)
        data = self._fetch_from_origin(url)
        self.cdn_cache[cache_key] = {'data': data, 'time': now}
        self.browser_cache[cache_key] = {'data': data, 'time': now}
        self._log_miss(url)
        return data

    def _log_hit(self, tier, url):
        pass  # In production, log to monitoring

    def _log_miss(self, url):
        pass

    def _fetch_from_origin(self, url):
        time.sleep(0.1)  # Simulate origin processing
        return f"Content for {url} at {time.time()}"

cache = MultiTierCache()

# First request — cache miss at all tiers
url = "/api/popular-data"
print("Request 1 (cold):")
data = cache.get(url)
print(f"  Got data (origin hit)\n")

# Second request — browser cache hit
print("Request 2 (immediate):")
data = cache.get(url)
print(f"  Got data from cache\n")

class CacheMonitor:
    def __init__(self):
        self.hits = 0
        self.misses = 0

    def log_hit(self):
        self.hits += 1

    def log_miss(self):
        self.misses += 1

    def hit_ratio(self):
        total = self.hits + self.misses
        return self.hits / total if total > 0 else 0

# Simulate traffic
monitor = CacheMonitor()
for i in range(1000):
    if random.random() < 0.85:  # 85% cache hit rate
        monitor.log_hit()
    else:
        monitor.log_miss()

print(f"Cache Hit Ratio: {monitor.hit_ratio():.1%}")
print(f"Hits: {monitor.hits}, Misses: {monitor.misses}")
print(f"Optimization target: >95%")

import time

class StaleWhileRevalidate:
    def __init__(self, max_age=60, stale_window=300):
        self.cache = {}
        self.max_age = max_age
        self.stale_window = stale_window

    def get(self, key, fetch_func):
        now = time.time()
        entry = self.cache.get(key)

        if entry is None:
            # Cache miss — fetch fresh
            print("  [MISS] Fetching fresh data...")
            data = fetch_func()
            self.cache[key] = {'data': data, 'time': now}
            return data

        age = now - entry['time']

        if age < self.max_age:
            # Fresh — serve from cache
            print(f"  [HIT] Serving fresh (age={age:.1f}s)")
            return entry['data']

        elif age < self.max_age + self.stale_window:
            # Stale but within window — serve stale, refresh in background
            print(f"  [STALE] Serving stale (age={age:.1f}s), refreshing...")
            fresh_data = fetch_func()
            self.cache[key] = {'data': fresh_data, 'time': now}
            return entry['data']  # Return stale while refresh happens

        else:
            # Too stale — fetch fresh
            print(f"  [EXPIRED] Stale expired (age={age:.1f}s), fetching fresh...")
            data = fetch_func()
            self.cache[key] = {'data': data, 'time': now}
            return data

def fetch_slow_data():
    time.sleep(1)  # Simulate slow origin
    return f"Data at {time.time()}"

cache = StaleWhileRevalidate(max_age=5, stale_window=10)

# First request — miss
print("t=0s:")
cache.get("/data", fetch_slow_data)

time.sleep(6)  # Past max_age, but within stale window
print("\nt=6s (stale but valid):")
cache.get("/data", fetch_slow_data)

time.sleep(12)  # Past stale window
print("\nt=18s (expired):")
cache.get("/data", fetch_slow_data)

import time

class CacheWarmer:
    def __init__(self, cache):
        self.cache = cache
        self.popular_urls = []

    def analyze_logs(self, log_file):
        # Analyze access patterns to find popular URLs
        self.popular_urls = [
            "/api/popular-page-1",
            "/api/popular-page-2",
            "/static/images/logo.png",
            "/static/css/main.css",
        ]
        print(f"Found {len(self.popular_urls)} popular URLs")

    def warm_up(self):
        print("Warming cache...")
        for url in self.popular_urls:
            # Simulate fetching each URL to populate cache
            print(f"  Warming: {url}")
            time.sleep(0.05)  # Simulate network
        print("Cache warmed!")

warmer = CacheWarmer(None)
warmer.analyze_logs("access.log")
warmer.warm_up()

class CachePurger:
    def __init__(self):
        self.purge_methods = {
            "Single URL": "Purge /api/users/42 → removes just that resource",
            "Wildcard": "Purge /api/users/* → removes all user resources",
            "Cache Tag": "Purge tag:users → removes all tagged resources",
            "Full Purge": "Purge everything → use sparingly, extreme load",
            "Surrogate Key": "HTTP header-based purging with Surrogate-Key",
        }

    def purge(self, method, target):
        description = self.purge_methods.get(method, "Unknown method")
        print(f"Purging: {description}")
        print(f"  Target: {target}")
        print(f"  Status: {'Purge accepted' if method in self.purge_methods else 'Failed'}")

purger = CachePurger()
purger.purge("Cache Tag", "tag:users-v2")
purger.purge("Single URL", "/api/outdated-data")

# Conceptual CDN configuration
cdn_config = {
    "cloudflare": {
        "caching_level": "standard",
        "browser_cache_ttl": 14400,  # 4 hours
        "edge_cache_ttl": 86400,     # 1 day
        "always_online": True,       # Serve stale if origin down
        "cache_by_device_type": True,
        "cache_by_language": True,
    },
    "fastly": {
        "default_ttl": 3600,
        "stale_while_revalidate": 86400,
        "stale_if_error": 259200,
        "surrogate_keys": True,
        "instant_purge": True,
    }
}

for provider, config in cdn_config.items():
    print(f"{provider.upper()}:")
    for key, value in config.items():
        print(f"  {key.replace('_', ' ').title():30} {value}")
    print()

class CachePerformanceDashboard:
    def __init__(self):
        self.metrics = {
            "cache_hit_ratio": 0.92,
            "origin_requests_per_second": 150,
            "bandwidth_savings_percent": 78,
            "avg_response_time_cached_ms": 15,
            "avg_response_time_origin_ms": 350,
            "purge_requests_per_hour": 5,
        }

    def display(self):
        print("=" * 50)
        print("CACHE PERFORMANCE DASHBOARD")
        print("=" * 50)
        for metric, value in self.metrics.items():
            name = metric.replace('_', ' ').title()
            if 'percent' in metric or 'ratio' in metric:
                print(f"{name:35} {value:.0%}")
            elif 'ms' in metric:
                print(f"{name:35} {value}ms")
            else:
                print(f"{name:35} {value}")
        print("=" * 50)
        improvement = (self.metrics["avg_response_time_origin_ms"] /
                      self.metrics["avg_response_time_cached_ms"])
        print(f"Cached responses are {improvement:.0f}x faster!")

dashboard = CachePerformanceDashboard()
dashboard.display()