基于OpentracingJaeger全链路灰度调用链

43次阅读

共计 11805 个字符，预计需要花费 30 分钟才能阅读完成。

当网关和服务在实施全链路分布式灰度发布和路由时候，我们需要一款追踪系统来监控网关和服务走的是哪个灰度组，哪个灰度版本，哪个灰度区域，甚至监控从 Http Header 头部全程传递的灰度规则和路由策略。这个功能意义在于：

  • 不仅可以监控全链路中基本的调用信息，也可以监控额外的灰度信息，有助于我们判断灰度发布和路由是否执行准确，一旦有问题，也可以快速定位
  • 可以监控流量何时切换到新版本，或者新的区域，或者新的机器上
  • 可以监控灰度规则和路由策略是否配置准确
  • 可以监控网关和服务灰度上下级树状关系
  • 可以监控全链路流量拓扑图

笔者尝试调研了一系列分布式追踪系统和中间件，包括 Opentracing、Uber Jaeger、Twitter Zipkin、Apache Skywalking、Pinpoint、CAT 等，最后决定采用 Opentracing + Uber Jaeger 方式来实现，重要原因除了易用性和可扩展性外，Opentracing 支持 WebMvc 和 WebFlux 两种方式，业界的追踪系统能支持 WebFlux 相对较少

[OpenTracing] OpenTracing 已进入 CNCF，正在为全球的分布式追踪系统提供统一的概念、规范、架构和数据标准。它通过提供平台无关、厂商无关的 API，使得开发人员能够方便的添加（或更换）追踪系统的实现。对于存在多样化的技术栈共存的调用链中，Opentracing 适配 Java、C、Go 和.Net 等技术栈，实现全链路分布式追踪功能。迄今为止，Uber Jaeger、Twitter Zipkin 和 Apache Skywalking 已经适配了 Opentracing 规范

笔者以 Nepxion 社区的 Discovery 开源框架（对该开源框架感兴趣的同学，请访问如下链接）为例子展开整合

源码主页，请访问
https://github.com/Nepxion/Discovery

指南主页，请访问
https://github.com/Nepxion/DiscoveryGuide

文档主页，请访问
https://pan.baidu.com/s/1i57rXaNKPuhGRqZ2MONZOA#list/path=%2FNepxion

整合的效果图





基本概念

灰度调用链主要包括如下 11 个参数。使用者可以自行定义要传递的调用链参数，例如：traceId, spanId 等；也可以自行定义要传递的业务调用链参数，例如：mobile, user 等 

1. n-d-service-group - 服务所属组或者应用
2. n-d-service-type - 服务类型，分为“网关”和“服务”3. n-d-service-id - 服务 ID
4. n-d-service-address - 服务地址，包括 Host 和 Port
5. n-d-service-version - 服务版本
6. n-d-service-region - 服务所属区域
7. n-d-version - 版本路由值
8. n-d-region - 区域路由值
9. n-d-address - 地址路由值
10. n-d-version-weight - 版本权重路由值
11. n-d-region-weight - 区域权重路由值

核心实现

Opentracing 通用模块

源码参考
https://github.com/Nepxion/Discovery/tree/master/discovery-plugin-strategy-opentracing

由于 OpenTracing 扩展需要兼顾到 Spring Cloud Gateway、Zuul 和服务，它的核心逻辑存在着一定的可封装性，所以笔者抽取出一个公共模块 discovery-plugin-strategy-opentracing，包含 configuration、operation、context 等模块，着重阐述 operation 模块，其它比较简单，不一一赘述了

在阐述前，笔者需要解释一个配置，该配置将决定核心实现以及终端界面的显示

  1. 如果开启，灰度信息输出到独立的 Span 节点中，意味着在界面显示中，灰度信息通过独立的 GRAY Span 节点来显示。优点是信息简洁明了，缺点是 Span 节点会增长一倍。我们可以称呼它为【模式 A】
  2. 如果关闭，灰度信息输出到原生的 Span 节点中，意味着在界面显示中，灰度信息会和原生 Span 节点的调用信息、协议信息等混在一起，缺点是信息庞杂混合，优点是 Span 节点数不会增长。我们可以称呼它为【模式 B】
