Table of Contents

Microservices distributed tracing with Zipkin and Micronaut

Use Zipkin distributed tracing to investigate the behaviour of your Micronaut apps.

Authors: Sergio del Amo

Micronaut Version: 2.5.0

1. Getting Started

In this guide, we are going to integrate Zipkin in a Micronaut app composed of three microservices.

Zipkin is a distributed tracing system. It helps gather timing data needed to troubleshoot latency problems in microservice architectures. It manages both the collection and lookup of this data.

You will discover how Micronaut eases Zipkin integration.

2. What you will need

To complete this guide, you will need the following:

  • Some time on your hands

  • A decent text editor or IDE

  • JDK 1.8 or greater installed with JAVA_HOME configured appropriately

3. Solution

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

4. Writing the app

To learn more about this sample app read Consul and Micronaut - Microservices service discovery guide. The application contains three microservices.

  • bookcatalogue - It returns a list of books. It uses a domain consisting of a book name and isbn.

  • bookinventory - It exposes an endpoint to check whether a book has sufficient stock to fulfil an order. It uses a domain consisting of a stock level and isbn.

  • bookrecommendation - It consumes previous services and exposes and endpoint which recommends book names which are in stock.

The bookcatalogue service consumes endpoints exposed by the other services. The following image illustrates the application flow:

flow

