Knowing how all your components work together: distributed tracing with Zipkin

转自: http://aredko.blogspot.com/2014/02/knowing-how-all-your-components-work.html

In today's post we will try to cover very interesting and important topic: distributed system tracing. What it practically means is that we will try to trace the request from the point it was issued by the client to the point the response to this request was received. At first, it looks quite straightforward but in reality it may involve many calls to several other systems, databases, NoSQL stores, caches, you name it ...

In 2010 Google published a paper about Dapper, a large-scale distributed systems tracing infrastructure (very interesting reading by the way). Later on, Twitter built its own implementation based on Dapper paper, called Zipkin and that's the one we are going to look at.

We will build a simple JAX-RS 2.0 server using great Apache CXF library. For the client side, we will use JAX-RS 2.0 client API and by utilizing Zipkin we will trace all the interactions between the client and the server (as well as everything happening on server side). To make an example a bit more illustrative, we will pretend that server uses some kind of database to retrieve the data. Our code will be a mix of pure Java and a bit of Scala (the choice of Scala will be cleared up soon).

One additional dependency in order for Zipkin to work is Apache Zookeeper. It is required for coordination and should be started in advance. Luckily, it is very easy to do:

• download the release from http://zookeeper.apache.org/releases.html (the current stable version at the moment of writing is 3.4.5)
• unpack it into zookeeper-3.4.5
• copy zookeeper-3.4.5/conf/zoo_sample.cfg to zookeeper-3.4.5/conf/zoo.cfg
• and just start Apache Zookeeper server

  Windows: zookeeper-3.4.5/bin/zkServer.cmd
  Linux: zookeeper-3.4.5/bin/zkServer.sh start

Now back to Zipkin. Zipkin is written in Scala. It is still in active development and the best way to start off with it is just by cloning its GitHub repository and build it from sources:

git clone https://github.com/twitter/zipkin.git

From architectural prospective, Zipkin consists of three main components:

• collector: collects traces across the system
• query: queries collected traces
• web: provides web-based UI to show the traces

To run them, Zipkin guys provide useful scripts in the bin folder with the only requirement that JDK 1.7 should be installed:

• bin/collector
• bin/query
• bin/web

Let's execute these scripts and ensure that every component has been started successfully, with no stack traces on the console (for curious readers, I was not able to make Zipkin work on Windows so I assume we are running it on Linux box). By default,Zipkin web UI is available on port 8080. The storage for traces is embedded SQLite engine. Though it works, the better storages (like awesome Redis) are available.

The preparation is over, let's do some code. We will start with JAX-RS 2.0 client part as it's very straightforward (ClientStarter.java):

01	package com.example.client;

02

03	import javax.ws.rs.client.Client;

04	import javax.ws.rs.client.ClientBuilder;

05	import javax.ws.rs.core.MediaType;

06	import javax.ws.rs.core.Response;

07

08	import com.example.zipkin.Zipkin;

09	import com.example.zipkin.client.ZipkinRequestFilter;

10	import com.example.zipkin.client.ZipkinResponseFilter;

11

12	public class ClientStarter {

13	public static void main( final String[] args ) throws Exception {

14	final Client client = ClientBuilder

15	.newClient()

16	.register( new ZipkinRequestFilter( "People", Zipkin.tracer() ), 1 )

17	.register( new ZipkinResponseFilter( "People", Zipkin.tracer() ), 1 );

18

19	final Response response = client

20	.target( "http://localhost:8080/rest/api/people" )

21	.request( MediaType.APPLICATION_JSON )

22

.get();

23

24	if( response.getStatus() == 200 ) {

25	System.out.println( response.readEntity( String.class ) );

26

}

27

28	response.close();

29	client.close();

30

31	// Small delay to allow tracer to send the trace over the wire

32	Thread.sleep( 1000 );

33

}

34

}

Except a couple of imports and classes with Zipkin in it, everything should look simple. So what those ZipkinRequestFilter andZipkinResponseFilter are for? Zipkin is awesome but it's not a magical tool. In order to trace any request in distributed system, there should be some context passed along with it. In REST/HTTP world, it's usually request/response headers. Let's take a look on ZipkinRequestFilter first (ZipkinRequestFilter.scala):

