精华内容
下载资源
问答
  • Sleuth

    2019-02-02 17:27:17
    文章目录原理介绍Brave和Zipkin使用依赖Sleuth对feign的支持Sleuth对RestTemplate的支持Sleuth对多线程的支持 原理介绍 Sleuth通过Trace定义一次业务调用链,根据它的信息,我们就知道多少个系统参与了该业务处理。 ...

    原理介绍

    Sleuth通过Trace定义一次业务调用链,根据它的信息,我们就知道多少个系统参与了该业务处理。
    Span用来记录系统间的调用顺序和时间戳信息。
    Trace和Span的信息经过整合,就能知道该业务的完整调用链。

    Brave和Zipkin

    Brave是一个用于捕捉分布式系统之间调用信息的工具库,然后将这些信息以Span的形式发送给Zipkin。
    参考:https://github.com/openzipkin/brave

    从2.0.0版本开始,Sleuth不再自己存储上下文信息,而是使用Brave作为调用链工具库,并且遵循Brave的命名和标记惯例。

    如果你想延用老版本的使用方式,可以配置spring.sleuth.http.legacy.enabled=true

    Zipkin是一个基于Google Dapper论文设计的分布式跟踪系统,它收集系统的延时数据并提供展示界面,以便用户排查问题。
    参考:https://github.com/openzipkin/zipkin

    Zipkin启动方式

    • java -jar zipkin.jar
    • 还支持源码部署和Docker镜像启动。
    • Zipkin支持各种持久化方式,默认存储在内存中
    • 部署后,默认的启动端口位9411,http://localhost:9411/

    使用

    引入spring-cloud-starter-sleuth依赖之后,我们的日志组件可以自动打印Span信息。可以随着feign、restTemplate往服务端传递,也可以在父子线程间传递。

    依赖

    <!--sleuth-->
    <dependency>
    	<groupId>org.springframework.cloud</groupId>
    	<artifactId>spring-cloud-starter-sleuth</artifactId>
    </dependency>
    
    <!--openfeign-->
    <dependency>
    	<groupId>org.springframework.cloud</groupId>
    	<artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
    
    
    <dependency>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    

    Sleuth对feign的支持

    • Feign提供了feign.Client接口以便开发者自定义远程调用功能。
    • Sleuth使用了TracingFeignClient实现Feign接口,在Http调用前,在Header中添加Span信息。
    public Response execute(Request request, Options options) throws IOException {
        Map<String, Collection<String>> headers = new HashMap(request.headers());
        Span span = this.handleSend(headers, request, (Span)null);
        if (log.isDebugEnabled()) {
            log.debug("Handled send of " + span);
        }
    
        Response response = null;
        IOException error = null;
    
        Object var9;
        try {
            SpanInScope ws = this.tracer.withSpanInScope(span);
            Throwable var8 = null;
    
            try {
                var9 = response = this.delegate.execute(this.modifiedRequest(request, headers), options);
            } catch (Throwable var27) {
                var9 = var27;
                var8 = var27;
                throw var27;
            } finally {
                if (ws != null) {
                    if (var8 != null) {
                        try {
                            ws.close();
                        } catch (Throwable var26) {
                            var8.addSuppressed(var26);
                        }
                    } else {
                        ws.close();
                    }
                }
    
            }
        } catch (RuntimeException | Error | IOException var29) {
            error = var29;
            throw var29;
        } finally {
            this.handleReceive(span, response, error);
            if (log.isDebugEnabled()) {
                log.debug("Handled receive of " + span);
            }
    
        }
    
        return (Response)var9;
    }
    
    

    Sleuth对RestTemplate的支持

    对RestTemplate的支持并不是临时初始化的,需要将RestTemplate注册成一个Bean。

    //
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by Fernflower decompiler)
    //
    
    package brave.spring.web;
    
    import brave.Span;
    import brave.Tracer;
    import brave.Tracing;
    import brave.Tracer.SpanInScope;
    import brave.http.HttpClientAdapter;
    import brave.http.HttpClientHandler;
    import brave.http.HttpTracing;
    import brave.propagation.Propagation.Setter;
    import brave.propagation.TraceContext.Injector;
    import java.io.IOException;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.http.HttpHeaders;
    import org.springframework.http.HttpRequest;
    import org.springframework.http.client.ClientHttpRequestExecution;
    import org.springframework.http.client.ClientHttpRequestInterceptor;
    import org.springframework.http.client.ClientHttpResponse;
    
    public final class TracingClientHttpRequestInterceptor implements ClientHttpRequestInterceptor {
        static final Setter<HttpHeaders, String> SETTER = new Setter<HttpHeaders, String>() {
            public void put(HttpHeaders carrier, String key, String value) {
                carrier.set(key, value);
            }
    
            public String toString() {
                return "HttpHeaders::set";
            }
        };
        final Tracer tracer;
        final HttpClientHandler<HttpRequest, ClientHttpResponse> handler;
        final Injector<HttpHeaders> injector;
    
        public static ClientHttpRequestInterceptor create(Tracing tracing) {
            return create(HttpTracing.create(tracing));
        }
    
        public static ClientHttpRequestInterceptor create(HttpTracing httpTracing) {
            return new TracingClientHttpRequestInterceptor(httpTracing);
        }
    
        @Autowired
        TracingClientHttpRequestInterceptor(HttpTracing httpTracing) {
            this.tracer = httpTracing.tracing().tracer();
            this.handler = HttpClientHandler.create(httpTracing, new TracingClientHttpRequestInterceptor.HttpAdapter());
            this.injector = httpTracing.tracing().propagation().injector(SETTER);
        }
    
        public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
            Span span = this.handler.handleSend(this.injector, request.getHeaders(), request);
            ClientHttpResponse response = null;
            IOException error = null;
    
            Object var9;
            try {
                SpanInScope ws = this.tracer.withSpanInScope(span);
                Throwable var8 = null;
    
                try {
                    var9 = response = execution.execute(request, body);
                } catch (Throwable var27) {
                    var9 = var27;
                    var8 = var27;
                    throw var27;
                } finally {
                    if (ws != null) {
                        if (var8 != null) {
                            try {
                                ws.close();
                            } catch (Throwable var26) {
                            }
                        } else {
                            ws.close();
                        }
                    }
    
                }
            } catch (RuntimeException | Error | IOException var29) {
                error = var29;
                throw var29;
            } finally {
                this.handler.handleReceive(response, error, span);
            }
    
            return (ClientHttpResponse)var9;
        }
    
        static final class HttpAdapter extends HttpClientAdapter<HttpRequest, ClientHttpResponse> {
            HttpAdapter() {
            }
    
            public String method(HttpRequest request) {
                return request.getMethod().name();
            }
    
            public String url(HttpRequest request) {
                return request.getURI().toString();
            }
    
            public String requestHeader(HttpRequest request, String name) {
                Object result = request.getHeaders().getFirst(name);
                return result != null ? result.toString() : "";
            }
    
            public Integer statusCode(ClientHttpResponse response) {
                try {
                    return response.getRawStatusCode();
                } catch (IOException var3) {
                    return null;
                }
            }
        }
    }
    
    

    Sleuth对多线程的支持

    Sleuth提供了三种多线程实现

    • LazyTraceExecutor
    • TraceableExecutorService
    • TraceableScheduleExecutorService
      它们可以在创建新的任务时新建一个Span。
      必须使用这三种多线程实现才有效。
    展开全文
  • sleuth

    2018-08-14 15:03:50
    跨进程的服务调用失败时,运维人员希望能够通过查看日志和查看服务之间的调用关系来定位问题,而Spring cloud sleuth组件正是为了解决微服务跟踪的组件。 作用: - sleuth+elk 结合,聚合微服务日志 - sleuth+ ...

    如何清晰地记录服务的调用链路是一个需要解决的问题
    跨进程的服务调用失败时,运维人员希望能够通过查看日志和查看服务之间的调用关系来定位问题,而Spring cloud sleuth组件正是为了解决微服务跟踪的组件。

    作用:
    - sleuth+elk 结合,聚合微服务日志
    - sleuth+ zipkin结合,显示文件调用链路

    查看日志文件并不是一个很好的方法,当微服务越来越多日志文件也会越来越多,通过ELK可以将日志聚合,并进行可视化展示和全文检索。

    ELK是一款日志分析系统,它是Logstash+ElasticSearch+Kibana的技术组合,它可以通过logstash收集各个微服务日志,并通过Kibana进行可视化展示,而且还可以对大量日志信息通过ElasticSearch进行全文检索。

    使用Docker安装ELK

    通过查看日志分析微服务的调用链路并不是一个很直观的方案,结合zipkin可以很直观地显示微服务之间的调用关系。

    通过zipkin可以将调用链路可视化显示。

    zipkin改进
    在这里对zipkin进行改进,主要包含两方面
    - 通过消息中间件收集sleuth数据
    - 持久化sleuth数据

    展开全文
  • 这篇文章主要讲述服务追踪组件zipkin,Spring Cloud Sleuth集成了zipkin组件。

    转载请标明出处:
    原文首发于:https://www.fangzhipeng.com/springcloud/2017/06/09/sc09-sleuth.html
    本文出自方志朋的博客

    个人博客纯净版:https://www.fangzhipeng.com/springcloud/2017/06/09/sc09-sleuth.html

    最新Finchley版本请访问:
    https://www.fangzhipeng.com/springcloud/2018/08/09/sc-f9-sleuth.html
    或者
    http://blog.csdn.net/forezp/article/details/81041078

    这篇文章主要讲述服务追踪组件zipkin,Spring Cloud Sleuth集成了zipkin组件。

    一、简介

    Add sleuth to the classpath of a Spring Boot application (see below for Maven and Gradle examples), and you will see the correlation data being collected in logs, as long as you are logging requests.

    ------ 摘自官网

    Spring Cloud Sleuth 主要功能就是在分布式系统中提供追踪解决方案,并且兼容支持了 zipkin,你只需要在pom文件中引入相应的依赖即可。

    二、服务追踪分析

    微服务架构上通过业务来划分服务的,通过REST调用,对外暴露的一个接口,可能需要很多个服务协同才能完成这个接口功能,如果链路上任何一个服务出现问题或者网络超时,都会形成导致接口调用失败。随着业务的不断扩张,服务之间互相调用会越来越复杂。

    在这里插入图片描述

    随着服务的越来越多,对调用链的分析会越来越复杂。它们之间的调用关系也许如下:

    在这里插入图片描述

    三、术语

    • Span:基本工作单元,例如,在一个新建的span中发送一个RPC等同于发送一个回应请求给RPC,span通过一个64位ID唯一标识,trace以另一个64位ID表示,span还有其他数据信息,比如摘要、时间戳事件、关键值注释(tags)、span的ID、以及进度ID(通常是IP地址)
      span在不断的启动和停止,同时记录了时间信息,当你创建了一个span,你必须在未来的某个时刻停止它。
    • Trace:一系列spans组成的一个树状结构,例如,如果你正在跑一个分布式大数据工程,你可能需要创建一个trace。
    • Annotation:用来及时记录一个事件的存在,一些核心annotations用来定义一个请求的开始和结束
      • cs - Client Sent -客户端发起一个请求,这个annotion描述了这个span的开始
      • sr - Server Received -服务端获得请求并准备开始处理它,如果将其sr减去cs时间戳便可得到网络延迟
      • ss - Server Sent -注解表明请求处理的完成(当请求返回客户端),如果ss减去sr时间戳便可得到服务端需要的处理请求时间
      • cr - Client Received -表明span的结束,客户端成功接收到服务端的回复,如果cr减去cs时间戳便可得到客户端从服务端获取回复的所有所需时间
        将Span和Trace在一个系统中使用Zipkin注解的过程图形化:

    将Span和Trace在一个系统中使用Zipkin注解的过程图形化:

    在这里插入图片描述

    四、构建工程

    基本知识讲解完毕,下面我们来实战,本文的案例主要有三个工程组成:一个server-zipkin,它的主要作用使用ZipkinServer 的功能,收集调用数据,并展示;一个service-hi,对外暴露hi接口;一个service-miya,对外暴露miya接口;这两个service可以相互调用;并且只有调用了,server-zipkin才会收集数据的,这就是为什么叫服务追踪了。

    4.1 构建server-zipkin

    建一个spring-boot工程取名为server-zipkin,在其pom引入依赖:

    
    <dependencies>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter</artifactId>
    		</dependency>
    
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-web</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-test</artifactId>
    			<scope>test</scope>
    		</dependency>
    
    		<dependency>
    			<groupId>io.zipkin.java</groupId>
    			<artifactId>zipkin-server</artifactId>
    		</dependency>
    
    		<dependency>
    			<groupId>io.zipkin.java</groupId>
    			<artifactId>zipkin-autoconfigure-ui</artifactId>
    		</dependency>
    
    	</dependencies>
    
    	<dependencyManagement>
    		<dependencies>
    			<dependency>
    				<groupId>org.springframework.cloud</groupId>
    				<artifactId>spring-cloud-dependencies</artifactId>
    				<version>Camden.SR6</version>
    				<type>pom</type>
    				<scope>import</scope>
    			</dependency>
    		</dependencies>
    	</dependencyManagement>
    

    在其程序入口类, 加上注解@EnableZipkinServer,开启ZipkinServer的功能:

    @SpringBootApplication
    @EnableZipkinServer
    public class ServerZipkinApplication {
    
    	public static void main(String[] args) {
    		SpringApplication.run(ServerZipkinApplication.class, args);
    	}
    }
    
    
    

    在配置文件application.yml指定服务端口为:

    server.port=9411
    

    4.2 创建service-hi

    在其pom引入起步依赖spring-cloud-starter-zipkin,代码如下:

    <dependencies>
    
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-web</artifactId>
    		</dependency>
    		<!--compile('org.springframework.cloud:spring-cloud-starter-zipkin')-->
    
    		<dependency>
    			<groupId>org.springframework.cloud</groupId>
    			<artifactId>spring-cloud-starter-zipkin</artifactId>
    		</dependency>
    
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-test</artifactId>
    			<scope>test</scope>
    		</dependency>
    	</dependencies>
    
    	<dependencyManagement>
    		<dependencies>
    			<dependency>
    				<groupId>org.springframework.cloud</groupId>
    				<artifactId>spring-cloud-dependencies</artifactId>
    				<version>Dalston.RC1</version>
    				<type>pom</type>
    				<scope>import</scope>
    			</dependency>
    		</dependencies>
    	</dependencyManagement>
    
    
    

    在其配置文件application.yml指定zipkin server的地址,头通过配置“spring.zipkin.base-url”指定:

    
    server.port=8988
    spring.zipkin.base-url=http://localhost:9411
    spring.application.name=service-hi
    
    

    通过引入spring-cloud-starter-zipkin依赖和设置spring.zipkin.base-url就可以了。

    对外暴露接口:

    @SpringBootApplication
    @RestController
    public class ServiceHiApplication {
    
    	public static void main(String[] args) {
    		SpringApplication.run(ServiceHiApplication.class, args);
    	}
    
    	private static final Logger LOG = Logger.getLogger(ServiceHiApplication.class.getName());
    
    
    	@Autowired
    	private RestTemplate restTemplate;
    
    	@Bean
    	public RestTemplate getRestTemplate(){
    		return new RestTemplate();
    	}
    
    	@RequestMapping("/hi")
    	public String callHome(){
    		LOG.log(Level.INFO, "calling trace service-hi  ");
    		return restTemplate.getForObject("http://localhost:8989/miya", String.class);
    	}
    	@RequestMapping("/info")
    	public String info(){
    		LOG.log(Level.INFO, "calling trace service-hi ");
    
    		return "i'm service-hi";
    
    	}
    
    	@Bean
    	public AlwaysSampler defaultSampler(){
    		return new AlwaysSampler();
    	}
    }
    
    
    
    

    4.3 创建service-miya

    创建过程痛service-hi,引入相同的依赖,配置下spring.zipkin.base-url。

    对外暴露接口:

    
    @SpringBootApplication
    @RestController
    public class ServiceMiyaApplication {
    
    	public static void main(String[] args) {
    		SpringApplication.run(ServiceMiyaApplication.class, args);
    	}
    
    	private static final Logger LOG = Logger.getLogger(ServiceMiyaApplication.class.getName());
    
    
    	@RequestMapping("/hi")
    	public String home(){
    		LOG.log(Level.INFO, "hi is being called");
    		return "hi i'm miya!";
    	}
    
    	@RequestMapping("/miya")
    	public String info(){
    		LOG.log(Level.INFO, "info is being called");
    		return restTemplate.getForObject("http://localhost:8988/info",String.class);
    	}
    
    	@Autowired
    	private RestTemplate restTemplate;
    
    	@Bean
    	public RestTemplate getRestTemplate(){
    		return new RestTemplate();
    	}
    }
    
    

    4.4 启动工程,演示追踪

    依次启动上面的三个工程,打开浏览器访问:http://localhost:9411/,会出现以下界面:

    在这里插入图片描述

    访问:http://localhost:8989/miya,浏览器出现:

    i’m service-hi

    再打开http://localhost:9411/的界面,点击Dependencies,可以发现服务的依赖关系:

    在这里插入图片描述

    点击find traces,可以看到具体服务相互调用的数据:

    在这里插入图片描述

    本文源码下载:
    https://github.com/forezp/SpringCloudLearning/tree/master/chapter9

    五、参考资料

    spring-cloud-sleuth

    利用Zipkin对Spring Cloud应用进行服务追踪分析

    Spring Cloud Sleuth使用简介

    优秀文章推荐:

    SouthEast
    扫码关注公众号有惊喜

    (转载本站文章请注明作者和出处 方志朋的博客

    展开全文
  • sleuth 简介

    千次阅读 2018-09-25 10:42:01
    sleuth 可以解决分布式系统的追踪问题。 Sleuth:日志收集工具包,封装了Dapper和log-based追踪以及Zipkin和HTrace操作; spring cloud 微服务框架可以看这里: 微服务 Spring Boot 2.0 + Spring cloud + consul ...

    sleuth 可以解决分布式系统的追踪问题。

    Sleuth:日志收集工具包,封装了Dapper和log-based追踪以及Zipkin和HTrace操作;

    spring cloud 微服务框架可以看这里:

    1. 微服务 Spring Boot 2.0 + Spring cloud + consul + Hystrix + zuul + config + feign (上)

    场景:

    1. 在分布式系统中,一个集群中有几十个微服务;
    2. 微服务调用微服务,一个或多个微服务的网络环境问题、硬件问题导致服务提供失败;

    疑问:

    1. 我们怎么去定位这个出问题的服务?
    2. 怎么定位出问题接口?
    3. 怎么分析行为诱因?
    4. 难道要逐个的看log?

    肯定不是,sleuth 可以给我们提供很好的方案,用服务链路追踪来快速查看。sleuth 集成了Zipkin、HTrace 几种链路追踪工具,我选择zipkin。

    sleuth中的一些术语

    1. Span:基本工作单元,例如,在一个新建的span中发送一个RPC等同于发送一个回应请求给RPC,span通过一个64位ID唯一标识,trace以另一个64位ID表示,span还有其他数据信息,比如摘要、时间戳事件、关键值注释(tags)、span的ID、以及进度ID(通常是IP地址) 
      span在不断的启动和停止,同时记录了时间信息,当你创建了一个span,你必须在未来的某个时刻停止它。
    2. Trace:一系列spans组成的一个树状结构,例如,如果你正在跑一个分布式工程,你可能需要创建一个trace。
    3. Annotation:用来及时记录一个事件的存在,一些核心annotations用来定义一个请求的开始和结束
    • cs - Client Sent -客户端发起一个请求,这个annotion描述了这个span的开始
    • sr - Server Received -服务端获得请求并准备开始处理它,如果将其sr减去cs时间戳便可得到网络延迟
    • ss - Server Sent -注解表明请求处理的完成(当请求返回客户端),如果ss减去sr时间戳便可得到服务端需要的处理请求时间
    • cr - Client Received -表明span的结束,客户端成功接收到服务端的回复,如果cr减去cs时间戳便可得到客户端从服务端获取回复的所有所需时间

    spring cloud 中的配置:

            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-sleuth</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-sleuth-zipkin</artifactId>
            </dependency>

    logback-spring.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <!--该日志将日志级别不同的log信息保存到不同的文件中 -->
    <configuration>
        <include resource="org/springframework/boot/logging/logback/defaults.xml" />
    
        <springProperty scope="context" name="springAppName"
                        source="spring.application.name" />
    
        <!-- 日志在工程中的输出位置 -->
        <property name="LOG_FILE" value="${BUILD_FOLDER:-build}/${springAppName}" />
    
        <!-- 控制台的日志输出样式 -->
        <property name="CONSOLE_LOG_PATTERN"
                  value="%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}" />
    
        <!-- 控制台输出 -->
        <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
            <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
                <level>INFO</level>
            </filter>
            <!-- 日志输出编码 -->
            <encoder>
                <pattern>${CONSOLE_LOG_PATTERN}</pattern>
                <charset>utf8</charset>
            </encoder>
        </appender>
    
        <!-- 为logstash输出的JSON格式的Appender -->
        <appender name="logstash"
                  class="ch.qos.logback.core.rolling.RollingFileAppender">
            <file>${LOG_FILE}.json</file>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <!--日志文件输出的文件名 -->
                <fileNamePattern>${LOG_FILE}.json.%d{yyyy-MM-dd}.gz</fileNamePattern>
                <!--日志文件保留天数 -->
                <MaxHistory>3</MaxHistory>
            </rollingPolicy>
            <!-- 日志输出编码 -->
            <encoder
                    class="net.logstash.logback.encoder.LoggingEventCompositeJsonEncoder">
                <providers>
                    <timestamp>
                        <timeZone>UTC</timeZone>
                    </timestamp>
                    <pattern>
                        <pattern>
                            {
                            "severity": "%level",
                            "service": "${springAppName:-}",
                            "trace": "%X{X-B3-TraceId:-}",
                            "span": "%X{X-B3-SpanId:-}",
                            "exportable": "%X{X-Span-Export:-}",
                            "pid": "${PID:-}",
                            "thread": "%thread",
                            "class": "%logger{40}",
                            "rest": "%message"
                            }
                        </pattern>
                    </pattern>
                </providers>
            </encoder>
        </appender>
    
    
        <!-- 为logstash输出的JSON格式的Appender -->
        <appender name="logstash2"
                  class="net.logstash.logback.appender.LogstashTcpSocketAppender">
            <destination>localhost:9600</destination>
            <!-- 日志输出编码 -->
            <encoder
                    class="net.logstash.logback.encoder.LoggingEventCompositeJsonEncoder">
                <providers>
                    <timestamp>
                        <timeZone>UTC</timeZone>
                    </timestamp>
                    <pattern>
                        <pattern>
                            {
                            "severity": "%level",
                            "service": "${springAppName:-}",
                            "trace": "%X{X-B3-TraceId:-}",
                            "span": "%X{X-B3-SpanId:-}",
                            "exportable": "%X{X-Span-Export:-}",
                            "pid": "${PID:-}",
                            "thread": "%thread",
                            "class": "%logger{40}",
                            "rest": "%message"
                            }
                        </pattern>
                    </pattern>
                </providers>
            </encoder>
        </appender>
    
        <!-- 日志输出级别 -->
        <root level="INFO">
            <appender-ref ref="console" />
            <appender-ref ref="logstash" />
            <appender-ref ref="logstash2" />
        </root>
    </configuration>
    

     

    展开全文
  • sleuth介绍

    2021-02-27 11:25:35
    spring Cloud Sleuth为 spring Cloud提供了分布式跟踪的解决方案,它大量借用了Google Dapper、 Twitter Zipkin和 Apache HTrace的设计,先来了解一下 Sleuth的术语, Sleuth借用了 Dapper的术语。 span(跨度):...
  • Spring Cloud Sleuth的样本-Users Microservice 一个简单的项目,展示spring-cloud-sleuth的工作原理。 此应用程序取决于 快速开始 使用所有依赖项运行此示例的最简单方法是从docker compose进行安装,并在项目的根...
  • Sleuth入门

    2021-05-18 22:08:02
    一、产生背景 在微服务框架中,一个由客户端发起的请求在后端系统中会经过多个不同的服务节点调用来协同产生最后的...二、Sleuth介绍 Spring Cloud Sleuth提供了一套完整的服务跟踪的解决方案并且兼容支持Zipkin ...
  • sleuth.docx

    2020-04-21 01:06:01
    spring -cloud -sleuth 分布式链路跟踪介绍 本节课来讨论微服务“跟踪"大家先看几个问题,对于一个大型的微服务架构系统,会有哪些常见问题? 如何串联调用链,快速定位问题 如何厘清微服务之间的依赖关系 如何进行...
  • Sleuth集成Zipkin

    2020-09-15 17:22:27
    SpringCloud Sleuth主要功能就是在分布式系统中提供链路追踪解决方案。但是Sleuth并没有UI界面。需要集成Zipkin完成数据的收集、存储、查找和展示。 目录 1 集成Sleuth 2 集成Zipkin 2.1 下载Zipkin的jar包...
  • Sleuth-crx插件

    2021-04-04 01:00:37
    Sleuth致力于为所有ISP创建一个公平的竞争环境。 Sleuth可以检查您的下载速度,并比较其他ISP的最高下载速度。 未来的集成将包括被动测试,当您没有获得所需的下载速度时,该被动通知将通知您。 侦探发展:copyright:
  • 微服务下的链路追踪(Sleuth+Zipkin)

    万次阅读 多人点赞 2019-02-20 15:00:57
    Sleuth简介 相关术语 使用Sleuth 引入依赖 创建服务 product-service order-service 启动&测试 Zipkin 使用Zipkin 参考文章 Sleuth简介 Sleuth是Spring Cloud的组件之一,它为Spring Cloud实现了一...
  • Laravel开发-sleuth

    2019-08-28 03:31:09
    Laravel开发-sleuth 暂无描述
  • Spring Cloud Sleuth

    2020-08-24 03:24:07
    Spring Cloud Sleuth
  • Play Sleuth Noir是由Hypothetical Software开发的经典神秘游戏。 此附加组件为该游戏的玩家提供了增强的体验。 附加功能:1)防止意外双击2)侦探音符上的单色3)“排除Alibi”按钮可排除所有真实的犯罪嫌疑,已...
  • 转载请标明出处: ... 本文出自方志朋的博客 ...这篇文章主要讲述服务追踪组件zipkin,Spring Cloud Sleuth集成了zipkin组件。 一、简介 Add sleuth to the classpath of a Spring Boot appli...
  • spring Cloud sleuth

    2021-04-12 13:51:11
    spring Cloud sleth:进行链路的监控显示 1.在pom文件中导入依赖 2.在application.yml里面添加zipkin sleuth相关配置 spring.zipkin.baseurl spring.zipkin.sleuth.sampler
  • Spring Cloud Sleuth.pdf

    2018-05-16 00:22:24
    1.Spring Cloud Sleuth.pdf1.Spring Cloud Sleuth.pdf
  • SpringCloud Sleuth入门介绍

    万次阅读 2019-06-30 11:54:49
    一、Sleuth介绍   为什么要使用微服务跟踪?它解决了什么问题? 1.微服务的现状? 微服务的现状   随着业务的发展,单体架构变为微服务架构,并且系统规模也变得越来越大,各微服务间的调用关系也变得越来越复杂...
  • Penguin Sleuth Kit 是一张可引导 CD 和 Vmware 虚拟平台。Penguin Sleuth Kit 改编了一个很好的 Linux 资源,包括在执行计算机取证分析和安全审计时有用的工具。 详情:www.linux-forensics.com
  • sleuth 链路跟踪

    2021-01-26 18:16:00
    sleuth 在服务中,产生链路跟踪日志数据 A–> B–>C–>D 每一个服务执行时 都会产生一个服务id 当做链路id serivce-id 链路id 当前服务id 是否发生到zipkin展现 产生链路日志,只需要添加sleuth依赖,不用做...
  • Sleuth源码解析

    2021-01-31 16:38:13
    span:span是sleuth中最基本的工作单元,一个微服务收到请求后会创建一个span同时产生一个span id,span id是一个64位的随机数,sleuth将其转化为16进制的字符串,打印在日志里面。其对应的实现类是RealSpan。 trace...
  • Sleuth

    2018-02-12 17:04:04
    服务跟踪,就是跟踪你的整个流程,查看一些每个微服务的耗时。为什么要实现微服务的跟踪:谈到微服务的服务跟踪,就不得不提一些分布式计算的八大误区:1.网络可靠2....sleuth的一些术语: span(跨度):...
  • CF49A Sleuth

    2019-09-25 15:36:34
    CF49A Sleuth 题目描述 Vasya plays the sleuth with his friends. The rules of the game are as follows: those who play for the first time, that is Vasya is the sleuth, he should invest...
  • Spring Boot Sleuth

    2020-02-17 20:02:35
    Spring Cloud Sleuth IntroductionSpring Boot Sleuth是Spring官方提供的一个支持链路跟踪的API框架实现,相比于国内林林总总的各种跟踪实现,Spring Sleuth是Spring官方实现的一个生成TraceID和SpanID的方案。...
  • The Sleuth Kit-开源

    2021-05-02 19:59:46
    Sleuth Kit是一个C ++库,是开放源代码文件系统取证工具的集合,除其他外,这些工具使您可以查看NTFS,FAT,FFS,EXT2,Ext3,HFS +和ISO9660图像中分配和删除的数据。
  • sleuth-skip-pattern-源码

    2021-03-16 01:40:06
    sleuth-skip-pattern

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,465
精华内容 6,186
关键字:

sleuth