Spring Sleuth与SOAP服务分布式追踪：原理、限制与手动集成指南

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>
<dependency>
    <groupId>com.revinate</groupId>
    <artifactId>jaxws-spring</artifactId>
    <version>1.0.0</version>
</dependency>
<!-- 如果底层使用CXF，可能还需要CXF相关依赖 -->
<dependency>
    <groupId>org.apache.cxf</groupId>
    <artifactId>cxf-rt-frontend-jaxws</artifactId>
    <version>${cxf.version}</version>
</dependency>
<dependency>
    <groupId>org.apache.cxf</groupId>
    <artifactId>cxf-rt-transports-http</artifactId>
    <version>${cxf.version}</version>
</dependency>

import brave.Span;
import brave.Tracer;
import brave.propagation.Propagation;
import brave.propagation.TraceContext;
import brave.propagation.TraceContext.Injector;
import brave.propagation.TraceContext.Extractor;
import brave.http.HttpTracing;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.xml.namespace.QName;
import javax.xml.ws.handler.MessageContext;
import javax.xml.ws.handler.soap.SOAPHandler;
import javax.xml.ws.handler.soap.SOAPMessageContext;
import java.util.Collections;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.HashMap;

@Component
public class SleuthSoapClientHandler implements SOAPHandler<SOAPMessageContext> {

    private final Tracer tracer;
    private final Propagation.Setter<Map<String, String>, String> headerSetter;
    private final Propagation.Getter<Map<String, String>, String> headerGetter; // 尽管是出站，但为了完整性可以考虑

    // 构造函数注入Tracer和HeaderSetter
    @Autowired
    public SleuthSoapClientHandler(Tracer tracer, HttpTracing httpTracing) {
        this.tracer = tracer;
        // 使用B3TextMapPropagation的Setter来注入B3头部
        // 对于自定义行李字段，需要单独处理或使用BaggagePropagation
        this.headerSetter = httpTracing.propagation().injector(Map::put);
        this.headerGetter = httpTracing.propagation().extractor(Map::get); // 示例，通常出站不需要getter
    }

    @Override
    public boolean handleMessage(SOAPMessageContext context) {
        Boolean outboundProperty = (Boolean) context.get(MessageContext.MESSAGE_OUTBOUND_PROPERTY);

        if (outboundProperty) { // 仅处理出站消息
            Span currentSpan = tracer.currentSpan();
            if (currentSpan == null) {
                // 如果没有当前Span，则可能是一个新的调用链的开始，或者不在Sleuth追踪的线程中
                // 此时可以选择创建一个新的Span，或者不注入任何头部
                // 为了与现有追踪链保持一致，我们通常只在有当前Span时注入
                return true;
            }

            // 获取当前HTTP请求头部
            Map<String, Object> requestHeaders = (Map<String, Object>) context.get(MessageContext.HTTP_REQUEST_HEADERS);
            if (requestHeaders == null) {
                requestHeaders = new HashMap<>();
                context.put(MessageContext.HTTP_REQUEST_HEADERS, requestHeaders);
            }

            // 将Sleuth追踪上下文注入到HTTP头部中
            Map<String, String> stringHeaders = new HashMap<>();
            headerSetter.inject(currentSpan.context(), stringHeaders);

            // 将stringHeaders转换并添加到实际的requestHeaders中
            stringHeaders.forEach((key, value) -> {
                // JAX-WS的HTTP_REQUEST_HEADERS通常期望List<String>作为值
                requestHeaders.put(key, Collections.singletonList(value));
            });

            // 额外处理自定义行李字段（如Caller-Id）
            // Sleuth的Baggage API提供了获取和设置行李字段的方法
            String callerId = tracer.currentSpan().context().findBaggage("Caller-Id");
            if (callerId != null && !callerId.isEmpty()) {
                requestHeaders.put("Caller-Id", Collections.singletonList(callerId));
            }

            // 更新消息上下文中的HTTP请求头部
            context.put(MessageContext.HTTP_REQUEST_HEADERS, requestHeaders);
            context.setScope(MessageContext.HTTP_REQUEST_HEADERS, MessageContext.Scope.APPLICATION);
        }
        return true;
    }

    @Override
    public boolean handleFault(SOAPMessageContext context) {
        return true;
    }

    @Override
    public void close(MessageContext context) {
        // 清理资源，如果需要
    }

    @Override
    public Set<QName> getHeaders() {
        // 返回此处理器感兴趣的SOAP Header，通常为空，因为我们处理的是HTTP Header
        return new HashSet<>();
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.xml.ws.BindingProvider;
import javax.xml.ws.handler.Handler;
import java.util.ArrayList;
import java.util.List;

@Configuration
public class SoapClientConfig {

    @Autowired
    private SleuthSoapClientHandler sleuthSoapClientHandler;

    @Bean
    public MySoapService mySoapService() {
        // 假设MySoapService是你的SOAP服务接口
        // 这是获取SOAP服务代理的一个示例，具体方式取决于你的jaxws-spring配置
        // 可能是通过FactoryBean或者直接的JaxWsPortProxyFactoryBean
        MySoapService service = new MySoapServiceService().getMySoapServicePort();

        if (service instanceof BindingProvider) {
            BindingProvider bp = (BindingProvider) service;
            List<Handler> handlerChain = new ArrayList<>();
            handlerChain.add(sleuthSoapClientHandler);
            bp.getBinding().setHandlerChain(handlerChain);
        }
        return service;
    }

    // 如果你使用JaxWsPortProxyFactoryBean，配置会更直接
    // @Bean
    // public JaxWsPortProxyFactoryBean mySoapServiceProxy() {
    //     JaxWsPortProxyFactoryBean factory = new JaxWsPortProxyFactoryBean();
    //     factory.setServiceName("MySoapServiceService");
    //     factory.setPortName("MySoapServicePort");
    //     factory.setServiceInterface(MySoapService.class);
    //     factory.setWsdlDocumentUrl("classpath:wsdl/MySoapService.wsdl");
    //     // 设置处理器链
    //     factory.setHandlerChain(Collections.singletonList(sleuthSoapClientHandler));
    //     return factory;
    // }
}

import javax.xml.ws.BindingProvider;
import javax.xml.ws.handler.Handler;
import java.util.ArrayList;
import java.util.List;

// ...
public class MyClient {

    @Autowired
    private SleuthSoapClientHandler sleuthSoapClientHandler;

    public void callSoapService() {
        MySoapServiceService serviceLocator = new MySoapServiceService();
        MySoapService mySoapService = serviceLocator.getMySoapServicePort();

        if (mySoapService instanceof BindingProvider) {
            BindingProvider bp = (BindingProvider) mySoapService;
            List<Handler> handlerChain = new ArrayList<>();
            handlerChain.add(sleuthSoapClientHandler);
            bp.getBinding().setHandlerChain(handlerChain);
        }

        // 现在可以调用SOAP服务了
        // mySoapService.someOperation();
    }
}