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

// Cache Strategy: Components, not Complete Feeds
 
// ❌ Naive approach: Cache complete feed per user
interface CachedFeed {
  userId: string;
  posts: FullPost[];  // Complete post data
}
// Problem: 2B users × 50KB/feed = 100 PB of cache (impossible)
// Problem: Any change to any post invalidates caches
 
// ✅ Better approach: Cache components separately
 
// 1. Feed Candidate Cache - Post IDs only
interface FeedCandidateCache {
  userId: string;
  postIds: string[];      // Just IDs, not content
  generatedAt: timestamp;
}
// Size: 2B users × 1500 posts × 32 bytes = 96 TB (feasible)
 
// 2. Post Content Cache - Shared across all users
interface PostCache {
  postId: string;
  content: PostContent;
  author: UserReference;
  mediaIds: string[];
}
// Size: Billions of posts, but each cached once
 
// 3. Engagement Cache - Updated independently
interface EngagementCache {
  postId: string;
  likes: number;
  comments: number;
  shares: number;
  lastUpdated: timestamp;
}
// Size: Small per-post, high update frequency
 
// 4. User Profile Cache - Shared across all posts
interface UserProfileCache {
  userId: string;
  name: string;
  profilePicUrl: string;
  // ... other profile fields
}
// Size: 3B users × 1KB = 3 TB
 
// Feed Assembly (at request time)
async function assembleRead(userId: string): Promise<Feed> {
  // 1. Get candidate post IDs (cached)
  const candidates = await feedCandidateCache.get(userId);
  
  // 2. Fetch post content (cached, high hit rate)
  const posts = await postCache.batchGet(candidates.postIds);
  
  // 3. Fetch engagement counts (cached, short TTL)
  const engagement = await engagementCache.batchGet(candidates.postIds);
  
  // 4. Fetch author profiles (cached, high hit rate)
  const authorIds = posts.map(p => p.authorId);
  const profiles = await userProfileCache.batchGet(authorIds);
  
  // 5. Rank and assemble (computed, not cached)
  return rankAndAssemble(posts, engagement, profiles);
}

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

// Cache-Aside Pattern
// Application manages cache explicitly
// Best for: Read-heavy data with infrequent updates
 
class CacheAsidePostStore {
  private cache: DistributedCache;
  private database: Database;
  
  async getPost(postId: string): Promise<Post | null> {
    // 1. Try cache first
    const cached = await this.cache.get(`post:${postId}`);
    if (cached) {
      return cached;
    }
    
    // 2. Cache miss: query database
    const post = await this.database.query(`SELECT * FROM posts WHERE id = ?`, [postId]);
    
    if (post) {
      // 3. Populate cache for next request
      await this.cache.set(`post:${postId}`, post, { ttl: 3600 });
    }
    
    return post;
  }
  
  async updatePost(postId: string, updates: Partial<Post>): Promise<void> {
    // 1. Update database (source of truth)
    await this.database.update('posts', postId, updates);
    
    // 2. Invalidate cache (or update it)
    await this.cache.delete(`post:${postId}`);
    // Alternative: await this.cache.set(`post:${postId}`, updatedPost);
  }
}
 
// Pros: Simple, only caches what's needed
// Cons: Cache misses hit database, potential cache stampede

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

// Write-Through Pattern
// Cache is always updated with database
// Best for: Data requiring strong consistency, frequently read after write
 
class WriteThroughProfileStore {
  private cache: DistributedCache;
  private database: Database;
  
  async getProfile(userId: string): Promise<Profile> {
    // Always read from cache (guaranteed to be populated)
    return this.cache.get(`profile:${userId}`);
  }
  