A request to bookrecommendation (http://localhost:8080/books) triggers several requests through our microservices mesh.

If you are using Java or Kotlin and IntelliJ IDEA, make sure you have enabled annotation processing.

annotationprocessorsintellij

5. Zipkin and Micronaut

5.1. Install Zipkin via Docker

The quickest way to start Zipkin is via Docker:

$ docker run -d -p 9411:9411 openzipkin/zipkin

5.2. Book catalogue

Add tracing dependency.

build.gradle
implementation("io.micronaut:micronaut-tracing")

Also, to send tracing spans to Zipkin the minimal configuration requires you add the following dependencies:

build.gradle
implementation("io.opentracing.brave:micronaut-tracing")
runtimeOnly("io.zipkin.brave:brave-instrumentation-http")
runtimeOnly("io.zipkin.reporter:zipkin-reporter")

Append to bookcatalogue service application.yml the following snippet:

bookcatalogue/src/main/resources/application.yml
tracing:
  zipkin:
    http:
      url: http://localhost:9411
    enabled: true
    sampler:
      probability: 1 (1)
1 Trace 100% of requests.

In production, you will probably want to trace a smaller percentage of the requests. However, in order to keep this tutorial easy, we set it to trace 100%.

Disable distributed tracing in tests:

bookcatalogue/src/test/resources/application-test.yml
tracing:
  zipkin:
    enabled: false

5.3. Book inventory

Add tracing dependency.

build.gradle
implementation("io.micronaut:micronaut-tracing")

Also, to send tracing spans to Zipkin the minimal configuration requires you add the following dependencies:

build.gradle
implementation("io.opentracing.brave:micronaut-tracing")
runtimeOnly("io.zipkin.brave:brave-instrumentation-http")
runtimeOnly("io.zipkin.reporter:zipkin-reporter")

Append to bookinventory service application.yml the following snippet:

bookinventory/src/main/resources/application.yml
tracing:
  zipkin:
    http:
      url: http://localhost:9411
    enabled: true
    sampler:
      probability: 1 (1)
1 Trace 100% of requests.

In production, you will probably want to trace a smaller percentage of the requests. However, in order to keep this tutorial easy, we set it to trace 100%.

Disable distributed tracing in tests:

bookinventory/src/test/resources/application-test.yml
tracing:
  zipkin:
    enabled: false

Annotate BookController method with @ContinueSpan and the method parameter with @SpanTag:

bookinventory/src/main/kotlin/example/micronaut/BooksController.kt
package example.micronaut

import io.micronaut.http.MediaType
import io.micronaut.http.annotation.Controller
import io.micronaut.http.annotation.Get
import io.micronaut.http.annotation.Produces
import io.micronaut.tracing.annotation.ContinueSpan
import io.micronaut.tracing.annotation.SpanTag
import java.util.Optional
import javax.validation.constraints.NotBlank

@Controller("/books")
open class BooksController {

    @Produces(MediaType.TEXT_PLAIN)
    @Get("/stock/{isbn}")
    @ContinueSpan (1)
    open fun stock(@SpanTag("stock.isbn") @NotBlank isbn: String): Boolean? {  (2)
        return bookInventoryByIsbn(isbn).map { (_, stock) -> stock > 0 }.orElse(null)
    }

    private fun bookInventoryByIsbn(isbn: String): Optional<BookInventory> {
        if (isbn == "1491950358") {
            return Optional.of(BookInventory(isbn, 4))

        } else if (isbn == "1680502395") {
            return Optional.of(BookInventory(isbn, 0))
        }
        return Optional.empty()
    }
}
1 The @ContinueSpan annotation will continue an existing span, wrapping the method call or reactive type.
2 The @SpanTag annotation can be used on method arguments to include the value of each argument within a Span’s tags. When you use @SpanTag you need either to annotate the method with @NewSpan or @ContinueSpan

5.4. Book recommendation

Add tracing dependency.

build.gradle
implementation("io.micronaut:micronaut-tracing")

Also, to send tracing spans to Zipkin the minimal configuration requires you add the following dependencies:

build.gradle
implementation("io.opentracing.brave:micronaut-tracing")
runtimeOnly("io.zipkin.brave:brave-instrumentation-http")
runtimeOnly("io.zipkin.reporter:zipkin-reporter")

Append to bookrecommendation service application.yml the following snippet:

bookrecommendation/src/main/resources/application.yml
tracing:
  zipkin:
    http:
      url: http://localhost:9411
    enabled: true
    sampler:
      probability: 1 (1)
1 Trace 100% of requests.

In production, you will probably want to trace a smaller percentage of the requests. However, in order to keep this tutorial easy, we set it to trace 100%.

Disable distributed tracing in tests:

bookrecommendation/src/test/resources/application-test.yml
tracing:
  zipkin:
    enabled: false

6. Running the app

Run bookcatalogue microservice:

To run the application execute ./gradlew run.

...
14:28:34.034 [main] INFO  io.micronaut.runtime.Micronaut - Startup completed in 499ms. Server Running: http://localhost:8081

Run bookinventory microservice:

To run the application execute ./gradlew run.

...
14:31:13.104 [main] INFO  io.micronaut.runtime.Micronaut - Startup completed in 506ms. Server Running: http://localhost:8082

Run bookrecommendation microservice:

To run the application execute ./gradlew run.

...
14:31:57.389 [main] INFO  io.micronaut.runtime.Micronaut - Startup completed in 523ms. Server Running: http://localhost:8080

You can run a cURL command to test the whole application:

$ curl http://localhost:8080/books
[{"name":"Building Microservices"}

You can then navigate to http://localhost:9411 t to access the Zipkin UI.

The previous request generates a trace composed by 5 spans.

zipkinui

In the previous image, you can see the requests to bookinventory are done in parallel.

You can see the details if you click the span:

zipkinclientserver

In the previous image, you can see that:

  • Whenever a Micronaut HTTP client executes a new network request, a span is involved.

  • Whenever a Micronaut Server receives a request, a span is involved.

The stock.isbn tags that we configured with @SpanTag is present as shown in the next image:

zipkintag

7. Generate a Micronaut app’s Native Image with GraalVM

We are going to use GraalVM, the polyglot embeddable virtual machine, to generate a Native image of our Micronaut application.

Native images compiled with GraalVM ahead-of-time improve the startup time and reduce the memory footprint of JVM-based applications.

Use of GraalVM’s native-image tool is only supported in Java or Kotlin projects. Groovy relies heavily on reflection which is only partially supported by GraalVM.

7.1. Native Image generation

The easiest way to install GraalVM is to use SDKMan.io.

# For Java 8
$ sdk install java 21.1.0.r8-grl

# For Java 11
$ sdk install java 21.1.0.r11-grl

You need to install the native-image component which is not installed by default.

$ gu install native-image

To generate a native image using Gradle run:

$ ./gradlew nativeImage

The native image will be created in build/native-image/application and can be run with ./build/native-image/application

It is also possible to customize the name of the native image or pass additional parameters to GraalVM:

build.gradle
nativeImage {
    args('--verbose')
    imageName('mn-graalvm-application') (1)
}
1 The native image name will now be mn-graalvm-application

Start the native images for the three microservices and run the same curl request as before to check that everything works with GraalVM.

8. Next steps

As you have seen in this tutorial, without any annotations you get distributing tracing up-and-running fast with Micronaut.

Micronaut includes several annotations to give you more flexibility. We introduced the @ContinueSpan, @SpanTag annotations. Also, you have at your disposal the @NewSpan annotation which will create a new span, wrapping the method call or reactive type.

Make sure to read more about Tracing with Zipkin inside Micronaut.

9. Help with Micronaut

Object Computing, Inc. (OCI) sponsored the creation of this Guide. A variety of consulting and support services are available.

Meet the Team.