Interview question

What is Distributed Tracing and how do you implement it with Spring Cloud Sleuth? Distributed Tracing क्या है और Spring Cloud Sleuth से कैसे implement करते हैं?

Answer

Distributed tracing tracks requests across microservices using trace IDs and span IDs. Spring Cloud Sleuth integrates with Zipkin/Jaeger for visualization. Essential for debugging in microservices architecture.

// Maven Dependency
<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>

// application.yml
spring:
  application:
    name: order-service
  sleuth:
    enabled: true
    sampler:
      probability: 1.0  # 100% sampling (use 0.1 in prod)
  zipkin:
    base-url: http://zipkin:9411

// Automatic Tracing (no code changes needed)
@RestController
@RequestMapping('/api/orders')
public class OrderController {
    // Spring Sleuth automatically adds trace IDs
    // Logs show: [order-service,abc123,def456,true]
    // trace-id=abc123, span-id=def456
    
    @GetMapping('/{id}')
    public ResponseEntity<Order> getOrder(@PathVariable String id) {
        // Sleuth automatically tracks this
        return ResponseEntity.ok(orderService.getOrder(id));
    }
}

// Manual Span Creation
@Service
public class OrderService {
    @Autowired
    private Tracer tracer;
    
    public Order processOrder(String orderId) {
        // Create custom span
        Span span = tracer.nextSpan().name('processOrder').start();
        try (Tracer.SpanInScope ws = tracer.withSpan(span)) {
            // Business logic
            return new Order();
        } finally {
            span.end();
        }
    }
}

// Cross-Service Tracing (RestTemplate, WebClient)
@Configuration
public class RestTemplateConfiguration {
    @Bean
    public RestTemplate restTemplate(
            RestTemplateBuilder builder,
            ClientHttpRequestFactory factory) {
        // Sleuth automatically injects trace headers
        return builder
            .requestFactory(factory)
            .build();
    }
}

// Docker Compose - Zipkin Setup
version: '3.8'
services:
  order-service:
    image: app:latest
    ports:
      - '8080:8080'
    environment:
      SPRING_ZIPKIN_BASE_URL: http://zipkin:9411
  
  payment-service:
    image: app:latest
    ports:
      - '8081:8081'
    environment:
      SPRING_ZIPKIN_BASE_URL: http://zipkin:9411
  
  zipkin:
    image: openzipkin/zipkin:latest
    ports:
      - '9411:9411'

// Trace Flow Visualization in Zipkin:
// 1. User request hits Order Service
// 2. Order Service calls Payment Service
// 3. Payment Service calls Database
// 4. All steps tracked with same trace-id
// 5. Zipkin shows timeline and latency

// Key Concepts:
// Trace ID - unique request identifier
// Span ID - individual operation
// Parent Span ID - call hierarchy
// Timestamp - when operation started
// Duration - how long it took

Distributed Tracing:

Problem: Microservices में request tracking मुश्किल

Solution: Sleuth + Zipkin

How it works:
1. Request में trace-id add करता है
2. सभी services same trace-id use करते हैं
3. Zipkin में visualize होता है

Configuration:
spring.sleuth.enabled: true
spring.zipkin.base-url: http://zipkin:9411

Log Format:
[service-name, trace-id, span-id, sampled]
[order-service, abc123, def456, true]

Manual Span:
Span span = tracer.nextSpan().name('op').start();

Benefit:
- Request flow देख सकते हैं
- Latency identify कर सकते हैं
- Bottlenecks find कर सकते हैं
- Debugging आसान हो जाती है

Was this answer clear?

Subjects

Related questions