# 启动和关闭调用链的灰度信息在 Opentracing 中以独立的 Span 节点输出，如果关闭，则灰度信息输出到原生的 Span 节点中。缺失则默认为 true
spring.application.strategy.trace.opentracing.separate.span.enabled=true

Opentracing 公共操作类 – StrategyOpentracingOperation.java

  • 装配注入 Opentracing 的 Tracer 对象

  • opentracingInitialize 方法，提供给网关和服务的 Span 节点初始化

    • 【模式 A】下，tracer.buildSpan(…).start() 实现新建一个 Span，并把它放置到存储上下文的 StrategyOpentracingContext 的 ThreadLocal 里
    • 【模式 B】下，不需要做任何工作

  • opentracingHeader 方法，提供给网关的灰度调用链输出

    • 【模式 A】下，首先从 StrategyOpentracingContext 的 ThreadLocal 里获取 Span 对象，其次把 customizationMap（自定义的调用链参数）的元素都放入到 Tag 中，最后把灰度调用链主 11 个参数（通过 strategyContextHolder.getHeader(…) 获取）和更多上下文信息放入到 Tag 中
    • 【模式 B】下，跟【模式 A】类似，唯一区别的是 Tags.COMPONENT 的处理，由于原生的 Span 节点已经带有该信息，所以不需要放入到 Tag 中

  • opentracingLocal 方法，提供给服务的灰度调用链输出

    • 【模式 A】下，首先从 StrategyOpentracingContext 的 ThreadLocal 里获取 Span 对象，其次把 customizationMap（自定义的调用链参数）的元素都放入到 Tag 中，最后把灰度调用链主 11 个参数（通过 pluginAdapter.getXXX() 获取）和更多上下文信息放入到 Tag 中
    • 【模式 B】下，跟【模式 A】类似，唯一区别的是 Tags.COMPONENT 的处理，由于原生的 Span 节点已经带有该信息，所以不需要放入到 Tag 中

  • opentracingError 方法，提供给服务的灰度调用链异常输出

    • 【模式 A】下，首先从 StrategyOpentracingContext 的 ThreadLocal 里获取 Span 对象，其次 span.log(…) 方法实现异常输出
    • 【模式 B】下，不需要做任何工作

  • opentracingClear 方法，灰度调用链的 Span 上报和清除

    • 【模式 A】下，首先从 StrategyOpentracingContext 的 ThreadLocal 里获取 Span 对象，其次 span.finish() 方法实现 Span 上报，最后 StrategyOpentracingContext.clearCurrentContext() 方法实现 Span 清除
    • 【模式 B】下，不需要做任何工作

  • getCurrentSpan 方法

    • 【模式 A】下，返回 StrategyOpentracingContext.getCurrentContext().getSpan()，即 opentracingInitialize 新建的 Span 对象
    • 【模式 B】下，返回 tracer.activeSpan()，即原生的 Span 对象 
public class StrategyOpentracingOperation {private static final Logger LOG = LoggerFactory.getLogger(StrategyOpentracingOperation.class);

    @Autowired
    protected PluginAdapter pluginAdapter;

    @Autowired
    protected StrategyContextHolder strategyContextHolder;

    @Autowired
    private Tracer tracer;

    @Value("${" + StrategyOpentracingConstant.SPRING_APPLICATION_STRATEGY_TRACE_OPENTRACING_ENABLED + ":false}")
    protected Boolean traceOpentracingEnabled;

    @Value("${" + StrategyOpentracingConstant.SPRING_APPLICATION_STRATEGY_TRACE_OPENTRACING_SEPARATE_SPAN_ENABLED + ":true}")
    protected Boolean traceOpentracingSeparateSpanEnabled;

