anchor.diff:  ==== Importing into other IDEs
   Maven is well supported by most Java IDEs. Refer to you vendor documentation.
   
  +
  +IMPORTANT: There are 2 different versions of language level used in Spring Cloud Sleuth. Java 1.7 is used for main sources and
  +Java 1.8 is used for tests. When importing your project to an IDE please activate the `ide` Maven profile to turn on
  +Java 1.8 for both main and test sources. Of course remember that you MUST NOT use Java 1.8 features in the main sources. If you do
  +so your app will break during the Maven build.
   
   == Contributing
   
  
positive.code: 
  Spring Cloud Sleuth borrows http://research.google.com/pubs/pub36356.html[Dapper's] terminology.
  
  *Span:* The basic unit of work. For example, sending an RPC is a new span, as is sending a response to an RPC. Span's are identified by a unique 64-bit ID for the span and another 64-bit ID for the trace the span is a part of.  Spans also have other data, such as descriptions, timestamped events, key-value annotations (tags), the ID of the span that caused them, and process ID's (normally IP address).
  
  Spans are started and stopped, and they keep track of their timing information.  Once you create a span, you must stop it at some point in the future.
  
  *Trace:* A set of spans forming a tree-like structure.  For example, if you are running a distributed big-data store, a trace might be formed by a put request.
  
  
  
  == Features
  
  
negative.code: 2016-02-02 15:31:01.936  INFO [bar,46ab0d418373cbc9,46ab0d418373cbc9,false] 23030 --- [nio-8081-exec-4] ...
  ----
  +
  notice the `[appname,traceId,spanId,exportable]` entries from the MDC:
  
      - *spanId* - the id of a specific operation that took place
      - *appname* - the name of the application that logged the span
      - *traceId* - the id of the latency graph that contains the span
      - *exportable* - whether the log should be exported to Zipkin or not
  
  * Provides an abstraction over common distributed tracing data models: traces, spans (forming a DAG), annotations,
  key-value annotations. Loosely based on HTrace, but Zipkin (Dapper) compatible.
  
  * Sleuth records timing information to aid in latency analysis. Using sleuth, you can pinpoint causes of
  latency in your applications. Sleuth is written to not log too much, and to not cause your production application to crash.
    - propagates structural data about your call-graph in-band, and the rest out-of-band.
    - includes opinionated instrumentation of layers such as HTTP
    - includes sampling policy to manage volume
    - can report to a Zipkin system for query and visualization
  
  * Instruments common ingress and egress points from Spring applications (servlet filter, async endpoints,
  rest template, scheduled actions, message channels, zuul filters, feign client).
  
  * Provides simple metrics of accepted / dropped spans.
  
  * If `spring-cloud-sleuth-zipkin` then the app will generate and collect Zipkin-compatible traces.
  By default it sends them via HTTP to a Zipkin server on localhost (port 9411).
  Configure the location of the service using `spring.zipkin.baseUrl`.
  
  * If `spring-cloud-sleuth-stream` then the app will generate and collect traces via https://github.com/spring-cloud/spring-cloud-stream[Spring Cloud Stream].
  Your app automatically becomes a producer of tracer messages that are sent over your broker of choice
  (e.g. RabbitMQ, Apache Kafka, Redis).
  
  IMPORTANT: If using Zipkin or Stream, configure the percentage of spans exported using `spring.sleuth.sampler.percentage`
  (default 0.1, i.e. 10%). *Otherwise you might think that Sleuth is not working cause it's omitting some spans.*
  
  NOTE: the SLF4J MDC is always set and logback users will immediately see the trace and span ids in logs per the example
   above. Other logging systems have to configure their own formatter to get the same result. The default is
   `logging.pattern.level` set to `%clr(%5p) %clr([${spring.application.name:},%X{X-Trace-Id:-},%X{X-Span-Id:-},%X{X-Span-Export:-}]){yellow}`
   (this is a Spring Boot feature for logback users).
   *This means that if you're not using SLF4J this pattern WILL NOT be automatically applied*.
  
  == Running the samples
  
  