spring-cloud Sleuth的使用方法

public static filter create(httptracing httptracing) {

  return new tracingfilter(httptracing);

}

//servlet运行时类

final servletruntime servlet = servletruntime.get();

//slf4jcurrenttracecontext

final currenttracecontext currenttracecontext;

final tracer tracer;

final httpserverhandler<httpservletrequest, httpservletresponse> handler;

//tracecontext的数据提取器

final tracecontext.extractor<httpservletrequest> extractor;

tracingfilter(httptracing httptracing) {

  tracer = httptracing.tracing().tracer();

  currenttracecontext = httptracing.tracing().currenttracecontext();

  handler = httpserverhandler.create(httptracing, adapter);

  extractor = httptracing.tracing().propagation().extractor(getter);

}

tracing tracing;

//客户端span解析器

httpclientparser clientparser;

string servername;

//服务端span解析器

httpserverparser serverparser;

httpsampler clientsampler, serversampler;

builder(tracing tracing) {

  if (tracing == null ) throw new nullpointerexception( "tracing == null" );

  final errorparser errorparser = tracing.errorparser();

  this .tracing = tracing;

  this .servername = "" ;

  // override to re-use any custom error parser from the tracing component

  this .clientparser = new httpclientparser() {

   @override protected errorparser errorparser() {

    return errorparser;

   }

  };

  this .serverparser = new httpserverparser() {

   @override protected errorparser errorparser() {

    return errorparser;

   }

  };

  this .clientsampler = httpsampler.trace_id;

  this .serversampler(httpsampler.trace_id);

}

@bean

@conditionalonmissingbean

// note: stable bean name as might be used outside sleuth

tracing tracing( @value ( "${spring.zipkin.service.name:${spring.application.name:default}}" ) string servicename,

     propagation.factory factory,

     currenttracecontext currenttracecontext,

     reporter<zipkin2.span> reporter,

     sampler sampler,

     errorparser errorparser,

     sleuthproperties sleuthproperties

) {

   return tracing.newbuilder()

       .sampler(sampler)

       .errorparser(errorparser)

       .localservicename(servicename)

       //extrafieldpropagation.factory

       .propagationfactory(factory)

       .currenttracecontext(currenttracecontext)

       .spanreporter(adjustedreporter(reporter))

       .traceid128bit(sleuthproperties.istraceid128())

       .supportsjoin(sleuthproperties.issupportsjoin())

       .build();

}

span span = handler.handlereceive(extractor, httprequest);

  // add attributes for explicit access to customization or span context

  request.setattribute(spancustomizer. class .getname(), span.customizer());

  request.setattribute(tracecontext. class .getname(), span.context());

  throwable error = null ;

  scope scope = currenttracecontext.newscope(span.context());

  try {

   // any downstream code can see tracer.currentspan() or use tracer.currentspancustomizer()

   chain.dofilter(httprequest, httpresponse);

  } catch (ioexception | servletexception | runtimeexception | error e) {

   error = e;

   throw e;

  } finally {

   scope.close();

   if (servlet.isasync(httprequest)) { // we don't have the actual response, handle later

    servlet.handleasync(handler, httprequest, httpresponse, span);

   } else { // we have a synchronous response, so we can finish the span

    handler.handlesend(adapter.adaptresponse(httprequest, httpresponse), error, span);

   }

  }

}

@configuration

  @conditionalonclass (mdc. class )

  @enableconfigurationproperties (sleuthslf4jproperties. class )

  protected static class slf4jconfiguration {

    @bean

    @conditionalonproperty (value = "spring.sleuth.log.slf4j.enabled" , matchifmissing = true )

    @conditionalonmissingbean

    public currenttracecontext slf4jspanlogger() {

      return slf4jcurrenttracecontext.create();

    }

    ...

   }

public static final class default extends currenttracecontext {

  static final threadlocal<tracecontext> default = new threadlocal<>();

  // inheritable as brave 3's threadlocalserverclientandlocalspanstate was inheritable

  static final inheritablethreadlocal<tracecontext> inheritable = new inheritablethreadlocal<>();

  final threadlocal<tracecontext> local;

  //静态方法create，local对象为threadlocal类型

  /** uses a non-inheritable static thread local */

  public static currenttracecontext create() {

   return new default ( default );

  }

  //local对象为inheritablethreadlocal类型

  //官方文档指出，inheritable方法在线程池的环境中需谨慎使用，可能会取出错误的tracecontext，这样会导致span等信息会记录并关联到错误的traceid上

  /**

   * uses an inheritable static thread local which allows arbitrary calls to {@link

   * thread#start()} to automatically inherit this context. this feature is available as it is was

   * the default in brave 3, because some users couldn't control threads in their applications.

   *

   * <p>this can be a problem in scenarios such as thread pool expansion, leading to data being

   * recorded in the wrong span, or spans with the wrong parent. if you are impacted by this,

   * switch to {@link #create()}.

   */

  public static currenttracecontext inheritable() {

   return new default (inheritable);

  }

  default (threadlocal<tracecontext> local) {

   if (local == null ) throw new nullpointerexception( "local == null" );

   this .local = local;

  }

  @override public tracecontext get() {

   return local.get();

  }

  //替换当前tracecontext，close方法将之前的tracecontext设置回去

  //scope接口继承了closeable接口，在try中使用会自动调用close方法，为了避免用户忘记close方法，还提供了runnable，callable，executor，executorservice包装方法

  @override public scope newscope( @nullable tracecontext currentspan) {

   final tracecontext previous = local.get();

   local.set(currentspan);

   class defaultcurrenttracecontextscope implements scope {

    @override public void close() {

     local.set(previous);

    }

   }

   return new defaultcurrenttracecontextscope();

  }

}

//返回一个新的scope，如果当前scope就是传入的scope，返回一个空scope

public scope maybescope( @nullable tracecontext currentspan) {

  //获取当前tracecontext

  tracecontext currentscope = get();

  //如果传入的tracecontext为空，且当前tracecontext为空返回空scope

  if (currentspan == null ) {

   if (currentscope == null ) return scope.noop;

   return newscope( null );

  }

  return currentspan.equals(currentscope) ? scope.noop : newscope(currentspan);

}