Spring Sleuth在SOAP出站调用中远程字段传播的定制化指南

sleuth:
  async:
    enabled: true
  baggage:
    remote-fields:
      - Caller-Id

import brave.Span;
import brave.Tracer;
import brave.baggage.BaggageField;
import brave.baggage.BaggageManager;
import brave.propagation.TraceContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.xml.namespace.QName;
import javax.xml.soap.SOAPEnvelope;
import javax.xml.soap.SOAPHeader;
import javax.xml.soap.SOAPMessage;
import javax.xml.ws.handler.MessageContext;
import javax.xml.ws.handler.soap.SOAPHandler;
import javax.xml.ws.handler.soap.SOAPMessageContext;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * JAX-WS Handler，用于将Spring Sleuth的追踪上下文和baggage字段注入到SOAP出站请求中。
 * 这些字段将作为HTTP请求头附加到SOAP消息的底层HTTP请求中。
 */
public class SleuthSoapClientHandler implements SOAPHandler<SOAPMessageContext> {

    private final Tracer tracer;
    private final BaggageManager baggageManager;
    private final List<String> remoteFields; // 从Sleuth配置中获取的远程字段名称列表

    // 通过构造函数注入Tracer和BaggageManager，以及配置的remote-fields
    public SleuthSoapClientHandler(Tracer tracer, BaggageManager baggageManager, List<String> remoteFields) {
        this.tracer = tracer;
        this.baggageManager = baggageManager;
        this.remoteFields = remoteFields != null ? remoteFields : Collections.emptyList();
    }

    @Override
    public boolean handleMessage(SOAPMessageContext context) {
        // 判断是否是出站消息
        Boolean outboundProperty = (Boolean) context.get(MessageContext.MESSAGE_OUTBOUND_PROPERTY);

        if (outboundProperty != null && outboundProperty.booleanValue()) { // 这是一个出站请求
            Span currentSpan = tracer.currentSpan();
            if (currentSpan == null) {
                // 没有活动的Span，无需传播追踪上下文
                return true;
            }

            TraceContext traceContext = currentSpan.context();

            try {
                // 获取HTTP请求头Map，如果不存在则创建
                // MessageContext.HTTP_REQUEST_HEADERS 允许我们操作底层HTTP请求头
                Map<String, List<String>> httpHeaders = (Map<String, List<String>>) context.get(MessageContext.HTTP_REQUEST_HEADERS);
                if (httpHeaders == null) {
                    httpHeaders = new HashMap<>();
                    context.put(MessageContext.HTTP_REQUEST_HEADERS, httpHeaders);
                    // 设置Scope为APPLICATION，确保这些头在整个请求生命周期中有效
                    context.setScope(MessageContext.HTTP_REQUEST_HEADERS, MessageContext.Scope.APPLICATION);
                }

                // 1. 注入B3追踪头部 (TraceId, SpanId, Sampled)
                // Sleuth通常会通过其自己的传播器将这些头注入到httpHeaders中，但为了确保，我们也可以手动添加
                // 这里我们直接使用TraceContext的信息
                addHttpHeader(httpHeaders, "X-B3-TraceId", traceContext.traceIdString());
                addHttpHeader(httpHeaders, "X-B3-SpanId", traceContext.spanIdString());
                if (traceContext.sampled() != null) {
                    addHttpHeader(httpHeaders, "X-B3-Sampled", traceContext.sampled() ? "1" : "0");
                }

                // 2. 注入remote-fields (baggage) 作为HTTP头部
                for (String fieldName : remoteFields) {
                    BaggageField field = BaggageField.getByName(fieldName);
                    if (field != null) {
                        String value = field.current();
                        if (value != null) {
                            addHttpHeader(httpHeaders, fieldName, value);
                            // 如果目标SOAP服务期望这些字段在SOAP Header中，可以按如下方式添加：
                            // SOAPMessage soapMessage = context.getMessage();
                            // SOAPEnvelope envelope = soapMessage.getSOAPPart().getEnvelope();
                            // SOAPHeader header = envelope.getHeader();
                            // if (header == null) {
                            //     header = envelope.addHeader();
                            // }
                            // QName qName = new QName("http://your.service.namespace.com", fieldName); // 替换为你的SOAP命名空间
                            // header.addHeaderElement(qName).setValue(value);
                        }
                    }
                }

            } catch (Exception e) {
                System.err.println("Error injecting Sleuth headers into SOAP message: " + e.getMessage());
                // 根据需要处理异常，例如记录日志
            }
        }
        return true; // 继续处理消息
    }

    private void addHttpHeader(Map<String, List<String>> headers, String name, String value) {
        headers.computeIfAbsent(name, k -> new ArrayList<>()).add(value);
    }

    @Override
    public boolean handleFault(SOAPMessageContext context) {
        // 处理故障消息，这里我们不做特殊处理
        return true;
    }

    @Override
    public void close(MessageContext context) {
        // 资源清理，这里没有需要清理的
    }

    @Override
    public Set<QName> getHeaders() {
        // 返回此Handler处理的SOAP Header的QName集合。
        // 由于我们主要操作HTTP Header，这里返回空集合即可。
        return Collections.emptySet();
    }
}

import brave.Tracer;
import brave.baggage.BaggageManager;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.remoting.jaxws.JaxWsPortProxyFactoryBean;

import javax.xml.ws.handler.Handler;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;

@Configuration
public class SoapClientConfig {

    @Autowired
    private Tracer tracer; // Spring Sleuth提供的Tracer Bean

    @Autowired
    private BaggageManager baggageManager; // Spring Sleuth提供的BaggageManager Bean

    @Value("${sleuth.baggage.remote-fields:}") // 从配置中获取remote-fields
    private List<String> remoteFields;

    @Bean
    public JaxWsPortProxyFactoryBean mySoapServiceClient() throws MalformedURLException {
        JaxWsPortProxyFactoryBean factory = new JaxWsPortProxyFactoryBean();
        factory.setServiceInterface(com.example.MySoapService.class); // 替换为你的SOAP服务接口
        factory.setWsdlDocumentUrl(new URL("classpath:wsdl/MyService.wsdl")); // 替换为你的WSDL路径
        factory.setNamespaceUri("http://example.com/soap"); // 替换为你的SOAP服务命名空间
        factory.setServiceName("MyService"); // 替换为你的SOAP服务名称
        factory.setPortName("MyServicePort"); // 替换为你的SOAP端口名称

        // 创建并注册SleuthSoapClientHandler
        List<Handler> handlers = new ArrayList<>();
        handlers.add(new SleuthSoapClientHandler(tracer, baggageManager, remoteFields));
        factory.setHandlers(handlers);

        return factory;
    }
}