  async updateProfile(userId: string, updates: Partial<Profile>): Promise<void> {
    // 1. Start transaction
    const tx = await this.database.beginTransaction();
    
    try {
      // 2. Update database
      await tx.update('profiles', userId, updates);
      
      // 3. Update cache (synchronously, before commit)
      const updatedProfile = await tx.query(`SELECT * FROM profiles WHERE id = ?`, [userId]);
      await this.cache.set(`profile:${userId}`, updatedProfile);
      
      // 4. Commit transaction
      await tx.commit();
    } catch (e) {
      await tx.rollback();
      throw e;
    }
  }
}
 
// Pros: Cache always consistent with DB, no cold start
// Cons: Write latency increased, requires careful error handling

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

// Write-Behind Pattern
// Write to cache immediately, async persist to database
// Best for: High write throughput, eventual consistency acceptable
 
class WriteBehindEngagementStore {
  private cache: DistributedCache;
  private writeQueue: WriteQueue;
  
  async incrementLikes(postId: string): Promise<number> {
    // 1. Increment in cache immediately (fast)
    const newCount = await this.cache.incr(`likes:${postId}`);
    
    // 2. Queue database write (async, batched)
    this.writeQueue.enqueue({
      type: 'increment',
      table: 'post_engagement',
      postId,
      field: 'likes',
      delta: 1,
    });
    
    return newCount;
  }
  
  // Background job processes write queue
  async processWriteQueue(): Promise<void> {
    const batch = await this.writeQueue.dequeue(100);
    
    // Coalesce increments for same post
    const coalesced = this.coalesceIncrements(batch);
    
    // Batch write to database
    await this.database.batchUpdate(coalesced);
  }
  
  coalesceIncrements(items: WriteItem[]): CoalescedWrite[] {
    const byPost = new Map();
    for (const item of items) {
      const key = `${item.postId}:${item.field}`;
      byPost.set(key, (byPost.get(key) || 0) + item.delta);
    }
    return [...byPost.entries()].map(([key, delta]) => ({
      postId: key.split(':')[0],
      field: key.split(':')[1],
      delta,
    }));
  }
}
 
// Pros: Very fast writes, natural batching
// Cons: Data loss risk if cache fails before persist, complex recovery

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

// Event-driven cache invalidation
 
class CacheInvalidator {
  private redis: RedisCluster;
  private eventBus: EventBus;
  
  constructor() {
    // Subscribe to relevant events
    this.eventBus.subscribe('post:updated', this.onPostUpdated.bind(this));
    this.eventBus.subscribe('post:deleted', this.onPostDeleted.bind(this));
    this.eventBus.subscribe('user:profile_updated', this.onProfileUpdated.bind(this));
    this.eventBus.subscribe('user:privacy_changed', this.onPrivacyChanged.bind(this));
    this.eventBus.subscribe('friendship:changed', this.onFriendshipChanged.bind(this));
  }
  
  async onPostUpdated(event: PostUpdatedEvent) {
    // Invalidate post content cache
    await this.redis.del(`post:${event.postId}`);
    
    // Invalidate CDN cache for media
    if (event.mediaChanged) {
      await this.cdnInvalidate(`/posts/${event.postId}/media/*`);
    }
  }
  
  async onPostDeleted(event: PostDeletedEvent) {
    // Invalidate all caches related to this post
    await this.redis.del([
      `post:${event.postId}`,
      `engagement:${event.postId}`,
      `comments:${event.postId}`,
    ]);
    
    // Invalidate feed caches that might contain this post
    // This is expensive - defer to background processing
    await this.queueFeedInvalidation({
      postId: event.postId,
      authorId: event.authorId,
    });
  }
  
  async onPrivacyChanged(event: PrivacyChangedEvent) {
    // Privacy changes require broader invalidation
    const userId = event.userId;
    
    // Invalidate all posts by this user
    const postIds = await this.getPostsByUser(userId);
    await this.redis.del(postIds.map(id => `post:${id}`));
    
    // Invalidate feed candidates for all friends
    // (they may need to see less or more content now)
    const friends = await this.getFriends(userId);
    await this.invalidateFeedCandidates(friends);
  }
  
