【第二十八章】 springboot + zipkin（brave定制-AsyncHttpClient）

最新推荐文章于 2021-06-26 18:24:10 发布
最新推荐文章于 2021-06-26 18:24:10 发布
阅读量109 收藏
点赞数
文章标签： java

brave本身没有对AsyncHttpClient提供类似于brave-okhttp的ClientRequestInterceptor和ClientResponseInterceptor，所以需要我们定制，而ServerRequestInterceptor和ServerResponseInterceptor是在BraveServletFilter部分直接指定就好了（这在任何client技术下都可以复用）。

实际上，ClientRequestInterceptor和ClientResponseInterceptor也是我们的定制点。

 

一、代码

基本参考第二十七章 springboot + zipkin（brave-okhttp实现）

1、service1

1.1、pom.xml

<!-- zipkin brave -->
        <dependency>
            <groupId>io.zipkin.brave</groupId>
            <artifactId>brave-core</artifactId>
            <version>3.9.0</version>
        </dependency>
        <dependency>
            <groupId>io.zipkin.brave</groupId>
            <artifactId>brave-spancollector-http</artifactId>
            <version>3.9.0</version>
        </dependency>
        <dependency>
            <groupId>io.zipkin.brave</groupId>
            <artifactId>brave-web-servlet-filter</artifactId>
            <version>3.9.0</version>
        </dependency>
        <!-- async-http-client -->
        <dependency>
            <groupId>com.ning</groupId>
            <artifactId>async-http-client</artifactId>
            <version>1.9.31</version>
        </dependency>

1.2、ZipkinConfig

package com.xxx.service1.zipkin.brave.async;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.github.kristofa.brave.Brave;
import com.github.kristofa.brave.EmptySpanCollectorMetricsHandler;
import com.github.kristofa.brave.Sampler;
import com.github.kristofa.brave.SpanCollector;
import com.github.kristofa.brave.http.DefaultSpanNameProvider;
import com.github.kristofa.brave.http.HttpSpanCollector;
import com.github.kristofa.brave.servlet.BraveServletFilter;
import com.ning.http.client.AsyncHttpClient;

@Configuration
public class ZipkinConfig {
    @Bean
    public SpanCollector spanCollector() {
        HttpSpanCollector.Config spanConfig = HttpSpanCollector.Config.builder()
                                              .compressionEnabled(false)//默认false，span在transport之前是否会被gzipped。
                                              .connectTimeout(5000)//5s，默认10s
                                              .flushInterval(1)//1s
                                              .readTimeout(6000)//5s，默认60s
                                              .build();
        return HttpSpanCollector.create("http://localhost:9411", 
                                        spanConfig,
                                        new EmptySpanCollectorMetricsHandler());
    }

    @Bean
    public Brave brave(SpanCollector spanCollector) {
        Brave.Builder builder = new Brave.Builder("asyn1 - service1 - 1");//指定serviceName
        builder.spanCollector(spanCollector);
        builder.traceSampler(Sampler.create(1));//采集率
        return builder.build();
    }

    @Bean
    public BraveServletFilter braveServletFilter(Brave brave) {
        /**
         * 设置sr、ss拦截器
         */
        return new BraveServletFilter(brave.serverRequestInterceptor(), 
                                      brave.serverResponseInterceptor(),
                                      new DefaultSpanNameProvider());
    }

    @Bean
    public AsyncHttpClient asyncHttpClient(){
        return new AsyncHttpClient();
    }
}

说明：指定了serviceName："asyn1 - service1 - 1"

1.3、ZipkinAsyncController

package com.xxx.service1.zipkin.brave.async;

import java.net.URI;
import java.util.concurrent.Future;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.github.kristofa.brave.Brave;
import com.github.kristofa.brave.http.DefaultSpanNameProvider;
import com.github.kristofa.brave.http.HttpClientRequest;
import com.github.kristofa.brave.http.HttpClientRequestAdapter;
import com.github.kristofa.brave.http.HttpClientResponseAdapter;
import com.github.kristofa.brave.http.HttpResponse;
import com.ning.http.client.AsyncHttpClient;
import com.ning.http.client.Request;
import com.ning.http.client.RequestBuilder;
import com.ning.http.client.Response;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;

@Api("zipkin brave async api")
@RestController
@RequestMapping("/zipkin/async/service1")
public class ZipkinAsyncController {

    @Autowired
    private AsyncHttpClient asyncHttpClient;
    @Autowired
    private Brave           brave;