01	package com.example.zipkin.client

02

03	import javax.ws.rs.client.ClientRequestFilter

04	import javax.ws.rs.ext.Provider

05	import javax.ws.rs.client.ClientRequestContext

06	import com.twitter.finagle.http.HttpTracing

07	import com.twitter.finagle.tracing.Trace

08	import com.twitter.finagle.tracing.Annotation

09	import com.twitter.finagle.tracing.TraceId

10	import com.twitter.finagle.tracing.Tracer

11

12

@Provider

13	class ZipkinRequestFilter( val name: String, val tracer: Tracer ) extendsClientRequestFilter {

14	def filter( requestContext: ClientRequestContext ): Unit = {

15	Trace.pushTracerAndSetNextId( tracer, true )

16

17	requestContext.getHeaders().add( HttpTracing.Header.TraceId, Trace.id.traceId.toString )

18	requestContext.getHeaders().add( HttpTracing.Header.SpanId, Trace.id.spanId.toString )

19

20	Trace.id._parentId foreach { id =>

21	requestContext.getHeaders().add( HttpTracing.Header.ParentSpanId, id.toString )

22

}

23

24	Trace.id.sampled foreach { sampled =>

25	requestContext.getHeaders().add( HttpTracing.Header.Sampled, sampled.toString )

26

}

27

28	requestContext.getHeaders().add( HttpTracing.Header.Flags, Trace.id.flags.toLong.toString )

29

30	if( Trace.isActivelyTracing ) {

31	Trace.recordRpcname( name,  requestContext.getMethod() )

32	Trace.recordBinary( "http.uri", requestContext.getUri().toString()  )

33	Trace.record( Annotation.ClientSend() )

34

}

35

}

36

}

A bit of Zipkin internals will make this code superclear. The central part of Zipkin API is Trace class. Every time we would like to initiate tracing, we should have a Trace Id and the tracer to actually trace it. This single line generates new Trace Id and register the tracer (internally this data is held in thread local state).

1	Trace.pushTracerAndSetNextId( tracer, true )

Traces are hierarchical by nature, so do Trace Ids: every Trace Id could be a root or part of another trace. In our example, we know for sure that we are the first and as such the root of the trace. Later on the Trace Id is wrapped into HTTP headers and will be passed along the request (we will see on server side how it is being used). The last three lines associate the useful information with the trace: name of our API (People), HTTP method, URI and most importantly, that it's the client sending the request to the server.

1	Trace.recordRpcname( name,  requestContext.getMethod() )

2	Trace.recordBinary( "http.uri", requestContext.getUri().toString()  )

3	Trace.record( Annotation.ClientSend() )

The ZipkinResponseFilter does the reverse to ZipkinRequestFilter and extract the Trace Id from the request headers (ZipkinResponseFilter.scala):

01	package com.example.zipkin.client

02

03	import javax.ws.rs.client.ClientResponseFilter

04	import javax.ws.rs.client.ClientRequestContext

05	import javax.ws.rs.client.ClientResponseContext

06	import javax.ws.rs.ext.Provider

07	import com.twitter.finagle.tracing.Trace

08	import com.twitter.finagle.tracing.Annotation

09	import com.twitter.finagle.tracing.SpanId

10	import com.twitter.finagle.http.HttpTracing

11	import com.twitter.finagle.tracing.TraceId

12	import com.twitter.finagle.tracing.Flags

13	import com.twitter.finagle.tracing.Tracer

14

15

@Provider

16	class ZipkinResponseFilter( val name: String, val tracer: Tracer ) extendsClientResponseFilter {

17	def filter( requestContext: ClientRequestContext, responseContext: ClientResponseContext ): Unit = {

18	val spanId = SpanId.fromString( requestContext.getHeaders().getFirst( HttpTracing.Header.SpanId ).toString() )

19

20	spanId foreach { sid =>

21	val traceId = SpanId.fromString( requestContext.getHeaders().getFirst( HttpTracing.Header.TraceId ).toString() )

22

23	val parentSpanId = requestContext.getHeaders().getFirst( HttpTracing.Header.ParentSpanId ) match {

24	case s: String => SpanId.fromString( s.toString() )

25	case _ => None

26

}

27

28	val sampled = requestContext.getHeaders().getFirst( HttpTracing.Header.Sampled ) match {

29	case s: String =>  s.toString.toBoolean

30	case _ => true

31

}

32

33	val flags = Flags( requestContext.getHeaders().getFirst( HttpTracing.Header.Flags ).toString.toLong )

34	Trace.setId( TraceId( traceId, parentSpanId, sid, Option( sampled ), flags ) )

35

}

36

37	if( Trace.isActivelyTracing ) {

38	Trace.record( Annotation.ClientRecv() )

39

}

40

}

41

}

