Why Caching Matters

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

"""
Framework for selecting appropriate caching layer based on data characteristics.
"""
from dataclasses import dataclass
from enum import Enum
from typing import Optional
 
 
class CachingLayer(Enum):
    BROWSER = "Browser/Client Cache"
    CDN = "CDN/Edge Cache"
    REVERSE_PROXY = "Reverse Proxy Cache"
    APPLICATION = "Application In-Process Cache"
    DISTRIBUTED = "Distributed Cache (Redis/Memcached)"
    DATABASE = "Database Query Cache"
    NONE = "No Caching Recommended"
 
 
@dataclass
class DataCharacteristics:
    """Characteristics of data to help determine caching strategy."""
    
    reads_per_write: float          # Ratio of reads to writes
    staleness_tolerance_seconds: float  # Acceptable staleness window
    is_user_specific: bool          # Whether data is personalized
    is_public: bool                 # Whether data is the same for all users
    size_bytes: int                 # Typical size of cached item
    access_frequency_per_minute: float  # How often this data is accessed
    computation_cost_ms: float      # Time to generate/fetch this data
    is_security_sensitive: bool     # Whether stale data could cause security issues
    requires_strong_consistency: bool  # Whether data must be current
 
 
def recommend_caching_layer(data: DataCharacteristics) -> tuple[CachingLayer, str]:
    """
    Recommend appropriate caching layer based on data characteristics.
    Returns recommended layer and explanation.
    """
    
    # Check for caching anti-patterns first
    if data.requires_strong_consistency:
        return (CachingLayer.NONE, 
                "Strong consistency requirement rules out caching")
    
    if data.is_security_sensitive and data.staleness_tolerance_seconds < 1:
        return (CachingLayer.NONE,
                "Security-sensitive data with near-zero staleness tolerance")
    
    if data.reads_per_write < 2:
        return (CachingLayer.NONE,
                f"Read/write ratio of {data.reads_per_write:.1f} too low for caching benefit")
    
    if data.access_frequency_per_minute < 0.1:
        return (CachingLayer.NONE,
                "Access frequency too low - cache would constantly cold-start")
    
    # Determine best layer based on characteristics
    
    # CDN layer for public, static-ish, large-scale content
    if (data.is_public and 
        not data.is_user_specific and 
        data.staleness_tolerance_seconds >= 60 and
        data.access_frequency_per_minute > 100):
        return (CachingLayer.CDN,
                "Public content with high access frequency - ideal for CDN edge caching")
    
    # Browser cache for static assets
    if (data.is_public and 
        data.staleness_tolerance_seconds >= 3600 and  # 1 hour+
        data.size_bytes > 10000):  # Larger assets worth caching
        return (CachingLayer.BROWSER,
                "Static content with long staleness tolerance - ideal for browser caching")
    
    # Application cache for very hot, small data
    if (data.size_bytes < 10000 and 
        data.access_frequency_per_minute > 1000 and
        data.computation_cost_ms < 10):
        return (CachingLayer.APPLICATION,
                "Hot, small data with very high frequency - in-process cache for lowest latency")
    
    # Distributed cache for shared, computed, or session data
    if (data.computation_cost_ms > 50 or
        data.reads_per_write > 100 or
        (data.is_user_specific and data.staleness_tolerance_seconds >= 60)):
        return (CachingLayer.DISTRIBUTED,
                "Computed/shared data with good read ratio - distributed cache for sharing across instances")
    
    # Database query cache as fallback for moderate cases
    if data.reads_per_write > 10 and data.staleness_tolerance_seconds >= 5:
        return (CachingLayer.DATABASE,
                "Moderate caching benefit - database query cache as lightweight option")
    
    return (CachingLayer.DISTRIBUTED,
            "General purpose caching - distributed cache provides good balance")
 
 