    @ApiOperation("trace第一步")
    @RequestMapping(value = "/test1", method = RequestMethod.GET)
    public String myboot() {

        try {
            RequestBuilder builder = new RequestBuilder();
            String url = "http://localhost:8032/zipkin/async/service2/test2";
            builder.setUrl(url);
            Request request = builder.build();

            clientRequestInterceptor(request);
            Future<Response> response = asyncHttpClient.executeRequest(request);
            clientResponseInterceptor(response.get());

            return response.get().getResponseBody();
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }

    private void clientRequestInterceptor(Request request) {
        brave.clientRequestInterceptor().handle(new HttpClientRequestAdapter(new HttpClientRequest() {

            @Override
            public URI getUri() {
                return URI.create(request.getUrl());
            }

            @Override
            public String getHttpMethod() {
                return request.getMethod();
            }

            @Override
            public void addHeader(String headerKey, String headerValue) {
                request.getHeaders().add(headerKey, headerValue);
            }
        }, new DefaultSpanNameProvider()));
    }

    private void clientResponseInterceptor(Response response) {
        brave.clientResponseInterceptor().handle(new HttpClientResponseAdapter(new HttpResponse() {
            public int getHttpStatusCode() {
                return response.getStatusCode();
            }
        }));
    }

}

说明：

  • clientRequestInterceptor(com.ning.http.client.Request request)
    • 其实就是在做cs
  • clientResponseInterceptor(com.ning.http.client.Response response)
    • 其实就是在做cr

 

2、service2

2.1、pom.xml

<!-- zipkin brave -->
        <dependency>
            <groupId>io.zipkin.brave</groupId>
            <artifactId>brave-core</artifactId>
            <version>3.9.0</version>
        </dependency>
        <dependency>
            <groupId>io.zipkin.brave</groupId>
            <artifactId>brave-spancollector-http</artifactId>
            <version>3.9.0</version>
        </dependency>
        <dependency>
            <groupId>io.zipkin.brave</groupId>
            <artifactId>brave-web-servlet-filter</artifactId>
            <version>3.9.0</version>
        </dependency>
        <!-- async-http-client -->
        <dependency>
            <groupId>com.ning</groupId>
            <artifactId>async-http-client</artifactId>
            <version>1.9.31</version>
        </dependency>

2.2、ZipkinConfig

package com.xxx.service1.zipkin.brave.async;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.github.kristofa.brave.Brave;
import com.github.kristofa.brave.EmptySpanCollectorMetricsHandler;
import com.github.kristofa.brave.Sampler;
import com.github.kristofa.brave.SpanCollector;
import com.github.kristofa.brave.http.DefaultSpanNameProvider;
import com.github.kristofa.brave.http.HttpSpanCollector;
import com.github.kristofa.brave.servlet.BraveServletFilter;
import com.ning.http.client.AsyncHttpClient;

@Configuration
public class ZipkinConfig {
    @Bean
    public SpanCollector spanCollector() {
        HttpSpanCollector.Config spanConfig = HttpSpanCollector.Config.builder()
                                              .compressionEnabled(false)//默认false，span在transport之前是否会被gzipped。
                                              .connectTimeout(5000)//5s，默认10s
                                              .flushInterval(1)//1s
                                              .readTimeout(6000)//5s，默认60s
                                              .build();
        return HttpSpanCollector.create("http://localhost:9411", 
                                        spanConfig,
                                        new EmptySpanCollectorMetricsHandler());
    }

    @Bean
    public Brave brave(SpanCollector spanCollector) {
        Brave.Builder builder = new Brave.Builder("asyn2 - service2 - 2");//指定serviceName
        builder.spanCollector(spanCollector);
        builder.traceSampler(Sampler.create(1));//采集率
        return builder.build();
    }

    @Bean
    public BraveServletFilter braveServletFilter(Brave brave) {
        /**
         * 设置sr、ss拦截器
         */
        return new BraveServletFilter(brave.serverRequestInterceptor(), 
                                      brave.serverResponseInterceptor(),
                                      new DefaultSpanNameProvider());
    }

