Eternita Edge · performance
A cache of page fragments, not whole pages, in front of your app or inside it — so a personalized page can still be almost entirely cached, and your app decides what is cacheable with a response header.
<fc:include> markers are resolved concurrently and stitched into the response.fewer origin renders, measured on a replay of 100,000 production requests against a live app — cache on vs. off, byte-identical responses. How it was measured
Send us an access log and we tell you what fraction of your traffic is cacheable and how much of it is bots. Free; we reply within one business day.
How It Works
Your origin returns a page with <fc:include url="…"/> markers in it. The edge
fetches each fragment through the same cache — in parallel — and stitches the answers into
the response. Every fragment has its own TTL, its own tags and its own cache level, so
a miss on one does not cost the others.
That is what makes a personalized page cacheable. The cart badge stays dynamic while the header, navigation, footer and product body cache for hours.
A fragment can be for some visitors only — crawlers, guests, or a type you declare. And fragments that miss together can be fetched from your origin in one call, if your origin opts in, each still cached under its own key.
Nothing is cached until your app says so. The default TTL is zero, so an origin that sets nothing gets a pure pass-through — a safe place to start.
<!-- the page your origin returns -->
<fc:include url="/common/header" />
<fc:include url="/product/42/body" />
<fc:include url="/cart/badge" />
<fc:include url="/store/cell?id=42" combine="true" />
<fc:include url="/seo/footer" client="bot" />
Each marker is a fragment with its own lifetime; combine batches
misses into one origin call, client limits who sees one.
# response headers your app sets on a page or a fragment
x-frontcache-component-maxage: bot:30d, guest:1h, customer:0
x-frontcache-component-tags: product-42|catalog
x-frontcache-component-refresh: soft
Crawlers from cache for a month, guests for an hour, customers always fresh; tagged for invalidation; refreshed in the background while the stale copy is served.
When Things Go Wrong
Every call to your origin goes through a circuit breaker, and every fragment has somewhere to fall back to.
When the origin answers 5xx or its circuit is open, content matched by URI pattern is served instead. A fragment that times out falls back the same way, and the rest of the page is served.
With refresh: soft an expired entry is served once more while a fresh copy is fetched
in the background, so the visitor is not kept waiting on the render.
One call clears every fragment tagged product-42, on every page that includes it
— through the management API, or the Java agent that sends it to every node of a cluster.
A memory tier in front of an on-disk index under the node’s home, so the working set is not limited by the heap. A fragment can be held in memory only.
A reverse proxy to an origin in any language, or a servlet filter inside your Java app — JSP and Spring included. Everything after the request arrives is the same engine.
Measured, With the Method
A replay of 100,000 real production requests against a live app, run twice back to back: once with the cache on, once with it switched off. Same app, same machine, same request stream, byte-identical responses.
hobbyray.com, a site we operate. The mechanism generalizes; the exact multiplier does not.
98.7% is that replay’s working set — a hot set by construction. Over the site’s full 681k-request log the same harness measures about 66.7%. Yours will depend on your TTLs and traffic shape.
The worst case. p99 improved only 42% and the single slowest request got slower: the uncached remainder queues behind 6× the throughput. Size the origin for that fraction.
Pro Cache Warmer
Fill the cache from a list of URLs — after a deploy, before a sale, on a new node — at a pace you set, so the origin is rendering at your speed, not the crowd’s.
Warmed exactly as a visitor would be served. Each URL goes through the node’s own front door, as the visitor type you choose — crawler, guest or one you declare — so what is stored is what that visitor reads. A refresh run overwrites entries without removing them first, so nobody meets an empty cache halfway through.
From the console. Edit or upload the list, check sample keys before the run, start it and watch it.
Each node’s card on the realtime monitor shows what its whole cluster is taking, beside the node’s own — the traffic a site takes, summed.
Challenge pages, adaptive defence, alerts, a console for many users and many sites, and support with a 1-business-day response.
Free and Pro
The whole cache engine is Apache-2.0, in both modes. Pro adds the warmer and the fleet view — $3,600 per node per year, 2-node minimum.
| Capability | Community — free | Pro |
|---|---|---|
| Fragment cache, includes, combining | Included, reverse proxy and servlet filter | Included |
| TTLs per visitor type | Bot, guest and up to 16 declared types | Included |
| Memory and disk tiers | Included | Included |
| Invalidation, fallbacks, circuit breaking | Included | Included |
| The benchmark harness | In the repository — replay your own node’s request log | Included |
| Cache warmer | — | From a URL list, as any visitor type, at your pace, from the console |
| Cluster request rate | Per node | Per node and per cluster |
What It Is Not
Know where the line is before you buy anything.
It composes with one. Keep your CDN for TLS, static assets, global points of presence and DDoS absorption; this sits at the origin and takes the page rendering off your app.
It caches what your app marks cacheable, and nothing else. Getting the most from it means setting TTLs per fragment — which is what the Assessment and the implementation work are for.
Each node keeps its own cache. Invalidation reaches every node through the API or the Java agent; entries are not shared between nodes.
Next Step
Send an access log for a free first look at what is cacheable — or have us replay it and write the plan: the $9,500 Cacheability Assessment, credited toward a first-year subscription.