Strictly speaking, in our example it's not necessary to extract the Trace Id from the request because both filters should be executed by the single thread. But the last line is very important: it marks the end of our trace by saying that client has received the response.

1	Trace.record( Annotation.ClientRecv() )

What's left is actually the tracer itself (Zipkin.scala):

01	package com.example.zipkin

02

03	import com.twitter.finagle.stats.DefaultStatsReceiver

04	import com.twitter.finagle.zipkin.thrift.ZipkinTracer

05	import com.twitter.finagle.tracing.Trace

06	import javax.ws.rs.ext.Provider

07

08	object Zipkin {

09	lazy val tracer = ZipkinTracer.mk( host = "localhost", port = 9410, DefaultStatsReceiver, 1 )

10

}

If at this point you are confused what all those traces and spans mean please look through this documentation page, you will get the basic understanding of those concepts.

At this point, there is nothing left on the client side and we are good to move to the server side. Our JAX-RS 2.0 server will expose the single endpoint (PeopleRestService.java):

01	package com.example.server.rs;

02

03	import java.util.Arrays;

04	import java.util.Collection;

05	import java.util.concurrent.Callable;

06

07	import javax.ws.rs.GET;

08	import javax.ws.rs.Path;

09	import javax.ws.rs.Produces;

10

11	import com.example.model.Person;

12	import com.example.zipkin.Zipkin;

13

14	@Path( "/people" )

15	public class PeopleRestService {

16	@Produces( { "application/json" } )

17

@GET

18	public Collection< Person > getPeople() {

19	return Zipkin.invoke( "DB", "FIND ALL", new Callable< Collection< Person > >() {

20

@Override

21	public Collection<person> call() throws Exception {

22	return Arrays.asList( new Person( "Tom", "Bombdil" ) );

23

}

24

} );

25

}

26

}

27

</person>

As we mentioned before, we will simulate the access to database and generate a child trace by using Zipkin.invoke wrapper (which looks very simple, Zipkin.scala):

01	package com.example.zipkin

02

03	import java.util.concurrent.Callable

04	import com.twitter.finagle.stats.DefaultStatsReceiver

05	import com.twitter.finagle.tracing.Trace

06	import com.twitter.finagle.zipkin.thrift.ZipkinTracer

07	import com.twitter.finagle.tracing.Annotation

08

09	object Zipkin {

10	lazy val tracer = ZipkinTracer.mk( host = "localhost", port = 9410, DefaultStatsReceiver, 1 )

11

12	def invoke[ R ]( service: String, method: String, callable: Callable[ R ] ): R = Trace.unwind {

13	Trace.pushTracerAndSetNextId( tracer, false )

14

15	Trace.recordRpcname( service, method );

16	Trace.record( new Annotation.ClientSend() );

17

18

try {

19	callable.call()

20	} finally {

21	Trace.record( new Annotation.ClientRecv() );

22

}

23

}

24

}

As we can see, in this case the server itself becomes a client for some other service (database).

The last and most important part of the server is to intercept all HTTP requests, extract the Trace Id from them so it will be possible to associate more data with the trace (annotate the trace). In Apache CXF it's very easy to do by providing own invoker (ZipkinTracingInvoker.scala):

01	package com.example.zipkin.server

02

03	import org.apache.cxf.jaxrs.JAXRSInvoker

04	import com.twitter.finagle.tracing.TraceId

05	import org.apache.cxf.message.Exchange

06	import com.twitter.finagle.tracing.Trace

07	import com.twitter.finagle.tracing.Annotation

08	import org.apache.cxf.jaxrs.model.OperationResourceInfo

