Spring Cloud Gateway 集成 SkyWalking 实现分布式追踪

SkyWalking 核心概念解析

在开始集成之前，我们需要了解 SkyWalking 的一些核心概念：

Trace（追踪）

Trace 表示一次完整的请求链路，从客户端发起请求到最终返回响应的全过程。每个 Trace 都有一个全局唯一的 Trace ID。

Span（跨度）

Span 是 Trace 中的基本单元，表示一个具体的操作或方法调用。每个 Span 包含操作名称、开始时间、持续时间、标签（Tags）等信息。

Segment（片段）

在 SkyWalking 中，Segment 是一个特殊概念，表示单个进程内的 Span 集合。当请求跨越多个服务时，每个服务都会生成自己的 Segment，这些 Segment 通过相同的 Trace ID 关联起来。

Context Propagation（上下文传播）

为了让分布式追踪正常工作，必须在服务调用过程中传递追踪上下文。SkyWalking 支持多种传播协议，包括：

• SW8 Header：SkyWalking 自定义的传播头
• W3C Trace Context：标准化的追踪上下文格式
• B3 Propagation：Zipkin 使用的传播格式

对于 Spring Cloud Gateway 这样的网关组件，正确配置上下文传播至关重要，因为它需要将接收到的追踪上下文传递给下游服务。

环境准备与依赖配置

在开始编码之前，我们需要准备好运行环境和相关依赖。

SkyWalking 后端服务部署

首先需要部署 SkyWalking OAP（Observability Analysis Platform）服务器和 UI 界面。可以通过 Docker 快速启动：

# 启动 SkyWalking OAP 服务器
docker run --name skywalking-oap -d -p11800:11800 -p12800:12800 apache/skywalking-oap-server:9.7.0

# 启动 SkyWalking UI
docker run --name skywalking-ui -d --link skywalking-oap:oap -p8080:8080 apache/skywalking-ui:9.7.0

启动完成后，可以通过浏览器访问 http://localhost:8080 查看 SkyWalking UI 界面。

Spring Cloud Gateway 项目依赖

创建一个新的 Spring Boot 项目，并添加必要的依赖。以下是 pom.xml 文件的关键部分：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.0</version>
        <relativePath/>
    </parent>
    <groupId>com.example</groupId>
    <artifactId>gateway-skywalking-demo</artifactId>
    <version>1.0.0</version>
    <properties>
        <java.version>11</java.version>
        <spring-cloud.version>2021.0.3</spring-cloud.version>
        <skywalking.version>9.7.0</skywalking.version>
    </properties>
    <dependencies>
        <!-- Spring Cloud Gateway -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>
        <!-- SkyWalking APM Agent Toolkit -->
        <dependency>
            <groupId>org.apache.skywalking</groupId>
            <artifactId>apm-toolkit-trace</artifactId>
            <version>${skywalking.version}</version>
        </dependency>
        <!-- 如果需要手动埋点，可以添加此依赖 -->
        <dependency>
            <groupId>org.apache.skywalking</groupId>
            <artifactId>apm-toolkit-logback-1.x</artifactId>
            <version>${skywalking.version}</version>
        </dependency>
        <!-- WebFlux 用于测试后端服务 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

SkyWalking Agent 配置

SkyWalking 提供了 Java Agent 方式进行自动探针，这是最简单且推荐的方式。下载对应版本的 SkyWalking Agent：

# 下载 SkyWalking Agent
wget https://archive.apache.org/dist/skywalking/9.7.0/apache-skywalking-apm-9.7.0.tar.gz
tar -xzf apache-skywalking-apm-9.7.0.tar.gz

解压后，在 agent/config/ 目录下找到 agent.config 文件，主要配置项包括：

# 服务名称，会在 SkyWalking UI 中显示
agent.service_name=${SW_AGENT_NAME:gateway-service}