    public void opentracingInitialize() {if (!traceOpentracingEnabled) {return;}

        if (!traceOpentracingSeparateSpanEnabled) {return;}

        Span span = tracer.buildSpan(DiscoveryConstant.SPAN_VALUE).start();
        StrategyOpentracingContext.getCurrentContext().setSpan(span);

        LOG.debug("Trace chain for Opentracing initialized...");
    }

    public void opentracingHeader(Map<String, String> customizationMap) {if (!traceOpentracingEnabled) {return;}

        Span span = getCurrentSpan();
        if (span == null) {LOG.error("Span not found in context to opentracing header");

            return;
        }

        if (MapUtils.isNotEmpty(customizationMap)) {for (Map.Entry<String, String> entry : customizationMap.entrySet()) {span.setTag(entry.getKey(), entry.getValue());
            }
        }

        if (traceOpentracingSeparateSpanEnabled) {span.setTag(Tags.COMPONENT.getKey(), DiscoveryConstant.TAG_COMPONENT_VALUE);
        }
        span.setTag(DiscoveryConstant.PLUGIN, DiscoveryConstant.PLUGIN_VALUE);
        span.setTag(DiscoveryConstant.TRACE_ID, span.context().toTraceId());
        span.setTag(DiscoveryConstant.SPAN_ID, span.context().toSpanId());
        span.setTag(DiscoveryConstant.N_D_SERVICE_GROUP, strategyContextHolder.getHeader(DiscoveryConstant.N_D_SERVICE_GROUP));
        ...

        String routeVersion = strategyContextHolder.getHeader(DiscoveryConstant.N_D_VERSION);
        if (StringUtils.isNotEmpty(routeVersion)) {span.setTag(DiscoveryConstant.N_D_VERSION, routeVersion);
        }
        ...

        LOG.debug("Trace chain information outputs to Opentracing...");
    }

    public void opentracingLocal(String className, String methodName, Map<String, String> customizationMap) {if (!traceOpentracingEnabled) {return;}

        Span span = getCurrentSpan();
        if (span == null) {LOG.error("Span not found in context to opentracing local");

            return;
        }

        if (MapUtils.isNotEmpty(customizationMap)) {for (Map.Entry<String, String> entry : customizationMap.entrySet()) {span.setTag(entry.getKey(), entry.getValue());
            }
        }

        if (traceOpentracingSeparateSpanEnabled) {span.setTag(Tags.COMPONENT.getKey(), DiscoveryConstant.TAG_COMPONENT_VALUE);
        }
        span.setTag(DiscoveryConstant.PLUGIN, DiscoveryConstant.PLUGIN_VALUE);
        span.setTag(DiscoveryConstant.CLASS, className);
        span.setTag(DiscoveryConstant.METHOD, methodName);
        span.setTag(DiscoveryConstant.TRACE_ID, span.context().toTraceId());
        span.setTag(DiscoveryConstant.SPAN_ID, span.context().toSpanId());
        span.setTag(DiscoveryConstant.N_D_SERVICE_GROUP, pluginAdapter.getGroup());
        ...

        String routeVersion = strategyContextHolder.getHeader(DiscoveryConstant.N_D_VERSION);
        if (StringUtils.isNotEmpty(routeVersion)) {span.setTag(DiscoveryConstant.N_D_VERSION, routeVersion);
        }
        ...

        LOG.debug("Trace chain information outputs to Opentracing...");
    }

    public void opentracingError(String className, String methodName, Throwable e) {if (!traceOpentracingEnabled) {return;}

        if (!traceOpentracingSeparateSpanEnabled) {return;}

        Span span = getCurrentSpan();
        if (span == null) {LOG.error("Span not found in context to opentracing error");

            return;
        }

        span.log(new ImmutableMap.Builder<String, Object>()
                .put(DiscoveryConstant.CLASS, className)
                .put(DiscoveryConstant.METHOD, methodName)
                .put(DiscoveryConstant.EVENT, Tags.ERROR.getKey())
                .put(DiscoveryConstant.ERROR_OBJECT, e)
                .build());

        LOG.debug("Trace chain error outputs to Opentracing...");
    }