  async invalidateFeedCandidates(userIds: string[]) {
    // For large invalidations, use background job
    if (userIds.length > 1000) {
      await this.queueBulkInvalidation(userIds);
      return;
    }
    
    // Direct invalidation for smaller batches
    await this.redis.del(userIds.map(id => `feed_candidates:${id}`));
  }
}

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

// Cascade invalidation can be expensive
// Example: User changes name → affects all their posts in all friends' feeds
 
class CascadeInvalidator {
  
  // Strategy 1: Lazy invalidation (check freshness on read)
  async lazyProfileCheck(post: CachedPost, viewer: string): Promise<Post> {
    const author = await profileCache.get(post.authorId);
    
    // Check if profile is newer than cached post
    if (author.lastModified > post.cachedAt) {
      // Profile changed, update embedded author data
      post.author = await this.refreshAuthorData(post, author);
    }
    
    return post;
  }
  
  // Strategy 2: Tag-based invalidation
  async tagBasedInvalidation(userId: string) {
    // All posts tagged with this author
    await this.redis.eval(`
      local keys = redis.call('keys', 'post:*:author:' .. ARGV[1])
      for i, key in ipairs(keys) do
        redis.call('del', key)
      end
      return #keys
    `, 0, userId);
  }
  
  // Strategy 3: TTL with version check
  async versionedRead(postId: string): Promise<Post> {
    const cached = await this.redis.hgetall(`post:${postId}`);
    
    // Check freshness version
    const currentVersion = await this.getPostVersion(postId);
    
    if (cached.version !== currentVersion) {
      // Stale cache, refresh
      return this.refreshPostCache(postId);
    }
    
    return cached.data;
  }
  
  // Strategy 4: Probabilistic expiration (avoid thundering herd)
  cacheWithProbabilisticExpiry(key: string, data: any, baseTTL: number) {
    // Add random jitter to TTL
    const ttl = baseTTL + Math.random() * baseTTL * 0.1;  // ±10%
    
    return this.redis.set(key, JSON.stringify(data), 'EX', Math.floor(ttl));
  }
}

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

// TAO API for social graph operations
 
// Object operations
const user = await tao.objectGet(userId);
await tao.objectSet(userId, { name: 'New Name', lastModified: now() });
 
// Association operations
// Create friendship edge
await tao.assocAdd(userId1, 'friend', userId2, {
  timestamp: now(),
  initiator: userId1,
});
 
// Query all friends (paginated)
const friends = await tao.assocRange(
  userId,           // Source object
  'friend',         // Association type
  0,               // Start offset
  100              // Count
);
 
// Query specific association
const isFriend = await tao.assocGet(userId1, 'friend', userId2);
 
// Count associations
const friendCount = await tao.assocCount(userId, 'friend');
 
// Multi-get for batch efficiency
const profiles = await tao.objectMultiGet([userId1, userId2, userId3]);
 
// TAO handles caching automatically:
// - Objects cached individually
// - Association lists cached as sorted sets
// - Writes invalidate relevant caches synchronously
// - Read scalability via cache replicas

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

// Lease-based cache get to prevent thundering herd
 
class LeaseMemcache {
  
  async getWithLease(key: string): Promise<{ value: any, lease?: string }> {
    const result = await this.memcache.getsWithLease(key);
    
    if (result.value !== null) {
      // Cache hit
      return { value: result.value };
    }
    
    // Cache miss - server issues lease
    if (result.lease) {
      // This request has the lease to rebuild cache
      return { value: null, lease: result.lease };
    }
    
    // Another request has the lease, wait briefly
    await sleep(10);
    return this.getWithLease(key);  // Retry
  }
  
  async setWithLease(key: string, value: any, lease: string) {
    // Only succeeds if lease is still valid
    return this.memcache.casWithLease(key, value, lease);
  }
  
