精华内容
下载资源
问答
  • SpringBoot应用监控

    千次阅读 2017-05-30 16:27:26
    SpringBoot提供了运行时的应用监控与系统管理功能,一般可以通过http、JMX、SSH协议来进行操作。SpringBoot提供的监控和管理的端点如下: actuator—-所有EndPoint的列表,需要加入Spring Hateoas的支持; auto...

    SpringBoot提供了运行时的应用监控与系统管理功能,一般可以通过http、JMX、SSH协议来进行操作。SpringBoot提供的监控和管理的端点如下:
    actuator—-所有EndPoint的列表,需要加入Spring Hateoas的支持;
    autoconfig—-当前应用的所有自动配置;
    beans—-当前应用的所有Beans的信息;
    configprops—-当前应用中的所有配置信息;
    dump—-显示当前应用线程状态信息;
    env—-显示当前应用的环境信息;
    health—-显示当前应用的健康状况;
    info—-显示当前应用信息;
    metrics—-显示当前应用的各项指标信息;
    mappings—-显示所有的@RequestMapping映射的路径;
    shutdown—-关闭当前应用(默认关闭);
    trace—-显示追踪信息(默认最新的http请求)

    1、http

    我们可以通过http实现对应用的监控和管理,我们只需要在pom.xml中增加以下依赖即可:

    <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>

    使用时只需要在url上加入对于的值即可,如:
    http://localhost:8080/health

    2、JMX

    当然,也可以通过JMX对应用进行监控和管理。在控制台调用java内置的jconsole来实现JMX监控。jconsole启动后,可以通过在MBean标签的org.springframework.boot域下可对我们的程序进行监控和管理。

    3、SSH

    我们还可以通过SSH或者telnet监控和管理我们的应用,这一点SpringBoot是借助CraSH来实现的。在应用中,我们只需要在SpringBoot项目中添加spring-boot-starter-remote-shell依赖即可。
    SSH的常用命令有help、metrics、endpoint等命令供使用,当然还有一些扩展命令。

    展开全文
  • Spring Boot 揭秘与实战(九) 应用监控篇 - HTTP 应用监控

    文章目录

    1. 1. 快速开始
    2. 2. 监控和管理端点
      1. 2.1. health 应用健康指标
      2. 2.2. info 查看应用信息
      3. 2.3. metrics 应用基本指标
      4. 2.4. trace 基本的HTTP跟踪信息
      5. 2.5. shutdown关闭当前应用
    3. 3. 定制端点
    4. 4. 源代码

    Spring Boot 提供运行时的应用监控和管理功能。本文,我们通过 HTTP 实现对应用的监控和管理。

    快速开始

    Spring Boot 监控核心是 spring-boot-starter-actuator 依赖,增加依赖后, Spring Boot 会默认配置一些通用的监控,比如 jvm 监控、类加载、健康监控等。

    1. <dependency>
    2. <groupId>org.springframework.boot</groupId>
    3. <artifactId>spring-boot-starter-actuator</artifactId>
    4. </dependency>

    如果,使用 HTTP 调用的方式,还需要 spring-boot-starter-web 依赖。

    1. <dependency>
    2. <groupId>org.springframework.boot</groupId>
    3. <artifactId>spring-boot-starter-web</artifactId>
    4. </dependency>

    监控和管理端点

    以最新的 Spring Boot 的版本 1.4.3 为准,列出目前支持的监控。

    HTTP方法 路径 描述
    GET /actuator 查看所有EndPoint的列表,需要加入 Spring HATEOAS 支持
    GET /autoconfig 查看应用的自动配置的使用情况
    GET /beans 查看应用的所有Bean的信息
    GET /configprops 查看应用的所有配置属性
    GET /dump 查看应用的线程状态信息
    GET /env 查看应用的所有环境信息
    GET /flyway 查看已经有迁徙路线数据库迁移
    GET /health 查看应用健康指标
    GET /info 查看应用信息
    GET /liquibase 查看已经有liquibase数据库迁移应用
    GET /mappings 查看所有url映射
    GET /metrics 查看应用基本指标
    POST /shutdown 允许优雅关闭当前应用(默认情况下不启用)
    GET /trace 查看基本的HTTP跟踪信息
    GET /docs 查看文档,需要依赖 spring-boot-actuator-docs
    GET /heapdump 返回一个gzip压缩 hprof 堆转储文件
    GET /jolokia 暴露JMX bean(当jolokia路径)
    GET /logfile 查看日志文件的内容(如果logging.file或logging.path属性已设置)。支持使用对HTTP范围标头到日志文件的部分恢复内容。
     

    health 应用健康指标

    我们可以通过 http://localhost:8080/health , 统计系统的状况,默认里面目前只有系统状况和磁盘状况。这些检测器都通过 HealthIndicator 接口实现,下篇文章,我会讲解到通过 HealthIndicator 接口实现自定义健康检测。

    info 查看应用信息

    默认情况下,只会返回一个空的 json 内容。我们可以在 application.properties 配置文件中通过 info 前缀来设置一些属性。

    1. info.author.realname=梁桂钊
    2. info.author.nickname=LiangGzone

    我们也可以在 application.yml 配置文件中设置一些属性。

    1. info.author:
    2. email: lianggzone@163.com
    3. blog: http://blog.720ui.com

    metrics 应用基本指标

    我们可以通过 http://localhost:8080/metrics, 获取当前应用的各类重要度量指标,比如:内存信息、线程信息、垃圾回收信息等。

    我们还可以通过 /metrics/{name} 接口来更细粒度的获取度量信息,比如我们可以通过访问 /metrics/mem.free 来获取当前可用内存数量。

    trace 基本的HTTP跟踪信息

    查看基本的 HTTP 跟踪信息。默认情况下,跟踪信息的存储采用 org.springframework.boot.actuate.trace.InMemoryTraceRepository 实现的内存方式,始终保留最近的 100 条请求记录。

    shutdown关闭当前应用

    shutdown 端点默认是不启用的,我们可以在 application.properties 中开启。此外,shutdown 端点不支持 GET 请求,我们需要通过 POST 方法访问。

    1. endpoints.shutdown.enabled=true

    定制端点

    端点可以在 Spring Boot 配置文件中进行定制。例如,上面,我们开启 shutdown 端点。

    1. endpoints.shutdown.enabled=true

    端点的前缀是,endpoints + “.”+ 端点名。

    默认的端点访问路径是根目录下,我们可以通过修改配置,进行定制。

    1. management.context-path=/manage

    此时,我们的访问地址就变成: http://localhost:8080/manage/info

    此外,默认监控的接口端口和业务的端口是一致的,我们出于安全性考虑,可以改变端点的访问的端口。

    1. management.port=9090

    我们甚至可以关闭 http 端点。

    1. management.port=-1
    展开全文
  • 使用 Prometheus 进行应用监控

    千次阅读 2020-06-27 12:51:50
    应用监控的定义与作用 对于工程师们来说,软件某一阶段的开发任务完成就意味着"done"了。然而从软件的生命周期来说,编码的完成只是开始,软件还需要符合预期地运行并试图达到人们对它设定的目标,而监控就是检验这...

    应用监控的定义与作用

    对于工程师们来说,软件某一阶段的开发任务完成就意味着"done"了。然而从软件的生命周期来说,编码的完成只是开始,软件还需要符合预期地运行并试图达到人们对它设定的目标,而监控就是检验这两点的常用可视化方法。

    按照监控的对象通常可以将监控分为基础设施监控,中间件监控,应用监控和业务监控,它们各自的监控对象与作用如下表所示:

    监控对象 判断软件是否符合预期地运行 判断业务目标是否达到
    基础设施监控 服务器、存储等软件的运行环境
    中间件监控 数据库、消息队列等公用软件
    应用监控 实现具体业务需求的软件
    业务监控 业务指标

    其中基础设施、中间件和应用层级的监控,由于都在软硬件系统内,它们之中任意一环出现问题都有可能导致软件运行出现异常,实际场景中这些监控通常需要互相配合、关联分析。

    而应用级别的监控,由于本身是业务的重要载体,应用监控有时也能直接反应业务指标是否达到,比如应用的吞吐量和时延等指标,当这些指标是业务的侧重点时,应用监控实际上就发挥了业务监控的作用。

    应用监控利器 Prometheus

    Prometheus是一套开源的监控体系,以指标为度量单位来描述应用的运行情况。

    组件及生态

    在这里插入图片描述
    这张图片是Prometheus官网上的架构图,可以看到 Prometheus 除了主要的 Prometheus Server 提供采集和存储指标的时序数据以外,还包括接受推送方式获取指标的 Pushgateway 和管理告警规则的 Alertmanger 等组件。在应用监控中我们主要关注的是 Prometheus Server 和集成到各类应用中负责产生指标的 prometheus client 库。

    特性

    Prometheus官网中介绍的特性主要有以下几点:

    • 多维度的指标数据模型(prometheus中每条时序数据包括时间戳,指标名称和标签等维度)
    • 指标查询语言PromQL(通过对原始指标数据进行标签筛选,以及取变化率、topN等数据处理函数操作,使得指标的表达更具灵活性)
    • 不依赖于分布式存储,实现单节点自治
    • 基于HTTP协议拉取时序数据(相比于Zabbix中使用json-rpc协议,HTTP协议更符合Web应用中远程调用的主流)

    在k8s集群中部署 Prometheus Operator

    Prometheus Operator 是在 k8s 集群中部署和维护 prometheus 服务的一种方式,它在 prometheus server 和 alertmanger 等服务端组件的基础上,还把监控对象和告警规则等配置也给"资源化"了,更容易在 k8s 集群中管理。

    演示项目 kube-prometheus

    Github 中的 kube-prometheus 项目是从 prometheus operator 中分离出来的,主要用来快速搭建一个演示环境。

    直接通过 kuebctl apply 命令在k8s集群中部署 prometheus operator:

    git clone https://github.com/coreos/kube-prometheus.git
    cd kube-prometheus/manifests
    kubectl apply -f setup
    kubeclt apply -f .
    

    以上命令中的 kubectl apply -f setup 主要创建 monitoring 命名空间,以及prometheus operator 这个控制器还有其他 CRD (自定义资源声明)。

    kubectl apply -f .则创建刚才定义好的自定义资源,以及各自的 ServiceAccount 和相关配置。

    各自定义资源的拓扑关系如下:
    在这里插入图片描述

    ServiceMonitor的作用

    其中跟应用监控关系最密切的就是ServiceMonitor资源,它的yaml文件类似这样:

    apiVersion: monitoring.coreos.com/v1
    kind: ServiceMonitor
    metadata:
      labels:
        k8s-app: alertmanager
      name: alertmanager
      namespace: monitoring
    spec:
      endpoints:
      - interval: 30s
        port: web
      selector:
        matchLabels:
          alertmanager: main
    
    

    ServiceMonitor通过标签筛选需要被监控的对象(k8s service),并且指定从它的哪个端口和url路径来拉取指标,并定义拉取操作的间隔时间。

    ServiceMonitor本质是对 prometheus 配置中指标数据来源(endpoint)的抽象,每新建一个 service monitor 资源,prometheus operator 就会在自定义资源 promethues 的配置文件中添加相应的配置,以达到和使用原生 prometheus 相同的效果,这就把原来需要需要手动和统一配置的任务通过 crd 来自动化实现了。

    上述例子中几乎所有资源都有对应的 Service Monitor,说明它们都有一个http/https 接口来暴露指标数据,这是因为谷歌还有coreos在设计这些组件时就要求每个组件都要有暴露自身状态的接口,它们在样式上是符合Prometheus 规范的文本信息,类似这样:

    # HELP go_gc_duration_seconds A summary of the pause duration of garbage collection cycles.
    # TYPE go_gc_duration_seconds summary
    go_gc_duration_seconds{quantile="0"} 0
    go_gc_duration_seconds{quantile="0.25"} 0
    go_gc_duration_seconds{quantile="0.5"} 0
    go_gc_duration_seconds{quantile="0.75"} 0
    go_gc_duration_seconds{quantile="1"} 0.0008235
    go_gc_duration_seconds_sum 0.0008235
    go_gc_duration_seconds_count 8
    

    每一个或一组指标都会包含描述信息、指标类型、指标名称和实时数据这些,prometheus在获取http接口中的文本信息后会进一步将它们转化为自己的时序数据模型(加上时间戳维度等)。

    Go应用中实现自定义指标

    在我们自己开发的应用程序中,也可以通过集成 prometheus 官方提供的client库来对外暴露 prometheus 风格的指标数据。

    以 Go 语言开发的应用为例,首先在项目中新建一个子目录(包)用来声明和注册需要对外暴露的应用指标:

    stat/prometheus.go:

    package stat
    
    import "github.com/prometheus/client_golang/prometheus"
    
    var (
    	testRequestCounter = prometheus.NewCounter(prometheus.CounterOpts{
    		Name: "test_request_total",
    		Help: "Total count of test request",
    	})
    )
    
    func init() {
    	prometheus.MustRegister(testRequestCounter)
    }
    

    示例中声明了一个 Counter 类型的指标,用于统计测试http请求的总数,在 init 函数中对该指标进行注册,之后我们在其他go文件中引入该包时就会自动注册这些指标。

    Counter类型是 prometheus 4种指标类型(Counter, Gauge, Histogram, Summary)的一种,用于描述只增不减的数据,比如http服务接收的请求数,具体可以查看 prometheus 的官方文档。

    main.go:

    package main
    
    import (
    	"github.com/gin-gonic/gin"
    	"github.com/prometheus/client_golang/prometheus"
    	"github.com/prometheus/client_golang/prometheus/promhttp"
    	"github.com/go-app/stat" //刚才写的声明指标的包
    )
    func main() {
        r := gin.Default()
    	r.GET("metrics",gin.WrapH(promhttp.Handler()))
    	r.GET("test",func(c *gin.Context) {
    	   stat.testRequestCounter.Inc()
    		c.JSON(http.StatusOK, gin.H{
    			"text": "hello world",
    		})
    	})
    	r.Run(":9090")
    }
    

    指标声明后还需要在合适的实际触发对指标数据的采集,比如这个例子中在每次访问 /test 请求时在 handle 函数中使请求计数器加1,如果是要统计所有的请求数的话,还可以把采集数据的操作放在中间件中,使任何请求都会触发计数器加1。

    实际场景中的应用监控比上述例子复杂得多,因为不同的应用程序可以采集的监控指标不同,即使是同类型的应用,在不同的业务场景下需要采集的指标也会有不同的侧重。但是在谷歌的 SRE 实践中仍然总结出了4个黄金指标,分别是:

    • 延迟 服务处理请求所需要的时间
    • 流量 对系统负载的度量,在http服务中通常是每秒的请求数
    • 错误 请求失败的速率
    • 饱和度 服务容量有多"满",通常是系统中某个最为受限的资源的某个具体指标的度量

    这些指标也可以通过 prometheus 的4中基本指标类型去表示,大致的关系是:

    Counter ==> 请求量,请求流量
    Gauge ==> 系统的饱和度(实时)
    Histogram ==> 请求延时在各个区间的分布
    Summary ==> 请求延时的中位数,9分位数,95分位数等

    根据黄金指标的指导理念,我又设计了一个更复杂一些的示例:
    假设有一个固定容量的消息队列,通过http的 /push 和 /pop 请求可以使队列增加或减少一条记录,在队列容量快要满或者快要全空的时候,请求的延时和错误率都会相应增加。

    以下是完整的示例代码和最终展示的Grafana图表,仅供参考:
    stat/prometheus.go:

    package stat
    
    import "github.com/prometheus/client_golang/prometheus"
    
    var (
    	MqRequestCounter = prometheus.NewCounterVec(prometheus.CounterOpts{
    		Namespace: "mq",
    		Name: "request_total",
    		Help: "Total count of success request",
    	},[]string{"direction"})
    	MqErrRequestCounter = prometheus.NewCounterVec(prometheus.CounterOpts{
    		Namespace: "mq",
    		Name: "err_request_total",
    		Help: "Total count of failed request",
    	},[]string{"direction"})
    	MqRequestDurationHistogram = prometheus.NewHistogramVec(prometheus.HistogramOpts{
    		Namespace: "mq",
    		Name: "request_duration_distribution",
    		Help: "Distribution state of request duration",
    		Buckets: prometheus.LinearBuckets(110,10,5),
    	},[]string{"direction"})
    	MqRequestDurationSummary = prometheus.NewSummaryVec(prometheus.SummaryOpts{
    		Namespace: "mq",
    		Name: "request_duration_quantiles",
    		Help: "Quantiles of request duration",
    		Objectives: map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.99: 0.001},
    	},[]string{"direction"})
    	MqCapacitySaturation = prometheus.NewGauge(prometheus.GaugeOpts{
    		Namespace: "mq",
    		Name: "capacity_saturation",
    		Help: "Capacity saturation of the message queue",
    	})
    )
    
    func init() {
    	prometheus.MustRegister(MqRequestCounter,MqErrRequestCounter,MqRequestDurationHistogram,MqRequestDurationSummary,MqCapacitySaturation)
    }
    

    main.go:

    package main
    
    import (
    	"fmt"
    	"github.com/gin-gonic/gin"
    	"github.com/prometheus/client_golang/prometheus"
    	"github.com/prometheus/client_golang/prometheus/promhttp"
    	"github.com/go-app/stat"
    	"math/rand"
    	"net/http"
    	"strings"
    	"time"
    )
    
    type queueConfig struct {
    	length int
    	maxErrorRate float64
    	maxDuration time.Duration
    }
    
    type messageQueue struct {
    	qc queueConfig
    	queue []string
    }
    
    var pushErrCount, popErrCount int
    
    func (m *messageQueue) push() (ok bool,duration time.Duration){
    	startTime := time.Now()
    	stat.MqRequestCounter.With(prometheus.Labels{"direction":"push"}).Inc()
    	factor := float64(len(m.queue))/float64(m.qc.length)
    	fixedDuration := time.Duration(float64(m.qc.maxDuration)*factor) + time.Millisecond*100
    	time.Sleep(fixedDuration)
    	errorRate := m.qc.maxErrorRate * factor
    	if rand.Intn(100) < int(errorRate*100) {
    		ok = false
    		pushErrCount += 1
    		stat.MqErrRequestCounter.With(prometheus.Labels{"direction":"push"}).Inc()
    	} else {
    		ok = true
    		m.queue = append(m.queue,"#")
    	}
    	duration = time.Now().Sub(startTime)
    	durationMs := float64(duration/time.Millisecond)
    	stat.MqRequestDurationHistogram.With(prometheus.Labels{"direction":"push"}).Observe(durationMs)
    	stat.MqRequestDurationSummary.With(prometheus.Labels{"direction":"push"}).Observe(durationMs)
    	fmt.Printf("%v",strings.Join(m.queue,""))
    	fmt.Printf("\t Factor: %v Success:%v Duration:%v PushErrCount:%v\n",factor,ok,duration,pushErrCount)
    	return
    }
    
    func (m *messageQueue) pop() (ok bool,duration time.Duration){
    	startTime := time.Now()
    	stat.MqRequestCounter.With(prometheus.Labels{"direction":"pop"}).Inc()
    	factor := float64(m.qc.length-len(m.queue))/float64(m.qc.length)
    	fixedDuration := time.Duration(float64(m.qc.maxDuration)*factor) + time.Millisecond*100
    	time.Sleep(fixedDuration)
    	errorRate := m.qc.maxErrorRate * factor
    	if rand.Intn(100) < int(errorRate*100) {
    		ok = false
    		popErrCount += 1
    		stat.MqErrRequestCounter.With(prometheus.Labels{"direction":"pop"}).Inc()
    	} else {
    		ok = true
    		m.queue = m.queue[:len(m.queue)-1]
    	}
    	duration = time.Now().Sub(startTime)
    	durationMs := float64(duration/time.Millisecond)
    	stat.MqRequestDurationHistogram.With(prometheus.Labels{"direction":"pop"}).Observe(durationMs)
    	stat.MqRequestDurationSummary.With(prometheus.Labels{"direction":"pop"}).Observe(durationMs)
    	fmt.Printf("%v",strings.Join(m.queue,""))
    	fmt.Printf("\t Factor: %v Success:%v Duration:%v PopErrCount:%v\n",factor,ok,duration,popErrCount)
    	return
    }
    
    func main() {
    	r := gin.Default()
    	r.GET("metrics",gin.WrapH(promhttp.Handler()))
    	api := r.Group("api")
    	qc := queueConfig{
    		length: 100,
    		maxErrorRate: 0.2,
    		maxDuration: 50*time.Millisecond,
    	}
    	mq := messageQueue{
    		qc: qc,
    		queue: make([]string,0,qc.length),
    	}
    
    	rand.Seed(time.Now().UnixNano())
    	api.POST("push",func(c *gin.Context) {
    		ok, duration := mq.push()
    		c.JSON(http.StatusOK,gin.H{
    			"success": ok,
    			"duration": duration,
    			"length": len(mq.queue),
    		})
    	})
    	api.POST("pop",func(c *gin.Context) {
    		ok, duration := mq.pop()
    		c.JSON(http.StatusOK,gin.H{
    			"success": ok,
    			"duration": duration,
    			"length": len(mq.queue),
    		})
    	})
    	go func() {
    		for {
    			saturation := float64(len(mq.queue))/float64(mq.qc.length)
    			stat.MqCapacitySaturation.Set(saturation)
    			time.Sleep(time.Second*5)
    		}
    	}()
    	r.Run(":9090")
    }
    

    client.go (用于持续对应用发起请求):

    package main
    
    import (
    	"encoding/json"
    	"fmt"
    	"io/ioutil"
    	"net/http"
    	"os"
    	"time"
    )
    
    type Body struct {
    	Success  bool          `json:"success"`
    	Duration time.Duration `json:"duration"`
    	Length   int           `json:"length"`
    }
    
    func main() {
    	pushFlag := true
    	var baseUrl string
    	if len(os.Args[1:]) == 0 {
    		baseUrl = "http://localhost:9090"
    	} else {
    		baseUrl = os.Args[1:][0]
    	}
    	pushUrl := baseUrl + "/api/push"
    	popUrl := baseUrl + "/api/pop"
    	for {
    		if pushFlag {
    			resp, err := http.Post(pushUrl, "application/json", nil)
    			if err != nil {
    				fmt.Fprint(os.Stderr, err)
    			}
    			bodyStr, err := ioutil.ReadAll(resp.Body)
    			if err != nil {
    				fmt.Fprint(os.Stderr, err)
    			}
    			body := &Body{}
    			err = json.Unmarshal(bodyStr, body)
    			if err != nil {
    				fmt.Fprint(os.Stderr, err)
    			}
    			fmt.Printf("%v\n", body)
    			resp.Body.Close()
    			if body.Length == 100 {
    				pushFlag = false
    			}
    		} else {
    			resp, err := http.Post(popUrl, "application/json", nil)
    			if err != nil {
    				fmt.Fprint(os.Stderr, err)
    			}
    			bodyStr, err := ioutil.ReadAll(resp.Body)
    			if err != nil {
    				fmt.Fprint(os.Stderr, err)
    			}
    			body := &Body{}
    			err = json.Unmarshal(bodyStr, body)
    			if err != nil {
    				fmt.Fprint(os.Stderr, err)
    			}
    			fmt.Printf("%v\n", body)
    			resp.Body.Close()
    			if body.Length == 0 {
    				pushFlag = true
    			}
    		}
    	}
    }
    

    Grafana图表:
    在这里插入图片描述

    展开全文
  • 实时应用监控平台CAT

    千次阅读 2019-06-14 20:07:07
    CAT 是基于 Java 开发的实时应用监控平台,为美团点评提供了全面的实时监控告警服务。 CAT 作为服务端项目基础组件,提供了 Java, C/C++, Node.js, Python, Go 等多语言客户端,已经在美团点评的基础架构中间件框架...

    https://github.com/dianping/cat

     

    CAT 简介

    • CAT 是基于 Java 开发的实时应用监控平台,为美团点评提供了全面的实时监控告警服务。
    • CAT 作为服务端项目基础组件,提供了 Java, C/C++, Node.js, Python, Go 等多语言客户端,已经在美团点评的基础架构中间件框架(MVC框架,RPC框架,数据库框架,缓存框架等,消息队列,配置系统等)深度集成,为美团点评各业务线提供系统丰富的性能指标、健康状况、实时告警等。
    • CAT 很大的优势是它是一个实时系统,CAT 大部分系统是分钟级统计,但是从数据生成到服务端处理结束是秒级别,秒级定义是48分钟40秒,基本上看到48分钟38秒数据,整体报表的统计粒度是分钟级;第二个优势,监控数据是全量统计,客户端预计算;链路数据是采样计算。

    Cat 产品价值

    • 减少故障发现时间
    • 降低故障定位成本
    • 辅助应用程序优化

    Cat 优势

    • 实时处理:信息的价值会随时间锐减,尤其是事故处理过程中
    • 全量数据:全量采集指标数据,便于深度分析故障案例
    • 高可用:故障的还原与问题定位,需要高可用监控来支撑
    • 故障容忍:故障不影响业务正常运转、对业务透明
    • 高吞吐:海量监控数据的收集,需要高吞吐能力做保证
    • 可扩展:支持分布式、跨 IDC 部署,横向扩展的监控系统

    监控模型:

    支持 Transaction、Event、Heartbeat、Metric 四种消息模型。 模型设计

    模块简介

    功能模块

    • cat-client: 客户端,上报监控数据
    • cat-consumer: 服务端,收集监控数据进行统计分析,构建丰富的统计报表
    • cat-alarm: 实时告警,提供报表指标的监控告警
    • cat-hadoop: 数据存储,logview 存储至 Hdfs
    • cat-home: 管理端,报表展示、配置管理等
    1. 根目录下 cat-client 模块以后不再维护,下个大版本更新计划移除。新版Java客户端参考:lib/java
    2. 管理端、服务端、告警服务均使用 cat-home 模块部署即可

    其他模块

    • integration:cat和一些第三方工具集成的内容(此部分一部分是由社区贡献,一部分官方贡献)
    • lib:CAT 的客户端,包括 Java、C/C++、Python、Node.js、Go
    • script:CAT 数据库脚本
    展开全文
  • CAT是基于Java开发的实时应用监控平台,包括实时应用监控,业务监控。 CAT作为大众点评网基础监控组件,它已经在中间件框架(MVC框架,RPC框架,数据库框架,缓存框架等)中得到广泛应用,为点评各业务线提供系统的...
  • 基于Prometheus的微服务应用监控

    千次阅读 2018-12-11 10:36:15
    基于Prometheus的微服务应用监控 北京易观智库网络科技有限公司 作者:李泰庆 导语: Prometheus是一套开源的系统监控报警框架。它启发于Google的borgmon 监控系统,由工作在 SoundCloud 的 google 前员工在 ...
  • Springboot 2.x应用监控 作用: 用于管理,监控应用,暴露自身信息。减少应用系统在采集应用指标的开发量。 1.添加依赖: <dependency> <groupId>org.springframework.boot</groupId> ...
  • spring boot提供了运行时的应用监控和管理的功能。我们可以通过http,JMX,SSH协议来进行操作。审计,监控及指标信息将会自动得到。 spring boot提供了监控和管理端点:actuator:所有EnPoint的列表,需要加入...
  • 而ARMS的“应用监控”就是保障这些复杂应用有效运行的秘密武器。近日,阿里中间件(Aliware)将该功能正式对外开放,目的是为用户在应用性能管理方面提供更多便利。 在微服务时代,IT企业的应
  • prometheus+grafana构建应用监控(一)

    千次阅读 2017-08-27 13:52:55
    监控目标 基础监控 ...应用监控 应用接口调用频率 应用接口响应时间 应用接口异常次数 其他 根据监控指标可配置定制化的阈值告警 选型比较 数据存储支持特性 监控信息不需要长时间保存 时间序列类型
  • ==========================================================================================...SpringBoot应用监控Actuator使用的安全隐患 问题阐述 由于系统被扫描出来有安全漏洞,发现访问http://xxxxxx/...
  • Spark 应用监控告警-Graphite_exporter

    千次阅读 2020-03-18 15:40:17
    Spark 应用监控告警-Graphite_exporter一、下载graphite_exporter1.1 修改graphite_exporter_mapping1.2 启动graphite_exporter二、Spark配置Graphite metrics三、启动Spark程序四、配置Prometheus4.1 查看...
  • ZoneMinder(简称ZM)是一套基于Linux操作系统的摄像机的视像数据监控应用软件(大家可以简单理解为网络摄像机)。ZoneMinder支持单一或多台视像镜头应用,包括摄取、分析、记录(包括移动侦测功能)、和监视来源,...
  • 应用监控人员依赖监控系统,收集数据,预测和报警。 报警设置不好, 会使管理人员疲于奔命,或者不能及时发现和处理影响应用性能的问题。 因此报警设置是应用监控系统的重要功能,体现系统的能力和水平。 早期...
  • CAT 是基于 Java 开发的实时应用监控平台,为美团点评提供了全面的实时监控告警服务。 CAT 作为服务端项目基础组件,提供了 Java, C/C++, Node.js, Python, Go 等多语言客户端,已经在美团点评的基础架构中间件框架...
  • JavaMelody应用监控

    2017-06-08 14:41:26
     JavaMelody是一款可以监控Java应用(比如项目war,ear包)以及应用服务器(比如Tomcat或Jboss weblogic等等)。可以通过图表给出监控数据。  软件下载参考google网址:http://code.google.com/p/jav
  • 系统和应用监控指标

    千次阅读 2019-03-15 20:08:58
    负载问题之前说过系统负载不超过3,我这里接近5的时候直接应用停顿了,所有的连接都断了 2019-03-15 19:35:03.322 WARN 108710 — [LI-WORKER-5-T-6] c.j.j.g.t.AbstractTCPClientTransport : [JSF-22114]No...
  • Spring Boot Admin:微服务应用监控 Spring Boot Admin 简介 监控信息演示 结合注册中心使用 功能演示 添加登录认证 文末福利 Spring Boot Admin 可以对SpringBoot应用的各项指标进行监控,可以作为微服务架构中...
  • 最简单使用promethus+spring boot admin搭建spring boot应用监控系统 promethus的安装使用 下载 官网地址 https://prometheus.io/ 打开download页面,选择操作系统(Operating system),cpu架构(Architecture)后选择...
  • 应用监控的对象包括各种设备,软件,需要多种处理技术。采用框架可以规范集成各种技术和软件,适应监控对象和监控功能不断发展的需要。不断改进和提高监控系统建设质量和效率。   监控框架 满足应用监控需求. ...
  • Spring Boot Actuator应用监控

    千次阅读 2018-06-17 15:26:36
    Spring boot Actuator 提供了一系列的端点来监控和度量应用,包括应用上下文全部Bean信息,自动化配置报告(显示自动配置条件是否通过),配置属性信息,显示应用健康状态等。 环境 Spring Boot 2.0.3 测试 1....
  • Spring Boot应用监控实战

    千次阅读 2018-05-02 10:21:40
    同样利用SpringBoot作为微服务单元的实例化技术选型时,我们不可避免的要面对的一个问题就是如何实时监控应用的运行状况数据,比如:健康度、运行指标、日志信息、线程状况等等。本文就该问题做一点探索并记录试验...
  • 一、Metrics 简介 应用监控系统 Metrics 由 Metrics.NET+InfluxDB+Grafana 组合而成,通过客户端 Metrics.NET 在业务代码中埋点,Metrics.NET 会把收集到的数据存储在 InfluxDB 数据库中,然后通过 Grafana 来展示...
  • 这些问题从反面说明了应用监控系统的作用。希望通过这些问题,国内企业能够加深对应用监控的认识和使用。提高信息应用的水平,更好地为客户服务。 实现一次上线就得到满意的效果。    应用监控发现系统运行...
  • 获得这种洞察力的最佳方法之一是使用强大的监控系统,该系统收集指标,可视化数据,并在事情出现故障时向操作员发出警报。 在本文中,我们将讨论什么是指标,监控和警报。我们将讨论它们为何重要,一般情况下你需要...
  • Mercury:唯品会全链路应用监控系统解决方案详解(含 PPT)
  • chronograf TICK应用监控

    千次阅读 2018-01-11 13:53:24
    1、数据保存策略 基本实时监控数据 一般情况下基于时间序列的point数据不会进行直接删除操作,一般我们平时只关心当前数据,历史数据不需要一直保存,不然会占用太多空间。这里可以配置数据保存策略(Retention ...
  • 支持 web 前后端、移动应用等。 了解更多信息,请移步sentry官网 二、sentry配置 1、注册sentry账号 使用sentry监控平台,必须先申请账号 2、登录sentry网站,重设语言和时区 1)点击账号旁的箭头,打开弹出 2)...
  • spring boot/cloud 应用监控

    千次阅读 2017-04-24 09:24:01
    应用监控功能,对于分布式系统非常重要。如果把分布式系统比作整个社会系统。那么各个服务对应社会中具体服务机构,比如银行、学校、超市等,那么监控就类似于警察局和医院,所以其重要性显而易见。这里说的,监控...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 57,745
精华内容 23,098
关键字:

应用监控