    @Bean
    public AsyncHttpClient asyncHttpClient(){
        return new AsyncHttpClient();
    }
}

说明：指定了serviceName："asyn2 - service2 - 2"

2.3、ZipkinAsyncController

package com.xxx.service2.zipkin.brave.async;

import java.net.URI;
import java.util.concurrent.Future;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.github.kristofa.brave.Brave;
import com.github.kristofa.brave.http.DefaultSpanNameProvider;
import com.github.kristofa.brave.http.HttpClientRequest;
import com.github.kristofa.brave.http.HttpClientRequestAdapter;
import com.github.kristofa.brave.http.HttpClientResponseAdapter;
import com.github.kristofa.brave.http.HttpResponse;
import com.ning.http.client.AsyncHttpClient;
import com.ning.http.client.Request;
import com.ning.http.client.RequestBuilder;
import com.ning.http.client.Response;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;

@Api("zipkin brave async api")
@RestController
@RequestMapping("/zipkin/async/service2")
public class ZipkinAsyncController {

    @Autowired
    private AsyncHttpClient asyncHttpClient;
    @Autowired
    private Brave           brave;

    @ApiOperation("trace第2步")
    @RequestMapping(value = "/test2", method = RequestMethod.GET)
    public String myboot2() {

        try {
            /*****************************serivce3*******************************/
            RequestBuilder builder3 = new RequestBuilder();
            String url3 = "http://localhost:8033/zipkin/async/service3/test3";
            builder3.setUrl(url3);
            Request request3 = builder3.build();

            clientRequestInterceptor(request3);
            Future<Response> response3 = asyncHttpClient.executeRequest(request3);
            clientResponseInterceptor(response3.get());

            /*****************************serivce4*******************************/
            RequestBuilder builder4 = new RequestBuilder();
            String url4 = "http://localhost:8034/zipkin/async/service4/test4";
            builder4.setUrl(url4);
            Request request4 = builder4.build();

            clientRequestInterceptor(request4);
            Future<Response> response4 = asyncHttpClient.executeRequest(request4);
            clientResponseInterceptor(response4.get());

            return response3.get().getResponseBody() + "=====" + response4.get().getResponseBody();
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }

    private void clientRequestInterceptor(Request request) {
        brave.clientRequestInterceptor().handle(new HttpClientRequestAdapter(new HttpClientRequest() {

            @Override
            public URI getUri() {
                return URI.create(request.getUrl());
            }

            @Override
            public String getHttpMethod() {
                return request.getMethod();
            }

            @Override
            public void addHeader(String headerKey, String headerValue) {
                request.getHeaders().add(headerKey, headerValue);
            }
        }, new DefaultSpanNameProvider()));
    }

    private void clientResponseInterceptor(Response response) {
        brave.clientResponseInterceptor().handle(new HttpClientResponseAdapter(new HttpResponse() {
            public int getHttpStatusCode() {
                return response.getStatusCode();
            }
        }));
    }

}

3、service3

3.1、pom.xml

<!-- zipkin brave -->
        <dependency>
            <groupId>io.zipkin.brave</groupId>
            <artifactId>brave-core</artifactId>
            <version>3.9.0</version>
        </dependency>
        <dependency>
            <groupId>io.zipkin.brave</groupId>
            <artifactId>brave-spancollector-http</artifactId>
            <version>3.9.0</version>
        </dependency>
        <dependency>
            <groupId>io.zipkin.brave</groupId>
            <artifactId>brave-web-servlet-filter</artifactId>
            <version>3.9.0</version>
        </dependency>

3.2、ZipkinConfig

package com.xxx.service3.zipkin.brave.async;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.github.kristofa.brave.Brave;
import com.github.kristofa.brave.EmptySpanCollectorMetricsHandler;
import com.github.kristofa.brave.Sampler;
import com.github.kristofa.brave.SpanCollector;
import com.github.kristofa.brave.http.DefaultSpanNameProvider;
import com.github.kristofa.brave.http.HttpSpanCollector;
import com.github.kristofa.brave.servlet.BraveServletFilter;

@Configuration
public class ZipkinConfig {
    @Bean
    public SpanCollector spanCollector() {
        HttpSpanCollector.Config spanConfig = HttpSpanCollector.Config.builder()
                                              .compressionEnabled(false)//默认false，span在transport之前是否会被gzipped。
                                              .connectTimeout(5000)//5s，默认10s
                                              .flushInterval(1)//1s
                                              .readTimeout(6000)//5s，默认60s
                                              .build();
        return HttpSpanCollector.create("http://localhost:9411", 
                                        spanConfig,
                                        new EmptySpanCollectorMetricsHandler());
    }

