feat: controller and analyzer add state counter

Author: askyrie

server/controller/db/metadb/model/model.go

@@ -117,6 +117,22 @@ type Controller struct {
 	Lcuuid             string    `gorm:"column:lcuuid;type:char(64);not null" json:"LCUUID"`
 }
 
+func (c Controller) GetLcuuid() string {
+	return c.Lcuuid
+}
+
+func (c Controller) GetName() string {
+	return c.Name
+}
+
+func (c Controller) GetIP() string {
+	return c.IP
+}
+
+func (c Controller) GetState() int {
+	return c.State
+}
+
 type AZControllerConnection struct {
 	ID           int    `gorm:"primaryKey;column:id;type:int;not null" json:"ID"`
 	AZ           string `gorm:"column:az;type:char(64);default:ALL" json:"AZ"`
@@ -153,6 +169,22 @@ type Analyzer struct {
 	Lcuuid            string    `gorm:"column:lcuuid;type:char(64);not null" json:"LCUUID"`
 }
 
+func (a Analyzer) GetLcuuid() string {
+	return a.Lcuuid
+}
+
+func (a Analyzer) GetName() string {
+	return a.Name
+}
+
+func (a Analyzer) GetIP() string {
+	return a.IP
+}
+
+func (a Analyzer) GetState() int {
+	return a.State
+}
+
 type AZAnalyzerConnection struct {
 	ID         int    `gorm:"primaryKey;column:id;type:int;not null" json:"ID"`
 	AZ         string `gorm:"column:az;type:char(64);default:ALL" json:"AZ"`

server/controller/monitor/analyzer.go

@@ -30,9 +30,12 @@ import (
 	"github.com/deepflowio/deepflow/server/controller/http/service/rebalance"
 	mconfig "github.com/deepflowio/deepflow/server/controller/monitor/config"
 	"github.com/deepflowio/deepflow/server/controller/trisolaris/refresh"
+	"github.com/deepflowio/deepflow/server/libs/stats"
 )
 
 type AnalyzerCheck struct {
+	stateCounter *SysStateCounter[metadbmodel.Analyzer]
+
 	cCtx                  context.Context
 	cCancel               context.CancelFunc
 	cfg                   mconfig.MonitorConfig
@@ -45,9 +48,15 @@ type AnalyzerCheck struct {
 
 func NewAnalyzerCheck(cfg *config.ControllerConfig, ctx context.Context) *AnalyzerCheck {
 	cCtx, cCancel := context.WithCancel(ctx)
+	stateCounter := NewSysStateCounter[metadbmodel.Analyzer]()
+	err := stats.RegisterCountableWithModulePrefix("controller_", "analyzer", stateCounter, stats.OptionStatTags{"type": "analyzer"})
+	if err != nil {
+		log.Error(err)
+	}
 	return &AnalyzerCheck{
 		cCtx:                  cCtx,
 		cCancel:               cCancel,
+		stateCounter:          stateCounter,
 		cfg:                   cfg.MonitorCfg,
 		healthCheckPort:       cfg.ListenPort,
 		healthCheckNodePort:   cfg.ListenNodePort,
@@ -231,6 +240,14 @@ func (c *AnalyzerCheck) healthCheck(orgDB *metadb.DB) {
 			}
 		}
 	}
+
+	analyzers = []metadbmodel.Analyzer{}
+	if err := metadb.DefaultDB.Find(&analyzers).Error; err != nil {
+		log.Errorf("get analyzer state from db error: %s", err.Error())
+	} else {
+		c.stateCounter.AddSysStateCounters(analyzers)
+	}
+
 	log.Info("analyzer health check end")
 }
 

server/controller/monitor/common.go

@@ -19,6 +19,7 @@ package monitor
 import (
 	"fmt"
 	"net/http"
+	"sync"
 	"time"
 
 	"github.com/deepflowio/deepflow/server/controller/common"
@@ -92,3 +93,61 @@ func getIPMap(hostType string) (map[string]bool, error) {
 	}
 	return res, nil
 }
+
+type SysComponent interface {
+	GetLcuuid() string
+	GetName() string
+	GetIP() string
+	GetState() int
+}
+
+type SysState struct {
+	Name  string `statsd:"name"`
+	IP    string `statsd:"ip"`
+	State uint64 `statsd:"state"`
+}
+
+type SysStateCounter[T SysComponent] struct {
+	mu       sync.Mutex
+	counters map[string]*SysState
+}
+
+func NewSysStateCounter[T SysComponent]() *SysStateCounter[T] {
+	return &SysStateCounter[T]{
+		counters: make(map[string]*SysState),
+	}
+}
+
+func (s *SysStateCounter[T]) GetCounter() interface{} {
+	s.mu.Lock()
+	counters := s.counters
+	counterSize := len(counters)
+	s.counters = make(map[string]*SysState, counterSize)
+	s.mu.Unlock()
+
+	if counterSize == 0 {
+		return nil
+	}
+
+	result := make([]*SysState, 0, counterSize)
+	for _, counter := range counters {
+		result = append(result, counter)
+	}
+	return result
+}
+
+func (s *SysStateCounter[T]) AddSysStateCounters(sysComponents []T) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	for _, sysComponent := range sysComponents {
+		s.counters[sysComponent.GetLcuuid()] = &SysState{
+			Name:  sysComponent.GetName(),
+			IP:    sysComponent.GetIP(),
+			State: uint64(sysComponent.GetState()),
+		}
+	}
+}
+
+func (s *SysStateCounter[T]) Closed() bool {
+	return false
+}

server/controller/monitor/controller.go

@@ -30,6 +30,7 @@ import (
 	"github.com/deepflowio/deepflow/server/controller/model"
 	mconfig "github.com/deepflowio/deepflow/server/controller/monitor/config"
 	"github.com/deepflowio/deepflow/server/controller/trisolaris/refresh"
+	"github.com/deepflowio/deepflow/server/libs/stats"
 )
 
 type dbAndIP struct {
@@ -38,6 +39,8 @@ type dbAndIP struct {
 }
 
 type ControllerCheck struct {
+	stateCounter *SysStateCounter[metadbmodel.Controller]
+
 	cCtx                    context.Context
 	cCancel                 context.CancelFunc
 	cfg                     mconfig.MonitorConfig
@@ -50,9 +53,15 @@ type ControllerCheck struct {
 
 func NewControllerCheck(cfg *config.ControllerConfig, ctx context.Context) *ControllerCheck {
 	cCtx, cCancel := context.WithCancel(ctx)
+	stateCounter := NewSysStateCounter[metadbmodel.Controller]()
+	err := stats.RegisterCountableWithModulePrefix("controller_", "controller", stateCounter, stats.OptionStatTags{"type": "controller"})
+	if err != nil {
+		log.Error(err)
+	}
 	return &ControllerCheck{
 		cCtx:                    cCtx,
 		cCancel:                 cCancel,
+		stateCounter:            stateCounter,
 		cfg:                     cfg.MonitorCfg,
 		healthCheckPort:         cfg.ListenPort,
 		healthCheckNodePort:     cfg.ListenNodePort,
@@ -240,6 +249,14 @@ func (c *ControllerCheck) healthCheck(orgDB *metadb.DB) {
 		}
 	}
 	c.cleanExceptionControllerData(orgDB, controllerIPs)
+
+	controllers = []metadbmodel.Controller{}
+	if err := metadb.DefaultDB.Find(&controllers).Error; err != nil {
+		log.Errorf("get controller state from db error: %s", err.Error())
+	} else {
+		c.stateCounter.AddSysStateCounters(controllers)
+	}
+
 	log.Info("controller health check end")
 }