ASP.NET Core整合Zipkin链路跟踪的实现方法

害羞小萌

前言

    在日常使用ASP.NET Core的开发或学习中，如果有需要使用链路跟踪系统，大多数情况下会优先选择SkyAPM。我们之前也说过SkyAPM设计确实比较优秀，巧妙的利用DiagnosticSource诊断跟踪日志，可以做到对项目无入侵方式的集成。其实还有一款比较优秀的链路跟踪系统，也可以支持ASP.NET Core，叫Zipkin。它相对于SkyWalking来说相对轻量级，使用相对来说比较偏原生的方式，而且支持Http的形式查询和提交链路数据。因为我们总是希望能拥有多一种的解决方案方便对比和参考，所以接下来我们就来学习一下关于Zipkin的使用方式。

Zipkin简介

    Zipkin是由Twitter开源的一款基于Java语言开发的分布式实时数据追踪系统(Distributed Tracking System),其主要功能是采集来自各个系统的实时监控数据。该系统让开发者可通过一个 Web 前端轻松的收集和分析数据，例如用户每次请求服务的处理时间等，可方便的监测系统中存在的瓶颈。它大致可以分为三个核心概念

• 首先是上报端，它主要通过代码的形式集成到程序中，用于上报Trace数据到Collector端。
• Collector负责接收客户端发送过来的数据，保存到内存或外部存储系统中，供UI展示。
• 存储端可以是基于zipkin内存完全不依赖外部存储的In-Memory形式或依赖外部存储系统的形式，一般采用外部存储系统存储链路数据，毕竟内存有限。它可支持的存储数据库有MySQL、Cassandra、Elasticsearch。
• UI负责展示采集的链路数据，及系统之间的依赖关系。

相对来说还是比较清晰的，如果用一张图表示整体架构的话，大致如下图所示(图片来源于网络)

在学习链路跟踪的过程中会设计到相关概念，我们接下来介绍链路跟踪几个相关的概念

• TranceId,一般一次全局的请求会有一个唯一的TraceId，用于代表一次唯一的请求。比如我请求了订单管理系统，而订单管理系统内部还调用了商品管理系统，而商品管理系统还调用了缓存系统或数据库系统。但是对全局或外部来说这是一次请求，所以会有唯一的一个TraceId。
• SpanId,虽然全局的来说是一次大的请求，但是在这个链路中内部间还会发起别的请求，这种内部间的每次请求会生成一个SpanId。
• 如果将整条链路串联起来的话，我们需要记录全局的TraceId，代表当前节点的SpanId和发起对当前节点调用的的父级ParentId。
• 然后基于链路跟踪的核心概念，然后介绍一下Zipkin衍生出来了几个相关概念
• cs:Clent Sent 客户端发起请求的时间，比如 dubbo 调用端开始执行远程调用之前。
• cr:Client Receive 客户端收到处理完请求的时间。
• ss:Server Receive 服务端处理完逻辑的时间。

1. sr - cs = 请求在网络上的耗时
2. ss - sr = 服务端处理请求的耗时
3. cr - ss = 回应在网络上的耗时
4. cr - cs = 一次调用的整体耗时

复制代码

关于zipkin概念相关的就介绍这么多，接下来我们介绍如何部署Zipkin。

部署ZipKin

    关于Zipkin常用的部署方式大概有两种，一种是通过下载安装JDK，然后运行zipkin.jar的方式，另一种是基于Docker的方式。为了方便我采用的是基于Docker的方式部署，因为采用原生的方式去部署还需要安装JDK，而且操作相对比较麻烦。咱们上面说过，虽然Zipkin可以将链路数据存放到内存中，但是这种操作方式并不实用，实际使用过程中多采用ElasticSearch存储链路数据。所以部署的时候需要依赖Zipkin和ElasticSearch，对于这种部署形式采用docker-compose的方式就再合适不过了，大家可以在Zipkin官方Github中找到docker的部署方式，地址是https://github.com/openzipkin/zipkin/tree/master/docker,官方使用的方式相对比较复杂，下载下来docker-compose相关文件之后我简化了它的使用方式，最终修改如下