  // Usage pattern
  async getCachedPost(postId: string): Promise<Post> {
    const { value, lease } = await this.getWithLease(`post:${postId}`);
    
    if (value) {
      return value;  // Cache hit
    }
    
    // Cache miss with lease - rebuild
    const post = await database.getPost(postId);
    
    if (lease) {
      await this.setWithLease(`post:${postId}`, post, lease);
    }
    
    return post;
  }
}
 
// Lease mechanism ensures only ONE request rebuilds cache
// All other requests wait and then get the cached value
// This prevents N simultaneous database queries

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

// Feature Store for ranking model inputs
 
interface FeatureStore {
  // Pre-computed features updated periodically
  userFeatures: Map<UserId, UserFeatureVector>;
  contentFeatures: Map<ContentId, ContentFeatureVector>;
  
  // Real-time features computed per-request
  realtimeFeatures: (context: Context) => FeatureVector;
}
 
class FeedFeatureStore {
  private offlineStore: RocksDB;        // Pre-computed features
  private onlineStore: Redis;           // Real-time features
  private featureCache: LocalCache;     // In-process cache
  
  async getUserFeatures(userId: string): Promise<UserFeatures> {
    // 1. Check process-local cache (hot users)
    const local = await this.featureCache.get(`user:${userId}`);
    if (local) return local;
    
    // 2. Check online store (recent computations)
    const online = await this.onlineStore.get(`user_features:${userId}`);
    if (online) {
      await this.featureCache.set(`user:${userId}`, online);
      return online;
    }
    
    // 3. Fall back to offline store (batch-computed features)
    const offline = await this.offlineStore.get(`user_features:${userId}`);
    await this.onlineStore.set(`user_features:${userId}`, offline, 'EX', 3600);
    await this.featureCache.set(`user:${userId}`, offline);
    return offline;
  }
  
  // Daily batch job pre-computes user features
  // Avoids computing 200+ features at request time
  async batchComputeUserFeatures(userIds: string[]) {
    for (const userId of userIds) {
      const features = await this.computeUserFeatures(userId);
      await this.offlineStore.put(`user_features:${userId}`, features);
    }
  }
}

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

// Cache monitoring instrumentation
 
class CacheMetrics {
  private metrics: MetricsClient;
  
  async instrumentedGet(cache: Cache, key: string): Promise<any> {
    const startTime = Date.now();
    
    try {
      const result = await cache.get(key);
      const latency = Date.now() - startTime;
      
      // Record metrics
      this.metrics.histogram('cache.latency', latency, {
        cache: cache.name,
        operation: 'get',
      });
      
      if (result !== null) {
        this.metrics.increment('cache.hit', 1, { cache: cache.name, key_pattern: this.extractPattern(key) });
      } else {
        this.metrics.increment('cache.miss', 1, { cache: cache.name, key_pattern: this.extractPattern(key) });
      }
      
      return result;
    } catch (error) {
      this.metrics.increment('cache.error', 1, { 
        cache: cache.name, 
        error_type: error.name 
      });
      throw error;
    }
  }
  
  // Dashboard alerts
  setupAlerts() {
    alert({
      name: 'cache_hit_rate_low',
      query: 'rate(cache_hit) / rate(cache_hit + cache_miss) < 0.9',
      severity: 'warning',
      message: 'Cache hit rate below 90%',
    });
    
    alert({
      name: 'cache_latency_high',
      query: 'percentile(cache_latency, 99) > 20ms',
      severity: 'critical',
      message: 'Cache p99 latency exceeds 20ms',
    });
    
    alert({
      name: 'cache_connection_errors',
      query: 'rate(cache_error) / rate(cache_*) > 0.001',
      severity: 'critical',
      message: 'Cache error rate exceeds 0.1%',
    });
  }
  
  // Extract key pattern for aggregation (e.g., "post:123" → "post:*")
  extractPattern(key: string): string {
    return key.replace(/[0-9]+/g, '*');
  }
}