mon: load metrics for numa nodes

Author: pnsafonov

pkg/config.go

@@ -49,7 +49,8 @@ func loadConfigAndInit(ctx *Context) error {
 	ctx.state.Idle = NewIdlePinCpu(ctx)
 
 	ctx.HttpApi = http_api.NewHttpApi(ctx, config0.Service.HttpApi)
-	ctx.Monitoring = monitoring.NewMonitoring(config0.Service.Monitoring)
+	numaNodesCount := len(pool.Nodes)
+	ctx.Monitoring = monitoring.NewMonitoring(config0.Service.Monitoring, numaNodesCount)
 
 	return nil
 }

pkg/monitoring.go

@@ -11,12 +11,26 @@ func setMonitoringState(ctx *Context) error {
 func fillMonitoringState(ctx *Context) *monitoring.State {
 	state := monitoring.NewState()
 
-	state.IdleLoad0 = ctx.pool.IdleLoad0
-	state.IdleLoad1 = ctx.pool.IdleLoad1
-	state.LoadFree0 = ctx.pool.LoadFree0
-	state.LoadFree1 = ctx.pool.LoadFree1
-	state.LoadUsed0 = ctx.pool.LoadUsed0
-	state.LoadUsed1 = ctx.pool.LoadUsed1
+	state.Pool.IdleLoad0 = ctx.pool.IdleLoad0
+	state.Pool.IdleLoad1 = ctx.pool.IdleLoad1
+	state.Pool.LoadFree0 = ctx.pool.LoadFree0
+	state.Pool.LoadFree1 = ctx.pool.LoadFree1
+	state.Pool.LoadUsed0 = ctx.pool.LoadUsed0
+	state.Pool.LoadUsed1 = ctx.pool.LoadUsed1
+
+	l0 := len(ctx.pool.Nodes)
+	for i := 0; i < l0; i++ {
+		node := ctx.pool.Nodes[i]
+
+		nodeMon := &monitoring.PoolNode{
+			Index:     i,
+			LoadFree0: node.LoadFree0,
+			LoadFree1: node.LoadFree1,
+			LoadUsed0: node.LoadUsed0,
+			LoadUsed1: node.LoadUsed1,
+		}
+		state.Pool.Nodes = append(state.Pool.Nodes, nodeMon)
+	}
 
 	return state
 }

pkg/monitoring/collector.go

@@ -2,65 +2,129 @@ package monitoring
 
 import (
 	"github.com/prometheus/client_golang/prometheus"
+	"strconv"
 	"time"
 )
 
 type StaticCollector struct {
+	PoolCollector *PoolCollector
+
+	State *State
+}
+
+type PoolCollector struct {
 	IdleLoad0 *prometheus.Desc
 	IdleLoad1 *prometheus.Desc
 	LoadFree0 *prometheus.Desc
 	LoadFree1 *prometheus.Desc
 	LoadUsed0 *prometheus.Desc
 	LoadUsed1 *prometheus.Desc
 
-	State *State
+	Nodes []*PoolNodeCollector
 }
 
-func NewStaticCollector() *StaticCollector {
-	ent := &StaticCollector{}
+type PoolNodeCollector struct {
+	Index     int
+	LoadFree0 *prometheus.Desc
+	LoadFree1 *prometheus.Desc
+	LoadUsed0 *prometheus.Desc
+	LoadUsed1 *prometheus.Desc
+}
 
-	ent.IdleLoad0 = prometheus.NewDesc("idle_load0",
+func NewPoolCollector(nodesCount int) *PoolCollector {
+	ent := &PoolCollector{}
+
+	ent.IdleLoad0 = prometheus.NewDesc("pool_idle_load0",
 		"400, 600, 800 %",
 		nil, nil,
 	)
-	ent.IdleLoad1 = prometheus.NewDesc("idle_load1",
+	ent.IdleLoad1 = prometheus.NewDesc("pool_idle_load1",
 		"0-100 %",
 		nil, nil,
 	)
-	ent.LoadFree0 = prometheus.NewDesc("load_free0",
+	ent.LoadFree0 = prometheus.NewDesc("pool_load_free0",
 		"400, 600, 800 %",
 		nil, nil,
 	)
-	ent.LoadFree1 = prometheus.NewDesc("load_free1",
+	ent.LoadFree1 = prometheus.NewDesc("pool_load_free1",
 		"0-100 %",
 		nil, nil,
 	)
-	ent.LoadUsed0 = prometheus.NewDesc("load_used0",
+	ent.LoadUsed0 = prometheus.NewDesc("pool_load_used0",
 		"400, 600, 800 %",
 		nil, nil,
 	)
-	ent.LoadUsed1 = prometheus.NewDesc("load_used1",
+	ent.LoadUsed1 = prometheus.NewDesc("pool_load_used1",
 		"0-100 %",
 		nil, nil,
 	)
 
-	ent.State = NewState()
+	for i := 0; i < nodesCount; i++ {
+		node := &PoolNodeCollector{
+			Index: i,
+		}
+
+		labels0 := prometheus.Labels{
+			"node": strconv.Itoa(i),
+		}
+
+		node.LoadFree0 = prometheus.NewDesc("node_load_free0",
+			"400, 600, 800 %",
+			nil, labels0,
+		)
+		node.LoadFree1 = prometheus.NewDesc("node_load_free1",
+			"0-100 %",
+			nil, labels0,
+		)
+		node.LoadUsed0 = prometheus.NewDesc("node_load_used0",
+			"400, 600, 800 %",
+			nil, labels0,
+		)
+		node.LoadUsed1 = prometheus.NewDesc("node_load_used1",
+			"0-100 %",
+			nil, labels0,
+		)
+
+		ent.Nodes = append(ent.Nodes, node)
+	}
+
+	return ent
+}
+
+func NewStaticCollector(nodesCount int) *StaticCollector {
+	pool := NewPoolCollector(nodesCount)
+
+	ent := &StaticCollector{
+		PoolCollector: pool,
+	}
 
 	return ent
 }
 
 func (x *StaticCollector) Describe(ch chan<- *prometheus.Desc) {
-	ch <- x.IdleLoad0
-	ch <- x.IdleLoad1
+	ch <- x.PoolCollector.IdleLoad0
+	ch <- x.PoolCollector.IdleLoad1
+	ch <- x.PoolCollector.LoadFree0
+	ch <- x.PoolCollector.LoadFree1
+	ch <- x.PoolCollector.LoadUsed0
+	ch <- x.PoolCollector.LoadUsed1
+
+	for _, node := range x.PoolCollector.Nodes {
+		ch <- node.LoadFree0
+		ch <- node.LoadFree1
+		ch <- node.LoadUsed0
+		ch <- node.LoadUsed1
+	}
+
 }
 
 func (x *StaticCollector) Collect(ch chan<- prometheus.Metric) {
-	m0 := prometheus.MustNewConstMetric(x.IdleLoad0, prometheus.GaugeValue, x.State.IdleLoad0)
-	m1 := prometheus.MustNewConstMetric(x.IdleLoad1, prometheus.GaugeValue, x.State.IdleLoad1)
-	m2 := prometheus.MustNewConstMetric(x.LoadFree0, prometheus.GaugeValue, x.State.LoadFree0)
-	m3 := prometheus.MustNewConstMetric(x.LoadFree1, prometheus.GaugeValue, x.State.LoadFree1)
-	m4 := prometheus.MustNewConstMetric(x.LoadUsed0, prometheus.GaugeValue, x.State.LoadUsed0)
-	m5 := prometheus.MustNewConstMetric(x.LoadUsed1, prometheus.GaugeValue, x.State.LoadUsed1)
+	m0 := prometheus.MustNewConstMetric(x.PoolCollector.IdleLoad0, prometheus.GaugeValue, x.State.Pool.IdleLoad0)
+	m1 := prometheus.MustNewConstMetric(x.PoolCollector.IdleLoad1, prometheus.GaugeValue, x.State.Pool.IdleLoad1)
+	m2 := prometheus.MustNewConstMetric(x.PoolCollector.LoadFree0, prometheus.GaugeValue, x.State.Pool.LoadFree0)
+	m3 := prometheus.MustNewConstMetric(x.PoolCollector.LoadFree1, prometheus.GaugeValue, x.State.Pool.LoadFree1)
+	m4 := prometheus.MustNewConstMetric(x.PoolCollector.LoadUsed0, prometheus.GaugeValue, x.State.Pool.LoadUsed0)
+	m5 := prometheus.MustNewConstMetric(x.PoolCollector.LoadUsed1, prometheus.GaugeValue, x.State.Pool.LoadUsed1)
 
 	now := time.Now()
 	mt0 := prometheus.NewMetricWithTimestamp(now, m0)
@@ -76,4 +140,26 @@ func (x *StaticCollector) Collect(ch chan<- prometheus.Metric) {
 	ch <- mt3
 	ch <- mt4
 	ch <- mt5
+
+	l0 := len(x.PoolCollector.Nodes)
+	for i := 0; i < l0; i++ {
+		node := x.State.Pool.Nodes[i]
+
+		nodeCollector := x.PoolCollector.Nodes[i]
+
+		mn0 := prometheus.MustNewConstMetric(nodeCollector.LoadFree0, prometheus.GaugeValue, node.LoadFree0)
+		mn1 := prometheus.MustNewConstMetric(nodeCollector.LoadFree1, prometheus.GaugeValue, node.LoadFree1)
+		mn2 := prometheus.MustNewConstMetric(nodeCollector.LoadUsed0, prometheus.GaugeValue, node.LoadUsed0)
+		mn3 := prometheus.MustNewConstMetric(nodeCollector.LoadUsed1, prometheus.GaugeValue, node.LoadUsed1)
+
+		mnt0 := prometheus.NewMetricWithTimestamp(now, mn0)
+		mnt1 := prometheus.NewMetricWithTimestamp(now, mn1)
+		mnt2 := prometheus.NewMetricWithTimestamp(now, mn2)
+		mnt3 := prometheus.NewMetricWithTimestamp(now, mn3)
+
+		ch <- mnt0
+		ch <- mnt1
+		ch <- mnt2
+		ch <- mnt3
+	}
 }

pkg/monitoring/monitoring.go

@@ -17,8 +17,8 @@ type Monitoring struct {
 	staticCollector *StaticCollector
 }
 
-func NewMonitoring(config *config.Monitoring) *Monitoring {
-	collector := NewStaticCollector()
+func NewMonitoring(config *config.Monitoring, numaNodesCount int) *Monitoring {
+	collector := NewStaticCollector(numaNodesCount)
 
 	ent := &Monitoring{
 		config:          config,

pkg/monitoring/state.go

@@ -1,14 +1,32 @@
 package monitoring
 
 type State struct {
+	Pool *Pool
+}
+
+type Pool struct {
 	IdleLoad0 float64
 	IdleLoad1 float64
 	LoadFree0 float64
 	LoadFree1 float64
 	LoadUsed0 float64
 	LoadUsed1 float64
+
+	Nodes []*PoolNode
+}
+
+type PoolNode struct {
+	Index     int
+	LoadFree0 float64
+	LoadFree1 float64
+	LoadUsed0 float64
+	LoadUsed1 float64
 }
 
 func NewState() *State {
-	return &State{}
+	pool := &Pool{}
+
+	return &State{
+		pool,
+	}
 }