Context Propagation in Quarkus

Traditional blocking code uses ThreadLocal variables to store contextual objects in order to avoid passing them as parameters everywhere. Many Quarkus extensions require those contextual objects to operate properly: RESTEasy, ArC and Transaction for example.

If you write reactive/async code, you have to cut your work into a pipeline of code blocks that get executed "later", and in practice after the method you defined them in have returned. As such, try/finally blocks as well as ThreadLocal variables stop working, because your reactive code gets executed in another thread, after the caller ran its finally block.

MicroProfile Context Propagation was made to make those Quarkus extensions work properly in reactive/async settings. It works by capturing those contextual values that used to be in thread-locals, and restoring them when your code is called.

Setting it up

If you are using Mutiny (the quarkus-mutiny extension), you just need to add the the quarkus-smallrye-context-propagation extension to enable context propagation.

In other words, add the following dependencies to your pom.xml:

    <!-- Mutiny and RestEasy support extensions if not already included -->
    <!-- Context Propagation extension -->

With this, you will get context propagation for ArC, RESTEasy and transactions, if you are using them.

Usage example with Mutiny


This section uses Mutiny reactive types, if you’re not familiar with them, read the Getting Started with Reactive guide first.

Let’s write a REST endpoint that reads the next 3 items from a Kafka topic, stores them in a database using Hibernate ORM with Panache (all in the same transaction) before returning them to the client, you can do it like this:

    // Get the prices stream
    @Channel("prices") Publisher<Double> prices;

    public Publisher<Double> prices() {
        // get the next three prices from the price stream
        return Multi.createFrom().publisher(prices)
                .map(price -> {
                    // store each price before we send them
                    Price priceEntity = new Price();
                    priceEntity.value = price;
                    // here we are all in the same transaction
                    // thanks to context propagation
                    return price;
                    // the transaction is committed once the stream completes

Notice that thanks to Mutiny support for context propagation, this works out of the box. The 3 items are persisted using the same transaction and this transaction is committed when the stream completes.

Usage example for CompletionStage

If you are using CompletionStage you need manual context propagation. You can do that by injecting a ThreadContext or ManagedExecutor that will propagate every context. For example, here we use the Vert.x Web Client to get the list of Star Wars people, then store them in the database using Hibernate ORM with Panache (all in the same transaction) before returning them to the client as JSON using JSON-B or Jackson:

    @Inject ThreadContext threadContext;
    @Inject ManagedExecutor managedExecutor;
    @Inject Vertx vertx;

    public CompletionStage<List<Person>> people() throws SystemException {
        // Create a REST client to the Star Wars API
        WebClient client = WebClient.create(vertx,
                         new WebClientOptions()
        // get the list of Star Wars people, with context capture
        return threadContext.withContextCapture(client.get("/api/people/").send())
                .thenApplyAsync(response -> {
                    JsonObject json = response.bodyAsJsonObject();
                    List<Person> persons = new ArrayList<>(json.getInteger("count"));
                    // Store them in the DB
                    // Note that we're still in the same transaction as the outer method
                    for (Object element : json.getJsonArray("results")) {
                        Person person = new Person();
               = ((JsonObject) element).getString("name");
                    return persons;
                }, managedExecutor);

Using ThreadContext or ManagedExecutor you can wrap most useful functional types and CompletionStage in order to get context propagated.

The injected ManagedExecutor uses the Quarkus thread pool.

Adding support for RxJava2

If you use Reactive Streams Operators (the quarkus-smallrye-reactive-streams-operators module), you get support for RxJava2 context propagation automatically, but if you don’t, you may want to include the following modules to get RxJava2 support:

    <!-- Automatic context propagation for RxJava2 -->
    Required if you want transactions extended to the end of methods returning
    an RxJava2 type.
    <!-- Required if you return RxJava2 types from your REST endpoints -->
</dependencies> 是基于 的非官方中文翻译站 ,最后更新 2020/04 。