1. version: "3.6"
2. services:
3. elasticsearch:
4. # 我使用的是7.5.0版本
5. image: elasticsearch:7.5.0
6. container_name: elasticsearch
7. restart: always
8. #暴露es端口
9. ports:
10. - 9200:9200
11. environment:
12. - discovery.type=single-node
13. - bootstrap.memory_lock=true
14. #es有内存要求
15. - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
16. ulimits:
17. memlock:
18. soft: -1
19. hard: -1
20. networks:
21. default:
22. aliases:
23. - elasticsearch
25. zipkin:
26. image: openzipkin/zipkin
27. container_name: zipkin
28. restart: always
29. networks:
30. default:
31. aliases:
32. - zipkin
33. environment:
34. #存储类型为es
35. - STORAGE_TYPE=elasticsearch
36. #es地址
37. - ES_HOSTS=elasticsearch:9200
38. ports:
39. - 9411:9411
40. #依赖es所以在es启动完成后在启动zipkin
41. depends_on:
42. - elasticsearch

复制代码

通过docker-compose运行编辑后的yaml文件,一条指令就可以运行起来

1. <PackageReference Include="zipkin4net" Version="1.5.0" />
2. <PackageReference Include="zipkin4net.middleware.aspnetcore" Version="1.5.0" />

复制代码

其中-f是指定文件名称，如果是docker-compose.yml则可以直接忽略文件名称，当shell中出现如下界面

并且在浏览器中输入http://localhost:9411/zipkin/出现如图所示，则说明Zikpin启动成功

整合ASP.NET Core

ZipKin启动成功之后，我们就可以将程序中的数据采集到Zipkin中去了，我新建了两个ASP.NET Core的程序，一个是OrderApi,另一个是ProductApi方便能体现出调用链路，其中OrderApi调用ProductApi接口，在两个项目中分别引入Zipkin依赖包

1. <PackageReference Include="zipkin4net" Version="1.5.0" />
2. <PackageReference Include="zipkin4net.middleware.aspnetcore" Version="1.5.0" />

复制代码

其中zipkin4net为核心包，zipkin4net.middleware.aspnetcore是集成ASP.NET Core的程序包。然后我们在Startup文件中添加如下方法

1. public void RegisterZipkinTrace(IApplicationBuilder app, ILoggerFactory loggerFactory, IHostApplicationLifetime lifetime)
2. {
3. lifetime.ApplicationStarted.Register(() =>
4. {
5. //记录数据密度，1.0代表全部记录
6. TraceManager.SamplingRate = 1.0f;
7. //链路日志
8. var logger = new TracingLogger(loggerFactory, "zipkin4net");
9. //zipkin服务地址和内容类型
10. var httpSender = new HttpZipkinSender("http://localhost:9411/", "application/json");
11. var tracer = new ZipkinTracer(httpSender, new JSONSpanSerializer(), new Statistics());
12. var consoleTracer = new zipkin4net.Tracers.ConsoleTracer();
14. TraceManager.RegisterTracer(tracer);
15. TraceManager.RegisterTracer(consoleTracer);
16. TraceManager.Start(logger);
18. });
19. //程序停止时停止链路跟踪
20. lifetime.ApplicationStopped.Register(() => TraceManager.Stop());
21. //引入zipkin中间件，用于跟踪服务请求,这边的名字可自定义代表当前服务名称
22. app.UseTracing(Configuration["nacos:ServiceName"]);
23. }

复制代码

然后我们在Configure方法中调用RegisterZipkinTrace方法即可。由于我们要在OrderApi项目中采用HttpClient的方式调用ProductAPI,默认zipkin4net是支持采集HttpClient发出请求的链路数据(由于在ProductApi中我们并不发送Http请求，所以可以不用集成一下操作)，具体集成形式如下，如果使用的是HttpClientFactory的方式，在ConfigureServices中配置如下

1. public void ConfigureServices(IServiceCollection services)
2. {
3. //由于我使用了Nacos作为服务注册中心
4. services.AddNacosAspNetCore(Configuration);
5. services.AddScoped<NacosDiscoveryDelegatingHandler>();
6. services.AddHttpClient(ServiceName.ProductService,client=> {
7. client.BaseAddress = new Uri($"http://{ServiceName.ProductService}");
8. })
9. .AddHttpMessageHandler<NacosDiscoveryDelegatingHandler>()
10. //引入zipkin trace跟踪httpclient请求，名称配置当前服务名称即可
11. .AddHttpMessageHandler(provider =>TracingHandler.WithoutInnerHandler(Configuration["nacos:ServiceName"]));
12. services.AddControllers();
13. }

复制代码

如果是直接是使用HttpClient的形式调用则可以采用以下方式

1. using (HttpClient client = new HttpClient(new TracingHandler("OrderApi")))
2. {
3. }

复制代码

然后我们在OrderApi中写一段调用ProductApi的代码

