Cache Invalidation at Scale

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

// Initiating a purge request
const purgeResponse = await cdnClient.purge({
  // Target specific URLs for precise invalidation
  urls: [
    'https://cdn.example.com/images/hero-banner.jpg',
    'https://cdn.example.com/api/products/featured',
    'https://cdn.example.com/css/main.css'
  ],
  // Optional: Target specific geographic regions
  regions: ['us-east', 'eu-west', 'ap-southeast'],
  // Request type: 'hard' removes immediately, 'soft' marks stale
  purgeType: 'hard'
});
 
// Response structure
console.log(purgeResponse);
/*
{
  purgeId: 'prg-8f4a2c1e-3b7d-4e5f-9a6b-1c2d3e4f5a6b',
  status: 'in_progress',
  requestedAt: '2024-01-15T10:30:00.000Z',
  estimatedCompletionMs: 5000,
  targetCount: 3,
  affectedEdgeNodes: 147,
  trackingUrl: 'https://api.cdn.com/purge/prg-8f4a2c1e-3b7d-4e5f-9a6b-1c2d3e4f5a6b'
}
*/
 
// Polling for completion (with exponential backoff)
async function waitForPurgeCompletion(purgeId: string, maxWaitMs: number = 30000) {
  const startTime = Date.now();
  let backoffMs = 500;
  
  while (Date.now() - startTime < maxWaitMs) {
    const status = await cdnClient.getPurgeStatus(purgeId);
    
    if (status.status === 'completed') {
      return { success: true, completedAt: status.completedAt };
    }
    
    if (status.status === 'failed') {
      throw new Error(`Purge failed: ${status.errorMessage}`);
    }
    
    // Exponential backoff with jitter
    await sleep(backoffMs + Math.random() * 100);
    backoffMs = Math.min(backoffMs * 2, 5000);
  }
  
  throw new Error('Purge completion timeout exceeded');
}

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

interface PurgeRequest {
  urls: string[];
  priority: 'critical' | 'high' | 'normal' | 'low';
  requestedAt: Date;
  retryCount: number;
}
 
class RateLimitedPurgeQueue {
  private queue: PriorityQueue<PurgeRequest>;
  private rateLimiter: SlidingWindowRateLimiter;
  private batchSize: number;
  
  constructor(
    maxPurgesPerMinute: number = 100,
    maxPurgesPerDay: number = 10000,
    batchSize: number = 50
  ) {
    this.queue = new PriorityQueue<PurgeRequest>(
      (a, b) => this.comparePriority(a, b)
    );
    this.rateLimiter = new SlidingWindowRateLimiter({
      perMinute: maxPurgesPerMinute,
      perDay: maxPurgesPerDay
    });
    this.batchSize = batchSize;
  }
 
  async enqueue(urls: string[], priority: PurgeRequest['priority'] = 'normal') {
    // Deduplicate URLs before queuing
    const uniqueUrls = [...new Set(urls)];
    
    // Split large requests into batches
    for (let i = 0; i < uniqueUrls.length; i += this.batchSize) {
      const batch = uniqueUrls.slice(i, i + this.batchSize);
      this.queue.enqueue({
        urls: batch,
        priority,
        requestedAt: new Date(),
        retryCount: 0
      });
    }
    
    this.processQueue();
  }
 
  private async processQueue() {
    while (!this.queue.isEmpty()) {
      // Check rate limits before dequeuing
      const tokensAvailable = await this.rateLimiter.checkAvailability();
      
      if (tokensAvailable === 0) {
        const waitTime = this.rateLimiter.getNextAvailableTime();
        await this.scheduleResumeIn(waitTime);
        return;
      }
      
      const request = this.queue.dequeue();
      
      try {
        await this.executePurge(request);
        await this.rateLimiter.consume(request.urls.length);
      } catch (error) {
        if (this.isRateLimitError(error)) {
          // Re-queue with backoff
          request.retryCount++;
          if (request.retryCount < 3) {
            this.queue.enqueue(request);
          } else {
            this.logPurgeFailed(request, error);
          }
        }
      }
    }
  }
 
  private comparePriority(a: PurgeRequest, b: PurgeRequest): number {
    const priorityOrder = { critical: 0, high: 1, normal: 2, low: 3 };
    const priorityDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
    if (priorityDiff !== 0) return priorityDiff;
    // Within same priority, FIFO
    return a.requestedAt.getTime() - b.requestedAt.getTime();
  }
}

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

interface PurgeVerificationResult {
  purgeId: string;
  verified: boolean;
  verificationMethod: string;
  sampledRegions: RegionVerification[];
  totalDurationMs: number;
}
 
interface RegionVerification {
  region: string;
  verified: boolean;
  cacheStatus: 'HIT' | 'MISS' | 'EXPIRED' | 'STALE';
  ageHeader: number | null;
  contentHash: string;
}
 