# Example evaluations
examples = [
    ("Product Catalog", DataCharacteristics(
        reads_per_write=500,
        staleness_tolerance_seconds=300,
        is_user_specific=False,
        is_public=True,
        size_bytes=5000,
        access_frequency_per_minute=10000,
        computation_cost_ms=50,
        is_security_sensitive=False,
        requires_strong_consistency=False
    )),
    ("User Session", DataCharacteristics(
        reads_per_write=100,
        staleness_tolerance_seconds=30,
        is_user_specific=True,
        is_public=False,
        size_bytes=2000,
        access_frequency_per_minute=100,
        computation_cost_ms=10,
        is_security_sensitive=True,
        requires_strong_consistency=False
    )),
    ("Account Balance", DataCharacteristics(
        reads_per_write=10,
        staleness_tolerance_seconds=0,
        is_user_specific=True,
        is_public=False,
        size_bytes=100,
        access_frequency_per_minute=50,
        computation_cost_ms=5,
        is_security_sensitive=True,
        requires_strong_consistency=True
    )),
    ("Feature Flags", DataCharacteristics(
        reads_per_write=100000,
        staleness_tolerance_seconds=60,
        is_user_specific=False,
        is_public=False,
        size_bytes=500,
        access_frequency_per_minute=50000,
        computation_cost_ms=2,
        is_security_sensitive=False,
        requires_strong_consistency=False
    )),
]
 
print("Caching Layer Recommendations")
print("=" * 60)
 