    @Bean
    public Brave brave(SpanCollector spanCollector) {
        Brave.Builder builder = new Brave.Builder("asyn3 - service3 - 3");//指定serviceName
        builder.spanCollector(spanCollector);
        builder.traceSampler(Sampler.create(1));//采集率
        return builder.build();
    }

    @Bean
    public BraveServletFilter braveServletFilter(Brave brave) {
        /**
         * 设置sr、ss拦截器
         */
        return new BraveServletFilter(brave.serverRequestInterceptor(), 
                                      brave.serverResponseInterceptor(),
                                      new DefaultSpanNameProvider());
    }
}

说明：指定了serviceName："asyn3 - service3 - 3" 

3.3、ZipkinAsyncController

package com.xxx.service3.zipkin.brave.async;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;

@Api("zipkin brave async api")
@RestController
@RequestMapping("/zipkin/async/service3")
public class ZipkinAsyncController {

    @ApiOperation("trace第3步")
    @RequestMapping(value = "/test3", method = RequestMethod.GET)
    public String myboot3() {

        try {
            return "async - service3";
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }

}

4、service4

4.1、pom.xml

<!-- zipkin brave -->
        <dependency>
            <groupId>io.zipkin.brave</groupId>
            <artifactId>brave-core</artifactId>
            <version>3.9.0</version>
        </dependency>
        <dependency>
            <groupId>io.zipkin.brave</groupId>
            <artifactId>brave-spancollector-http</artifactId>
            <version>3.9.0</version>
        </dependency>
        <dependency>
            <groupId>io.zipkin.brave</groupId>
            <artifactId>brave-web-servlet-filter</artifactId>
            <version>3.9.0</version>
        </dependency>

4.2、ZipkinConfig

package com.xxx.service4.zipkin.brave.async;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.github.kristofa.brave.Brave;
import com.github.kristofa.brave.EmptySpanCollectorMetricsHandler;
import com.github.kristofa.brave.Sampler;
import com.github.kristofa.brave.SpanCollector;
import com.github.kristofa.brave.http.DefaultSpanNameProvider;
import com.github.kristofa.brave.http.HttpSpanCollector;
import com.github.kristofa.brave.servlet.BraveServletFilter;

@Configuration
public class ZipkinConfig {
    @Bean
    public SpanCollector spanCollector() {
        HttpSpanCollector.Config spanConfig = HttpSpanCollector.Config.builder()
                                              .compressionEnabled(false)//默认false，span在transport之前是否会被gzipped。
                                              .connectTimeout(5000)//5s，默认10s
                                              .flushInterval(1)//1s
                                              .readTimeout(6000)//5s，默认60s
                                              .build();
        return HttpSpanCollector.create("http://localhost:9411", 
                                        spanConfig,
                                        new EmptySpanCollectorMetricsHandler());
    }

    @Bean
    public Brave brave(SpanCollector spanCollector) {
        Brave.Builder builder = new Brave.Builder("asyn4 - service4 - 4");//指定serviceName
        builder.spanCollector(spanCollector);
        builder.traceSampler(Sampler.create(1));//采集率
        return builder.build();
    }

    @Bean
    public BraveServletFilter braveServletFilter(Brave brave) {
        /**
         * 设置sr、ss拦截器
         */
        return new BraveServletFilter(brave.serverRequestInterceptor(), 
                                      brave.serverResponseInterceptor(),
                                      new DefaultSpanNameProvider());
    }

}

说明：指定了serviceName："asyn4 - service4 - 4"

4.3、ZipkinAsyncController

package com.xxx.service4.zipkin.brave.async;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;

@Api("zipkin brave async api")
@RestController
@RequestMapping("/zipkin/async/service4")
public class ZipkinAsyncController {

