Spring Boot REST APIの分散トレーシング - Micrometer Tracingでリクエストを追跡する

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// build.gradle
dependencies {
    // Spring Boot Actuator（必須）
    implementation 'org.springframework.boot:spring-boot-starter-actuator'
    
    // Micrometer Tracing Bridge for Brave
    implementation 'io.micrometer:micrometer-tracing-bridge-brave'
    
    // Zipkin Reporter for Brave
    implementation 'io.zipkin.reporter2:zipkin-reporter-brave'
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# application.yml
spring:
  application:
    name: user-service  # サービス名（Zipkinで表示される）

management:
  tracing:
    sampling:
      probability: 1.0  # サンプリング率（1.0 = 100%、本番では0.1程度を推奨）
    export:
      zipkin:
        endpoint: http://localhost:9411/api/v2/spans  # Zipkinのエンドポイント

1
2

# Zipkinサーバーの起動
docker run -d -p 9411:9411 --name zipkin openzipkin/zipkin

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

package com.example.demo.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/users")
public class UserController {

    private static final Logger logger = LoggerFactory.getLogger(UserController.class);

    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        logger.info("Getting user with id: {}", id);
        
        // 処理をシミュレート
        simulateProcessing();
        
        return new User(id, "John Doe", "john@example.com");
    }

    private void simulateProcessing() {
        try {
            Thread.sleep(100);  // 100msの処理時間をシミュレート
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

1
2
3
4

package com.example.demo.controller;

public record User(Long id, String name, String email) {
}

1

curl http://localhost:8080/api/users/1

1
2
3
4
5
6
7
8

# application.yml
logging:
  pattern:
    correlation: "[${spring.application.name:},%X{traceId:-},%X{spanId:-}] "
  include-application-name: false
  level:
    root: INFO
    com.example.demo: DEBUG

1

[user-service,803B448A0489F84084905D3093480352,3425F23BB2432450] INFO  c.e.demo.controller.UserController - Getting user with id: 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

<!-- src/main/resources/logback-spring.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <include resource="org/springframework/boot/logging/logback/defaults.xml"/>
    
    <springProperty scope="context" name="appName" source="spring.application.name"/>
    
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>
                %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] [${appName},%X{traceId:-},%X{spanId:-}] %-5level %logger{36} - %msg%n
            </pattern>
        </encoder>
    </appender>
    
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
    </root>
</configuration>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestClient;

@Configuration
public class RestClientConfig {

    @Bean
    public RestClient restClient(RestClient.Builder builder) {
        // 自動構成されたBuilderを使用することが重要
        return builder
                .baseUrl("http://localhost:8081")
                .build();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

package com.example.demo.service;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestClient;

@Service
public class OrderService {

    private static final Logger logger = LoggerFactory.getLogger(OrderService.class);
    private final RestClient restClient;

    public OrderService(RestClient restClient) {
        this.restClient = restClient;
    }

    public Order getOrderWithUserDetails(Long orderId) {
        logger.info("Fetching order with id: {}", orderId);
        
        // 外部サービス（User Service）を呼び出し
        // Trace IDが自動的にHTTPヘッダーに追加される
        User user = restClient.get()
                .uri("/api/users/{id}", 1L)
                .retrieve()
                .body(User.class);
        
        logger.info("Retrieved user: {}", user.name());
        
        return new Order(orderId, user, "COMPLETED");
    }
}

1
2
3
4
5
6
7

package com.example.demo.service;

public record Order(Long id, User user, String status) {
}

public record User(Long id, String name, String email) {
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

package com.example.demo.service;

import io.micrometer.observation.Observation;
import io.micrometer.observation.ObservationRegistry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

@Service
public class PaymentService {

    private static final Logger logger = LoggerFactory.getLogger(PaymentService.class);
    private final ObservationRegistry observationRegistry;

    public PaymentService(ObservationRegistry observationRegistry) {
        this.observationRegistry = observationRegistry;
    }

    public PaymentResult processPayment(Long orderId, Double amount) {
        // カスタムObservation（Span）の作成
        return Observation.createNotStarted("payment.process", observationRegistry)
                .lowCardinalityKeyValue("orderId", orderId.toString())
                .lowCardinalityKeyValue("paymentMethod", "CREDIT_CARD")
                .observe(() -> {
                    logger.info("Processing payment for order: {}", orderId);
                    
                    // 決済処理
                    validatePayment(amount);
                    executePayment(orderId, amount);
                    
                    return new PaymentResult(orderId, "SUCCESS", amount);
                });
    }

    private void validatePayment(Double amount) {
        Observation.createNotStarted("payment.validate", observationRegistry)
                .observe(() -> {
                    logger.info("Validating payment amount: {}", amount);
                    // バリデーション処理
                });
    }

    private void executePayment(Long orderId, Double amount) {
        Observation.createNotStarted("payment.execute", observationRegistry)
                .observe(() -> {
                    logger.info("Executing payment for order: {}", orderId);
                    // 決済実行処理
                    try {
                        Thread.sleep(200);  // 処理時間をシミュレート
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                });
    }
}

1
2
3
4

package com.example.demo.service;

public record PaymentResult(Long orderId, String status, Double amount) {
}

1
2
3
4
5

# application-prod.yml
management:
  tracing:
    sampling:
      probability: 0.1  # 10%のリクエストのみトレース

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

package com.example.demo.config;

import brave.sampler.Sampler;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;

@Configuration
public class TracingConfig {

    @Bean
    @Profile("prod")
    public Sampler productionSampler() {
        // 本番環境では10%のリクエストをサンプリング
        return Sampler.create(0.1f);
    }

    @Bean
    @Profile("!prod")
    public Sampler developmentSampler() {
        // 開発環境ではすべてのリクエストをトレース
        return Sampler.ALWAYS_SAMPLE;
    }
}

1
2
3
4
5
6
7
8
9

# application.yml
management:
  tracing:
    baggage:
      remote-fields:
        - x-request-id  # 伝播するカスタムヘッダー
      correlation:
        fields:
          - x-request-id  # MDCに追加するフィールド

1
2
3
4
5
6
7
8
9

# application.yml
management:
  endpoints:
    web:
      exposure:
        include: health,info,prometheus
  health:
    defaults:
      enabled: true

1
2
3
4
5
6

# application.yml
logging:
  level:
    io.micrometer.tracing: DEBUG
    brave: DEBUG
    zipkin2: DEBUG