    public void opentracingClear() {if (!traceOpentracingEnabled) {return;}

        if (!traceOpentracingSeparateSpanEnabled) {return;}

        Span span = getCurrentSpan();
        if (span != null) {span.finish();
        } else {LOG.error("Span not found in context to opentracing clear");
        }
        StrategyOpentracingContext.clearCurrentContext();

        LOG.debug("Trace chain context of Opentracing cleared...");
    }

    public Span getCurrentSpan() {return traceOpentracingSeparateSpanEnabled ? StrategyOpentracingContext.getCurrentContext().getSpan() : tracer.activeSpan();
    }

    public String getTraceId() {if (!traceOpentracingEnabled) {return null;}

        Span span = getCurrentSpan();
        if (span != null) {return span.context().toTraceId();}

        return null;
    }

    public String getSpanId() {if (!traceOpentracingEnabled) {return null;}

        Span span = getCurrentSpan();
        if (span != null) {return span.context().toSpanId();}

        return null;
    }
}

Opentracing Service 模块

源码参考
https://github.com/Nepxion/Discovery/tree/master/discovery-plugin-strategy-starter-service-opentracing

实现 OpenTracing 对服务的扩展，包含 configuration、tracer 等模块，着重阐述 tracer 模块，其它比较简单，不一一赘述了

Opentracing 的服务追踪类 – DefaultServiceStrategyOpentracingTracer.java

  • 继承 DefaultServiceStrategyTracer，并注入 StrategyOpentracingOperation
  • trace 方法里先执行 opentracingInitialize 初始化 Span，这样可以让后面的逻辑都可以从 Span 中拿到 traceId 和 spanId，执行 opentracingLocal 实现服务的灰度调用链输出
  • error 方法里执行 opentracingError 实现服务的灰度调用链异常输出
  • release 方法里执行 opentracingClear 实现灰度调用链的 Span 上报和清除 
public class DefaultServiceStrategyOpentracingTracer extends DefaultServiceStrategyTracer {
    @Autowired
    private StrategyOpentracingOperation strategyOpentracingOperation;

    @Override
    public void trace(ServiceStrategyTracerInterceptor interceptor, MethodInvocation invocation) {strategyOpentracingOperation.opentracingInitialize();

        super.trace(interceptor, invocation);

        strategyOpentracingOperation.opentracingLocal(interceptor.getMethod(invocation).getDeclaringClass().getName(), interceptor.getMethodName(invocation), getCustomizationMap());
    }

    @Override
    public void error(ServiceStrategyTracerInterceptor interceptor, MethodInvocation invocation, Throwable e) {super.error(interceptor, invocation, e);

        strategyOpentracingOperation.opentracingError(interceptor.getMethod(invocation).getDeclaringClass().getName(), interceptor.getMethodName(invocation), e);
    }

    @Override
    public void release(ServiceStrategyTracerInterceptor interceptor, MethodInvocation invocation) {super.release(interceptor, invocation);

        strategyOpentracingOperation.opentracingClear();}

    @Override
    public String getTraceId() {return strategyOpentracingOperation.getTraceId();
    }

    @Override
    public String getSpanId() {return strategyOpentracingOperation.getSpanId();
    }
}

Opentracing Spring Cloud Gateway 模块

源码参考
https://github.com/Nepxion/Discovery/tree/master/discovery-plugin-strategy-starter-gateway-opentracing

实现 OpenTracing 对 Spring Cloud Gateway 的扩展，跟 discovery-plugin-strategy-starter-service-opentracing 模块类似，不一一赘述了

Opentracing Zuul 模块

源码参考
https://github.com/Nepxion/Discovery/tree/master/discovery-plugin-strategy-starter-zuul-opentracing

实现 OpenTracing 对 Zuul 的扩展，跟 discovery-plugin-strategy-starter-service-opentracing 模块类似，不一一赘述了

使用说明

