(promethues）node_exporter注册自定义监控数据，简单展示(1)

2401_83973943

于 2024-05-15 14:57:34 发布

阅读量281

点赞数 4

文章标签：运维 linux 面试

本文链接：https://blog.csdn.net/2401_83973943/article/details/138908858

版权

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以点击这里获取！

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

// 定义 customMetricsCollector 结构体
type customMetricsCollector struct {
logger log.Logger
//…
}

type netflow struct {
//flowSend prometheus.Gauge
//flowReceive prometheus.Gauge
//label *prometheus.CounterVec
flowSend *prometheus.CounterVec
flowReceive *prometheus.CounterVec
}

func NewMetrics(reg prometheus.Registerer) *netflow {
m := &netflow{
flowSend: prometheus.NewCounterVec(
prometheus.CounterOpts{
Name: “flowSend”,
Help: “Current flowSend of the Host.”,
},
[]string{“host”},
),
flowReceive: prometheus.NewCounterVec(
prometheus.CounterOpts{
Name: “flowReceive”,
Help: “Current flowReceive of the Host.”,
},
[]string{“host”},
),
}
reg.MustRegister(m.flowSend)
reg.MustRegister(m.flowReceive)
return m
}

func init() {
//1. 在该函数中调用 registerCollector() 函数,注册自定义 customMetricsCollector
registerCollector(“netflow_metrics”, defaultEnabled, NewCustomMetricsCollector)
}

// 2. 定义 customMetricsCollector 的工厂函数,后续传入 registerCollector() 函数中,以便创建 customMetricsCollector 对象
func NewCustomMetricsCollector(logger log.Logger) (Collector, error) {
return &customMetricsCollector{
logger: logger,
}, nil
}

// 实现 Update() 函数,以便在处理请求时被 Collector.Collect() 调用
func (c *customMetricsCollector) Update(ch chan<- prometheus.Metric) error {
reg := prometheus.NewRegistry()

// Create new metrics and register them using the custom registry.
m := NewMetrics(reg)
//var metricType prometheus.ValueType

//metricType = prometheus.CounterValue

result, err := exec.Command("sh", "-c", "iftop -t -N -n -s 1 2>/dev/null |grep -A 1 -E '^ [0-9]'").Output()
if err != nil {
	fmt.Println("Error:", string(result))
} else {
	lines := strings.Split(string(result), "\n")
	fmt.Println(lines)
	fmt.Println(len(lines) - 1)
	var count = 1
	var groupnum = 0
	all_netflow := make(map[string]string)
	//send\_rece\_arr := make([]float64, 6)
	var send_flow = ""
	for i := 0; i < len(lines)-1; i++ {
		//fmt.Println("--------------------------------------++++")
		//fmt.Println(lines[i])
		slice0 := strings.Split(lines[i], " ")
		if (count % 2) != 0 {
			groupnum++
			//发送
			send_arr := make([]string, 7)
			var scount = 0
			//fmt.Printf("%d 组发送流量：%s\n", groupnum, slice0)
			for \_, v := range slice0 {
				if v != "" {
					//fmt.Println(v)
					send_arr[scount] = v
					scount++
				}
			}
			fmt.Println(send_arr)
			fmt.Println(send_arr[1], send_arr[len(send_arr)-2])
			send_flow = send_arr[len(send_arr)-2]
		} else {

			//接收
			rece_arr := make([]string, 6)
			var rcount = 0
			for \_, v := range slice0 {
				if v != "" {
					//fmt.Println(v)
					rece_arr[rcount] = v
					rcount++
				}
			}
			fmt.Println(rece_arr)
			fmt.Println(rece_arr[0], rece_arr[len(rece_arr)-2])
			//transformtokb(send\_flow)
			rece_flow := rece_arr[len(rece_arr)-2]
			fmt.Println(transformtokb(send_flow), transformtokb(rece_flow))
			send_flow = strconv.FormatFloat(transformtokb(send_flow), 'f', 2, 64)
			rece_flow = strconv.FormatFloat(transformtokb(rece_flow), 'f', 2, 64)
			all_netflow[rece_arr[0]] = send_flow + "|" + rece_flow
			send_flow = ""
		}
		count++
	}
	// 流量获取结束

	// 把切片里的有效数据放到map中

	netflow_send := make(map[string]float64)
	netflow_rece := make(map[string]float64)
	for desthost, flowsize := range all_netflow {
		p_send := 0.00
		p_rece := 0.00
		p_send, \_ = strconv.ParseFloat(strings.Split(flowsize, "|")[0], 2)
		p_rece, \_ = strconv.ParseFloat(strings.Split(flowsize, "|")[1], 2)
		netflow_send[desthost] = p_send
		netflow_rece[desthost] = p_rece
		m.flowSend.With(prometheus.Labels{"host": desthost}).Add(float64(p_send))
		m.flowReceive.With(prometheus.Labels{"host": desthost}).Add(float64(p_rece))

	}

}
return nil

}

// 对b/Kb/Mb数据进行转换
func transformtokb(flow string) float64 {
newstr := “”
for _, v := range flow {
if v == ‘K’ {
//fmt.Println(newstr)
strInt, err := strconv.ParseFloat(newstr, 2)
if err != nil {
fmt.Println(“transformtokb v is K”,err)
}
finalResult := float64(strInt)
return finalResult
//break
} else if v == ‘b’ {
//fmt.Println(newstr)
strInt, err := strconv.ParseFloat(newstr, 2)
if err != nil {
fmt.Println(“transformtokb v is b”,err)
}
//fmt.Println(str_int / 1024)
//var final_result=0.0
//final_result :=
finalResult := math.Round(float64(strInt/1024)*1000) / 1000
return finalResult
//break
} else if v == ‘M’ {
//fmt.Println(newstr)
strInt, err := strconv.ParseFloat(newstr, 2)
if err != nil {
fmt.Println(“transformtokb v is M”,err)
}
//fmt.Println(str_int * 1024)
//final_result := float64(str_int * 1024)
finalResult := math.Round(float64(strInt*1024)*1000) / 1000
return finalResult
}
newstr += string(v)
}
return 0
}


#### 3.编译


参照之前编译博客：[Linux环境下编译并运行go项目]( )  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/d9ddf510abb447b9b7608784f8e49dcd.png)  
 **还可以这样安装go环境：**

