Edge caching on Cloudflare — how do you get 95%+ hit rate without stale data?

// One Cloudflare-style edge cache in front of a news site for one simulated day.
// The edge is a Map (no eviction); the origin is a version counter per page.
// Purge is modelled as instant; Cloudflare reports under 150 ms P50 for Instant Purge.

let seed = 11;
function rand() { // Park-Miller generator, identical in every language
  seed = (seed * 48271) % 2147483647;
  return seed / 2147483647;
}
const ARTICLES = 2000, N = 300000, DAY = 86400;
const cdf = [];
let total = 0;
for (let k = 1; k <= ARTICLES; k++) { total += 1 / k; cdf.push(total); }
function pick() { // Zipf popularity: article k has weight 1/k
  const u = rand() * total;
  let lo = 0, hi = ARTICLES - 1;
  while (lo < hi) { const mid = (lo + hi) >> 1; if (cdf[mid] < u) lo = mid + 1; else hi = mid; }
  return lo + 1;
}

// Build the day once so every strategy sees the same traffic and the same edits.
const events = [];
for (let i = 0; i < N; i++) {
  const t = Math.floor((i * DAY) / N);
  const r = rand();
  const page = r < 0.1 ? "/" : "/a/" + pick();
  const q = rand();
  const query = q < 0.2 ? "?utm_source=s" + Math.floor(rand() * 30) : q < 0.3 ? "?fbclid=" + i : "";
  events.push({ t, url: page + query, page });
}
const edits = []; // an editor updates an article every 432 s (199 edits in the day)
for (let t = 432; t < DAY; t += 432) edits.push({ t, page: "/a/" + pick() });

function run(name, cfg) {
  const version = new Map(), edge = new Map(), byTag = new Map(); // byTag: page -> its cache keys
  const ver = (p) => version.get(p) || 0;
  let hits = 0, origin = 0, stale = 0, maxStale = 0, e = 0;
  const changedAt = new Map();
  for (const ev of events) {
    while (e < edits.length && edits[e].t <= ev.t) { // apply edits that happened before this request
      const ed = edits[e++];
      for (const p of [ed.page, "/"]) { version.set(p, ver(p) + 1); changedAt.set(p, ed.t); }
      if (cfg.purgeTags) for (const p of [ed.page, "/"]) { // purge by tag: every key carrying the tag
        for (const k of byTag.get(p) || []) edge.delete(k);
        byTag.delete(p);
      }
    }
    if (!cfg.cache) { origin++; continue; }
    const key = cfg.stripTracking ? ev.page : ev.url; // the cache key
    const c = edge.get(key);
    const fresh = c && ev.t < c.storedAt + cfg.ttl;
    const swr = c && !fresh && ev.t < c.storedAt + cfg.ttl + (cfg.swr || 0);
    if (fresh || swr) {
      hits++;
      if (c.v !== ver(ev.page)) { stale++; maxStale = Math.max(maxStale, ev.t - changedAt.get(ev.page)); }
      if (swr) { origin++; edge.set(key, { v: ver(ev.page), storedAt: ev.t }); } // background refresh
      continue;
    }
    origin++;
    edge.set(key, { v: ver(ev.page), storedAt: ev.t });
    if (!byTag.has(ev.page)) byTag.set(ev.page, new Set());
    byTag.get(ev.page).add(key);
  }
  const pct = (Math.round((hits * 1000) / N) / 10).toFixed(1);
  console.log(`  ${name.padEnd(36)} ${pct.padStart(5)}%  ${String(origin).padStart(7)}  ${String(stale).padStart(6)}  ${String(maxStale).padStart(9)}`);
}

console.log(`One day: ${N} requests, ${ARTICLES} articles + home page, ${edits.length} edits`);
console.log("  strategy                              hit    origin   stale  max stale s");
run("default (HTML not cached)", { cache: false });
run("cache everything, TTL 60 s", { cache: true, ttl: 60 });
run("TTL 1 day, no purge", { cache: true, ttl: DAY });
run("TTL 1 day + purge by tag", { cache: true, ttl: DAY, purgeTags: true });
run("  + strip utm and fbclid from key", { cache: true, ttl: DAY, purgeTags: true, stripTracking: true });
run("TTL 300 s + swr 600 s, clean key", { cache: true, ttl: 300, swr: 600, stripTracking: true });

const distinct = new Set(events.map((x) => x.url)).size, clean = new Set(events.map((x) => x.page)).size;
console.log(`\nDistinct cache keys: ${distinct} with raw URLs, ${clean} after stripping tracking parameters`);