1. [Route("orderapi/[controller]")]
2. public class OrderController : ControllerBase
3. {
4. private List<OrderDto> orderDtos = new List<OrderDto>();
5. private readonly IHttpClientFactory _clientFactory;
7. public OrderController(IHttpClientFactory clientFactory)
8. {
9. orderDtos.Add(new OrderDto { Id = 1, TotalMoney=222,Address="北京市",Addressee="me",From="淘宝",SendAddress="武汉" });
10. _clientFactory = clientFactory;
11. }
13. /// <summary>
14. /// 获取订单详情接口
15. /// </summary>
16. /// <param name="id">订单id</param>
17. /// <returns></returns>
18. [HttpGet("getdetails/{id}")]
19. public async Task<OrderDto> GetOrderDetailsAsync(long id)
20. {
21. OrderDto orderDto = orderDtos.FirstOrDefault(i => i.Id == id);
22. if (orderDto != null)
23. {
24. OrderDetailDto orderDetailDto = new OrderDetailDto
25. {
26. Id = orderDto.Id,
27. TotalMoney = orderDto.TotalMoney,
28. Address = orderDto.Address,
29. Addressee = orderDto.Addressee,
30. From = orderDto.From,
31. SendAddress = orderDto.SendAddress
32. };
33. //调用ProductApi服务接口
34. var client = _clientFactory.CreateClient(ServiceName.ProductService);
35. var response = await client.GetAsync($"/productapi/product/getall");
36. var result = await response.Content.ReadAsStringAsync();
38. orderDetailDto.Products = JsonConvert.DeserializeObject<List<OrderProductDto>>(result);
39. return orderDetailDto;
40. }
41. return orderDto;
42. }
43. }

复制代码

在ProductApi中我们只需要编写调用RegisterZipkinTrace方法即可，和OrderApi一样，我们就不重复粘贴了。因为ProductApi不需要调用别的服务，所以可以不必使用集成HttpClient,只需要提供简单的接口即可

1. [Route("productapi/[controller]")]
2. public class ProductController : ControllerBase
3. {
4. private List<ProductDto> productDtos = new List<ProductDto>();
5. public ProductController()
6. {
7. productDtos.Add(new ProductDto { Id = 1,Name="酒精",Price=22.5m });
8. productDtos.Add(new ProductDto { Id = 2, Name = "84消毒液", Price = 19.9m });
9. }
11. /// <summary>
12. /// 获取所有商品信息
13. /// </summary>
14. /// <returns></returns>
15. [HttpGet("getall")]
16. public IEnumerable<ProductDto> GetAll()
17. {
18. return productDtos;
19. }
20. }

复制代码

启动这两个项目，调用OrderApi的getdetails接口，完成后打开zipkin界面

点击进去可查看链路详情

总结起来核心操作其实就两个，一个是在发送请求的地方，使用TracingHandler记录发起端的链路情况，然后在接收请求的服务端使用UseTracing记录来自于客户端请求的链路情况。

改进集成方式

    其实在上面的演示中，我们可以明显的看到明显的不足，就是很多时候其实我们没办法去设置HttpClient相关的参数的，很多框架虽然也是使用的HttpClient或HttpClientFactory相关，但是在外部我们没办法通过自定义的方式去设置他们的相关操作，比如Ocelot其实也是使用HttpClient相关发起的转发请求，但是对外我们没办法通过我们的程序去设置HttpClient的参数。还有就是在.Net Core中WebRequest其实也是对HttpClient的封装，但是我们同样没办法在我们的程序中给他们传递类似TracingHandler的操作。现在我们从TracingHandler源码开始解读看看它的内部到底是如何工作的，zipkin官方提供的.net core插件zipkin4net的源码位于
https://github.com/openzipkin/zipkin4net,我们找到TracingHandler类所在的位置[点击查看源码👈]，由于TracingHandler本身就是DelegatingHandler的子类，所以我们主要看SendAsync方法，大致抽离出来如下

1. protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, System.Threading.CancellationToken cancellationToken)
2. {
3. Func<HttpRequestMessage, string> _getClientTraceRpc = _getClientTraceRpc = getClientTraceRpc ?? (request => request.Method.ToString());
4. IInjector<HttpHeaders> _injector = Propagations.B3String.Injector<HttpHeaders>((carrier, key, value) => carrier.Add(key, value));
5. //记录发起请求客户端链路信息的类是ClientTrace
6. using (var clientTrace = new ClientTrace(_serviceName, _getClientTraceRpc(request)))
7. {
8. if (clientTrace.Trace != null)
9. {
10. _injector.Inject(clientTrace.Trace.CurrentSpan, request.Headers);
11. }
13. var result = await clientTrace.TracedActionAsync(base.SendAsync(request, cancellationToken));
14. //AddAnnotation是记录标签信息，我们可以在zipkin链路详情中看到这些标签
15. if (clientTrace.Trace != null)
16. {
17. //记录请求路径
18. clientTrace.AddAnnotation(Annotations.Tag(zipkinCoreConstants.HTTP_PATH, result.RequestMessage.RequestUri.LocalPath));
19. //记录请求的http方法
20. clientTrace.AddAnnotation(Annotations.Tag(zipkinCoreConstants.HTTP_METHOD, result.RequestMessage.Method.Method));
21. if (_logHttpHost)
22. {
23. //记录主机
24. clientTrace.AddAnnotation(Annotations.Tag(zipkinCoreConstants.HTTP_HOST, result.RequestMessage.RequestUri.Host));
25. }
26. if (!result.IsSuccessStatusCode)
27. {
28. clientTrace.AddAnnotation(Annotations.Tag(zipkinCoreConstants.HTTP_STATUS_CODE, ((int)result.StatusCode).ToString()));
29. }
30. }
31. return result;
32. }
33. }

复制代码

实现方式比较简单，就是借助ClientTrace记录一些标签，其他的相关操作都是由zipkin4net提供的。我们在之前的文章.Net Core中的诊断日志DiagnosticSource讲解中层说道HttpClient底层会有发出诊断日志，我们可以借助这个思路，来对HttpClient进行链路跟踪埋点。
我们结合Microsoft.Extensions.DiagnosticAdapter扩展包定义如下类

1. public class HttpDiagnosticListener: ITraceDiagnosticListener
2. {
3. public string DiagnosticName => "HttpHandlerDiagnosticListener";
5. private ClientTrace clientTrace;
6. private readonly IInjector<HttpHeaders> _injector = Propagations.B3String.Injector<HttpHeaders>((carrier, key, value) => carrier.Add(key, value));
8. [DiagnosticName("System.Net.Http.Request")]
9. public void HttpRequest(HttpRequestMessage request)
10. {
11. clientTrace = new ClientTrace("apigateway", request.Method.Method);
12. if (clientTrace.Trace != null)
13. {
14. _injector.Inject(clientTrace.Trace.CurrentSpan, request.Headers);
15. }
16. }
18. [DiagnosticName("System.Net.Http.Response")]
19. public void HttpResponse(HttpResponseMessage response)
20. {
21. if (clientTrace.Trace != null)
22. {
23. clientTrace.AddAnnotation(Annotations.Tag(zipkinCoreConstants.HTTP_PATH, response.RequestMessage.RequestUri.LocalPath));
24. clientTrace.AddAnnotation(Annotations.Tag(zipkinCoreConstants.HTTP_METHOD, response.RequestMessage.Method.Method));
25. clientTrace.AddAnnotation(Annotations.Tag(zipkinCoreConstants.HTTP_HOST, response.RequestMessage.RequestUri.Host));
26. if (!response.IsSuccessStatusCode)
27. {
28. clientTrace.AddAnnotation(Annotations.Tag(zipkinCoreConstants.HTTP_STATUS_CODE, ((int)response.StatusCode).ToString()));
29. }
30. }
31. }
33. [DiagnosticName("System.Net.Http.Exception")]
34. public void HttpException(HttpRequestMessage request,Exception exception)
35. {
36. }
37. }

复制代码

ITraceDiagnosticListener是我们方便操作DiagnosticListener定义的接口，接口仅包含DiagnosticName用来表示DiagnosticListener监听的名称，有了这个接口接下来的操作我们会方便许多，接下来我们来看订阅操作的实现。

1. public class TraceObserver :IObserver<DiagnosticListener>
2. {
3. private IEnumerable<ITraceDiagnosticListener> _traceDiagnostics;
4. public TraceObserver(IEnumerable<ITraceDiagnosticListener> traceDiagnostics)
5. {
6. _traceDiagnostics = traceDiagnostics;
7. }
9. public void OnCompleted()
10. {
11. }
13. public void OnError(Exception error)
14. {
15. }
17. public void OnNext(DiagnosticListener listener)
18. {
19. //这样的话我们可以更轻松的扩展其他DiagnosticListener的操作
20. var traceDiagnostic = _traceDiagnostics.FirstOrDefault(i=>i.DiagnosticName==listener.Name);
21. if (traceDiagnostic!=null)
22. {
23. //适配订阅
24. listener.SubscribeWithAdapter(traceDiagnostic);
25. }
26. }
27. }

复制代码

通过这种操作我们就无需关心如何将自定义的DiagnosticListener订阅类适配到DiagnosticAdapter中去，方便我们自定义其他DiagnosticListener的订阅类，这样的话我们只需注册自定义的订阅类即可。