09	import org.apache.cxf.jaxrs.ext.MessageContextImpl

10	import com.twitter.finagle.tracing.SpanId

11	import com.twitter.finagle.http.HttpTracing

12	import com.twitter.finagle.tracing.Flags

13	import scala.collection.JavaConversions._

14	import com.twitter.finagle.tracing.Tracer

15	import javax.inject.Inject

16

17	class ZipkinTracingInvoker extends JAXRSInvoker {

18	@Inject val tracer: Tracer = null

19

20	def trace[ R ]( exchange: Exchange )( block: => R ): R = {

21	val context = new MessageContextImpl( exchange.getInMessage() )

22	Trace.pushTracer( tracer )

23

24	val id = Option( exchange.get( classOf[ OperationResourceInfo ] ) ) map { ori =>

25	context.getHttpHeaders().getRequestHeader( HttpTracing.Header.SpanId ).toList match {

26	case x :: xs => SpanId.fromString( x ) map { sid =>

27	val traceId = context.getHttpHeaders().getRequestHeader( HttpTracing.Header.TraceId ).toList match {

28	case x :: xs => SpanId.fromString( x )

29	case _ => None

30

}

31

32	val parentSpanId = context.getHttpHeaders().getRequestHeader( HttpTracing.Header.ParentSpanId ).toList match {

33	case x :: xs => SpanId.fromString( x )

34	case _ => None

35

}

36

37	val sampled = context.getHttpHeaders().getRequestHeader( HttpTracing.Header.Sampled ).toList match {

38	case x :: xs =>  x.toBoolean

39	case _ => true

40

}

41

42	val flags = context.getHttpHeaders().getRequestHeader( HttpTracing.Header.Flags ).toList match {

43	case x :: xs =>  Flags( x.toLong )

44	case _ => Flags()

45

}

46

47	val id = TraceId( traceId, parentSpanId, sid, Option( sampled ), flags )

48	Trace.setId( id )

49

50	if( Trace.isActivelyTracing ) {

51	Trace.recordRpcname( context.getHttpServletRequest().getProtocol(), ori.getHttpMethod() )

52	Trace.record( Annotation.ServerRecv() )

53

}

54

55

id

56

}

57

58	case _ => None

59

}

60

}

61

62	val result = block

63

64	if( Trace.isActivelyTracing ) {

65	id map { id => Trace.record( new Annotation.ServerSend() ) }

66

}

67

68

result

69

}

70

71

@Override

72	override def invoke( exchange: Exchange, parametersList: AnyRef ): AnyRef = {

73	trace( exchange )( super.invoke( exchange, parametersList ) )

74

}

75

}

Basically, the only thing this code does is extracting Trace Id from request and associating it with the current thread. Also please notice that we associate additional data with the trace marking the server participation.

1	Trace.recordRpcname( context.getHttpServletRequest().getProtocol(), ori.getHttpMethod() )

2	Trace.record( Annotation.ServerRecv() )

To see the tracing in live, let's start our server (please notice that sbt should be installed), assuming all Zipkin components andApache Zookeeper are already up and running:

sbt 'project server' 'run-main com.example.server.ServerStarter'

then the client:

sbt 'project client' 'run-main com.example.client.ClientStarter'

and finally open Zipkin web UI at http://localhost:8080. We should see something like that (depending how many times you have run the client):

Alternatively, we can build and run fat JARs using sbt-assembly plugin:

sbt assembly
java -jar server/target/zipkin-jaxrs-2.0-server-assembly-0.0.1-SNAPSHOT.jar
java -jar client/target/zipkin-jaxrs-2.0-client-assembly-0.0.1-SNAPSHOT.jar

If we click on any particular trace, the more detailed information will be shown, much resembling client <-> server <-> databasechain.

Even more details are shown when we click on particular element in the tree.

Lastly, the bonus part is components / services dependency graph.

As we can see, all the data associated with the trace is here and follows hierarchical structure. The root and child traces are detected and shown, as well as timelines for client send/receive and server receive/send chains. Our example is quite naive and simple, but even like that it demonstrates how powerful and useful distributed system tracing is. Thanks to Zipkin guys.

The complete source code is available on GitHub.