Videos

Goblin in action, recorded on quarkus-goblin-demo — The Falling Whale — a medieval tavern whose services are guarded by MicroProfile Fault Tolerance, running under real traffic with Prometheus, Grafana, Loki and Tempo. Every scenario can be replayed on the demo application.

The complete guide

Every assault, the blast radius, the chaos layers, profiles, scenarios and auto-off, the history and the Markdown report, the observability stack, driving Goblin from an AI agent through Dev MCP, and the post-mortem the tavern writes on its own. About seven minutes.

0:00

Getting started: the Dev UI and the Chaos Dashboard
0:38

Server-side assaults (see Assault types)
2:01

Client-side assaults
2:33

Blast radius (see Targeting)
2:54

Chaos layers (see Chaos layers)
3:54

Profiles, scenarios and auto-off (see Profiles)
4:45

History and Markdown report (see Dev UI panel)
5:24

Observability: Prometheus, Grafana, Loki, Tempo (see Metrics (Micrometer / Prometheus) and Tracing (OpenTelemetry))
6:11

AI agents with Dev MCP (see Driving Goblin from an AI agent)
6:24

Wrapping up: Disable all and the post-mortem

Testing your API timeouts with latency

A slow dependency is sneakier than a failing one: it answers, just too late. This video injects latency layer by layer and watches what the timeouts really do: a timeout that never sees the latency, a timeout doing its job, the grey zone around the timeout, a service without a timeout, retries that multiply the waiting time, and an average response time that hides the tail. About six minutes.

0:00

Introduction
1:33

Baseline: normal service
1:47

The latency the timeout never sees — latency on the HTTP_IN layer
2:08

The timeout does its job — latency on the SERVICE layer
2:34

The grey zone
3:09

No timeout — latency on the DATABASE layer
3:31

Timeout × retries, and the circuit breaker — client latency on the HTTP_OUT layer
4:07

The average lies — latency on part of the requests
4:50

What your tools see: Grafana, Tempo
5:24

Key takeaways

The key takeaways:

  1. Put a timeout on every remote call, and check that it covers the slow part: a fault injected on the inbound HTTP boundary hits the request before the guarded method runs (see Chaos layers).

  2. Set it above your normal p99, or it cuts healthy requests.

  3. Count the real budget: timeout × (retries + 1) + delays, and keep it below the timeout of your own caller.

  4. Add a fallback and a circuit breaker to fail fast when the dependency stops answering.

  5. Watch percentiles, not the average.

To replay these scenarios on your own application, see End-to-end example: prove your resilience annotations work.

The three-minute tour

The same story as the complete guide, at a faster pace: every assault layer by layer under real traffic, then the observability stack and the post-mortem.