for name, characteristics in examples:
    layer, explanation = recommend_caching_layer(characteristics)
    print(f"
{name}:")
    print(f"  Recommended: {layer.value}")
    print(f"  Rationale: {explanation}")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175

"""
Analyzer for identifying caching opportunities from query logs.
This simulates the analysis you'd do on actual production data.
"""
from dataclasses import dataclass
from collections import defaultdict
from datetime import datetime, timedelta
from typing import Dict, List, Tuple
import math
 
 
@dataclass
class QueryLogEntry:
    """Represents a single query from the log."""
    query_hash: str       # Normalized query hash
    query_pattern: str    # Human-readable query pattern
    execution_time_ms: float
    result_size_bytes: int
    timestamp: datetime
    was_write: bool
 
 
def analyze_caching_opportunities(
    query_logs: List[QueryLogEntry],
    analysis_window: timedelta
) -> Dict:
    """
    Analyze query logs to identify caching opportunities.
    
    Returns prioritized list of queries/patterns that would benefit from caching.
    """
    
    # Aggregate metrics per query pattern
    stats = defaultdict(lambda: {
        "read_count": 0,
        "write_count": 0,
        "total_time_ms": 0,
        "total_bytes": 0,
        "timestamps": [],
        "latencies": []
    })
    
    for entry in query_logs:
        s = stats[entry.query_pattern]
        if entry.was_write:
            s["write_count"] += 1
        else:
            s["read_count"] += 1
            s["total_time_ms"] += entry.execution_time_ms
            s["total_bytes"] += entry.result_size_bytes
            s["latencies"].append(entry.execution_time_ms)
            s["timestamps"].append(entry.timestamp)
    
    # Calculate caching metrics for each pattern
    opportunities = []
    
    for pattern, s in stats.items():
        if s["read_count"] == 0:
            continue
        
        read_count = s["read_count"]
        write_count = max(s["write_count"], 1)  # Avoid division by zero
        
        # Key metrics
        read_write_ratio = read_count / write_count
        avg_latency_ms = s["total_time_ms"] / read_count
        avg_size_bytes = s["total_bytes"] / read_count
        
        # Burstiness: Are reads clustered or spread out?
        if len(s["timestamps"]) > 1:
            intervals = [
                (s["timestamps"][i] - s["timestamps"][i-1]).total_seconds()
                for i in range(1, len(s["timestamps"]))
            ]
            avg_interval = sum(intervals) / len(intervals)
            burstiness = 1.0 / avg_interval if avg_interval > 0 else float('inf')
        else:
            burstiness = 0
        
        # Calculate cache value score
        # Higher is better for caching
        cache_value_score = (
            math.log10(max(read_write_ratio, 1)) * 2 +       # High R/W ratio helps
            math.log10(max(avg_latency_ms, 1)) * 3 +         # High latency helps
            math.log10(max(read_count, 1)) * 1 +             # High frequency helps
            -math.log10(max(avg_size_bytes / 1000, 1)) * 0.5  # Large size hurts
        )
        
        # Estimate potential savings
        # Assume 90% hit rate, 1ms cache latency
        potential_latency_saved = avg_latency_ms * 0.9 * read_count
        
        opportunities.append({
            "pattern": pattern,
            "read_count": read_count,
            "read_write_ratio": round(read_write_ratio, 1),
            "avg_latency_ms": round(avg_latency_ms, 2),
            "avg_size_kb": round(avg_size_bytes / 1024, 2),
            "cache_value_score": round(cache_value_score, 2),
            "potential_time_saved_sec": round(potential_latency_saved / 1000, 2),
            "recommendation": get_recommendation(read_write_ratio, avg_latency_ms, read_count)
        })
    
    # Sort by cache value score
    opportunities.sort(key=lambda x: x["cache_value_score"], reverse=True)
    
    return {
        "analysis_window": str(analysis_window),
        "total_queries_analyzed": len(query_logs),
        "unique_patterns": len(opportunities),
        "opportunities": opportunities[:10],  # Top 10
        "summary": generate_summary(opportunities)
    }
 
 
def get_recommendation(rw_ratio: float, latency: float, count: int) -> str:
    """Generate caching recommendation based on metrics."""
    if rw_ratio < 2:
        return "Not recommended - insufficient read/write ratio"
    if latency < 5 and count < 100:
        return "Low priority - minimal latency savings"
    if rw_ratio > 100 and latency > 50:
        return "STRONG - High ratio, high latency, excellent candidate"
    if rw_ratio > 10:
        return "Recommended - Good ratio for caching"
    return "Consider - May benefit from caching"
 
 
def generate_summary(opportunities: List[Dict]) -> Dict:
    """Generate summary statistics."""
    if not opportunities:
        return {"message": "No caching opportunities identified"}
    
    strong = sum(1 for o in opportunities if "STRONG" in o["recommendation"])
    recommended = sum(1 for o in opportunities if "Recommended" in o["recommendation"])
    
    total_savings = sum(o["potential_time_saved_sec"] for o in opportunities[:10])
    
    return {
        "strong_candidates": strong,
        "recommended_candidates": recommended,
        "potential_time_saved_top10_sec": round(total_savings, 2),
        "top_pattern": opportunities[0]["pattern"] if opportunities else None
    }
 
 
# Simulated analysis
sample_log = [
    QueryLogEntry("h1", "SELECT * FROM products WHERE id = ?", 45, 5000, datetime.now() - timedelta(hours=i), False)
    for i in range(1000)  # 1000 product reads
] + [
    QueryLogEntry("h2", "UPDATE products SET price = ? WHERE id = ?", 10, 0, datetime.now() - timedelta(hours=i*100), True)
    for i in range(2)  # 2 product updates
] + [
    QueryLogEntry("h3", "SELECT * FROM orders WHERE user_id = ?", 120, 15000, datetime.now() - timedelta(minutes=i), False)
    for i in range(500)
] + [
    QueryLogEntry("h4", "INSERT INTO orders ...", 20, 0, datetime.now() - timedelta(minutes=i*2), True)
    for i in range(200)
]
 
result = analyze_caching_opportunities(sample_log, timedelta(hours=24))
 
print("Caching Opportunity Analysis")
print("=" * 60)
print(f"Queries Analyzed: {result['total_queries_analyzed']}")
print(f"Unique Patterns: {result['unique_patterns']}")
print("
Top Opportunities:")
for i, opp in enumerate(result['opportunities'], 1):
    print(f"
{i}. {opp['pattern'][:50]}")
    print(f"   Reads: {opp['read_count']} | R/W Ratio: {opp['read_write_ratio']}")
    print(f"   Avg Latency: {opp['avg_latency_ms']}ms | Size: {opp['avg_size_kb']}KB")
    print(f"   Cache Score: {opp['cache_value_score']} | {opp['recommendation']}")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221

/**
 * Implementation examples of common caching strategies.
 * These illustrate the patterns; production code would include 
 * error handling, metrics, and more sophisticated features.
 */
 
interface Cache<T> {
    get(key: string): Promise<T | null>;
    set(key: string, value: T, ttlMs?: number): Promise<void>;
    delete(key: string): Promise<void>;
}
 
interface DataStore<T> {
    read(key: string): Promise<T | null>;
    write(key: string, value: T): Promise<void>;
}
 
/**
 * Cache-Aside (Lazy Loading)
 * Application explicitly manages cache reads and writes.
 */
class CacheAsideRepository<T> {
    constructor(
        private cache: Cache<T>,
        private store: DataStore<T>,
        private ttlMs: number = 300000 // 5 minutes default
    ) {}
    
    async read(key: string): Promise<T | null> {
        // 1. Check cache first
        const cached = await this.cache.get(key);
        if (cached !== null) {
            return cached; // Cache hit
        }
        
        // 2. Cache miss - fetch from origin
        const value = await this.store.read(key);
        
        // 3. Populate cache (only if value exists)
        if (value !== null) {
            await this.cache.set(key, value, this.ttlMs);
        }
        
        return value;
    }
    
    async write(key: string, value: T): Promise<void> {
        // Write to origin
        await this.store.write(key, value);
        
        // Invalidate cache (or update it)
        await this.cache.delete(key);
    }
}
 
/**
 * Write-Through
 * Writes go to both cache and origin synchronously.
 */
class WriteThroughRepository<T> {
    constructor(
        private cache: Cache<T>,
        private store: DataStore<T>,
        private ttlMs: number = 300000
    ) {}
    
    async read(key: string): Promise<T | null> {
        // Same as cache-aside for reads
        const cached = await this.cache.get(key);
        if (cached !== null) {
            return cached;
        }
        
        const value = await this.store.read(key);
        if (value !== null) {
            await this.cache.set(key, value, this.ttlMs);
        }
        
        return value;
    }
    
    async write(key: string, value: T): Promise<void> {
        // Write to BOTH cache and origin
        // Use Promise.all for parallel writes, but origin is source of truth
        
        // Origin first (if this fails, we don't pollute cache)
        await this.store.write(key, value);
        
        // Then cache
        await this.cache.set(key, value, this.ttlMs);
    }
}
 
/**
 * Write-Behind (Write-Back)
 * Writes go to cache immediately, async flush to origin.
 * WARNING: Risk of data loss if cache fails before flush.
 */
class WriteBehindRepository<T> {
    private pendingWrites: Map<string, { value: T; timestamp: number }> = new Map();
    private flushIntervalMs: number = 1000;
    
    constructor(
        private cache: Cache<T>,
        private store: DataStore<T>,
        private ttlMs: number = 300000
    ) {
        // Start background flusher
        this.startFlusher();
    }
    
    async read(key: string): Promise<T | null> {
        // Check pending writes first (most recent data)
        const pending = this.pendingWrites.get(key);
        if (pending) {
            return pending.value;
        }
        
        // Then cache
        const cached = await this.cache.get(key);
        if (cached !== null) {
            return cached;
        }
        
        // Finally origin
        const value = await this.store.read(key);
        if (value !== null) {
            await this.cache.set(key, value, this.ttlMs);
        }
        
        return value;
    }
    
    async write(key: string, value: T): Promise<void> {
        // Write to cache immediately
        await this.cache.set(key, value, this.ttlMs);
        
        // Queue for async flush to origin
        this.pendingWrites.set(key, { value, timestamp: Date.now() });
        
        // Returns immediately - origin write is async
    }
    
    private startFlusher(): void {
        setInterval(async () => {
            const toFlush = new Map(this.pendingWrites);
            this.pendingWrites.clear();
            
            for (const [key, { value }] of toFlush) {
                try {
                    await this.store.write(key, value);
                } catch (error) {
                    // Re-queue failed writes (with backoff in production)
                    console.error(`Failed to flush ${key}, re-queuing`);
                    this.pendingWrites.set(key, { value, timestamp: Date.now() });
                }
            }
        }, this.flushIntervalMs);
    }
}
 
/**
 * Refresh-Ahead
 * Proactively refresh cache entries before they expire.
 */
class RefreshAheadRepository<T> {
    private refreshThreshold: number = 0.8; // Refresh at 80% of TTL
    
    constructor(
        private cache: Cache<T>,
        private store: DataStore<T>,
        private ttlMs: number = 300000
    ) {}
    
    async read(key: string): Promise<T | null> {
        const cached = await this.cache.get(key);
        
        if (cached !== null) {
            // Check if we should refresh ahead
            // (In real implementation, track cache entry age)
            this.maybeRefreshAsync(key);
            return cached;
        }
        
        // Cache miss
        const value = await this.store.read(key);
        if (value !== null) {
            await this.cache.set(key, value, this.ttlMs);
        }
        
        return value;
    }
    
    private async maybeRefreshAsync(key: string): Promise<void> {
        // In production, track entry age and refresh if near expiry
        // This is a simplified illustration
        // Don't await - fire and forget
        this.store.read(key).then(async (value) => {
            if (value !== null) {
                await this.cache.set(key, value, this.ttlMs);
            }
        }).catch(() => {
            // Ignore refresh failures - cache still has value
        });
    }
    
    async write(key: string, value: T): Promise<void> {
        await this.store.write(key, value);
        await this.cache.delete(key);
    }
}
 
// Usage example
console.log(`
Cache Strategy Selection Guide:
  
  Cache-Aside: Default choice for most read-heavy workloads
  Write-Through: When you need strong consistency
  Write-Behind: Write-heavy with acceptable data loss risk
  Refresh-Ahead: Predictable hot data, minimize cache misses
`);