# OAP 服务器地址
collector.backend_service=${SW_AGENT_COLLECTOR_BACKEND_SERVICES:localhost:11800}

# 日志级别
logging.level=${SW_LOGGING_LEVEL:INFO}

# 是否启用插件
plugin.springmvc.collect_http_params=false
plugin.springwebflux.collect_http_params=false

启动应用时需要指定 Agent 路径：

java -javaagent:/path/to/skywalking-agent/skywalking-agent.jar \
-Dskywalking.agent.service_name=gateway-service \
-jar gateway-skywalking-demo.jar

基础路由配置与自动追踪

现在让我们创建一个基础的 Spring Cloud Gateway 应用，并验证 SkyWalking 的自动追踪功能。

应用主类

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

路由配置

创建 application.yml 文件，配置基本的路由规则：

server:
  port: 8081
spring:
  application:
    name: gateway-service
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: http://localhost:8082
          predicates:
            - Path=/api/user/**
        - id: order-service
          uri: http://localhost:8083
          predicates:
            - Path=/api/order/**
      default-filters:
        - DedupeResponseHeader=Access-Control-Allow-Credentials Access-Control-Allow-Origin
logging:
  level:
    org.springframework.cloud.gateway: DEBUG

测试后端服务

为了验证追踪效果，我们需要创建简单的后端服务。这里以用户服务为例：

@RestController
@RequestMapping("/api/user")
public class UserController {
    @GetMapping("/{id}")
    public Mono<Map<String, Object>> getUser(@PathVariable String id) {
        Map<String, Object> user = new HashMap<>();
        user.put("id", id);
        user.put("name", "User " + id);
        user.put("email", "user" + id + "@example.com");
        return Mono.just(user);
    }

    @PostMapping
    public Mono<Map<String, Object>> createUser(@RequestBody Map<String, Object> user) {
        user.put("id", "new-user-id");
        return Mono.just(user);
    }
}

对应的 OrderService 类似：

@RestController
@RequestMapping("/api/order")
public class OrderController {
    @GetMapping("/{id}")
    public Mono<Map<String, Object>> getOrder(@PathVariable String id) {
        Map<String, Object> order = new HashMap<>();
        order.put("id", id);
        order.put("userId", "user-123");
        order.put("amount", 99.99);
        order.put("status", "PAID");
        return Mono.just(order);
    }
}

启动验证

按照以下顺序启动服务：

1. 启动 SkyWalking OAP 和 UI
2. 启动 User Service（端口 8082）
3. 启动 Order Service（端口 8083）
4. 启动 Gateway Service（端口 8081），使用 SkyWalking Agent

然后发送测试请求：

# 测试用户服务路由
curl http://localhost:8081/api/user/123

# 测试订单服务路由
curl http://localhost:8081/api/order/456

在 SkyWalking UI 中，你应该能够看到完整的调用链路，包含 Gateway Service → User Service 或 Gateway Service → Order Service 的调用关系。

HTTP Request -> Forward Request -> Response -> HTTP Response
Client       -> Gateway Service   -> User Service -> Client

自定义过滤器中的追踪增强

虽然 SkyWalking Agent 能够自动追踪大部分场景，但在某些情况下我们需要在自定义过滤器中添加额外的追踪信息。这有助于更好地理解网关内部的处理逻辑。

全局过滤器中的追踪

创建一个全局过滤器，在其中添加自定义的追踪标签：

@Component
@Order(-1)
public class TracingGlobalFilter implements GlobalFilter {
    private static final Logger logger = LoggerFactory.getLogger(TracingGlobalFilter.class);

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 获取当前的追踪上下文
        String traceId = TraceContext.traceId();
        String segmentId = TraceContext.segmentId();
        ServerHttpRequest request = exchange.getRequest();
        String path = request.getPath().pathWithinApplication().value();
        String method = request.getMethodValue();

        logger.info("Processing request: {} {}, TraceId: {}, SegmentId: {}", method, path, traceId, segmentId);

        // 添加自定义标签到当前 Span
        AbstractSpan span = SkywalkingContextManager.getSpan();
        if (span != null) {
            span.tag("gateway.route.path", path);
            span.tag("gateway.request.method", method);
            span.tag("gateway.client.ip", getClientIpAddress(request));
        }
        return chain.filter(exchange);
    }

    private String getClientIpAddress(ServerHttpRequest request) {
        HttpHeaders headers = request.getHeaders();
        String xForwardedFor = headers.getFirst("X-Forwarded-For");
        if (xForwardedFor != null && !xForwardedFor.isEmpty()) {
            return xForwardedFor.split(",")[0].trim();
        }
        return request.getRemoteAddress() != null ? request.getRemoteAddress().getAddress().getHostAddress() : "unknown";
    }
}

路由特定过滤器中的追踪

我们还可以为特定路由创建自定义过滤器：

@Component
public class AuthFilter implements GatewayFilter {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        String authHeader = request.getHeaders().getFirst("Authorization");
        AbstractSpan span = SkywalkingContextManager.getSpan();

        if (span != null) {
            span.tag("gateway.auth.header.present", String.valueOf(authHeader != null));
        }

        if (authHeader == null || !authHeader.startsWith("Bearer ")) {
            ServerHttpResponse response = exchange.getResponse();
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            response.getHeaders().add("WWW-Authenticate", "Bearer realm=\"api\"");
            return response.setComplete();
        }

        // 验证 token 的逻辑...
        String token = authHeader.substring(7);
        boolean valid = validateToken(token);

        if (span != null) {
            span.tag("gateway.auth.token.valid", String.valueOf(valid));
        }

        if (!valid) {
            ServerHttpResponse response = exchange.getResponse();
            response.setStatusCode(HttpStatus.FORBIDDEN);
            return response.setComplete();
        }
        return chain.filter(exchange);
    }

    private boolean validateToken(String token) {
        // 简化的 token 验证逻辑
        return token.length() > 10;
    }
}

然后在路由配置中使用这个过滤器：

spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: http://localhost:8082
          predicates:
            - Path=/api/user/**
          filters:
            - name: AuthFilter

异常处理中的追踪

在网关中处理异常时，我们也应该记录相关的追踪信息：

@RestControllerAdvice
public class GlobalExceptionHandler {
    private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);

    @ExceptionHandler(Exception.class)
    public ResponseEntity<Map<String, Object>> handleException(Exception ex, ServerWebExchange exchange) {
        String traceId = TraceContext.traceId();
        logger.error("Exception occurred, TraceId: {}", traceId, ex);

        AbstractSpan span = SkywalkingContextManager.getSpan();
        if (span != null) {
            span.log(Instant.now(), Map.of(
                "event", "error",
                "error.kind", ex.getClass().getSimpleName(),
                "message", ex.getMessage(),
                "stack", ExceptionUtils.getStackTrace(ex)
            ));
            span.errorOccurred();
        }

        Map<String, Object> errorResponse = new HashMap<>();
        errorResponse.put("timestamp", Instant.now().toString());
        errorResponse.put("traceId", traceId);
        errorResponse.put("error", ex.getMessage());
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(errorResponse);
    }
}

上下文传播的深入理解

在微服务架构中，正确的上下文传播是分布式追踪的关键。Spring Cloud Gateway 作为网关，必须确保接收到的追踪上下文能够正确传递给下游服务。

默认传播行为

SkyWalking Agent 默认会自动处理常见的 HTTP 客户端库的上下文传播，包括：

• WebClient（Spring WebFlux）
• RestTemplate（Spring MVC）
• Feign Client
• OkHttp
• Apache HttpClient

对于 Spring Cloud Gateway，它内部使用 WebClient 进行 HTTP 请求转发，因此 SkyWalking 能够自动注入和提取追踪头信息。

自定义传播头

在某些场景下，我们可能需要自定义传播头或者处理特殊的传播需求。可以通过实现 ContextCarrierCustomizer 接口：

@Component
public class CustomContextCarrierCustomizer implements ContextCarrierCustomizer {
    @Override
    public void customize(ContextCarrier carrier) {
        // 添加自定义的 baggage 信息
        carrier.baggageItems().put("tenant-id", getCurrentTenantId());
        carrier.baggageItems().put("user-role", getCurrentUserRole());
    }

    private String getCurrentTenantId() {
        // 从当前上下文中获取租户 ID
        return "default-tenant";
    }

    private String getCurrentUserRole() {
        // 从当前上下文中获取用户角色
        return "anonymous";
    }
}

跨协议传播

如果网关需要与其他协议的服务通信（如 gRPC、Dubbo 等），SkyWalking 也提供了相应的插件支持。确保在 Agent 配置中启用了相应的插件：

# 启用 gRPC 插件
plugin.grpc.enabled=true

# 启用 Dubbo 插件
plugin.dubbo.enabled=true

传播头格式选择

SkyWalking 支持多种传播头格式，可以通过配置选择：

# 使用 W3C Trace Context 格式（推荐）
propagation.format=w3c

# 或者使用 SkyWalking 自定义格式
# propagation.format=sw8

W3C Trace Context 是标准化的格式，具有更好的兼容性，建议在新项目中使用。

OrderService -> UserService -> Gateway -> Client
(traceparent: 00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01)
HTTP Request (with traceparent header) -> Extract trace context
Forward Request (with traceparent header) -> Internal Call (with trace context)
Response -> Response -> Response

性能监控与指标分析

除了分布式追踪，SkyWalking 还提供了丰富的性能监控和指标分析功能。让我们看看如何利用这些功能来监控 Spring Cloud Gateway 的性能。

关键性能指标

SkyWalking 自动收集以下关键指标：

• 吞吐量（Throughput）：每秒处理的请求数
• 响应时间（Response Time）：P99、P95、平均响应时间
• 成功率（Success Rate）：成功请求占总请求的比例
• JVM 指标：内存使用、GC 次数、线程数等

自定义业务指标

我们还可以通过 SkyWalking 的 Meter API 添加自定义业务指标：

@Component
public class BusinessMetricsCollector {
    private final MeterRegistry meterRegistry;

    public BusinessMetricsCollector(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
    }

    public void recordApiCall(String apiName, long durationMs, boolean success) {
        // 记录 API 调用次数
        Counter.builder("gateway.api.calls")
            .tag("api", apiName)
            .tag("success", String.valueOf(success))
            .register(meterRegistry)
            .increment();

        // 记录 API 响应时间
        Timer.builder("gateway.api.response.time")
            .tag("api", apiName)
            .register(meterRegistry)
            .record(durationMs, TimeUnit.MILLISECONDS);
    }

    public void recordRateLimiting(String routeId) {
        Counter.builder("gateway.rate.limited.requests")
            .tag("route", routeId)
            .register(meterRegistry)
            .increment();
    }
}

在过滤器中使用这些指标：

@Component
@Order(0)
public class MetricsGlobalFilter implements GlobalFilter {
    private final BusinessMetricsCollector metricsCollector;

    public MetricsGlobalFilter(BusinessMetricsCollector metricsCollector) {
        this.metricsCollector = metricsCollector;
    }

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        long startTime = System.currentTimeMillis();
        String path = exchange.getRequest().getPath().pathWithinApplication().value();
        return chain.filter(exchange).doOnTerminate(() -> {
            long duration = System.currentTimeMillis() - startTime;
            boolean success = exchange.getResponse().getStatusCode() != null
                    && exchange.getResponse().getStatusCode().is2xxSuccessful();
            metricsCollector.recordApiCall(path, duration, success);
        });
    }
}

告警配置

SkyWalking 支持基于指标的告警功能。可以在 alarm-settings.yml 中配置告警规则：

rules:
  # 网关响应时间告警
  gateway_response_time_rule:
    metrics-name: service_resp_time
    op: ">"
    threshold: 1000
    period: 10
    count: 3
    silence-period: 5
    message: Gateway response time is too high

  # 网关错误率告警
  gateway_error_rate_rule:
    metrics-name: service_sla
    op: "<"
    threshold: 95
    period: 10
    count: 2
    silence-period: 5
    message: Gateway error rate is too high

高级场景：动态路由与追踪

在实际生产环境中，Spring Cloud Gateway 经常需要支持动态路由配置。让我们看看在这种场景下如何保持追踪的一致性。

动态路由配置

首先创建动态路由的服务：

@Service
public class DynamicRouteService {
    private final RouteDefinitionWriter routeDefinitionWriter;
    private final ApplicationEventPublisher eventPublisher;

    public DynamicRouteService(RouteDefinitionWriter routeDefinitionWriter, ApplicationEventPublisher eventPublisher) {
        this.routeDefinitionWriter = routeDefinitionWriter;
        this.eventPublisher = eventPublisher;
    }

    public void addRoute(RouteDefinition routeDefinition) {
        routeDefinitionWriter.save(Mono.just(routeDefinition)).subscribe();
        eventPublisher.publishEvent(new RefreshRoutesEvent(this));
        // 记录追踪信息
        AbstractSpan span = SkywalkingContextManager.getSpan();
        if (span != null) {
            span.log(Instant.now(), Map.of(
                "event", "route.added",
                "route.id", routeDefinition.getId(),
                "route.uri", routeDefinition.getUri().toString()
            ));
        }
    }

    public void removeRoute(String routeId) {
        // 删除路由的逻辑...
        eventPublisher.publishEvent(new RefreshRoutesEvent(this));
        AbstractSpan span = SkywalkingContextManager.getSpan();
        if (span != null) {
            span.log(Instant.now(), Map.of(
                "event", "route.removed",
                "route.id", routeId
            ));
        }
    }
}

路由变更的追踪

创建一个控制器来管理动态路由：

@RestController
@RequestMapping("/admin/routes")
public class RouteAdminController {
    private final DynamicRouteService dynamicRouteService;

    public RouteAdminController(DynamicRouteService dynamicRouteService) {
        this.dynamicRouteService = dynamicRouteService;
    }

    @PostMapping
    public ResponseEntity<String> addRoute(@RequestBody RouteDefinition routeDefinition) {
        try {
            dynamicRouteService.addRoute(routeDefinition);
            return ResponseEntity.ok("Route added successfully");
        } catch (Exception e) {
            AbstractSpan span = SkywalkingContextManager.getSpan();
            if (span != null) {
                span.log(Instant.now(), Map.of(
                    "event", "route.add.failed",
                    "error", e.getMessage()
                ));
                span.errorOccurred();
            }
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Failed to add route: " + e.getMessage());
        }
    }

    @DeleteMapping("/{routeId}")
    public ResponseEntity<String> removeRoute(@PathVariable String routeId) {
        dynamicRouteService.removeRoute(routeId);
        return ResponseEntity.ok("Route removed successfully");
    }
}

动态路由的监控

为了监控动态路由的效果，我们可以创建专门的指标：

@Component
public class RouteMetricsCollector {
    private final MeterRegistry meterRegistry;
    private final AtomicInteger activeRoutesCount;

    public RouteMetricsCollector(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.activeRoutesCount = Gauge.builder("gateway.active.routes.count")
            .register(meterRegistry, new AtomicInteger(0));
    }

    public void onRouteAdded(String routeId) {
        activeRoutesCount.incrementAndGet();
        Counter.builder("gateway.routes.added")
            .tag("route.id", routeId)
            .register(meterRegistry)
            .increment();
    }

    public void onRouteRemoved(String routeId) {
        activeRoutesCount.decrementAndGet();
        Counter.builder("gateway.routes.removed")
            .tag("route.id", routeId)
            .register(meterRegistry)
            .increment();
    }
}

故障排查与最佳实践

在实际使用过程中，可能会遇到各种问题。以下是一些常见问题的排查方法和最佳实践。

常见问题排查

1. 追踪数据未显示

可能原因：

• SkyWalking Agent 未正确加载
• OAP 服务器地址配置错误
• 网络连接问题

排查步骤：

# 检查 Agent 是否加载
java -javaagent:/path/to/agent/skywalking-agent.jar -jar app.jar

# 查看应用日志中的 Agent 启动信息
grep "SkyWalking Agent" application.log

# 检查网络连通性
telnet localhost 11800

2. 调用链路断裂

可能原因：

• 上下文传播头未正确传递
• 自定义 HTTP 客户端未被 Agent 拦截
• 异步处理导致上下文丢失

解决方案：

// 确保在异步操作中传递上下文
CompletableFuture.supplyAsync(() -> {
    // 在异步任务中恢复上下文
    try (var ignored = SkywalkingContextManager.capture().restore()) {
        // 执行业务逻辑
        return businessLogic();
    }
});

3. 性能影响过大

优化建议：

• 调整采样率配置
• 禁用不必要的插件
• 优化日志级别

# 降低采样率（默认是 -1，表示全量采集）
agent.sample_n_per_3_secs=1

# 禁用不需要的插件
plugin.mongodb.enabled=false
plugin.redis.enabled=false

最佳实践

1. 合理命名服务

使用有意义的服务名称，便于在 UI 中识别：

agent.service_name=${SW_AGENT_NAME:api-gateway-prod}

2. 添加业务标签

在关键业务点添加自定义标签，便于过滤和分析：

AbstractSpan span = SkywalkingContextManager.getSpan();
if (span != null) {
    span.tag("business.order.id", orderId);
    span.tag("business.user.id", userId);
}

3. 监控关键路径

重点关注核心业务路径的性能指标，设置合理的告警阈值。

4. 定期清理数据

配置合适的数据保留策略，避免存储空间不足：

# storage setting
storage:
  selector: ${SW_STORAGE:h2}
  h2:
    driver: ${SW_STORAGE_H2_DRIVER:org.h2.jdbcx.JdbcDataSource}
    url: ${SW_STORAGE_H2_URL:jdbc:h2:mem:skywalking-oap-db}
    user: ${SW_STORAGE_H2_USER:sa}
    password: ${SW_STORAGE_H2_PASSWORD:}
    metadata_query_max_size: ${SW_STORAGE_H2_METADATA_QUERY_MAX_SIZE:5000}
    max_size_of_array_column: ${SW_STORAGE_H2_MAX_SIZE_OF_ARRAY_COLUMN:2000}
    num_of_searchable_values_per_tag: ${SW_STORAGE_H2_NUM_OF_SEARCHABLE_VALUES_PER_TAG:2}
# 数据保留天数
ttl: ${SW_CORE_TTL:7}

与其他监控工具的集成

虽然 SkyWalking 功能强大，但在某些场景下可能需要与其他监控工具集成。

与 Prometheus 集成

SkyWalking 支持将指标导出到 Prometheus：

# 启用 Prometheus exporter
metrics.exporter.prometheus.enabled=true
metrics.exporter.prometheus.port=9090

然后可以在 Prometheus 中配置抓取目标：

scrape_configs:
  - job_name: 'skywalking'
    static_configs:
      - targets: ['localhost:9090']

与 Grafana 集成

使用 Grafana 可以创建更丰富的仪表板。SkyWalking 官方提供了 Grafana 仪表板模板，可以从 Grafana 官方网站搜索 "SkyWalking" 获取。

日志集成

将 SkyWalking 的 Trace ID 注入到日志中，便于日志关联：

<!-- logback-spring.xml -->
<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
            <layout class="org.apache.skywalking.apm.toolkit.log.logback.v1.x.TraceIdPatternLogbackLayout">
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%tid] [%thread] %-5level %logger{36} -%msg%n</pattern>
            </layout>
        </encoder>
    </appender>
    <root level="INFO">
        <appender-ref ref="STDOUT"/>
    </root>
</configuration>

这样日志中就会包含 Trace ID，格式如：2023-10-01 12:00:00.000 [TID: 4bf92f3577b34da6a3ce929d0e0e4736.0.15847361234560001] [main] INFO ...

实际案例分析

让我们通过一个实际案例来展示 SkyWalking 在 Spring Cloud Gateway 中的应用价值。

场景描述

假设我们有一个电商平台，架构如下：

• API Gateway：Spring Cloud Gateway，处理所有外部请求
• User Service：用户服务，处理用户相关操作
• Product Service：商品服务，处理商品相关操作
• Order Service：订单服务，处理订单相关操作
• Payment Service：支付服务，处理支付相关操作

用户下单流程：Client → Gateway → Order Service → User Service + Product Service → Payment Service

问题发现

某天运营反馈用户下单成功率下降，需要快速定位问题。

排查过程

1. 查看服务拓扑图：在 SkyWalking UI 中查看服务拓扑，发现 Order Service 到 Payment Service 的调用出现大量错误。
2. 分析调用链路：选择一个失败的 Trace，查看详细调用链路。
3. 查看指标趋势：发现 Payment Service 的响应时间在过去 1 小时内急剧上升，从平均 200ms 上升到 30s。
4. 检查日志：通过 Trace ID 关联日志，发现 Payment Service 连接第三方支付网关超时。

解决方案

• 临时方案：增加 Payment Service 的超时时间
• 长期方案：优化第三方支付网关的连接池配置，添加熔断机制

预防措施

• 为 Payment Service 添加专门的告警规则
• 在网关层添加针对支付接口的限流策略
• 定期进行压力测试，监控关键路径性能

总结与展望

通过本文的详细介绍，我们深入了解了如何在 Spring Cloud Gateway 中集成 SkyWalking 实现分布式追踪。从基础配置到高级场景，从自动追踪到手动埋点，从性能监控到故障排查，SkyWalking 为我们提供了全方位的可观测性解决方案。

核心收获

1. 无缝集成：SkyWalking Agent 能够自动追踪 Spring Cloud Gateway 的路由请求，无需修改大量业务代码
2. 完整链路：通过正确的上下文传播，实现了从客户端到后端服务的完整调用链路追踪
3. 深度监控：不仅能够追踪请求路径，还能监控性能指标、设置告警、分析依赖关系
4. 灵活扩展：支持自定义标签、业务指标、异常日志等，满足各种监控需求

未来展望

随着云原生技术的发展，可观测性变得越来越重要。SkyWalking 也在不断演进，未来的方向包括：

• eBPF 支持：通过 eBPF 技术实现更底层的网络监控
• OpenTelemetry 兼容：更好地与 OpenTelemetry 生态集成
• AI 辅助分析：利用机器学习自动发现异常模式和根因分析
• 多语言支持：继续完善对各种编程语言的支持

对于 Spring Cloud Gateway 用户来说，合理使用 SkyWalking 不仅能够提升系统的可观测性，还能显著提高故障排查效率，保障业务稳定性。

如果你正在构建基于微服务的系统架构，强烈建议将 SkyWalking 纳入你的技术栈。它将成为你运维和开发过程中的得力助手，让你对系统的运行状态了如指掌。

记住，在复杂的分布式系统中，"看不见"往往比"有问题"更可怕。有了 SkyWalking 这样的工具，我们终于可以让微服务架构变得透明可见！