X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=pkg%2Fxapp%2Fmetrics.go;h=f85c4887c45e14ade25c082e0c6adf78b345d889;hb=c8382f13e7126e4038b88b0f8af33db983b7ea3a;hp=e31fdb7b07ab55078f78fc0ce938488add8746e7;hpb=6e075ceec8c477237f7d0c6d987837a8798dd4ec;p=ric-plt%2Fxapp-frame.git diff --git a/pkg/xapp/metrics.go b/pkg/xapp/metrics.go index e31fdb7..f85c488 100644 --- a/pkg/xapp/metrics.go +++ b/pkg/xapp/metrics.go @@ -20,21 +20,134 @@ package xapp import ( + "fmt" "github.com/gorilla/mux" "github.com/prometheus/client_golang/prometheus" "github.com/prometheus/client_golang/prometheus/promauto" "github.com/prometheus/client_golang/prometheus/promhttp" + "sync" ) -type Metrics struct { - Namespace string -} - +//----------------------------------------------------------------------------- // Alias -type CounterOpts prometheus.CounterOpts +//----------------------------------------------------------------------------- +type CounterOpts prometheus.Opts type Counter prometheus.Counter type Gauge prometheus.Gauge +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- + +type MetricGroupsCache struct { + sync.RWMutex //This is for map locking + counters map[string]Counter + gauges map[string]Gauge +} + +func (met *MetricGroupsCache) CIs(metric string) bool { + met.RLock() + defer met.RUnlock() + _, ok := met.counters[metric] + return ok +} + +func (met *MetricGroupsCache) CGet(metric string) Counter { + met.RLock() + defer met.RUnlock() + return met.counters[metric] +} + +func (met *MetricGroupsCache) CInc(metric string) { + met.RLock() + defer met.RUnlock() + met.counters[metric].Inc() +} + +func (met *MetricGroupsCache) CAdd(metric string, val float64) { + met.RLock() + defer met.RUnlock() + met.counters[metric].Add(val) +} + +func (met *MetricGroupsCache) GIs(metric string) bool { + met.RLock() + defer met.RUnlock() + _, ok := met.gauges[metric] + return ok +} + +func (met *MetricGroupsCache) GGet(metric string) Gauge { + met.RLock() + defer met.RUnlock() + return met.gauges[metric] +} + +func (met *MetricGroupsCache) GSet(metric string, val float64) { + met.RLock() + defer met.RUnlock() + met.gauges[metric].Set(val) +} + +func (met *MetricGroupsCache) GInc(metric string) { + met.RLock() + defer met.RUnlock() + met.gauges[metric].Inc() +} + +func (met *MetricGroupsCache) GDec(metric string) { + met.RLock() + defer met.RUnlock() + met.gauges[metric].Dec() +} + +func (met *MetricGroupsCache) CombineCounterGroups(srcs ...map[string]Counter) { + met.Lock() + defer met.Unlock() + for _, src := range srcs { + for k, v := range src { + met.counters[k] = v + } + } +} + +func (met *MetricGroupsCache) CombineGaugeGroups(srcs ...map[string]Gauge) { + met.Lock() + defer met.Unlock() + for _, src := range srcs { + for k, v := range src { + met.gauges[k] = v + } + } +} + +func NewMetricGroupsCache() *MetricGroupsCache { + entry := &MetricGroupsCache{} + entry.counters = make(map[string]Counter) + entry.gauges = make(map[string]Gauge) + return entry +} + +//----------------------------------------------------------------------------- +// All counters/gauges registered via Metrics instances: +// Counter names are build from: namespace, subsystem, metric and possible labels +//----------------------------------------------------------------------------- +var globalLock sync.Mutex +var cache_allcounters map[string]Counter +var cache_allgauges map[string]Gauge + +func init() { + cache_allcounters = make(map[string]Counter) + cache_allgauges = make(map[string]Gauge) +} + +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- +type Metrics struct { + Namespace string +} + func NewMetrics(url, namespace string, r *mux.Router) *Metrics { if url == "" { url = "/ric/v1/metrics" @@ -51,36 +164,194 @@ func NewMetrics(url, namespace string, r *mux.Router) *Metrics { return &Metrics{Namespace: namespace} } -func (m *Metrics) RegisterCounter(opts CounterOpts) Counter { - Logger.Info("Register new counter with opts: %v", opts) +/* + * Helpers + */ +func (m *Metrics) getFullName(opts prometheus.Opts, labels []string) string { + labelname := "" + for _, lbl := range labels { + if len(labelname) == 0 { + labelname += lbl + } else { + labelname += "_" + lbl + } + } + return fmt.Sprintf("%s_%s_%s_%s", opts.Namespace, opts.Subsystem, opts.Name, labelname) +} +/* + * Handling counters + */ +func (m *Metrics) registerCounter(opts CounterOpts) Counter { + Logger.Info("Register new counter with opts: %v", opts) return promauto.NewCounter(prometheus.CounterOpts(opts)) } func (m *Metrics) RegisterCounterGroup(opts []CounterOpts, subsytem string) (c map[string]Counter) { + globalLock.Lock() + defer globalLock.Unlock() c = make(map[string]Counter) for _, opt := range opts { opt.Namespace = m.Namespace opt.Subsystem = subsytem - c[opt.Name] = m.RegisterCounter(opt) + + id := m.getFullName(prometheus.Opts(opt), []string{}) + if _, ok := cache_allcounters[id]; !ok { + cache_allcounters[id] = m.registerCounter(opt) + } + + c[opt.Name] = cache_allcounters[id] } return } -func (m *Metrics) RegisterGauge(opts CounterOpts) Gauge { +/* + * Handling gauges + */ +func (m *Metrics) registerGauge(opts CounterOpts) Gauge { Logger.Info("Register new gauge with opts: %v", opts) - return promauto.NewGauge(prometheus.GaugeOpts(opts)) } func (m *Metrics) RegisterGaugeGroup(opts []CounterOpts, subsytem string) (c map[string]Gauge) { + globalLock.Lock() + defer globalLock.Unlock() c = make(map[string]Gauge) for _, opt := range opts { opt.Namespace = m.Namespace opt.Subsystem = subsytem - c[opt.Name] = m.RegisterGauge(opt) + + id := m.getFullName(prometheus.Opts(opt), []string{}) + if _, ok := cache_allgauges[id]; !ok { + cache_allgauges[id] = m.registerGauge(opt) + } + + c[opt.Name] = cache_allgauges[id] + } + + return +} + +/* + * Handling counter vectors + * + * Example: + + vec := Metric.RegisterCounterVecGroup( + []CounterOpts{ + {Name: "counter1", Help: "counter1"}, + {Name: "counter2", Help: "counter2"}, + }, + []string{"host"}, + "SUBSYSTEM") + + stat:=Metric.GetCounterGroupFromVects([]string{"localhost:8888"}, vec) + +*/ +type CounterVec struct { + Vec *prometheus.CounterVec + Opts CounterOpts +} + +func (m *Metrics) registerCounterVec(opts CounterOpts, labelNames []string) *prometheus.CounterVec { + Logger.Info("Register new counter vector with opts: %v labelNames: %v", opts, labelNames) + return promauto.NewCounterVec(prometheus.CounterOpts(opts), labelNames) +} + +func (m *Metrics) RegisterCounterVecGroup(opts []CounterOpts, labelNames []string, subsytem string) (c map[string]CounterVec) { + c = make(map[string]CounterVec) + for _, opt := range opts { + entry := CounterVec{} + entry.Opts = opt + entry.Opts.Namespace = m.Namespace + entry.Opts.Subsystem = subsytem + entry.Vec = m.registerCounterVec(entry.Opts, labelNames) + c[opt.Name] = entry + } + return +} + +func (m *Metrics) GetCounterGroupFromVectsWithPrefix(prefix string, labels []string, vects ...map[string]CounterVec) (c map[string]Counter) { + globalLock.Lock() + defer globalLock.Unlock() + c = make(map[string]Counter) + for _, vec := range vects { + for name, opt := range vec { + + id := m.getFullName(prometheus.Opts(opt.Opts), labels) + if _, ok := cache_allcounters[id]; !ok { + Logger.Info("Register new counter from vector with opts: %v labels: %v prefix: %s", opt.Opts, labels, prefix) + cache_allcounters[id] = opt.Vec.WithLabelValues(labels...) + } + c[prefix+name] = cache_allcounters[id] + } } + return +} + +func (m *Metrics) GetCounterGroupFromVects(labels []string, vects ...map[string]CounterVec) (c map[string]Counter) { + return m.GetCounterGroupFromVectsWithPrefix("", labels, vects...) +} + +/* + * Handling gauge vectors + * + * Example: + + vec := Metric.RegisterGaugeVecGroup( + []CounterOpts{ + {Name: "gauge1", Help: "gauge1"}, + {Name: "gauge2", Help: "gauge2"}, + }, + []string{"host"}, + "SUBSYSTEM") + + stat:=Metric.GetGaugeGroupFromVects([]string{"localhost:8888"},vec) + +*/ +type GaugeVec struct { + Vec *prometheus.GaugeVec + Opts CounterOpts +} + +func (m *Metrics) registerGaugeVec(opts CounterOpts, labelNames []string) *prometheus.GaugeVec { + Logger.Info("Register new gauge vector with opts: %v labelNames: %v", opts, labelNames) + return promauto.NewGaugeVec(prometheus.GaugeOpts(opts), labelNames) +} + +func (m *Metrics) RegisterGaugeVecGroup(opts []CounterOpts, labelNames []string, subsytem string) (c map[string]GaugeVec) { + c = make(map[string]GaugeVec) + for _, opt := range opts { + entry := GaugeVec{} + entry.Opts = opt + entry.Opts.Namespace = m.Namespace + entry.Opts.Subsystem = subsytem + entry.Vec = m.registerGaugeVec(entry.Opts, labelNames) + c[opt.Name] = entry + + } + return +} + +func (m *Metrics) GetGaugeGroupFromVectsWithPrefix(prefix string, labels []string, vects ...map[string]GaugeVec) (c map[string]Gauge) { + globalLock.Lock() + defer globalLock.Unlock() + c = make(map[string]Gauge) + for _, vec := range vects { + for name, opt := range vec { + id := m.getFullName(prometheus.Opts(opt.Opts), labels) + if _, ok := cache_allgauges[id]; !ok { + Logger.Info("Register new gauge from vector with opts: %v labels: %v prefix: %s", opt.Opts, labels, prefix) + cache_allgauges[id] = opt.Vec.WithLabelValues(labels...) + } + c[prefix+name] = cache_allgauges[id] + } + } return } + +func (m *Metrics) GetGaugeGroupFromVects(labels []string, vects ...map[string]GaugeVec) (c map[string]Gauge) { + return m.GetGaugeGroupFromVectsWithPrefix("", labels, vects...) +}