Introduction
As microservices architecture grows in complexity, managing, debugging, and monitoring service interactions can become quite challenging. One of the most effective tools for understanding and troubleshooting such distributed systems is Distributed Tracing. It enables tracking of requests as they flow through multiple services in a microservices architecture, helping you to monitor the performance of individual services and pinpoint where bottlenecks or failures occur.
In this blog, we’ll explain the concept of distributed tracing and demonstrate its implementation using a demo microservices architecture for an online learning platform. The platform consists of microservices such as eureka-server (discovery service), api-gateway, user-service, course-service, and admin-service. We’ll also use Zipkin, a popular distributed tracing system, to trace requests across these services.
What is Distributed Tracing
Distributed tracing is a technique to trace the flow of a request through multiple microservices in a distributed architecture. It helps to:
- Visualize request flow across services.
- Identify bottlenecks and performance issues.
- Diagnose errors and failures more effectively.
- Provide insights into inter-service communication latencies.
Key components in distributed tracing:
- Trace : Represents the entire journey of a request across different microservices.
- Span : A single operation within the trace, often representing one service’s processing.
- Parent/Child Spans : Relationships between operations, showing which services called others.
Here in demo, A request to fetch students-course details our system travels through multiple services:
- API Gateway : Acts as the entry point for the request.
- User Service : Retrieves user details.
- Course Service : Fetches the courses related to the user.
By enabling distributed tracing, we can track this request as it moves through these services, measure the time spent in each service, and diagnose any issues along the way.
Tracing will automatically be enabled across the microservices. Spring Cloud Sleuth will add a trace ID and span ID to each request, which will be logged and passed across service boundaries.
Key Benefits of Distributed Tracing
- Improved Observability : Visualize the complete path of requests, making debugging easier.
- Error Detection : Easily identify which service is causing performance issues or errors.
- Performance Optimization : Pinpoint bottlenecks and reduce latency across microservices.
Prerequisites
- Java 17 : Our microservices are built using Spring Boot, which runs on Java 17.
- Maven : Maven is required for building Spring Boot projects.
- Spring Boot Development Environment (here IntelliJ IDEA).
- Zipkin : For tracing requests.
Setting Up Spring Boot Application
Create Microservices that you need for your application. I’m going to implemented a dummy project for an online learning platform, which includes services like eureka-server (discovery service), api-gateway, user-service, course-service, and admin-service.
Step 1 : Configuring Spring Boot for Distributed Tracing
Spring Boot offers support for distributed tracing through Spring Cloud Sleuth, which automatically instruments your application to generate trace and span IDs for each request. By default, Sleuth sends these tracing data to Zipkin.
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>
Add the dependencies for Sleuth and Zipkin in the pom.xml of each microservice:
Step 2 : Configure application properties
Configure application properties to enable Sleuth and Zipkin. In each service’s application.properties:
spring.zipkin.base-url=http://zipkin:9411
spring.sleuth.sampler.probability=1.0
- spring.zipkin.base-url : Defines the URL of the Zipkin server.
- spring.sleuth.sampler.probability : Set to 1.0 to trace 100% of requests (for testing purposes)
With this setup, each request that goes through the microservices will automatically generate trace data and send it to Zipkin.
Step 3 : Setting up Zipkin in Docker(If use docker)
Zipkin is a popular tool used for distributed tracing. We’ll run Zipkin in a Docker container.
Add Zipkin to your docker-compose.yml:
services:
# Other microservices definitions
zipkin:
image: openzipkin/zipkin
container_name: zipkin
ports:
- "9411:9411"
networks:
- microservices-network
The zipkin service will be available at http://localhost:9411 after running Docker Compose.
Step 4 : Running the Microservices and Zipkin(If use docker)
Now that we have Zipkin and distributed tracing enabled, let’s run the entire setup:
docker-compose up --build
This command will:
- Build and start each microservice in a container.
- Start the Zipkin service.
- Register all microservices with Eureka and open their respective ports.
Step 5 : Testing Distributed Tracing
Once everything is up and running, you can trigger requests that flow through multiple services.
For example
- A client makes a request to the API Gateway at http://localhost:8080.
- The API Gateway forwards the request to the appropriate microservice.
- Each service processes the request and communicates with other services as needed.
- Sleuth traces the request and its journey through various services, and sends the trace data to Zipkin.
Step 6 : Viewing Traces in Zipkin
After running a few requests, open Zipkin’s web interface by visiting http://localhost:9411.
You’ll see a list of traces, showing how requests traveled across the services. By selecting a specific trace, you can view the detailed breakdown, including:
- Duration of each service’s response.
- Latency between services.
- Error details (if any) for failed requests.
You can also drill down into individual spans to see how long each operation took and identify performance bottlenecks or failure points.
Conclusion
Distributed tracing is an essential tool for gaining insight into the performance and health of a microservices architecture. By using Spring Cloud Sleuth and Zipkin, we can efficiently trace and monitor requests across various services in our microservices ecosystem.
In this guide, we demonstrated how to implement distributed tracing in a microservices-based online learning platform with Dockerized Spring Boot services. This setup enables seamless tracing and monitoring of requests across the eureka-server, API-gateway, user-service, course-service, and admin-service.
By leveraging distributed tracing, developers and operations teams can more easily debug, monitor, and improve the performance of their distributed systems.
