feat:support custom labels

Author: jimyag

config.toml

@@ -2,13 +2,18 @@
 name_server = "223.5.5.5"
 
 [web]
-address = "0.0.0.0:8080"
+address = "0.0.0.0:9113"
 
 [[targets]]
 addr = "223.5.5.5"
+[targets.labels]
+"some_label" = "test"
+
 
 [[targets]]
 addr = "114.114.114.114"
+[targets.labels]
+"custom_label" = "hihihihi"
 
 [global_labels]
 "from" = "192.168.2.1"

config/config.go

@@ -72,7 +72,7 @@ func (c *Config) Verify() {
 	}
 
 	if len(c.Targets) == 0 {
-		log.Panic().Msg("No targets specified")
+		log.Panic().Msg("no targets specified")
 	}
 }
 
@@ -105,13 +105,11 @@ func (cfg *Config) TargetConfigByAddr(addr string) TargetConfig {
 func (c *Config) GenMonitor() (*mon.Monitor, error) {
 	var bind4, bind6 string
 	if ln, err := net.Listen("tcp4", "127.0.0.1:0"); err == nil {
-		// ipv4 enabled
-		ln.Close()
+		_ = ln.Close()
 		bind4 = "0.0.0.0"
 	}
 	if ln, err := net.Listen("tcp6", "[::1]:0"); err == nil {
-		// ipv6 enabled
-		ln.Close()
+		_ = ln.Close()
 		bind6 = "::"
 	}
 	pinger, err := ping.New(bind4, bind6)
@@ -129,17 +127,17 @@ func (c *Config) GenMonitor() (*mon.Monitor, error) {
 	monitor.HistorySize = c.Ping.History
 	resolver := c.SetupResolver()
 	for i, target := range c.Targets {
-		addrs, err := resolver.LookupIPAddr(context.Background(), target.Addr)
+		ipAddrs, err := resolver.LookupIPAddr(context.Background(), target.Addr)
 		if err != nil {
 			log.Error(err).Str("target", target.Addr).Msg("cannot resolve target address")
 			continue
 		}
-		for j, addr := range addrs {
-			key := genPingMonitorKey(target.Addr, addr)
-			if err := monitor.AddTargetDelayed(key, addr,
+		for j, ipAddr := range ipAddrs {
+			key := genPingMonitorKey(target.Addr, ipAddr)
+			if err := monitor.AddTargetDelayed(key, ipAddr,
 				time.Duration(10*i+j)*time.Millisecond,
 			); err != nil {
-				log.Error(err).Str("target", target.Addr).
+				log.Error(err).Str("addr", target.Addr).
 					Str("key", key).
 					Msg("cannot add target")
 			}
@@ -149,22 +147,21 @@ func (c *Config) GenMonitor() (*mon.Monitor, error) {
 	return monitor, nil
 }
 
-// genPingMonitorKey returns a unique key for the monitor based on target and addr
+// genPingMonitorKey returns a unique key for the monitor based on addr and ipAddr
 // for example: "test.host.com 192.168.2.1 v4"
-func genPingMonitorKey(target string, addr net.IPAddr) string {
-	if addr.IP.To4() == nil {
-		return fmt.Sprintf("%s %s v6", target, addr.String())
+func genPingMonitorKey(addr string, ipAddr net.IPAddr) string {
+	if ipAddr.IP.To4() == nil {
+		return fmt.Sprintf("%s %s v6", addr, ipAddr.String())
 	}
-	return fmt.Sprintf("%s %s v4", target, addr.String())
+	return fmt.Sprintf("%s %s v4", addr, ipAddr.String())
 }
 
-func ParseMonitorKey(key string) (string, net.IPAddr) {
-
+func ParseMonitorKey(key string) (addr string, ipAddr net.IPAddr, version string) {
 	parts := strings.Split(key, " ")
 	if len(parts) != 3 {
 		log.Panic().Str("key", key).Msg("cannot parse monitor key")
 	}
-	host := parts[0]
+	addr = parts[0]
 	ip := net.ParseIP(parts[1])
 	if ip == nil {
 		log.Panic().Str("key", key).Msg("unexpected ip in monitor key")
@@ -176,5 +173,10 @@ func ParseMonitorKey(key string) (string, net.IPAddr) {
 	if parts[2] == "v6" && ip.To4() != nil {
 		log.Panic().Str("key", key).Msg("unexpected ip version in monitor key")
 	}
-	return host, net.IPAddr{IP: ip}
+	if ip.To4() == nil {
+		version = "v4"
+	} else {
+		version = "v6"
+	}
+	return addr, net.IPAddr{IP: ip}, version
 }

config/custom_lable.go

@@ -0,0 +1,46 @@
+package config
+
+type CustomLabel struct {
+	label    []string
+	labelKey map[string]struct{}
+}
+
+func NewCustomLabel(targets []TargetConfig) *CustomLabel {
+	cl := CustomLabel{
+		label:    make([]string, 0),
+		labelKey: make(map[string]struct{}),
+	}
+
+	for _, t := range targets {
+		if t.Labels == nil {
+			continue
+		}
+
+		for k := range t.Labels {
+			if _, ok := cl.labelKey[k]; ok {
+				continue
+			}
+			cl.label = append(cl.label, k)
+			cl.labelKey[k] = struct{}{}
+		}
+	}
+	return &cl
+
+}
+
+func (cl *CustomLabel) Labels() []string {
+	return cl.label
+}
+
+func (cl *CustomLabel) Values(target TargetConfig) []string {
+	values := make([]string, len(cl.label))
+	if target.Labels == nil {
+		return values
+	}
+	for i, l := range cl.label {
+		if _, ok := target.Labels[l]; ok {
+			values[i] = target.Labels[l]
+		}
+	}
+	return values
+}

config/target.go

@@ -1,7 +1,6 @@
 package config
 
 type TargetConfig struct {
-	Addr string `yaml:"addr"`
-	// TODO support labels
-	// Labels map[string]string `yaml:"labels"`
+	Addr   string            `yaml:"addr"`
+	Labels map[string]string `yaml:"labels"`
 }

main.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"fmt"
 	"net/http"
 	"os"
 
@@ -33,12 +32,8 @@ func main() {
 	prometheus.MustRegister(ping)
 	http.Handle("/metrics", promhttp.Handler())
 
-	go func() {
-		log.Info().Str("address", cfg.Web.Address).Msg("starting web server")
-		if err := http.ListenAndServe(cfg.Web.Address, nil); err != nil {
-			fmt.Println(err)
-		}
-	}()
-
-	select {}
+	log.Info().Str("address", cfg.Web.Address).Msg("starting web server")
+	if err := http.ListenAndServe(cfg.Web.Address, nil); err != nil {
+		log.Panic(err).Msg("listen failed")
+	}
 }

metrics/ping.go

@@ -2,7 +2,6 @@ package metrics
 
 import (
 	"sort"
-	"strings"
 
 	mon "github.com/digineo/go-ping/monitor"
 	"github.com/jimyag/log"
@@ -14,6 +13,7 @@ import (
 type Ping struct {
 	monitor    *mon.Monitor
 	cfg        *config.Config
+	cl         *config.CustomLabel
 	globalKey  []string
 	metrics    map[string]*mon.Metrics
 	bestDesc   *prometheus.Desc
@@ -28,9 +28,11 @@ func New(cfg *config.Config) *Ping {
 	if err != nil {
 		log.Panic(err).Msg("gen monitor")
 	}
+	cl := config.NewCustomLabel(cfg.Targets)
 	p := &Ping{
 		monitor: m,
 		cfg:     cfg,
+		cl:      cl,
 	}
 	p.init()
 	return p
@@ -40,22 +42,25 @@ func (p *Ping) Collect(ch chan<- prometheus.Metric) {
 	if m := p.monitor.Export(); len(m) > 0 {
 		p.metrics = m
 	}
-	for target, metrics := range p.metrics {
-		// target ip version
-		l := strings.Split(target, " ")
+	for key, metrics := range p.metrics {
+		// addr ipAddr version
+		addr, ipAddr, version := config.ParseMonitorKey(key)
+		labelValues := []string{addr, ipAddr.String(), version}
 		if p.globalKey != nil {
 			for _, k := range p.globalKey {
-				l = append(l, p.cfg.GlobalLabels[k])
+				labelValues = append(labelValues, p.cfg.GlobalLabels[k])
 			}
 		}
+		customLabelVal := p.cl.Values(p.cfg.TargetConfigByAddr(addr))
+		labelValues = append(labelValues, customLabelVal...)
 		if metrics.PacketsSent > metrics.PacketsLost {
-			ch <- prometheus.MustNewConstMetric(p.bestDesc, prometheus.GaugeValue, float64(metrics.Best), l...)
-			ch <- prometheus.MustNewConstMetric(p.worstDesc, prometheus.GaugeValue, float64(metrics.Worst), l...)
-			ch <- prometheus.MustNewConstMetric(p.meanDesc, prometheus.GaugeValue, float64(metrics.Mean), l...)
-			ch <- prometheus.MustNewConstMetric(p.stdDevDesc, prometheus.GaugeValue, float64(metrics.StdDev), l...)
+			ch <- prometheus.MustNewConstMetric(p.bestDesc, prometheus.GaugeValue, float64(metrics.Best), labelValues...)
+			ch <- prometheus.MustNewConstMetric(p.worstDesc, prometheus.GaugeValue, float64(metrics.Worst), labelValues...)
+			ch <- prometheus.MustNewConstMetric(p.meanDesc, prometheus.GaugeValue, float64(metrics.Mean), labelValues...)
+			ch <- prometheus.MustNewConstMetric(p.stdDevDesc, prometheus.GaugeValue, float64(metrics.StdDev), labelValues...)
 		}
 		loss := float64(metrics.PacketsLost) / float64(metrics.PacketsSent)
-		ch <- prometheus.MustNewConstMetric(p.lossDesc, prometheus.GaugeValue, loss, l...)
+		ch <- prometheus.MustNewConstMetric(p.lossDesc, prometheus.GaugeValue, loss, labelValues...)
 	}
 }
 
@@ -68,14 +73,17 @@ func (p *Ping) Describe(ch chan<- *prometheus.Desc) {
 }
 
 func (p *Ping) init() {
-	label := []string{"target", "ip", "version"}
+	// base labels
+	label := []string{"addr", "ip", "version"}
 	if p.cfg.GlobalLabels != nil {
 		p.globalKey = make([]string, 0, len(p.cfg.GlobalLabels))
 		for k := range p.cfg.GlobalLabels {
 			p.globalKey = append(p.globalKey, k)
 		}
 		sort.Strings(p.globalKey)
 		label = append(label, p.globalKey...)
+		// set custom labels
+		label = append(label, p.cl.Labels()...)
 	}
 	p.bestDesc = newDesc("rtt_best", "best round trip time", label, nil)
 	p.worstDesc = newDesc("rtt_worst", "worst round trip time", label, nil)