Presets
Playback
Test profile
How long and how hard the test pushes.
Service under test
Workers, speed and the waiting room.
Memory and failure
The leak, the limit and the SLO the verdict uses.
Actions
Layers
Model checks
The science
What the page models
A service with c identical workers, each finishing a request at rate mu, takes requests arriving at rate lambda. Arrivals are Poisson and service times exponential, so the queue is the classic M/M/c system. The engine is a discrete-event simulation: every arrival, start and completion is an event; nothing is averaged in advance.
Utilisation and the hockey stick
Utilisation is rho = lambda / (c mu). The probability that a request has to wait is the Erlang-C formula C(c, a) = [a^c / c! * 1/(1-rho)] / [sum_{k<c} a^k/k! + a^c / c! * 1/(1-rho)] with offered load a = lambda/mu. Mean number in the system is L = C(c,a) * rho/(1-rho) + a. As rho approaches 1 the queue grows without bound, which is why a burst test at 90 % utilisation already stretches latency (graph 4).
Little's law
For any stable system, L = lambda W: the long-run average number of requests in the system equals the throughput times the mean time each spends there. The page measures all three from the same run and shows how far apart they are.
The leak, the GC and the OOM kill
Each accepted request leaks leak kilobytes that are never freed, so heap is base + leak * accepted + w * N (w = buffer per request still in the system). When the heap reaches the container limit the process is killed, everything in flight is lost, and requests are refused during the restart. With a constant arrival rate the time to the limit is T = (limit - base) / (lambda * leak): a leak that is invisible in a 5-minute burst is fatal in a multi-hour soak.
Garbage-collector pressure is modelled as a service-rate loss mu_eff = mu (1 - g f^3) with f = (heap - base)/(limit - base). This cubic law is an illustrative assumption, not a measurement of any runtime; it only shows why latency often rises before a leaking service finally dies.
Burst vs soak: what each exposes
A burst test (short, high rate) probes capacity: queueing, the bounded waiting room, shed load, and memory held by backlog. A soak test (long, moderate rate) probes accumulation: leaks, fragmentation, file handles, log growth. Neither replaces the other.
The three checks
(1) A separate 120,000-arrival run of the event engine at rho = 0.75 is compared with the Erlang-C closed form for L. (2) On that run, the time-average L is compared with measured lambda x W (Little's law). (3) A leak-only run at 100 req/s is compared with the formula for time to the limit.
Simplifications
Real services have non-exponential service times, retries, timeouts, autoscaling, connection pools and leaks that depend on the code path, not on a request count. Arrival thinning is exact for the piecewise-constant spike used here. This is a capacity-planning and test-design model only; it contains no attack or stress-tooling content.
What to try
- Load "Burst test" and let it finish: the heap barely moves and the verdict is PASSED. Now load "Soak test": memory climbs along the yellow leak line, GC slows the workers near the end, and the service is OOM-killed after about 6.4 hours of test time.
- Load "Same build, leak fixed" to see the same 8 hours pass. The difference is only the leak slider.
- Overload burst: with lambda above c*mu the waiting room fills and the surplus is dropped; make the waiting room huge and the backlog itself kills the process (buffers per request).
- Drag the utilisation up in graph 4 by raising lambda: mean time in the system follows the M/M/c curve and explodes near rho = 1. Compare 1 worker with 8 at the same utilisation.
- "Midday spike on a soak" shows a queue absorbing a short overload and draining afterwards.