分布式链路追踪 —— 基于Dubbo的traceId追踪传递

文章目录

  • 原文链接
  • RpcContext 上下文对象
  • Dubbo 过滤器(Filter)对象
  • 基于Dubbo的traceId追踪传递实现

原文链接

RpcContext 上下文对象

在实现 Dubbo 调用之间的链路跟踪之前,先简单了解 RpcContext 上下文对象和 Filter 过滤器对象,Dubbo 分布式链路追踪是基于这两个对象实现。

概要

  • RpcContext 是 Dubbo 框架提供的一个类,它的设计目标是提供一个 dubbo 调用的上下文对象,用于在远程过程调用(RPC)期间传递、共享请求和响应的相关信息。它可以用于存储、访问与当前 RPC 调用相关的数据,如调用方的 IP 地址、附加参数、上下文变量等。它提供了一些静态方法和属性,可以方便地获取和设置与当前线程相关的 RPC 上下文。

    public class RpcContext {
    
        private static final InternalThreadLocal<RpcContext> LOCAL = new InternalThreadLocal<RpcContext>() {
            protected RpcContext initialValue() {
                return new RpcContext();
            }
        };
        private static final InternalThreadLocal<RpcContext> SERVER_LOCAL = new InternalThreadLocal<RpcContext>() {
            protected RpcContext initialValue() {
                return new RpcContext();
            }
        };
        private final Map<String, String> attachments = new HashMap();
        private final Map<String, Object> values = new HashMap();
        // ......
    }
    

原理

  • RpcContext 是基于 ThreadLocal 实现的,做到了线程隔离。RpcContext是与线程绑定的,每个线程都有自己的一个 RpcContext 实例并使用 ThreadLocal 变量来存储,避免并发访问问题。当客户端发起一个 RPC 请求时,Dubbo 框架会创建一个新的线程来处理该请求,并且会将 RpcContext 与该线程进行绑定,这样看,对于每次 RPC 请求,RpcContext 也是唯一的。但对于同一个线程内的多个 RPC 请求,它们共享同一个 RpcContext 实例。

  • RpcContext 实例会在请求处理期间一直存在,并在请求处理完成后需要清理当前线程上的 RpcContext 实例中的数据,以确保下次使用该线程处理新的请求时,RpcContext 是一个干净的状态。

    对于服务消费方,Dubbo 框架在请求发送、响应后没有清除 RpcContext 实例中的数据;

    对于服务提供方,Dubbo 框架在收到请求并处理后,会去清除 RpcContext 实例中的数据,这个在 ContextFilter 服务提供方过滤器中可以看到。

使用场景

  • 可以在 dubbo 的拦截器、过滤器或服务提供者/消费者的代码中使用 RpcContext 来获取和设置上下文信息,以满足特定的业务需求,如日志跟踪、传递身份验证信息等。

下面是一些常用的 RpcContext 方法和属性:

  • RpcContext.getContext(): 获取当前线程的 RpcContext 实例。
  • RpcContext.isConsumerSide(): 判断当前线程是否处于消费者端。
  • RpcContext.isProviderSide(): 判断当前线程是否处于提供者端。
  • RpcContext.getRemoteAddress(): 获取远程调用的地址。
  • RpcContext.getLocalAddress(): 获取本地调用的地址。
  • RpcContext.setAttachment(String key, String value): 设置附加参数。
  • RpcContext.getAttachment(String key): 获取指定键的附件信息。
  • RpcContext.getAttachments(): 获取所有的附件信息。

Dubbo 过滤器(Filter)对象

Dubbo Filter 介绍

dubbo 的 Filter 是 dubbo 框架提供的一个功能扩展点,用于对服务提供者和消费者之间的请求和响应进行拦截过滤处理,比如认证和授权、日志跟踪、传递一些公共信息等。

如 dubbo 原生 Filter 实现类,如:ConsumerContextFilter 和 ContextFilter

  • ConsumerContextFilter 是一个服务消费方的过滤器,用于在服务消费者发起 RPC 调用之前或之后,对上下文信息进行处理和传递,用于收集和发送调用方的上下文信息到服务提供者端。

    ConsumerContextFilter 源码:通过这个过滤器可以看到在 RPC 调用之前会获取 RpcContext 对象并设置相关参数,Dubbo 框架会借助 RpcContext 对象将相关数据透传到服务提供方。

    @Activate(
        group = {"consumer"},
        order = -10000
    )
    public class ConsumerContextFilter implements Filter {
        public ConsumerContextFilter() {
        }
    
        public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
            RpcContext.getContext().setInvoker(invoker).setInvocation(invocation).setLocalAddress(NetUtils.getLocalHost(), 0).setRemoteAddress(invoker.getUrl().getHost(), invoker.getUrl().getPort()).setRemoteApplicationName(invoker.getUrl().getParameter("remote.application")).setAttachment("remote.application", invoker.getUrl().getParameter("application"));
            if (invocation instanceof RpcInvocation) {
                ((RpcInvocation)invocation).setInvoker(invoker);
            }
    
            return invoker.invoke(invocation);
        }
    }
    

    @Activate 注解是 Dubbo 框架提供的一个扩展点激活注解,用于指定在特定条件下激活扩展点。

    在上述过滤器中,@Activate(group = Constants.CONSUMER, order = -10000) 是对一个扩展点的激活配置。具体解释如下:

    • group = {"consumer"}: 在指定的分组激活,如 consumer,表示该扩展点在消费者端被激活。
    • order = -10000: 指定激活的顺序为 -10000。在 Dubbo 框架中,扩展点的激活顺序可以通过 order 值来进行控制,值越小表示优先级越高。
  • ContextFilter 是一个服务提供方的过滤器,用于在服务提供者收到 RPC 调用请求之前或之后,对上下文信息进行处理和传递,如清除 RpcContext 实例中的数据,以确保下次使用该线程处理新的请求时,RpcContext 是一个干净的状态。

    ContextFilter 源码:在处理请求后去清除 RpcContext 中相关数据。

    @Activate(
        group = {"provider"},
        order = -10000
    )
    public class ContextFilter implements Filter, Filter.Listener {
        private static final String TAG_KEY = "dubbo.tag";
        public ContextFilter() {
        }
        
        public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
            // ......
            Result var6;
            try {
                // 禁止清除RpcContext的功能。这意味着在调用invoker.invoke(invocation)之后,RpcContext中的上下文信息不能被清除。
                RpcContext.getContext().clearAfterEachInvoke(false);
                var6 = invoker.invoke(invocation);
            } finally {
                // 开启允许清除RpcContext的功能。
                RpcContext.getContext().clearAfterEachInvoke(true);
                // 显式清除RpcContext中的上下文信息。
                RpcContext.removeContext();
                RpcContext.removeServerContext();
            }
    
            return var6;
        }
        // ......
    }
    

