在spring-cloud-sleuth的META-INF里的spring.factories里设置了一下：
org.springframework.boot.env.EnvironmentPostProcessor=
org.springframework.cloud.sleuth.autoconfig.TraceEnvironmentPostProcessor
这样，TraceEnvironmentPostProcessor被配置在了ioc容器初始化之前。spring-cloud-sleuth-core包的org.springframework.cloud.sleuth.annotation.TraceEnvironmentPostProcessor.java
public class TraceEnvironmentPostProcessor implements EnvironmentPostProcessor { private static final String PROPERTY_SOURCE_NAME = "defaultProperties"; private static final String SPRING_AOP_PROXY_TARGET_CLASS = "spring.aop.proxyTargetClass"; @Override 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()方法里保证了两件事情:
1、设置了spring.aop.proxyTargetClass参数为true保证了cglib代理的开启，并加入了日志的追踪打印的模板。
2、而后在配置类TraceAutoConfiguration中生成了Tracer，默认实现为DefaultTraces，作用为正式创建一个工作单元span。
紧随其后的配置类为SleuthAnnotationAutoConfiguration，见spring-cloud-sleuth-core包的org.springframework.cloud.sleuth.annotation.SleuthAnnotationAutoConfiguration.java
@Configuration @ConditionalOnBean(Tracer.class) @ConditionalOnProperty(name = "spring.sleuth.annotation.enabled", matchIfMissing = true) @AutoConfigureAfter(TraceAutoConfiguration.class) @EnableConfigurationProperties(SleuthAnnotationProperties.class) public class SleuthAnnotationAutoConfiguration { @Bean @ConditionalOnMissingBean SpanCreator spanCreator(Tracer tracer) { return new DefaultSpanCreator(tracer); } //...
@Bean
SleuthAdvisorConfig sleuthAdvisorConfig() {
return new SleuthAdvisorConfig();
}
}
此处根据之前生成的Tracer进一步创建了其包装类SpanCreator，并最重要的是生成了代理的配置类SleuthAdvisorConfig。
class SleuthAdvisorConfig extends AbstractPointcutAdvisor implements BeanFactoryAware { private Advice advice; private Pointcut pointcut; private BeanFactory beanFactory; @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(); } /** * Checks if a class or a method is is annotated with Sleuth related annotations */ 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(); }
class SleuthInterceptor implements IntroductionInterceptor, BeanFactoryAware { private static final Log logger = LogFactory.getLog(MethodHandles.lookup().lookupClass()); private static final String CLASS_KEY = "class"; private static final String METHOD_KEY = "method"; private BeanFactory beanFactory; private SpanCreator spanCreator; private Tracer tracer; private SpanTagAnnotationHandler spanTagAnnotationHandler; private ErrorParser errorParser; @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()方法中。
class SpanContextHolder { private static final Log log = org.apache.commons.logging.LogFactory .getLog(SpanContextHolder.class); private static final ThreadLocal<SpanContext> CURRENT_SPAN = new NamedThreadLocal<>( "Trace Context"); /** * Get the current span out of the thread context */ 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。