Quarkus SmallRye OpenTracing

This guide explains how your Quarkus application can utilize OpenTracing to provide distributed tracing for interactive web applications.

OpenTelemetry is the recommended approach to tracing and telemetry for Quarkus.

The SmallRye OpenTracing support is discontinued and this extension is not actively maintained. If you are interested in maintaining this extension, please reach out to us in the GitHub issues of this extension.


To complete this guide, you need:

  • Roughly 15 minutes

  • An IDE

  • JDK 11+ installed with JAVA_HOME configured appropriately

  • Apache Maven 3.9.5

  • A working container runtime (Docker or Podman)

  • The Quarkus CLI

  • Optionally Mandrel or GraalVM installed and configured appropriately if you want to build a native executable (or Docker if you use a native container build)


In this guide, we create a straightforward REST application to demonstrate distributed tracing.


We recommend that you follow the instructions in the next sections and create the application step by step. However, you can skip right to the completed example.

The completed example is located in the quickstart directory.

Creating the Maven project

First, we need a new project. Create a new project with the following command:

quarkus create app org.acme:opentracing-quickstart \
    --extension='resteasy-reactive,quarkus-smallrye-opentracing' \
cd opentracing-quickstart

This command generates the Maven project and imports the smallrye-opentracing extension, which includes the OpenTracing support and the default Jaeger tracer.

If you already have your Quarkus project configured, you can add the smallrye-opentracing extension to your project by running the following command in your project base directory:

quarkus extension add smallrye-opentracing

This will add the following to your build file:


Examine the Jakarta REST resource

Create the src/main/java/org/acme/opentracing/TracedResource.java file with the following content:

package org.acme.opentracing;

import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;
import org.jboss.logging.Logger;

public class TracedResource {

    private static final Logger LOG = Logger.getLogger(TracedResource.class);

    public String hello() {
        LOG.info("hello"); (1)
        return "hello";
1 The log event carries OpenTracing information as well. In order to print OpenTracing information to the console output, the console log handler with the required OpenTracing event’s keys needs to be defined in the application.properties file.

Notice that there is no tracing specific code included in the application. By default, requests sent to this endpoint will be traced without any code changes being required. It is also possible to enhance the tracing information. This can be achieved by SmallRye OpenTracing an implementation of MicroProfile OpenTracing.

Create the configuration

There are two ways to configure the Jaeger tracer within the application.

The first approach is by providing the properties within the src/main/resources/application.properties file:

quarkus.jaeger.service-name=myservice (1)
quarkus.jaeger.sampler-type=const (2)
quarkus.jaeger.sampler-param=1 (3)
quarkus.log.console.format=%d{HH:mm:ss} %-5p traceId=%X{traceId}, parentId=%X{parentId}, spanId=%X{spanId}, sampled=%X{sampled} [%c{2.}] (%t) %s%e%n (4)
1 If the quarkus.jaeger.service-name property (or JAEGER_SERVICE_NAME environment variable) is not provided then a "no-op" tracer will be configured, resulting in no tracing data being reported to the backend.
2 Set up a sampler that uses a constant sampling strategy.
3 Sample all requests. Set sampler-param to somewhere between 0 and 1, e.g. 0.50, if you do not wish to sample all requests.
4 Add trace IDs into log message.

The second approach is to supply the properties as environment variables. These can be specified using jvm.args as shown in the following section.

Run the application

The first step is to start the tracing system to collect and display the captured traces:

docker run -p 5775:5775/udp -p 6831:6831/udp -p 6832:6832/udp -p 5778:5778 -p 16686:16686 -p 14268:14268 jaegertracing/all-in-one:latest

Now we are ready to run our application. If using application.properties to configure the tracer:

quarkus dev

or if configuring the tracer via environment variables:


Once both the application and tracing system are started, you can make a request to the provided endpoint:

$ curl http://localhost:8080/hello

When the first request has been submitted, the Jaeger tracer within the app will be initialized:

2019-10-16 09:35:23,464 INFO  [io.jae.Configuration] (executor-thread-1) Initialized tracer=JaegerTracer(version=Java-0.34.0, serviceName=myservice, reporter=RemoteReporter(sender=UdpSender(), closeEnqueueTimeout=1000), sampler=ConstSampler(decision=true, tags={sampler.type=const, sampler.param=true}), tags={hostname=localhost.localdomain, jaeger.version=Java-0.34.0, ip=}, zipkinSharedRpcSpan=false, expandExceptionLogs=false, useTraceId128Bit=false)
13:20:11 INFO  traceId=1336b2b0a76a96a3, parentId=0, spanId=1336b2b0a76a96a3, sampled=true [or.ac.qu.TracedResource] (executor-thread-63) hello

Then visit the Jaeger UI to see the tracing information.

Hit CTRL+C to stop the application.

Tracing additional methods

REST endpoints are automatically traced. If you need to trace additional methods, you can add the org.eclipse.microprofile.opentracing.Traced annotation to CDI bean classes or their non-private methods.

This can be useful to trace incoming requests from non-REST calls (like request coming from a message) or to create spans inside a trace.

Here is an example of a FrancophoneService which methods are traced.

import jakarta.enterprise.context.ApplicationScoped;

import org.eclipse.microprofile.opentracing.Traced;

public class FrancophoneService {

    public String bonjour() {
        return "bonjour";
The best way to add OpenTracing capability to reactive messaging based applications is by adding the Traced annotation to all incoming methods.

Additional instrumentation

The OpenTracing API Contributions project offers additional instrumentation that can be used to add tracing to a large variety of technologies/components.

The instrumentation documented in this section has been tested with Quarkus and works in both standard and native mode.


The JDBC instrumentation will add a span for each JDBC queries done by your application, to enable it, add the following dependency to your build file:


Then, you need to enable it in the configuration:


quarkus.datasource.jdbc.tracing is a build time configuration property: it makes sure all the tracing infrastructure is included in your application.

This is especially important when building a native executable as we need to make sure the OpenTracing JDBC driver has been registered for reflection, together with the underlying JDBC driver.

The Agroal extension will take care of adjusting the JDBC URL with the tracing prefix when tracing is enabled, so you do not have to adjust the JDBC URL yourself.

By default, when quarkus.datasource.jdbc.tracing is true, tracing is enabled at runtime but you can explicitly disable it by setting the following property:


This way, you can have your Quarkus application ready for tracing and toggle JDBC tracing at runtime.


The Kafka instrumentation will add a span for each message sent to or received from a Kafka topic. To enable it, add the following dependency to your build file:


It contains OpenTracing interceptors that must be registered on Kafka producers and consumers.

If you followed the Kafka guide, the interceptors can be added on the generated-price and the prices channels as follows:

# Configure the Kafka sink (we write to it)

# Configure the Kafka source (we read from it)
interceptor.classes accept a list of classes separated by a comma.

MongoDB client

The Mongo Driver instrumentation will add a span for each command executed by your application. To enable it, add the following dependency to your build file:


It contains the OpenTracing CommandListener that will be registered on the configuration of the mongo client. Following the MongoDB guide, the command listener will be registered defining the config property as follows:

# Enable tracing commands in MongoDB client

Zipkin compatibility mode

To enable it, add the following dependency to your build file:


It contains the dependencies to convert the request to zipkin format. The zipkin compatibility mode will be activated after defining the config property as follows:

# Enable zipkin compatibility mode

Configuration Reference

Configuration property fixed at build time - All other configuration properties are overridable at runtime

Configuration property






http-path, class-method


Jaeger Configuration Reference

For more information about the Jaeger extension configuration, have a look at the Jaeger extension documentation.