自定义 Dubbo Filter

  1. 实现 org.apache.dubbo.rpc.Filter接口:

    import org.apache.dubbo.rpc.*;
    
    public class CustomFilter implements Filter {
        @Override
        public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
            // 自定义过滤逻辑
            return invoker.invoke(invocation);
        }
    }
    
  2. 创建 Dubbo 的 SPI 扩展文件(META-INF/dubbo/org.apache.dubbo.rpc.Filter)中,将自定义过滤器的实现类指定为对应的扩展点:

    customFilter=com.example.CustomFilter
    

    分布式链路追踪 —— 基于Dubbo的traceId追踪传递_第1张图片

  3. 使过滤器生效:

    方式一:在自定义过滤器上使用注解:

    @Activate(group = {"consumer"})
    

    方式二:在配置文件(这里使用application.properties)中配置:

    dubbo.consumer.filter=customFilter
    

    通过以上步骤,在服务消费方指定了一个自定义过滤器,该过滤器将在服务消费者发起远程调用前后执行自定义的逻辑。

基于Dubbo的traceId追踪传递实现

要实现在 Dubbo 接口之间传递 TraceID,可以使用 Dubbo 的拦截器(Filter)机制来实现。下面是一个示例代码,演示了如何在 Dubbo 接口调用中传递 TraceID 进行追踪,其中具体 Filter 实现过程前面已讲述,这里只展示实现类代码。需要 demo 示例代码,请关注【Qin的学习营地】,回复【基于Dubbo的traceId追踪传递】。

这里使用 spring boot 整合 dubbo,详细搭建过程请参考:Dubbo 快速入门使用教程

这里通过打印日志来可视化结果,使用了 Slf4J 的 MDC,通过设置 MDC.put(key, value),并在日志配置文件中配置 key,日志打印时会将配置 key 的地方转换为 value 打印出来。

  1. 创建 Dubbo 的服务提供方拦截器类,从 RpcContext 中获取 traceid 参数,并设置到 MDC 中,请求处理完后清除 MDC 中的 traceid 参数:

    @Slf4j
    @Activate(group = {"provider"})
    public class TraceIdProviderFilter implements Filter {
        @Override
        public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
            String traceId = RpcContext.getContext().getAttachment("traceId");
            if (traceId != null) {
                MDC.put("traceId", traceId);
            }
            try {
                return invoker.invoke(invocation);
            } finally {
                MDC.remove("traceId");
            }
        }
    }
    
  2. 创建 Dubbo 的服务消费方拦截器类,向 RpcContext 中写入 traceid 参数:

    @Slf4j
    @Activate(group = {"consumer"})
    public class TraceIdConsumerFilter implements Filter {
        @Override
        public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
            String traceId = MDC.get("traceId");
            if (traceId == null) {
                traceId = UUID.randomUUID().toString().replace("-", "");
            }
            RpcContext.getContext().setAttachment("traceId", traceId);
            MDC.put("traceId", traceId);
            log.info("consumer ——> provider");
            return invoker.invoke(invocation);
        }
    }
    
  3. 服务消费方调用逻辑:

    @Slf4j
    @Component
    public class ProducerService {
    
        @Reference(retries = -1, version="1.0.0", timeout = 15000)
        private HelloService helloService;
    
        public String consumerSayHello(String name){
            String traceId = UUID.randomUUID().toString().replace("-", "");
            MDC.put("traceId", traceId);
            String hello = helloService.sayHello(name);
            log.info("consumer receive response : "+ hello);
            return hello;
        }
    }
    
  4. 运行后看日志打印结果,可以看到服务提供方的 traceId 和服务消费方的 traceId 两者一致,服务消费方的 traceId 透传到服务提供方。

    消费方:

    分布式链路追踪 —— 基于Dubbo的traceId追踪传递_第2张图片

    提供方:

    分布式链路追踪 —— 基于Dubbo的traceId追踪传递_第3张图片

​ 分布式链路追踪
基于Dubbo的traceId追踪传递

本文首先介绍 Dubbo 的 RpcContext 上下文和 Filter 过滤器,然后再介绍基于Dubbo的traceId追踪传递的实现。

你可能感兴趣的:(Java,分布式,dubbo,分布式链路追踪,基于Dubbo的链路追踪)