spring cloud sleuth在spring中创建span

在spring-cloud-sleuth的META-INF里的spring.factories里设置了一下：

org.springframework.boot.env.EnvironmentPostProcessor=\
org.springframework.cloud.sleuth.autoconfig.TraceEnvironmentPostProcessor

 

这样，TraceEnvironmentPostProcessor被配置在了ioc容器初始化之前。

 

public void postProcessEnvironment(ConfigurableEnvironment environment,
      SpringApplication application) {
   Map<String, Object> map = new HashMap<String, Object>();
   // This doesn't work with all logging systems but it's a useful default so you see
   // traces in logs without having to configure it.
   if (Boolean.parseBoolean(environment.getProperty("spring.sleuth.enabled", "true"))) {
      map.put("logging.pattern.level",
            "%5p [${spring.zipkin.service.name:${spring.application.name:-}},%X{X-B3-TraceId:-},%X{X-B3-SpanId:-},%X{X-Span-Export:-}]");
   }
   // TODO: Remove this in 2.0.x. For compatibility we always set to true
   if (!environment.containsProperty(SPRING_AOP_PROXY_TARGET_CLASS)) {
      map.put(SPRING_AOP_PROXY_TARGET_CLASS, "true");
   }
   addOrReplace(environment.getPropertySources(), map);
}

在TraceEnvironmentPostProcessor的postProcessEnvironment()方法里保证了两件事情，设置了spring.aop.proxyTargetClass参数为true保证了cglib代理的开启，并加入了日志的追踪打印的模板。

 

而后在配置类TraceAutoConfiguration中生成了Tracer，默认实现为DefaultTraces，作用为正式创建一个工作单元span。

紧随其后的配置类为SleuthAnnotationAutoConfiguration，此处根据之前生成的Tracer进一步创建了其包装类SpanCreator，并最重要的是生成了代理的配置类SleuthAdvisorConfig。

@PostConstruct
public void init() {
   this.pointcut = buildPointcut();
   this.advice = buildAdvice();
   if (this.advice instanceof BeanFactoryAware) {
      ((BeanFactoryAware) this.advice).setBeanFactory(this.beanFactory);
   }
}

 

其初始化方法中，完成了切面与切面增强的创建。

 

其buildPointcut()方法：

private Pointcut buildPointcut() {
   return new AnnotationClassOrMethodOrArgsPointcut();
}
private final class AnnotationClassOrMethodOrArgsPointcut extends
      DynamicMethodMatcherPointcut {

   @Override
   public boolean matches(Method method, Class<?> targetClass, Object... args) {
      return getClassFilter().matches(targetClass);
   }

   @Override public ClassFilter getClassFilter() {
      return new ClassFilter() {
         @Override public boolean matches(Class<?> clazz) {
            return new AnnotationClassOrMethodFilter(NewSpan.class).matches(clazz) ||
                  new AnnotationClassOrMethodFilter(ContinueSpan.class).matches(clazz);
         }
      };
   }

}

private final class AnnotationClassOrMethodFilter extends AnnotationClassFilter {

   private final AnnotationMethodsResolver methodResolver;

   AnnotationClassOrMethodFilter(Class<? extends Annotation> annotationType) {
      super(annotationType, true);
      this.methodResolver = new AnnotationMethodsResolver(annotationType);
   }

   @Override
   public boolean matches(Class<?> clazz) {
      return super.matches(clazz) || this.methodResolver.hasAnnotatedMethods(clazz);
   }

}

 

显而易见，切面的匹配通过目标类是否满足使用了NewSpan或者ContinueSpan注解。

 

 

切面的增强则通过buildAdvice来构造Interceptor来通过代理使用invoke()方法来完成生成span的目的。

private Advice buildAdvice() {
   return new SleuthInterceptor();
}