1. services.AddSingleton<TraceObserver>();
2. services.AddSingleton<ITraceDiagnosticListener, HttpDiagnosticListener>();

复制代码

通过这种改进方式，我们可以解决类似HttpClient封装到框架中，并且我们我们无法通过外部程序去修改设置的时候。比如我们在架构中引入了Ocelot网关，我们就可以采用类似这种方式，在网关层集成zipkin4net。

自定义埋点

    通过上面我们查看TracingHandler的源码我们得知埋点主要是通过ClientTrace进行的，它是在发起请求的客户端进行埋点。在服务端埋点的方式我们可以通过TracingMiddleware中间件中的源码查看到[点击查看源码👈]叫ServerTrace。有了ClientTrace和ServerTrace我们可以非常轻松的实现一次完整的客户端和服务端埋点，只需要通过它们打上一些标签即可。其实它们都是对Trace类的封装，我们找到它们的源码进行查看

1. public class ClientTrace : BaseStandardTrace, IDisposable
2. {
3. public ClientTrace(string serviceName, string rpc)
4. {
5. if (Trace.Current != null)
6. {
7. Trace = Trace.Current.Child();
8. }
10. Trace.Record(Annotations.ClientSend());
11. Trace.Record(Annotations.ServiceName(serviceName));
12. Trace.Record(Annotations.Rpc(rpc));
13. }
15. public void Dispose()
16. {
17. Trace.Record(Annotations.ClientRecv());
18. }
19. }
21. public class ServerTrace : BaseStandardTrace, IDisposable
22. {
23. public override Trace Trace
24. {
25. get
26. {
27. return Trace.Current;
28. }
29. }
31. public ServerTrace(string serviceName, string rpc)
32. {
33. Trace.Record(Annotations.ServerRecv());
34. Trace.Record(Annotations.ServiceName(serviceName));
35. Trace.Record(Annotations.Rpc(rpc));
36. }
38. public void Dispose()
39. {
40. Trace.Record(Annotations.ServerSend());
41. }
42. }

复制代码

因此，如果你想通过更原始的方式去记录跟踪日志可以采用如下方式

1. var trace = Trace.Create();
2. trace.Record(Annotations.ServerRecv());
3. trace.Record(Annotations.ServiceName(serviceName));
4. trace.Record(Annotations.Rpc("GET"));
5. trace.Record(Annotations.ServerSend());
6. trace.Record(Annotations.Tag("http.url", "<url>"));

复制代码

示例Demo

由于上面说的比较多，而且有一部分关于源码的解读，为了防止由本人文笔有限，给大家带来理解误区，另一方面也为了更清晰的展示Zipkin的集成方式，我自己做了一套Demo，目录结构如下

ApiGateway为网关项目可以转发针对OrderApi的请求，OrderApi和ProductApi用于模拟业务系统，这三个项目都集成了zipkin4net链路跟踪，他们之间是通过Nacos实现服务的注册和发现。这个演示Demo我本地是可以直接运行成功的，如果有下载下来运行不成功的，可以评论区给我留言。由于博客园有文件上传大小的限制，所以我将Demo上传到了百度网盘中
下载链接:链接: https://pan.baidu.com/s/1LDyoRQehaE0FzedFTC4_Og 提取码: i45x 

总结

    以上就是关于Zipkin以及ASP.NET Core整合Zipkin的全部内容，希望能给大家带来一定的帮助。如果你有实际需要也可以继续自行研究。Zipkin相对于我们常用的Skywalking而且，它的使用方式比较原生，许多操作都需要自行通过代码操作，而SkyAPM可以做到对代码无入侵的方式集成。Skywalking是一款APM(应用性能管理)，链路跟踪只是它功能的一部分。而Zipkin是一款专注于链路跟踪的系统，个人感觉就链路跟踪这一块而言，Zipkin更轻量级(如果使用ES作为存储数据库的话，Skywalking默认会生成一堆索引，而Zipkin默认是每天创建一个索引)，而且链路信息检索、详情展示、链路数据上报形式等相对于Skywalking形式也更丰富一些。但是整体而言Skywalking更强大，比如应用监控、调用分析、集成方式等。技术并无好坏之分，适合自己的才是更好的，多一个解决方案，就多一个解决问题的思路，我觉得这是对于我们程序开发人员来说都应该具备的认知。

到此这篇关于ASP.NET Core整合Zipkin链路跟踪的实现方法的文章就介绍到这了,更多相关ASP.NET Core整合Zipkin链路跟踪内容请搜索晓枫资讯以前的文章或继续浏览下面的相关文章希望大家以后多多支持晓枫资讯！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！