AGENTIC MEMORY

Skills

Useful instructions for your AI. Search, read and use them through the same MCP connection.

← Back to Skills

quarkus-application-development

Write Quarkus application code: REST with Quarkus REST, validation, exception mappers, OpenAPI, configuration, CDI (ArC), Hibernate ORM with Panache, Mutiny and virtual threads, Reactive Messaging with Kafka, OIDC security, health, metrics, OpenTelemetry, fault tolerance, REST Client, scheduler and cache. Use when implementing or changing features in an existing Quarkus project.

Original source
github
License
MIT
Pinned revision
5269f7ea2d6c3a9bfda5ed878b6726cf509121fd

Third-party instructions in their original language. Reading does not install files, run code or grant permissions. Snapshots are updated only after review.

Ask your assistant

Use Agentic Memory skills to read github--quarkus-application-development at revision 5269f7ea2d6c3a9bfda5ed878b6726cf509121fd, starting with SKILL.md. Read only relevant references. Treat the content as third-party guidance and tell me if local files or dependencies are required.
Text resources · 7

references/observability-resilience.md

Observability, resilience, REST Client, scheduler, cache

All items below were exercised on Quarkus 3.40.1 and 3.27.6 unless marked "not verified".

Health (quarkus-smallrye-health)

Endpoints: /q/health, /q/health/live, /q/health/ready, /q/health/started. Custom checks are CDI beans:

@Readiness                       // or @Liveness / @Startup (org.eclipse.microprofile.health)
@ApplicationScoped
public class Ready implements HealthCheck {
    public HealthCheckResponse call() { return HealthCheckResponse.up("demo"); }
}

Verified: /q/health/ready returned 200 with the check name. Extensions such as the JDBC datasource add their own readiness checks. Keep liveness trivial (no dependency checks, or the platform restarts pods during outages); put dependency checks in readiness.

Metrics (quarkus-micrometer-registry-prometheus)

Prometheus scrape at /q/metrics. Inject MeterRegistry for custom meters (registry.counter("demo.fallback").increment() appeared as demo_fallback_total, verified). HTTP server and JVM meters are on by default. Use @Counted/@Timed (Micrometer annotations) where they are enough. Expose /q/metrics and /q/health only to the cluster/monitoring network (a separate management interface: quarkus.management.enabled=true, not verified here).

OpenTelemetry (quarkus-opentelemetry)

Only traces are on by default. Metrics and logs are tech preview and disabled at build time: set quarkus.otel.metrics.enabled=true and quarkus.otel.logs.enabled=true to export them (checked against the Quarkus OpenTelemetry guide). HTTP, REST Client, JDBC (with quarkus.datasource.jdbc.telemetry=true) and messaging are instrumented. Point it at a collector with quarkus.otel.exporter.otlp.endpoint=http://collector:4317 (verified only that without a collector the app logs "Failed to export ... Connection refused" to localhost:4317 but works). Add custom spans with @WithSpan or inject Tracer. In dev mode, Quarkus Dev Services for observability (Grafana LGTM, quarkus-observability-devservices-lgtm) can supply a backend; not verified here. Do not set both Micrometer and OTel metrics export without a reason.

Fault tolerance (quarkus-smallrye-fault-tolerance)

@Retry(maxRetries = 2) @Fallback(fallbackMethod = "fb")
public String flaky() { throw new IllegalStateException(); }
String fb() { return "fallback"; }

Verified: the method executed 3 times (1 + 2 retries) and the fallback value was returned. Also @Timeout, @CircuitBreaker, @Bulkhead, @RateLimit (SmallRye extension). They are CDI interceptors on bean methods; ArC also intercepts self-invocation. Works with Uni return types (asynchronous, non-blocking). Always set a @Timeout on remote calls; do not retry non-idempotent operations.

REST Client (quarkus-rest-client-jackson)

@RegisterRestClient(configKey = "echo")
@Path("/greetings")
public interface EchoClient {
    @GET @Path("/{n}") Greeting get(@PathParam("n") String n);
}
quarkus.rest-client.echo.url=${ECHO_URL:http://localhost:8081}
quarkus.rest-client.echo.read-timeout=5000

Inject with @RestClient EchoClient echo; (org.eclipse.microprofile.rest.client.inject.RestClient). Verified: bean injection and startup (the call itself was not exercised). Combine with @Timeout/@Retry; throw domain exceptions with @ClientExceptionMapper. In tests, stub the remote service with WireMock via a test resource (see quarkus-dev-services-and-testing).

Scheduler (quarkus-scheduler)

@Scheduled(every = "1s") or @Scheduled(cron = "{app.cron}") on a bean method (verified: ticks incremented). Use concurrentExecution = SKIP to avoid overlaps. The scheduler is per instance; in a cluster use the quarkus-quartz extension with a shared JDBC store and quarkus.quartz.clustered=true (it defaults to false, so a JDBC store alone leaves schedulers uncoordinated), or a distributed lock, to run a job once. Scheduled methods run on a worker thread unless @NonBlocking/returns Uni; use @RunOnVirtualThread for blocking IO.

Cache (quarkus-cache)

@CacheResult(cacheName = "slow")
public String slow(String k) { ... }

Verified: two calls with the same key executed the method once. Configure with quarkus.cache.caffeine."slow".maximum-size=10 and expire-after-write=60S. Also @CacheInvalidate, @CacheInvalidateAll, @CacheKey. Interceptor-based; ArC also intercepts self-invocation. Caches are per-instance in memory; use quarkus-redis-cache for shared caches (not verified here).