@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
   Method method = invocation.getMethod();
   if (method == null) {
      return invocation.proceed();
   }
   Method mostSpecificMethod = AopUtils
         .getMostSpecificMethod(method, invocation.getThis().getClass());
   NewSpan newSpan = SleuthAnnotationUtils.findAnnotation(mostSpecificMethod, NewSpan.class);
   ContinueSpan continueSpan = SleuthAnnotationUtils.findAnnotation(mostSpecificMethod, ContinueSpan.class);
   if (newSpan == null && continueSpan == null) {
      return invocation.proceed();
   }
   Span span = tracer().getCurrentSpan();
   String log = log(continueSpan);
   boolean hasLog = StringUtils.hasText(log);
   try {
      if (newSpan != null) {
         span = spanCreator().createSpan(invocation, newSpan);
      }
      if (hasLog) {
         logEvent(span, log + ".before");
      }
      spanTagAnnotationHandler().addAnnotatedParameters(invocation);
      addTags(invocation, span);
      return invocation.proceed();
   } catch (Exception e) {
      if (logger.isDebugEnabled()) {
         logger.debug("Exception occurred while trying to continue the pointcut", e);
      }
      if (hasLog) {
         logEvent(span, log + ".afterFailure");
      }
      errorParser().parseErrorTags(tracer().getCurrentSpan(), e);
      throw e;
   } finally {
      if (span != null) {
         if (hasLog) {
            logEvent(span, log + ".after");
         }
         if (newSpan != null) {
            tracer().close(span);
         }
      }
   }
}

 

当通过代理走到此处的invoke()方法说明此时涉及到了与别的服务的调用，需要生成新的spanId，那么就在这里newSpan注解生成新的spanId，如果该方法实现了ContinueSpan注解，那么就在现有的spanId。

 

 

如果采用newSpan注解，那么这里需要通过之前的在配置类中生成的tracer的getCurrentSpan()方法获取当前的span。

具体的实现在SpanContextHolder的getCurrentSpan()方法中。

static Span getCurrentSpan() {
   return isTracing() ? CURRENT_SPAN.get().span : null;
}

 

通过ThreadLoacl来获得当前的span，也就是说，当新的trace请求到来时，可以通过ThreadLoacl来存储。

 

 

紧接着通过spanCreator的createSpan()方法来证实获得新的span。

@Override public Span createSpan(MethodInvocation pjp, NewSpan newSpanAnnotation) {
   String name = StringUtils.isEmpty(newSpanAnnotation.name()) ?
         pjp.getMethod().getName() : newSpanAnnotation.name();
   String changedName = SpanNameUtil.toLowerHyphen(name);
   if (log.isDebugEnabled()) {
      log.debug("For the class [" + pjp.getThis().getClass() + "] method "
            + "[" + pjp.getMethod().getName() + "] will name the span [" + changedName + "]");
   }
   return createSpan(changedName);
}

private Span createSpan(String name) {
   if (this.tracer.isTracing()) {
      return this.tracer.createSpan(name, this.tracer.getCurrentSpan());
   }
   return this.tracer.createSpan(name);
}

 

Span的名字在注解中的名字和方法名中有限选择前者，而后根据通过tracer的createSpan()来获得span。

 

@Override
public Span createSpan(String name, Span parent) {
   if (parent == null) {
      return createSpan(name);
   }
   return continueSpan(createChild(parent, name));
}

 

如果此时没有任何span存在，那么直接通过createSpan().

 

@Override
public Span createSpan(String name) {
   return this.createSpan(name, this.defaultSampler);
}

@Override
public Span createSpan(String name, Sampler sampler) {
   String shortenedName = SpanNameUtil.shorten(name);
   Span span;
   if (isTracing()) {
      span = createChild(getCurrentSpan(), shortenedName);
   }
   else {
      long id = createId();
      span = Span.builder().name(shortenedName)
            .traceIdHigh(this.traceId128 ? createTraceIdHigh() : 0L)
            .traceId(id)
            .spanId(id).build();
      if (sampler == null) {
         sampler = this.defaultSampler;
      }
      span = sampledSpan(span, sampler);
      this.spanLogger.logStartedSpan(null, span);
   }
   return continueSpan(span);
}

 

这里可以看到spanId的构造，如果当时是首次构建spanId，那么首先会创建一个traceId，作为本次跟踪流 的id。并与第一次的spanID相同。

 

但是，此时若是已经存在span，也就是说这并不是第一次，那么就没有必要将traceId设为该次创建的spanId，而是在createChild()方法中，记录当前的traceId为原来收到的traceId,并将收到的spanId作为parentId，并将savedSpan指向原来的span，重新生成一个spanId，并将新的span作为当前的span。

 

在完成了span的创建后，则会经过sample的判断，此次是否要使用span记录，可以根据配置修改sample的类型，如果采用了百分比类型的，那么可能不会记录下来，完全复制一份span，但是把其exportable属性改为false。