Distributed Tracing with Micrometer and OpenTelemetry

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-opentelemetry</artifactId>
</dependency>

spring.application.name=order-service
server.port=8080
catalog.url=http://localhost:8081

# trace every request (the default is 0.1 - one request in ten)
management.tracing.sampling.probability=1.0
# for this demonstration: hand finished spans to the exporter every second (default 5s)
management.opentelemetry.tracing.export.schedule-delay=1s
logging.level.com.javabrahman=INFO

spring.application.name=catalog-service
server.port=8081

management.tracing.sampling.probability=1.0
management.opentelemetry.tracing.export.schedule-delay=1s
logging.level.com.javabrahman=INFO

//CatalogApp.java
package com.javabrahman.cloud.tracing.catalog;

import com.javabrahman.cloud.tracing.shared.ConsoleSpanExporter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Import;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@Import(ConsoleSpanExporter.class)
@RestController
public class CatalogApp {

  private static final Logger log = LoggerFactory.getLogger(CatalogApp.class);

  record Book(String isbn, String title, int price) {}

  @GetMapping("/books/{isbn}")
  Book book(@PathVariable String isbn, @RequestHeader("traceparent") String traceparent) {
    log.info("Looking up book {} - traceparent header: {}", isbn, traceparent);
    return new Book(isbn, "Effective Java", 450);
  }

  public static void main(String[] args) {
    SpringApplication.run(CatalogApp.class, args);
  }
}

//OrderApp.java
package com.javabrahman.cloud.tracing.order;

import com.javabrahman.cloud.tracing.shared.ConsoleSpanExporter;
import io.micrometer.observation.Observation;
import io.micrometer.observation.ObservationRegistry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Import;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestClient;

@SpringBootApplication
@Import(ConsoleSpanExporter.class)
@RestController
public class OrderApp {

  private static final Logger log = LoggerFactory.getLogger(OrderApp.class);

  record OrderRequest(String isbn, int quantity) {}
  record Book(String isbn, String title, int price) {}
  record Order(String title, int quantity, int total) {}

  private final RestClient catalog;
  private final ObservationRegistry observations;

  OrderApp(RestClient.Builder builder, @Value("${catalog.url}") String catalogUrl, ObservationRegistry observations) {
    this.catalog = builder.baseUrl(catalogUrl).build();
    this.observations = observations;
  }

  @PostMapping("/orders")
  Order place(@RequestBody OrderRequest request) {
    log.info("Placing an order for {} x {}", request.quantity(), request.isbn());
    Book book = catalog.get().uri("/books/{isbn}", request.isbn()).retrieve().body(Book.class);

    // a span of our own around a piece of business logic
    int total = Observation.createNotStarted("order.pricing", observations)
        .lowCardinalityKeyValue("currency", "INR")
        .observe(() -> priceWithDiscount(book.price(), request.quantity()));

    log.info("Order total is {}", total);
    return new Order(book.title(), request.quantity(), total);
  }

  private int priceWithDiscount(int price, int quantity) {
    log.info("Pricing {} copies", quantity);
    int total = price * quantity;
    return quantity >= 3 ? total * 90 / 100 : total;
  }

  public static void main(String[] args) {
    SpringApplication.run(OrderApp.class, args);
  }
}

//ConsoleSpanExporter.java
package com.javabrahman.cloud.tracing.shared;

import io.opentelemetry.sdk.common.CompletableResultCode;
import io.opentelemetry.sdk.trace.data.SpanData;
import io.opentelemetry.sdk.trace.export.SpanExporter;
import java.util.Collection;
import org.springframework.stereotype.Component;

@Component
public class ConsoleSpanExporter implements SpanExporter {

  @Override
  public CompletableResultCode export(Collection<SpanData> spans) {
    for (SpanData span : spans) {
      String parent = span.getParentSpanContext().isValid() ? span.getParentSpanId() : "none";
      long micros = (span.getEndEpochNanos() - span.getStartEpochNanos()) / 1_000;
      System.out.printf("SPAN %-8s %-22s trace=%s span=%s parent=%s %d us%n",
          span.getKind(), span.getName(), span.getTraceId(), span.getSpanId(), parent, micros);
    }
    return CompletableResultCode.ofSuccess();
  }

  @Override
  public CompletableResultCode flush() {
    return CompletableResultCode.ofSuccess();
  }

  @Override
  public CompletableResultCode shutdown() {
    return CompletableResultCode.ofSuccess();
  }
}

management.opentelemetry.tracing.export.otlp.endpoint=http://localhost:4318/v1/traces
management.tracing.sampling.probability=0.1