    @ApiOperation("trace第4步")
    @RequestMapping(value = "/test4", method = RequestMethod.GET)
    public String myboot3() {

        try {
            return "async - service4";
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }

}

二、测试结果

1、依赖关系图：

 

2、span时间消耗图

 

3、详情图

点击第4个span，查看详情：

weixin_33995481
关注
springboot-dubbo-demo:springboot dubbo zipkin整合 微服务
04-29
springboot-dubbo-demo本demo是利用dubbo官方的 来实现微服务的一种尝试。涉及的技术框架有springboot,dubbo,ehcache,redis,swagger-ui,分布式Id.全链路追踪用了demo简单的模拟了一个用户登录获取token的过程。其中...
2024年分布式进阶(二十二)Zipkin基础知识介绍(1)，面试复盘怎么做
最新发布
2401_84619245的博客
05-12 364
cookies,sessionStorage,localStorage 的区别？Doctype作⽤?了解 this 嘛，bind，call，apply 具体指什么。serviceWorker的使用原理是啥？完成链路调用的记录后，如何来计算调用的延迟呢，这就需要利用。箭头函数和普通函数有啥区别？一种数据传输的方式，比如最简单的HTTP方式，Canvas 和 SVG 图形的区别是什么？如何实现浏览器内多个标签页之间的通信？HTML5 的离线储存的使用和原理？简述⼀下src与href的区别？
SpringBoot+Zipkin（定制AsyncHttpClient）
u012005912的专栏
10-26 937
引言 由于原有业务服务中使用的是第三方的HttpClient组件调用业务服务接口，而SpringCloud-Sleuth本身没有对AsyncHttpClient提供类似于ClientRequestInterceptor和ClientResponseInterceptor，所以需要我们定制，而ServerRequestInterceptor和ServerResponseInterceptor是在B...
SpringBoot下Brave方式集成Zipkin实现分布式全链路监控
weixin_30455661的博客
09-10 512
目录 Zipkin 简介 Springboot 集成 Zipkin 安装启动 zipkin 版本说明 项目结构 工程端口分配 引入 Maven 依赖 配置文件、收集器的设置 编写 Controller 发送请...
spring boot +brave-5.8.0+zipkin 实现分布式链路监控
October
10-09 1638
目录 摘要 zipkin部署 POM文件修改 配置文件修改 配置类添加 摘要 Brave 2018年之前的版本基本已经废弃了，现在都是使用2019年最新的版本。博文使用的是目前最新的5.8.0版本。其基本原理就是使用Brave的拦截器来拦截RestTemplate的http请求，并发送给zipkin的Collector。对于现有的Sping boot 服务来说，修改不是太多。详细也...
zipkin-server-2.23.9-exec.jar
07-18
"zipkin-server-2.23.9-exec.jar" 是 Zipkin 服务器的一个可执行 JAR 文件，它包含了运行 Zipkin 服务所需的所有依赖，使得用户可以直接启动这个 JAR 来部署 Zipkin 服务器。 Zipkin 的核心功能包括： 1. **追踪...
最新版-zipkin-server-2.23.2-exec.jar.rar
09-02
Zipkin 是一个分布式追踪系统，它能够收集服务之间的调用数据，帮助开发者分析和调试微服务架构中的延迟问题。在给定的文件“最新版-zipkin-server-2.23.2-exec.jar.rar”中，包含的是Zipkin Server的执行版本2.23.2...
zipkin-storage-kafka:基于Kafka的Zipkin存储
05-08
邮编存储：Kafka [EXPERIMENTAL] 基于Kafka的Zipkin存储。 +----------------------------*zipkin*---------------------------------... | ^ +-->( autocomplete-tags ) ( collected-spans )-|->[ partitioning ]
zipkin-server-2.12.9-exec.jar
12-20
1. 添加依赖：在SpringBoot项目中，通过Maven或Gradle添加Zipkin的相关依赖，如`spring-cloud-starter-zipkin`。 2. 配置Zipkin Server：在`application.yml`或`application.properties`中配置Zipkin Server的地址...
spring cloud sleuth+zipkin使用异步线程池traceId重复问题
06-26 3336
项目中使用了@Async线程池进行异步调用，为了便于重现问题，把线程池线程数设置位1。 观察发现：第一次调用的时候异步线程打印的traceId跟主线程一样，然后后续的traceId都跟第一次一样，一直重复使用。 直接查看源码进行研究，首先定位到异步线程池的traceId处理是在org.springframework.cloud.sleuth.instrument.async.TraceAsyncAspect这个类: 这里使用了aop进行处理，逻辑看起来也很简单，如果当前span不为null就直接使用当前的
zipkin
热门推荐
liaokailin的专栏
07-31 7万+
zipkinzipkin为分布式链路调用监控系统，聚合各业务系统调用延迟数据，达到链路调用监控跟踪。architecture 如图，在复杂的调用链路中假设存在一条调用链路响应缓慢，如何定位其中延迟高的服务呢？ 日志： 通过分析调用链路上的每个服务日志得到结果 zipkin：使用zipkin的web UI可以一眼看出延迟高的服务 如图所示，各业务系统在彼此调用时，将特定的跟踪消息传递至zipkin,
Java分布式跟踪系统Zipkin（二）：Brave源码分析-Tracer和Span
12-05 2376
所有博文均在个人独立博客http://blog.mozhu.org首发，欢迎访问！ Brave是Java版的Zipkin客户端，它将收集的跟踪信息，以Span的形式上报给Zipkin系统。 （Zipkin是基于Google的一篇论文，名为Dapper，Dapper在荷兰语里是“勇敢的”的意思，...
Java分布式跟踪系统Zipkin（六）：Brave源码分析-Brave和SpringBoot整合
墨竹
12-05 3497
所有博文均在个人独立博客http://blog.mozhu.org首发，欢迎访问！Zipkin是用当下最流行的SpringBoot开发的，SpringBoot将Spring项目的开发过程大大简化，一切主流的开发框架都可以通过添加jar包和配置，自动激活，现在越来越受广大Java开发人员的喜爱。 上一篇博文中，我们分析了Brave是如何在SpringMVC项目中使用的，这一篇博文我们继续分析Brav
SpringBoot2.0 ZipKin示例
攻城狮
07-03 1万+
Zipkin是一种分布式跟踪系统。它有助于收集解决微服务架构中延迟问题所需的时序数据。它管理这些数据的收集和查找。Zipkin的设计基于 Google Dapper论文。应用程序用于向Zipkin报告时间数据。Zipkin用户界面还提供了一个依赖关系图，显示每个应用程序有多少跟踪请求。如果您正在解决延迟问题或错误问题，则可以根据应用程序，跟踪长度，注释或时间戳过滤或排序所有跟踪。选择跟踪后，您可以...
使用Zipkin 和 Brave 实现http(springmvc)服务调用跟踪(一)
blacklau的专栏
04-08 1万+
Zipkin 是一款开源的分布式实时数据追踪系统（Distributed Tracking System），基于 Google Dapper 的论文设计而来，由 Twitter 公司开发贡献。其主要功能是聚集来自各个异构系统的实时监控数据，用来追踪微服务架构下的系统延时问题。    Brave 是用来装备 Java 程序的类库，提供了面向 Standard Servlet、Sprin
基于SpringBoot2.X的微服务架构，整合Eureka注册中心、Config配置中心、Bus消息总线、Hystrix熔断、Turbine聚合监控、Zipkin服务跟踪
xiaojun081004的博客
12-12 1989
基于SpringBoot2.X的微服务架构，整合Eureka注册中心、Config配置中心、Bus消息总线、Hystrix熔断、Turbine聚合监控、Zipkin服务跟踪Eureka注册中心引入依赖定义配置文件定义启动引导类运行启动类Config配置中心引入依赖定义配置文件定义启动引导类自定义json格式数据配置文件解析创建JsonPropertiesSourceLoader.java配置自动加...
【框架----SpringBoot】【1.0】【第二十八章】 springboot + zipkin（brave定制-AsyncHttpClient）
Sunny
06-17 298
brave本身没有对AsyncHttpClient提供类似于brave-okhttp的ClientRequestInterceptor和ClientResponseInterceptor，所以需要我们定制，而ServerRequestInterceptor和ServerResponseInterceptor是在BraveServletFilter部分直接指定就好了（这在任何client技术下都可以...
springboot 2.0.3 自定义配置rabbitmq
tuonioooo
07-08 3185
springboot 2.0.3 自定义配置rabbitmq参考文档：rabbitmq官网教程：http://www.rabbitmq.com/getstarted.htmlspringboot官网教程：https://docs.spring.io/spring-amqp/docs/2.0.4.RELEASE/reference/html/WEB登录界面http://192.168.111.103...
org.springframework.web.client.ResourceAccessException: I/O error on POST request for "http://zipkin-cis-pro.zipkin-cis-pro.svc:9411/api/v2/spans": zipkin-cis-pro.zipkin-cis-pro.svc; nested exception is java.net.UnknownHostException: zipkin-cis-pro.zipkin-cis-pro.svc at org.springframework.web.client.RestTemplate.doExecute(RestTemplate.java:748) ~[spring-web-5.2.6.RELEASE.jar:5.2.6.RELEASE]
07-13
具体的错误信息是"zipkin-cis-pro.zipkin-cis-pro.svc"这个主机名无法解析，导致了java.net.UnknownHostException异常。 这个问题通常是由于网络连接问题或者主机名解析配置不正确引起的。你可以尝试以下几个解决...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值