[源码分析] OpenTracing之跟踪Redis
目录
0x00 摘要
本文将通过研究OpenTracing的Redis埋点插件来进一步深入理解OpenTracing。
0x01 总体逻辑
1.1 相关概念
Tracer是用来管理Span的统筹者，负责创建span和传播span。它表示从头到尾的一个请求的调用链，是一次完整的跟踪，从请求到服务器开始，服务器返回response结束，跟踪每次rpc调用的耗时。它的标识符是“traceID”。
Span是一个更小的单位，表示一个RPC调用过程。一个“trace”包含有许多跨度(span)，每个跨度捕获调用链内的一个工作单元(系统或服务节点)，并由“spanId”标识。 每个跨度具有一个父跨度，并且一个“trace”的所有跨度形成有向无环图(DAG)。
1.2 埋点插件
对一个应用的跟踪要关注的无非就是 客户端——>web 层——>rpc 服务——>dao 后端存储、cache 缓存、消息队列 mq 等这些基础组件。OpenTracing 插件的作用实际上也就是对不同组件进行埋点，以便基于这些组件采集应用的链路数据。
不同组件有不同的应用场景和扩展点，因此针对不同的框架，需要开发对应的OpenTracing API 插件用来实现自动埋点。
对于Redis来说各种插件更是层出不穷，所以OpenTracing 对与 Redis 各种插件也做了不同处理，比如 Jedis，Redisson，Spring Data Redis 2.x。本文主要是以 Redisson 为例说明，最后用spring-cloud-redis进行补充对照**。
1.3 总体逻辑
总体思路是使用代理模式。因为 Redis 并没有提供像 Servlet 那样的过滤器或者拦截器，所以 Redis OpenTracing 插件没有进行常规埋点，而是通过组合的方式自定义若干代理类，比如 TracingRedissonClient 和 TracingRList .....。
- TracingRedissonClient 代理了 Redis Client。
- TracingRList 代理了Redis List 数据结构。
- 还有其他类代理其他Redis数据结构，比如TracingRMap。
这些代理类将具体完成Tracing 功能。比如代理类 TracingRedissonClient 包含了两个成员变量:
- private final RedissonClient redissonClient; 是真正的 Redis Client。
- private final TracingRedissonHelper tracingRedissonHelper; 是具体针对 Redission 的Tracing 功能类，比如构建Span。
最后各种代理对 Redis 进行拦截：
- 在执行具体的连接操作之前创建相关的 Span。
- 在操作结束之后结束 Span，并进行上报。
具体可以见下图
+--------------------------+ +-------------------------+ +-------------------------+
| TracingRedissonClient | | TracingRMap | | TracingRList |
| +----------------------+ | | +---------------------+ | | +---------------------+ |
| | RedissonClient | | | | RMap | | | | RList | | ....
| | | | | | | | | | | |
| | TracingRedissonHelper| | | |TracingRedissonHelper| | | |TracingRedissonHelper| |
| +----------------------+ | | +---------------------+ | | +---------------------+ |
+--------------------------+ +-------------------------+ +-------------------------+
| | |
| | |
| | |
| | |
| v |
| +---------------+-----------------+ |
+-----------> | TracingRedissonHelper | <--------+
| +-----------------------------+ |
| | Tracer +-----+
| +-----------------------------+ | |
+---------------------------------+ |
|
+---------------------------------+ |
| TracingConfiguration | |
| +----------------------------+ | |
| | Tracer <-------+
| +----------------------------| |
+---------------------------------+
下图是为了手机观看。
0x02 示例代码
我们使用代码自带的test来做说明。我们可以看到有两个代理类 TracingRedissonClient 和 TracingRList。
- beforeClass 起到了系统启动的作用。
- 首先定义了一个tracer（这里是MockTracer，真正使用时候会用到其他Tracer）。
- 然后使用这个Tracer来构建一个代理类
TracingRedissonClient。
- 后续各种测试操作都是使用这个client在进行Redis操作。
- 会通过代理类
TracingRedissonClient得到一个org.redisson.api.RList以备后续操作。这个 RList 实际是OpenTracing 进行修改的另一个代理类TracingRList。 - 会对这个
TracingRList进行操作 ：list.add("key"); - 针对 Redisson 的异步操作，也进行了操作测试。
- 会通过代理类
具体代码如下：
public class TracingRedissonTest {
private static final MockTracer tracer = new MockTracer();
private static RedisServer redisServer;
private static RedissonClient client;
@BeforeClass
public static void beforeClass() {
redisServer = RedisServer.builder().setting("bind 127.0.0.1").build();
redisServer.start();
Config config = new Config();
config.useSingleServer().setAddress("redis://127.0.0.1:6379");
client = new TracingRedissonClient(Redisson.create(config),
new TracingConfiguration.Builder(tracer).build());
}
@Test
public void test_list() {
RList<Object> list = client.getList("list");
list.add("key");
assertTrue(list.contains("key"));
List<MockSpan> spans = tracer.finishedSpans();
assertEquals(2, spans.size());
checkSpans(spans);
assertNull(tracer.activeSpan());
}
@Test
public void test_config_span_name() throws Exception {
......
final MockSpan parent = tracer.buildSpan("test").start();
try (Scope ignore = tracer.activateSpan(parent)) {
RMap<String, String> map = customClient.getMap("map_config_span_name");
map.getAsync("key").get(15, TimeUnit.SECONDS);
}
parent.finish();
......
}
}
0x03 Redis代理
前面我们提到了对于Redis是使用了代理来完成功能，下面我们具体来讲解。
3.1 Client 代理类
TracingRedissonClient 实现了 Redis Client 代理功能，其包含两个成员变量。
- RedissonClient redissonClient; 是真正的Redis Client，代理类最终是通过此Client进行Redis操作。
- TracingRedissonHelper tracingRedissonHelper; 完成了Tracing 功能。
具体在使用中，比如在测试代码会通过 Client 代理类得到一个 TracingRList 以备后续操作（这是另一个代理类）。
- TracingRList 实现了
org.redisson.api.RList接口。 - 在构建 TracingRList 会把 TracingRedissonHelper 作为参数传递进去。
RList<Object> list = client.getList("list");
具体代码如下：
public class TracingRedissonClient implements RedissonClient {
private final RedissonClient redissonClient;
private final TracingRedissonHelper tracingRedissonHelper;
public TracingRedissonClient(RedissonClient redissonClient, TracingConfiguration configuration) {
this.redissonClient = redissonClient;
this.tracingRedissonHelper = new TracingRedissonHelper(configuration);
}
@Override
public <V> RList<V> getList(String name) {
// 通过代理生成
return new TracingRList<>(redissonClient.getList(name), tracingRedissonHelper);
}
// 其他操作
......
}
3.2 List 代理类
TracingRList 是Redis List代理类（Redis插件还有其他代理类，代理其他Redis数据结构）。里面也是两个变量：
- RList
- TracingRedissonHelper 完成 Tracing 功能。
在具体 add 函数中：
- 在执行具体的命令前先通过
tracingRedissonHelper.buildSpan构建 Span 进行埋点操作。 - 然后添加 Tag。
- 最后通过
tracingRedissonHelper.decorate进行实际 Redis 操作。
具体代码如下：
public class TracingRList<V> extends TracingRExpirable implements RList<V> {
private final RList<V> list;
private final TracingRedissonHelper tracingRedissonHelper;
@Override
public boolean add(V element) {
Span span = tracingRedissonHelper.buildSpan("add", list);
span.setTag("element", nullable(element));
return tracingRedissonHelper.decorate(span, () -> list.add(element));
}
// 其他操作
.....
}
0x04 Tracing功能类
前面一直在提TracingRedissonHelper是Tracing功能类，下面我们就深入研究下 tracingRedissonHelper.decorate(span, () -> list.add(element)); 做了什么。
4.1 配置类
在初始化 Redis Client时候，生成了 TracingConfiguration。
client = new TracingRedissonClient(Redisson.create(config),
new TracingConfiguration.Builder(tracer).build());
TracingConfiguration 之中就定义了io.opentracing.Tracer以及其他配置项。
具体类定义如下：
public class TracingConfiguration {
static final int DEFAULT_KEYS_MAX_LENGTH = 100;
private final Tracer tracer;
private final boolean traceWithActiveSpanOnly;
private final int keysMaxLength;
private final Function<String, String> spanNameProvider;
private final Map<String, String> extensionTags;
// 其他操作
......
}
4.2 Tracing基础功能类
io.opentracing.contrib.redis.common.TracingHelper 是OpenTracing 通用的 Redis Tracing 功能类，我们看到里面有 Tracer 变量（就是TracingConfiguration之中的Tracer），也有 SpanBuilder 这样的helper 函数。
业务逻辑具体在 decorate 函数中有体现。参数 Supplier
return tracingRedissonHelper.decorate(span, () -> list.add(object));
Supplier 是 JAVA8 提供的接口，这个接口是一个提供者的意思，只有一个get的抽象类，没有默认的方法以及静态的方法。get方法返回一个泛型T，这就是一个创建对象的工厂。
所以decorate的作用在我们这里就是：
- 用
tracer.scopeManager().activate(span)来激活当前span。 - 返回对象，执行Redis操作，我们例子就是
() -> list.add(element) - 调用
span.finish();完成了结束操作，如果采样就会上报。
测试代码 执行流程图如下：
TracingRList TracingHelper
+ +
+---+--+ |
| add | begin |
+---+--+ |
| |
| invoke |
| v
| ----------------> +-------+------+
| | buildSpan |
| <---------------+ +-------+------+
| Return |
| |
+---+-------+ |
|span.setTag| |
+---+-------+ |
| |
| |
| |
| invoke +-------------v-------------------------+
| -----------> |decorate(span, () -> list.add(element))|
| +-------------+-------------------------+
| |
| |
| |
| v begin tracing
| +-------------+----------------------+
| |tracer.scopeManager().activate(span)|
| +-------------+----------------------+
| |
| |
| |
| v Real Redis action
+-----+------------+ <----+ +-----+--------+
| list.add(element)| |supplier.get()|
+-----+------------+ +----> +-----+--------+
| |
| |
| v end tracing
| decorate Return +-----+-------+
| <----------------+ |span.finish()|
| +-------------+
+--+---+
| add | end
+--+---+
|
|
|
v
具体 TracingHelper 代码如下：
public class TracingHelper {
public static final String COMPONENT_NAME = "java-redis";
public static final String DB_TYPE = "redis";
protected final Tracer tracer;
private final boolean traceWithActiveSpanOnly;
private final Function<String, String> spanNameProvider;
private final int maxKeysLength;
private final Map<String, String> extensionTags;
public Span buildSpan(String operationName) {
if (traceWithActiveSpanOnly && tracer.activeSpan() == null) {
return NoopSpan.INSTANCE;
} else {
return builder(operationName).start();
}
}
private SpanBuilder builder(String operationName) {
SpanBuilder sb = tracer.buildSpan(spanNameProvider.apply(operationName))
.withTag(Tags.COMPONENT.getKey(), COMPONENT_NAME)
.withTag(Tags.SPAN_KIND.getKey(), Tags.SPAN_KIND_CLIENT)
.withTag(Tags.DB_TYPE.getKey(), DB_TYPE);
extensionTags.forEach(sb::withTag);
return sb;
}
public <T> T decorate(Span span, Supplier<T> supplier) {
try (Scope ignore = tracer.scopeManager().activate(span)) { // 激活span
return supplier.get(); // 执行Redis操作
} catch (Exception e) {
onError(e, span);
throw e;
} finally {
span.finish();// 完成了结束操作，如果采样就会上报。
}
}
// 其他操作
.....
}
4.3 Redission专用Tracing功能类
TracingRedissonHelper 是具体实现了Redission 的 Tracing 功能，主要是针对异步操作。
4.3.1 测试代码
官方测试代码如下
final MockSpan parent = tracer.buildSpan("test").start();
try (Scope ignore = tracer.activateSpan(parent)) {
RMap<String, String> map = customClient.getMap("map_config_span_name");
map.getAsync("key").get(15, TimeUnit.SECONDS); // Redis异步操作
}
parent.finish();
能看到，测试的思路是：
- 生成一个parent Span
- 然后使用redis map进行异步操作，getAsync这里会生成一个 client span。
- parent span结束
具体下面我们会讲解。
4.3.2 TracingRedissonHelper
TracingRedissonHelper 需要针对 Redisson 来进行特殊设置，就是因为Redisson同时还为分布式锁提供了异步执行的相关方法。
所以需要对异步操作进行处理。其中：
- RFuture 是 org.redisson.api 包下面的类，
- CompletableRFuture 是 io.opentracing.contrib.redis.redisson 包下面的类，针对 RFuture 做了特殊处理。
prepareRFuture函数是执行Redis具体操作的函数，其作用如下：
- 通过 futureSupplier.get(); 获取redisFuture（ prepareRFuture的参数span是之前 getAsync 生成的child span ）。
- 设置 redisFuture 的 whenComplete函数，在whenComplete函数中会对传入的Span进行 finish操作 ，这个span 其实是child span。这样异步的Tracing通过Client Span完成。
- 继续操作，恢复parent span，在redisFuture基础上生成CompletableRFuture，然后继续设置redisFuture.whenComplete，如果redisFuture完成，则调用 customRedisFuture.complete。
- 返回，外界测试函数会finish parent span。
针对官方测试代码，执行流程图如下：
+------------+
| Parent Span|
+-----+------+
|
v
TracingRMap TracingRedissonHelper
+ +
| |
| v
+----+-----+ Invoke +----+------+
| getAsync | +-----------------------> | buildSpan |create Child Span
+----+-----+ +----+------+
| |
| v
| +-----+--------+
| |prepareRFuture|
| +-----+--------+
| |
| Real redis action v
+-----+----------------+ <--------+ +-------+-------------+
|() -> map.getAsync(key| | futureSupplier.get()|
+-----+----------------+ +--------> +-------+-------------+
| Future |
| |
| +-------v---------+
| |setCompleteAction|
| +-------+---------+
| |
| |
| +------v-------+
| | whenComplete |
| +------+-------+
| |
| v
| +------+-------+
| | span.finish()| Child Span
| +------+-------+
| |
| v
| +--------+----------+
| | continueScopeSpan |
| +--------+----------+
| |
| v
| +---------+----------+
| | tracer.activeSpan()|
| +---------+----------+
| | Parent Span
| |
| v
| +-----+--------+
| |activate(span)|
| +-----+--------+
| |
| |
| v
| return +------------+-----------------+
| <-------------------- | customRedisFuture.complete(v)|
| +------------------------------+
|
+----v----------+
|parent.finish()|
+---------------+
具体代码如下：
class TracingRedissonHelper extends TracingHelper {
TracingRedissonHelper(TracingConfiguration tracingConfiguration) {
super(tracingConfiguration);
}
Span buildSpan(String operationName, RObject rObject) {
return buildSpan(operationName).setTag("name", rObject.getName());
}
private <T> RFuture<T> continueScopeSpan(RFuture<T> redisFuture) {
Span span = tracer.activeSpan();
CompletableRFuture<T> customRedisFuture = new CompletableRFuture<>(redisFuture);
redisFuture.whenComplete((v, throwable) -> {
try (Scope ignored = tracer.scopeManager().activate(span)) {
if (throwable != null) {
customRedisFuture.completeExceptionally(throwable);
} else {
customRedisFuture.complete(v);
}
}
});
return customRedisFuture;
}
private <V> RFuture<V> setCompleteAction(RFuture<V> future, Span span) {
future.whenComplete((v, throwable) -> {
if (throwable != null) {
onError(throwable, span);
}
span.finish();
});
return future;
}
<V> RFuture<V> prepareRFuture(Span span, Supplier<RFuture<V>> futureSupplier) {
RFuture<V> future;
try {
future = futureSupplier.get();
} catch (Exception e) {
onError(e, span);
span.finish();
throw e;
}
return continueScopeSpan(setCompleteAction(future, span));
}
}
4.4 TracingRMap代理类的异步处理
TracingRMap 实现了 org.redisson.api.RMap。这里就使用了上述的异步相关的功能，比如 getAsync。
所以调用了 prepareRFuture 的功能。
public class TracingRMap<K, V> extends TracingRExpirable implements RMap<K, V> {
private final RMap<K, V> map;
private final TracingRedissonHelper tracingRedissonHelper;
@Override
public RFuture<V> getAsync(K key) {
Span span = tracingRedissonHelper.buildSpan("getAsync", map);
span.setTag("key", nullable(key));
return tracingRedissonHelper.prepareRFuture(span, () -> map.getAsync(key));
}
// 其他操作
......
}
0x05 spring-cloud-redis
opentracing-spring-cloud-redis-starter 实现了对 spring-cloud-redis 的Tracing功能。
Spring Cloud 埋点实现主要实现原理是利用Spring AOP切片技术抽象埋点行为，比如TraceAsyncAspect 切面类，使用@Around 声明拦截规则，后面的逻辑与手动埋点类似，创建一个span，将业务逻辑包围起来即可。
5.1 Bean
首先，利用注解生成一些Bean，比如。
@Configuration
@AutoConfigureAfter({TracerRegisterAutoConfiguration.class, org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration.class})
@ConditionalOnBean(RedisConnectionFactory.class)
@ConditionalOnProperty(name = "opentracing.spring.cloud.redis.enabled", havingValue = "true", matchIfMissing = true)
@EnableConfigurationProperties(RedisTracingProperties.class)
public class RedisAutoConfiguration {
@Bean
public RedisAspect openTracingRedisAspect(Tracer tracer, RedisTracingProperties properties) {
return new RedisAspect(tracer, properties);
}
}
5.2 拦截规则
其次，使用 @Around 和 @Pointcut 声明拦截规则。具体是通过一层代理来是实现的拦截。对所有的 Redis connection 都通过 TracingRedisConnection 进行了一层包装。
@Aspect
public class RedisAspect {
private final Tracer tracer;
private final RedisTracingProperties properties;
RedisAspect(Tracer tracer, RedisTracingProperties properties) {
this.tracer = tracer;
this.properties = properties;
}
@Pointcut("target(org.springframework.data.redis.connection.RedisConnectionFactory)")
public void connectionFactory() {}
@Pointcut("execution(org.springframework.data.redis.connection.RedisConnection *.getConnection(..))")
public void getConnection() {}
@Pointcut("execution(org.springframework.data.redis.connection.RedisClusterConnection *.getClusterConnection(..))")
public void getClusterConnection() {}
@Around("getConnection() && connectionFactory()")
public Object aroundGetConnection(final ProceedingJoinPoint pjp) throws Throwable {
final RedisConnection connection = (RedisConnection) pjp.proceed();
final String prefixOperationName = this.properties.getPrefixOperationName();
final TracingConfiguration tracingConfiguration = new TracingConfiguration.Builder(tracer)
.withSpanNameProvider(RedisSpanNameProvider.PREFIX_OPERATION_NAME(prefixOperationName))
.build();
return new TracingRedisConnection(connection, tracingConfiguration);
}
@Around("getClusterConnection() && connectionFactory()")
public Object aroundGetClusterConnection(final ProceedingJoinPoint pjp) throws Throwable {
final RedisClusterConnection clusterConnection = (RedisClusterConnection) pjp.proceed();
final String prefixOperationName = this.properties.getPrefixOperationName();
final TracingConfiguration tracingConfiguration = new TracingConfiguration.Builder(tracer)
.withSpanNameProvider(RedisSpanNameProvider.PREFIX_OPERATION_NAME(prefixOperationName))
.build();
return new TracingRedisClusterConnection(clusterConnection, tracingConfiguration);
}
}
5.2 埋点
在执行具体的命令前后通过自己提供的 API 进行埋点操作，基本上就是：redisTemplate的操作会在每个操作中调用connect做操作，比如 set操作中调用 connection.set(rawKey, rawValue) ，所以就通过 TracingRedisConnection来做一个封装，在做真正connection操作前后进行tracing。
流程图如下：
redisTemplate TracingRedisConnection
+ +
| |
| |
v |
+--------------+-----------------+ |
|redisTemplate.opsForValue().set | |
+--------------+-----------------+ |
| |
| |
| |
| |
v |
+-----------+-----------+ |
| RedisTemplate.execute | |
+-----------+-----------+ |
| |
| |
v v
+-------------+-------------+ invoke +-+---+
| DefaultValueOperations.set| +----------------------> | set |
+-------------+-------------+ +-+---+
| |
| |
| v begin tracing
| +---------+--------------+
| | TracingHelper.doInScope|
| +---------+--------------+
| |
| v
| +---+-----+
| |buildSpan|
| +---+-----+
| |
| v
| +---------+-----------+
| |activateAndCloseSpan |
| +---------+-----------+
| |
| |
v Real redis action |
+--------------+-------------------+ <----------------- |
| () -> connection.set(key, value) | |
+--------------+-------------------+ +-----------------> |
| |
| | end tracing
| return +------v--------+
| <--------------------------------+ |span.finish(); |
| +---------------+
|
|
v
代码如下：
public class TracingRedisConnection implements RedisConnection {
private final RedisConnection connection;
private final TracingConfiguration tracingConfiguration;
private final TracingHelper helper;
public TracingRedisConnection(RedisConnection connection,
TracingConfiguration tracingConfiguration) {
this.connection = connection;
this.tracingConfiguration = tracingConfiguration;
this.helper = new TracingHelper(tracingConfiguration);
}
// 在 span 的生命周期内执行具体命令
@Override
public Object execute(String command, byte[]... args) {
// 执行命令
return helper.doInScope(command, () -> connection.execute(command, args));
}
// 其他操作
.....
}
具体Span是在TracingHelper中完成。
public class TracingHelper {
public static final String COMPONENT_NAME = "java-redis";
public static final String DB_TYPE = "redis";
protected final Tracer tracer;
private final boolean traceWithActiveSpanOnly;
private final Function<String, String> spanNameProvider;
private final int maxKeysLength;
private final Map<String, String> extensionTags;
public <T> T doInScope(String command, Supplier<T> supplier) {
Span span = this.buildSpan(command);
return this.activateAndCloseSpan(span, supplier);
}
// 其他操作
.....
}
0xFF 参考
蚂蚁金服开源分布式链路跟踪组件 SOFATracer 埋点机制剖析
https://github.com/opentracing/opentracing-java