示例参考
https://github.com/Nepxion/DiscoveryGuide

使用方式

Opentracing 输出方式以 Uber Jaeger 为例来说明，步骤非常简单

  1. 从 https://pan.baidu.com/s/1i57rXaNKPuhGRqZ2MONZOA#list/path=%2FNepxion 获取 Jaeger-1.14.0.zip，Windows 操作系统下解压后运行 jaeger.bat，Mac 和 Lunix 操作系统请自行研究
  2. 执行 Postman 调用后，访问 http://localhost:16686 查看灰度调用链
  3. 灰度调用链支持 WebMvc 和 WebFlux 两种方式，以 GRAY 字样的标记来标识

开关控制

对于 Opentracing 调用链功能的开启和关闭，需要通过如下开关做控制：

# 启动和关闭调用链。缺失则默认为 false
spring.application.strategy.trace.enabled=true
# 启动和关闭调用链的 Opentracing 输出，支持 F 版或更高版本的配置，其它版本不需要该行配置。缺失则默认为 false
spring.application.strategy.trace.opentracing.enabled=true
# 启动和关闭调用链的灰度信息在 Opentracing 中以独立的 Span 节点输出，如果关闭，则灰度信息输出到原生的 Span 节点中。缺失则默认为 true
spring.application.strategy.trace.opentracing.separate.span.enabled=true

可选功能

自定义调用链上下文参数的创建（该类不是必须的），继承 DefaultStrategyTracerAdapter

// 自定义调用链上下文参数的创建
// 对于 getTraceId 和 getSpanId 方法，在 Opentracing 等调用链中间件引入的情况下，由调用链中间件决定，在这里定义不会起作用；在 Opentracing 等调用链中间件未引入的情况下，在这里定义才有效，下面代码中表示从 Http Header 中获取，并全链路传递
// 对于 getCustomizationMap 方法，表示输出到调用链中的定制化业务参数，可以同时输出到日志和 Opentracing 等调用链中间件，下面代码中表示从 Http Header 中获取，并全链路传递
public class MyStrategyTracerAdapter extends DefaultStrategyTracerAdapter {
    @Override
    public String getTraceId() {return StringUtils.isNotEmpty(strategyContextHolder.getHeader(DiscoveryConstant.TRACE_ID)) ? strategyContextHolder.getHeader(DiscoveryConstant.TRACE_ID) : StringUtils.EMPTY;
    }

    @Override
    public String getSpanId() {return StringUtils.isNotEmpty(strategyContextHolder.getHeader(DiscoveryConstant.SPAN_ID)) ? strategyContextHolder.getHeader(DiscoveryConstant.SPAN_ID) : StringUtils.EMPTY;
    }

    @Override
    public Map<String, String> getCustomizationMap() {return new ImmutableMap.Builder<String, String>()
                .put("mobile", StringUtils.isNotEmpty(strategyContextHolder.getHeader("mobile")) ? strategyContextHolder.getHeader("mobile") : StringUtils.EMPTY)
                .put("user", StringUtils.isNotEmpty(strategyContextHolder.getHeader("user")) ? strategyContextHolder.getHeader("user") : StringUtils.EMPTY)
                .build();}
}

在配置类里 @Bean 方式进行调用链类创建，覆盖框架内置的调用链类 

@Bean
public StrategyTracerAdapter strategyTracerAdapter() {return new MyStrategyTracerAdapter();
}

本文作者

任浩军，10 多年开源经历，Github ID：@HaojunRen，Nepxion 开源社区创始人，Nacos Group Member，Spring Cloud Alibaba & Nacos & Sentinel Committer

请联系我

微信、公众号和文档

本文由博客一文多发平台 OpenWrite 发布！

正文完
发表至： java
2019-10-29
 0
DRS是啥你都不知道不是吧不是吧
关于java:框架篇ByteBuffer和nettyByteBuf详解
关于java:气抖冷竟然还有这种事Java程序员先面饿了么后面阿里竟遇同一面试官
Springboot构建应用程序