X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=pkg%2Fxapp%2Fmetrics.go;h=f85c4887c45e14ade25c082e0c6adf78b345d889;hb=refs%2Fchanges%2F47%2F4947%2F1;hp=d2d801c01109a410485d8cab392b84f01618fcf3;hpb=f619d03fbe1a5f4711f56bc973139a2094044066;p=ric-plt%2Fxapp-frame.git

diff --git a/pkg/xapp/metrics.go b/pkg/xapp/metrics.go
index d2d801c..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.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,6 +164,21 @@ func NewMetrics(url, namespace string, r *mux.Router) *Metrics {
 	return &Metrics{Namespace: namespace}
 }
 
+/*
+ * 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
  */
@@ -60,11 +188,19 @@ func (m *Metrics) registerCounter(opts CounterOpts) Counter {
 }
 
 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
@@ -79,11 +215,19 @@ func (m *Metrics) registerGauge(opts CounterOpts) Gauge {
 }
 
 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
@@ -112,7 +256,6 @@ type CounterVec struct {
 
 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)
 }
 
@@ -129,17 +272,28 @@ func (m *Metrics) RegisterCounterVecGroup(opts []CounterOpts, labelNames []strin
 	return
 }
 
-func (m *Metrics) GetCounterGroupFromVects(labels []string, vects ...map[string]CounterVec) (c map[string]Counter) {
+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 {
-			c[name] = opt.Vec.WithLabelValues(labels...)
-			Logger.Info("Register new counter for vector with opts: %v labels: %v", opt.Opts, labels)
+
+			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
  *
@@ -163,7 +317,6 @@ type GaugeVec struct {
 
 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)
 }
 
@@ -181,36 +334,24 @@ func (m *Metrics) RegisterGaugeVecGroup(opts []CounterOpts, labelNames []string,
 	return
 }
 
-func (m *Metrics) GetGaugeGroupFromVects(labels []string, vects ...map[string]GaugeVec) (c map[string]Gauge) {
+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 {
-			c[name] = opt.Vec.WithLabelValues(labels...)
-			Logger.Info("Register new gauge for vector with opts: %v labels: %v", opt.Opts, labels)
-		}
-	}
-	return
-}
 
-/*
- *
- */
-func (m *Metrics) CombineCounterGroups(srcs ...map[string]Counter) map[string]Counter {
-	trg := make(map[string]Counter)
-	for _, src := range srcs {
-		for k, v := range src {
-			trg[k] = v
+			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 trg
+	return
 }
 
-func (m *Metrics) CombineGaugeGroups(srcs ...map[string]Gauge) map[string]Gauge {
-	trg := make(map[string]Gauge)
-	for _, src := range srcs {
-		for k, v := range src {
-			trg[k] = v
-		}
-	}
-	return trg
+func (m *Metrics) GetGaugeGroupFromVects(labels []string, vects ...map[string]GaugeVec) (c map[string]Gauge) {
+	return m.GetGaugeGroupFromVectsWithPrefix("", labels, vects...)
 }