async function verifyPurgeWithMultiRegionSampling(
  purgeId: string,
  targetUrl: string,
  expectedContentHash: string,
  regions: string[] = ['us-east', 'us-west', 'eu-west', 'ap-southeast']
): Promise<PurgeVerificationResult> {
  const startTime = Date.now();
  
  // First, wait for CDN to report purge completion
  await waitForPurgeCompletion(purgeId);
  
  // Then verify from multiple regions
  const verifications = await Promise.all(
    regions.map(async (region) => {
      const response = await fetchFromRegion(targetUrl, region);
      const headers = response.headers;
      const body = await response.text();
      const actualHash = computeHash(body);
      
      return {
        region,
        verified: actualHash === expectedContentHash,
        cacheStatus: parseCacheStatus(headers.get('X-Cache')),
        ageHeader: parseInt(headers.get('Age') || '0'),
        contentHash: actualHash
      };
    })
  );
  
  const allVerified = verifications.every(v => v.verified);
  
  // Log for observability
  metrics.recordPurgeVerification({
    purgeId,
    success: allVerified,
    regionsSuccess: verifications.filter(v => v.verified).length,
    regionsTotal: verifications.length,
    durationMs: Date.now() - startTime
  });
  
  if (!allVerified) {
    const failedRegions = verifications.filter(v => !v.verified);
    alerting.warn('Purge verification failed for regions', {
      purgeId,
      failedRegions: failedRegions.map(r => r.region)
    });
  }
  
  return {
    purgeId,
    verified: allVerified,
    verificationMethod: 'multi-region-content-hash',
    sampledRegions: verifications,
    totalDurationMs: Date.now() - startTime
  };
}

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

// Event-driven purge architecture using message queue
// This decouples content updates from purge execution
 
interface ContentUpdateEvent {
  eventId: string;
  contentType: 'product' | 'article' | 'image' | 'config';
  entityId: string;
  action: 'create' | 'update' | 'delete';
  timestamp: Date;
  metadata: Record<string, string>;
}
 
class PurgeEventProcessor {
  constructor(
    private urlResolver: ContentUrlResolver,
    private purgeClient: CDNPurgeClient,
    private deduplicator: PurgeDeduplicator
  ) {}
 
  async processEvent(event: ContentUpdateEvent): Promise<void> {
    // 1. Resolve content event to affected cache URLs
    const affectedUrls = await this.urlResolver.resolveUrls(event);
    
    // 2. Deduplicate against recently purged URLs
    const urlsToPurge = await this.deduplicator.filter(affectedUrls);
    
    if (urlsToPurge.length === 0) {
      return; // Already purged recently
    }
    
    // 3. Determine purge priority based on content type
    const priority = this.determinePriority(event);
    
    // 4. Issue purge with appropriate strategy
    const purgeId = await this.purgeClient.purge({
      urls: urlsToPurge,
      priority,
      metadata: {
        triggerEvent: event.eventId,
        contentType: event.contentType
      }
    });
    
    // 5. Track for deduplication window (typically 60s)
    await this.deduplicator.markPurged(urlsToPurge, 60);
    
    // 6. Emit purge initiated event for downstream processing
    await this.emitPurgeEvent({
      purgeId,
      urls: urlsToPurge,
      triggerEvent: event.eventId,
      status: 'initiated'
    });
  }
 
  private determinePriority(event: ContentUpdateEvent): string {
    // Critical: breaking news, security fixes
    // High: product info, pricing
    // Normal: regular content updates
    // Low: non-time-sensitive updates
    
    if (event.metadata.urgent === 'true') return 'critical';
    if (event.contentType === 'product') return 'high';
    return 'normal';
  }
}
 
// URL Resolution: Maps content changes to cache URLs
class ContentUrlResolver {
  async resolveUrls(event: ContentUpdateEvent): Promise<string[]> {
    const urls: string[] = [];
    
    switch (event.contentType) {
      case 'product':
        // Product detail page
        urls.push(`${CDN_BASE}/products/${event.entityId}`);
        // Product API endpoint
        urls.push(`${CDN_BASE}/api/v1/products/${event.entityId}`);
        // Related collection pages (resolved via database)
        const collections = await this.getProductCollections(event.entityId);
        collections.forEach(c => {
          urls.push(`${CDN_BASE}/collections/${c.slug}`);
        });
        break;
        
      case 'article':
        urls.push(`${CDN_BASE}/articles/${event.entityId}`);
        urls.push(`${CDN_BASE}/api/articles/${event.entityId}`);
        // Invalidate article listing pages
        urls.push(`${CDN_BASE}/articles`);
        break;
        
      // ... other content types
    }
    
    return urls;
  }
}