[root@hadoop1011 ~]# tar -zxvf go1.20.12.linux-amd64.tar.gz -C /usr/local/go1.20.12/

[root@hadoop1011 ~]# vim /etc/profile.d/go.sh
export PATH=$PATH:/usr/local/go1.20.12/go/bin
[root@hadoop1011 ~]# source /etc/profile

[root@hadoop1011 node_exporter-master]# ./node_exporter


新开一个窗口

[root@hadoop1011 node_exporter-master]#curl -L 127.0.0.1:9100/metrics|grep netflow
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
0 0 0 0 0 0 0 0 --:–:-- 0:00:12 --:–:-- 0# HELP node_netflow_receive Receive netflow from remote host.

TYPE node_netflow_receive gauge

node_netflow_receive{remote_host=“192.168.196.73”} 0.813
node_netflow_receive{remote_host=“192.168.10.100”} 2529.28
node_netflow_receive{remote_host=“192.168.10.101”} 2068.48
node_netflow_receive{remote_host=“192.168.10.103”} 1853.44
node_netflow_receive{remote_host=“192.168.10.104”} 1710.08
node_netflow_receive{remote_host=“192.168.10.99”} 1792

HELP node_netflow_send Send remote host netflow.

TYPE node_netflow_send gauge

node_netflow_send{remote_host=“192.168.196.73”} 1.72
node_netflow_send{remote_host=“192.168.10.100”} 2109.44
node_netflow_send{remote_host=“192.168.10.101”} 2805.76
node_netflow_send{remote_host=“192.168.10.103”} 2088.96
node_netflow_send{remote_host=“192.168.10.104”} 2529.28
node_netflow_send{remote_host=“192.168.10.99”} 2078.72
node_scrape_collector_duration_seconds{collector=“netflow”} 12.064428387
node_scrape_collector_success{collector=“netflow”} 1
100 95019 0 95019 0 0 7873 0 --:–:-- 0:00:12 --:–:-- 23415
[root@hadoop1011 node_exporter-master]#

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以点击这里获取！

2401_83973943

关注

4
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
(promethues）node_exporter注册自定义监控数据，简单展示(1)

/ 定义 customMetricsCollector 结构体//…},),},),return m//1. 在该函数中调用 registerCollector() 函数,注册自定义 customMetricsCollector// 2. 定义 customMetricsCollector 的工厂函数,后续传入 registerCollector() 函数中,以便创建 customMetricsCollector 对象。
复制链接

扫一扫