package xapp
import (
+ "fmt"
+ "sync"
+
"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"
)
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+func strSliceCompare(a, b []string) bool {
+ if len(a) != len(b) {
+ return false
+ }
+ for i, v := range a {
+ if v != b[i] {
+ return false
+ }
+ }
+ return true
+}
+
//-----------------------------------------------------------------------------
// Alias
//-----------------------------------------------------------------------------
type Counter prometheus.Counter
type Gauge prometheus.Gauge
-//-----------------------------------------------------------------------------
-//
-//-----------------------------------------------------------------------------
-
-type MetricGroupsCache struct {
- Counters map[string]Counter
- Gauges map[string]Gauge
+type CounterVec struct {
+ Vec *prometheus.CounterVec
+ Opts CounterOpts
+ Labels []string
}
-func (met *MetricGroupsCache) CInc(metric string) {
- met.Counters[metric].Inc()
+type GaugeVec struct {
+ Vec *prometheus.GaugeVec
+ Opts CounterOpts
+ Labels []string
}
-func (met *MetricGroupsCache) CAdd(metric string, val float64) {
- met.Counters[metric].Add(val)
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+type MetricGroupsCacheCounterRegisterer interface {
+ RegisterCounter(CounterOpts) Counter
}
-func (met *MetricGroupsCache) GSet(metric string, val float64) {
- met.Gauges[metric].Set(val)
+type MetricGroupsCacheCounterRegistererFunc func(CounterOpts) Counter
+
+func (fn MetricGroupsCacheCounterRegistererFunc) RegisterCounter(copts CounterOpts) Counter {
+ return fn(copts)
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
-type Metrics struct {
- lock sync.Mutex
- Namespace string
- MetricGroupsCacheMap map[string]*MetricGroupsCache
+type MetricGroupsCacheGaugeRegisterer interface {
+ RegisterGauge(CounterOpts) Gauge
}
-func NewMetrics(url, namespace string, r *mux.Router) *Metrics {
- if url == "" {
- url = "/ric/v1/metrics"
- }
- if namespace == "" {
- namespace = "ricxapp"
- }
+type MetricGroupsCacheGaugeRegistererFunc func(CounterOpts) Gauge
- Logger.Info("Serving metrics on: url=%s namespace=%s", url, namespace)
+func (fn MetricGroupsCacheGaugeRegistererFunc) RegisterGauge(copts CounterOpts) Gauge {
+ return fn(copts)
+}
- // Expose 'metrics' endpoint with standard golang metrics used by prometheus
- r.Handle(url, promhttp.Handler())
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
- return &Metrics{Namespace: namespace, MetricGroupsCacheMap: make(map[string]*MetricGroupsCache)}
+type MetricGroupsCache struct {
+ sync.RWMutex //This is for map locking
+ counters map[string]Counter
+ gauges map[string]Gauge
+ regcnt MetricGroupsCacheCounterRegisterer
+ reggau MetricGroupsCacheGaugeRegisterer
}
-/*
- * 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 (met *MetricGroupsCache) Registerer(regcnt MetricGroupsCacheCounterRegisterer, reggau MetricGroupsCacheGaugeRegisterer) {
+ met.regcnt = regcnt
+ met.reggau = reggau
}
-func (m *Metrics) RegisterCounterGroup(opts []CounterOpts, subsytem string) (c map[string]Counter) {
- c = make(map[string]Counter)
- for _, opt := range opts {
- opt.Namespace = m.Namespace
- opt.Subsystem = subsytem
- c[opt.Name] = m.registerCounter(opt)
+func (met *MetricGroupsCache) cReg(metric string) Counter {
+ if met.regcnt != nil {
+ cntr := met.regcnt.RegisterCounter(CounterOpts{Name: metric, Help: "Amount of " + metric + "(auto)"})
+ met.counters[metric] = cntr
+ return cntr
}
-
- return
+ return nil
+}
+func (met *MetricGroupsCache) gReg(metric string) Gauge {
+ if met.reggau != nil {
+ gaug := met.reggau.RegisterGauge(CounterOpts{Name: metric, Help: "Amount of " + metric + "(auto)"})
+ met.gauges[metric] = gaug
+ return gaug
+ }
+ return nil
}
-/*
- * 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 (met *MetricGroupsCache) CIs(metric string) bool {
+ met.Lock()
+ defer met.Unlock()
+ _, ok := met.counters[metric]
+ return ok
}
-func (m *Metrics) RegisterGaugeGroup(opts []CounterOpts, subsytem string) (c map[string]Gauge) {
- c = make(map[string]Gauge)
- for _, opt := range opts {
- opt.Namespace = m.Namespace
- opt.Subsystem = subsytem
- c[opt.Name] = m.registerGauge(opt)
+func (met *MetricGroupsCache) CGet(metric string) Counter {
+ met.Lock()
+ defer met.Unlock()
+ cntr, ok := met.counters[metric]
+ if !ok {
+ cntr = met.cReg(metric)
}
+ return cntr
+}
- return
+func (met *MetricGroupsCache) CInc(metric string) {
+ met.Lock()
+ defer met.Unlock()
+ cntr, ok := met.counters[metric]
+ if !ok {
+ cntr = met.cReg(metric)
+ }
+ cntr.Inc()
}
-/*
- * Handling counter vectors
- *
- * Example:
+func (met *MetricGroupsCache) CAdd(metric string, val float64) {
+ met.Lock()
+ defer met.Unlock()
+ cntr, ok := met.counters[metric]
+ if !ok {
+ cntr = met.cReg(metric)
+ }
+ cntr.Add(val)
+}
- vec := Metric.RegisterCounterVecGroup(
- []CounterOpts{
- {Name: "counter1", Help: "counter1"},
- {Name: "counter2", Help: "counter2"},
- },
- []string{"host"},
- "SUBSYSTEM")
+func (met *MetricGroupsCache) GIs(metric string) bool {
+ met.Lock()
+ defer met.Unlock()
+ _, ok := met.gauges[metric]
+ return ok
+}
- stat:=Metric.GetCounterGroupFromVects([]string{"localhost:8888"}, vec)
+func (met *MetricGroupsCache) GGet(metric string) Gauge {
+ met.Lock()
+ defer met.Unlock()
+ gaug, ok := met.gauges[metric]
+ if !ok {
+ gaug = met.gReg(metric)
+ }
+ return gaug
+}
-*/
-type CounterVec struct {
- Vec *prometheus.CounterVec
- Opts CounterOpts
+func (met *MetricGroupsCache) GSet(metric string, val float64) {
+ met.Lock()
+ defer met.Unlock()
+ gaug, ok := met.gauges[metric]
+ if !ok {
+ gaug = met.gReg(metric)
+ }
+ gaug.Set(val)
}
-func (m *Metrics) registerCounterVec(opts CounterOpts, labelNames []string) *prometheus.CounterVec {
- Logger.Info("Register new counter vector with opts: %v labelNames: %v", opts, labelNames)
+func (met *MetricGroupsCache) GAdd(metric string, val float64) {
+ met.Lock()
+ defer met.Unlock()
+ gaug, ok := met.gauges[metric]
+ if !ok {
+ gaug = met.gReg(metric)
+ }
+ gaug.Add(val)
+}
- return promauto.NewCounterVec(prometheus.CounterOpts(opts), labelNames)
+func (met *MetricGroupsCache) GInc(metric string) {
+ met.Lock()
+ defer met.Unlock()
+ gaug, ok := met.gauges[metric]
+ if !ok {
+ gaug = met.gReg(metric)
+ }
+ gaug.Inc()
}
-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
+func (met *MetricGroupsCache) GDec(metric string) {
+ met.Lock()
+ defer met.Unlock()
+ gaug, ok := met.gauges[metric]
+ if !ok {
+ gaug = met.gReg(metric)
}
- return
+ gaug.Dec()
}
-func (m *Metrics) GetCounterGroupFromVectsWithPrefix(prefix string, labels []string, vects ...map[string]CounterVec) (c map[string]Counter) {
- c = make(map[string]Counter)
- for _, vec := range vects {
- for name, opt := range vec {
- c[prefix+name] = opt.Vec.WithLabelValues(labels...)
- Logger.Info("Register new counter for vector with opts: %v labels: %v", opt.Opts, labels)
+func (met *MetricGroupsCache) combineCounterGroupsWithPrefix(prefix string, srcs ...map[string]Counter) {
+ for _, src := range srcs {
+ for k, v := range src {
+ met.counters[prefix+k] = v
}
}
- return
}
-func (m *Metrics) GetCounterGroupFromVects(labels []string, vects ...map[string]CounterVec) (c map[string]Counter) {
- return m.GetCounterGroupFromVectsWithPrefix("", labels, vects...)
+func (met *MetricGroupsCache) CombineCounterGroupsWithPrefix(prefix string, srcs ...map[string]Counter) {
+ met.Lock()
+ defer met.Unlock()
+ met.combineCounterGroupsWithPrefix(prefix, srcs...)
}
-/*
- * Handling gauge vectors
- *
- * Example:
+func (met *MetricGroupsCache) CombineCounterGroups(srcs ...map[string]Counter) {
+ met.Lock()
+ defer met.Unlock()
+ met.combineCounterGroupsWithPrefix("", srcs...)
+}
- vec := Metric.RegisterGaugeVecGroup(
- []CounterOpts{
- {Name: "gauge1", Help: "gauge1"},
- {Name: "gauge2", Help: "gauge2"},
- },
- []string{"host"},
- "SUBSYSTEM")
+func (met *MetricGroupsCache) combineGaugeGroupsWithPrefix(prefix string, srcs ...map[string]Gauge) {
+ for _, src := range srcs {
+ for k, v := range src {
+ met.gauges[prefix+k] = v
+ }
+ }
+}
- stat:=Metric.GetGaugeGroupFromVects([]string{"localhost:8888"},vec)
+func (met *MetricGroupsCache) CombineGaugeGroupsWithPrefix(prefix string, srcs ...map[string]Gauge) {
+ met.Lock()
+ defer met.Unlock()
+ met.combineGaugeGroupsWithPrefix(prefix, srcs...)
+}
-*/
-type GaugeVec struct {
- Vec *prometheus.GaugeVec
- Opts CounterOpts
+func (met *MetricGroupsCache) CombineGaugeGroups(srcs ...map[string]Gauge) {
+ met.Lock()
+ defer met.Unlock()
+ met.combineGaugeGroupsWithPrefix("", srcs...)
}
-func (m *Metrics) registerGaugeVec(opts CounterOpts, labelNames []string) *prometheus.GaugeVec {
- Logger.Info("Register new gauge vector with opts: %v labelNames: %v", opts, labelNames)
+func NewMetricGroupsCache() *MetricGroupsCache {
+ entry := &MetricGroupsCache{}
+ entry.counters = make(map[string]Counter)
+ entry.gauges = make(map[string]Gauge)
+ entry.regcnt = nil
+ entry.reggau = nil
+ return entry
+}
- return promauto.NewGaugeVec(prometheus.GaugeOpts(opts), labelNames)
+func NewMetricGroupsCacheWithRegisterers(regcnt MetricGroupsCacheCounterRegisterer, reggau MetricGroupsCacheGaugeRegisterer) *MetricGroupsCache {
+ entry := NewMetricGroupsCache()
+ entry.regcnt = regcnt
+ entry.reggau = reggau
+ return entry
}
-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
+//-----------------------------------------------------------------------------
+// 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
+var cache_allcountervects map[string]CounterVec
+var cache_allgaugevects map[string]GaugeVec
+
+func init() {
+ cache_allcounters = make(map[string]Counter)
+ cache_allgauges = make(map[string]Gauge)
+ cache_allcountervects = make(map[string]CounterVec)
+ cache_allgaugevects = make(map[string]GaugeVec)
+}
- }
- return
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+type Metrics struct {
+ Namespace string
}
-func (m *Metrics) GetGaugeGroupFromVectsWithPrefix(prefix string, labels []string, vects ...map[string]GaugeVec) (c map[string]Gauge) {
- c = make(map[string]Gauge)
- for _, vec := range vects {
- for name, opt := range vec {
- c[prefix+name] = opt.Vec.WithLabelValues(labels...)
- Logger.Info("Register new gauge for vector with opts: %v labels: %v", opt.Opts, labels)
- }
+func NewMetrics(url, namespace string, r *mux.Router) *Metrics {
+ if url == "" {
+ url = "/ric/v1/metrics"
}
- return
-}
+ Logger.Info("Serving metrics on: url=%s namespace=%s", url, namespace)
-func (m *Metrics) GetGaugeGroupFromVects(labels []string, vects ...map[string]GaugeVec) (c map[string]Gauge) {
- return m.GetGaugeGroupFromVectsWithPrefix("", labels, vects...)
+ // Expose 'metrics' endpoint with standard golang metrics used by prometheus
+ r.Handle(url, promhttp.Handler())
+ return &Metrics{Namespace: namespace}
}
/*
- *
+ * Helpers
*/
-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
+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 trg
+ return fmt.Sprintf("%s_%s_%s_%s", opts.Namespace, opts.Subsystem, opts.Name, labelname)
}
-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
- }
+//
+//
+//
+func (m *Metrics) RegisterCounter(opts CounterOpts, subsytem string) Counter {
+ globalLock.Lock()
+ defer globalLock.Unlock()
+ opts.Namespace = m.Namespace
+ opts.Subsystem = subsytem
+ id := m.getFullName(prometheus.Opts(opts), []string{})
+ if _, ok := cache_allcountervects[id]; ok {
+ Logger.Warn("Register new counter with opts: %v, name conflicts existing counter vector", opts)
+ return nil
+ }
+ if _, ok := cache_allcounters[id]; !ok {
+ Logger.Debug("Register new counter with opts: %v", opts)
+ cache_allcounters[id] = promauto.NewCounter(prometheus.CounterOpts(opts))
}
- return trg
+ return cache_allcounters[id]
}
-/*
- *
- */
-func (m *Metrics) GroupCacheGet(id string) *MetricGroupsCache {
- m.lock.Lock()
- defer m.lock.Unlock()
- entry, ok := m.MetricGroupsCacheMap[id]
- if ok == false {
+//
+//
+//
+func (m *Metrics) RegisterCounterGroup(optsgroup []CounterOpts, subsytem string) map[string]Counter {
+ c := make(map[string]Counter)
+ for _, opts := range optsgroup {
+ c[opts.Name] = m.RegisterCounter(opts, subsytem)
+ }
+ return c
+}
+
+//
+//
+//
+func (m *Metrics) RegisterLabeledCounter(opts CounterOpts, labelNames []string, labelValues []string, subsytem string) Counter {
+ globalLock.Lock()
+ defer globalLock.Unlock()
+ opts.Namespace = m.Namespace
+ opts.Subsystem = subsytem
+ vecid := m.getFullName(prometheus.Opts(opts), []string{})
+ if _, ok := cache_allcounters[vecid]; ok {
+ Logger.Warn("Register new counter vector with opts: %v labelNames: %v, name conflicts existing counter", opts, labelNames)
return nil
}
- return entry
+ if _, ok := cache_allcountervects[vecid]; !ok {
+ Logger.Debug("Register new counter vector with opts: %v labelNames: %v", opts, labelNames)
+ entry := CounterVec{}
+ entry.Opts = opts
+ entry.Labels = labelNames
+ entry.Vec = promauto.NewCounterVec(prometheus.CounterOpts(entry.Opts), entry.Labels)
+ cache_allcountervects[vecid] = entry
+ }
+ entry := cache_allcountervects[vecid]
+ if strSliceCompare(entry.Labels, labelNames) == false {
+ Logger.Warn("id:%s cached counter vec labels dont match %v != %v", vecid, entry.Labels, labelNames)
+ return nil
+ }
+ valid := m.getFullName(prometheus.Opts(entry.Opts), labelValues)
+ if _, ok := cache_allcounters[valid]; !ok {
+ Logger.Debug("Register new counter from vector with opts: %v labelValues: %v", entry.Opts, labelValues)
+ cache_allcounters[valid] = entry.Vec.WithLabelValues(labelValues...)
+ }
+ return cache_allcounters[valid]
+}
+
+//
+//
+//
+func (m *Metrics) RegisterLabeledCounterGroup(optsgroup []CounterOpts, labelNames []string, labelValues []string, subsytem string) map[string]Counter {
+ c := make(map[string]Counter)
+ for _, opts := range optsgroup {
+ c[opts.Name] = m.RegisterLabeledCounter(opts, labelNames, labelValues, subsytem)
+ }
+ return c
+}
+
+//
+//
+//
+func (m *Metrics) RegisterGauge(opts CounterOpts, subsytem string) Gauge {
+ globalLock.Lock()
+ defer globalLock.Unlock()
+ opts.Namespace = m.Namespace
+ opts.Subsystem = subsytem
+ id := m.getFullName(prometheus.Opts(opts), []string{})
+ if _, ok := cache_allgaugevects[id]; ok {
+ Logger.Warn("Register new gauge with opts: %v, name conflicts existing gauge vector", opts)
+ return nil
+ }
+ if _, ok := cache_allgauges[id]; !ok {
+ Logger.Debug("Register new gauge with opts: %v", opts)
+ cache_allgauges[id] = promauto.NewGauge(prometheus.GaugeOpts(opts))
+ }
+ return cache_allgauges[id]
}
-func (m *Metrics) GroupCacheAddCounters(id string, vals map[string]Counter) {
- m.lock.Lock()
- defer m.lock.Unlock()
- entry, ok := m.MetricGroupsCacheMap[id]
- if ok == false {
- entry = &MetricGroupsCache{}
- m.MetricGroupsCacheMap[id] = entry
+//
+//
+//
+func (m *Metrics) RegisterGaugeGroup(optsgroup []CounterOpts, subsytem string) map[string]Gauge {
+ c := make(map[string]Gauge)
+ for _, opts := range optsgroup {
+ c[opts.Name] = m.RegisterGauge(opts, subsytem)
}
- m.MetricGroupsCacheMap[id].Counters = m.CombineCounterGroups(m.MetricGroupsCacheMap[id].Counters, vals)
+ return c
}
-func (m *Metrics) GroupCacheAddGauges(id string, vals map[string]Gauge) {
- m.lock.Lock()
- defer m.lock.Unlock()
- entry, ok := m.MetricGroupsCacheMap[id]
- if ok == false {
- entry = &MetricGroupsCache{}
- m.MetricGroupsCacheMap[id] = entry
+//
+//
+//
+func (m *Metrics) RegisterLabeledGauge(opts CounterOpts, labelNames []string, labelValues []string, subsytem string) Gauge {
+ globalLock.Lock()
+ defer globalLock.Unlock()
+ opts.Namespace = m.Namespace
+ opts.Subsystem = subsytem
+ vecid := m.getFullName(prometheus.Opts(opts), []string{})
+ if _, ok := cache_allgauges[vecid]; ok {
+ Logger.Warn("Register new gauge vector with opts: %v labelNames: %v, name conflicts existing counter", opts, labelNames)
+ return nil
+ }
+ if _, ok := cache_allgaugevects[vecid]; !ok {
+ Logger.Debug("Register new gauge vector with opts: %v labelNames: %v", opts, labelNames)
+ entry := GaugeVec{}
+ entry.Opts = opts
+ entry.Labels = labelNames
+ entry.Vec = promauto.NewGaugeVec(prometheus.GaugeOpts(entry.Opts), entry.Labels)
+ cache_allgaugevects[vecid] = entry
+ }
+ entry := cache_allgaugevects[vecid]
+ if strSliceCompare(entry.Labels, labelNames) == false {
+ Logger.Warn("id:%s cached gauge vec labels dont match %v != %v", vecid, entry.Labels, labelNames)
+ return nil
+ }
+ valid := m.getFullName(prometheus.Opts(entry.Opts), labelValues)
+ if _, ok := cache_allgauges[valid]; !ok {
+ Logger.Debug("Register new gauge from vector with opts: %v labelValues: %v", entry.Opts, labelValues)
+ cache_allgauges[valid] = entry.Vec.WithLabelValues(labelValues...)
+ }
+ return cache_allgauges[valid]
+}
+
+//
+//
+//
+func (m *Metrics) RegisterLabeledGaugeGroup(optsgroup []CounterOpts, labelNames []string, labelValues []string, subsytem string) map[string]Gauge {
+ c := make(map[string]Gauge)
+ for _, opts := range optsgroup {
+ c[opts.Name] = m.RegisterLabeledGauge(opts, labelNames, labelValues, subsytem)
}
- m.MetricGroupsCacheMap[id].Gauges = m.CombineGaugeGroups(m.MetricGroupsCacheMap[id].Gauges, vals)
+ return c
}
Code Review / ric-plt / xapp-frame.git / blobdiff