X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=pkg%2Fxapp%2Fmetrics.go;h=8e13f7c0cef42760a52c6a40288351f0f7afbc4e;hb=refs%2Ftags%2Fv0.9.19;hp=4f673d04987b07f798ff59a21ee8a1a543da48b8;hpb=7117d0d6bd49a3099d1efb36941096a502c9a4bb;p=ric-plt%2Fxapp-frame.git diff --git a/pkg/xapp/metrics.go b/pkg/xapp/metrics.go index 4f673d0..8e13f7c 100644 --- a/pkg/xapp/metrics.go +++ b/pkg/xapp/metrics.go @@ -21,13 +21,29 @@ 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 //----------------------------------------------------------------------------- @@ -47,16 +63,30 @@ type GaugeVec struct { Labels []string } -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 +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- +type MetricGroupsCacheCounterRegisterer interface { + RegisterCounter(CounterOpts) Counter +} + +type MetricGroupsCacheCounterRegistererFunc func(CounterOpts) Counter + +func (fn MetricGroupsCacheCounterRegistererFunc) RegisterCounter(copts CounterOpts) Counter { + return fn(copts) +} + +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- +type MetricGroupsCacheGaugeRegisterer interface { + RegisterGauge(CounterOpts) Gauge +} + +type MetricGroupsCacheGaugeRegistererFunc func(CounterOpts) Gauge + +func (fn MetricGroupsCacheGaugeRegistererFunc) RegisterGauge(copts CounterOpts) Gauge { + return fn(copts) } //----------------------------------------------------------------------------- @@ -67,73 +97,127 @@ type MetricGroupsCache struct { sync.RWMutex //This is for map locking counters map[string]Counter gauges map[string]Gauge + regcnt MetricGroupsCacheCounterRegisterer + reggau MetricGroupsCacheGaugeRegisterer +} + +func (met *MetricGroupsCache) Registerer(regcnt MetricGroupsCacheCounterRegisterer, reggau MetricGroupsCacheGaugeRegisterer) { + met.regcnt = regcnt + met.reggau = reggau +} + +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 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 } func (met *MetricGroupsCache) CIs(metric string) bool { - met.RLock() - defer met.RUnlock() + met.Lock() + defer met.Unlock() _, ok := met.counters[metric] return ok } func (met *MetricGroupsCache) CGet(metric string) Counter { - met.RLock() - defer met.RUnlock() - return met.counters[metric] + met.Lock() + defer met.Unlock() + cntr, ok := met.counters[metric] + if !ok { + cntr = met.cReg(metric) + } + return cntr } func (met *MetricGroupsCache) CInc(metric string) { - met.RLock() - defer met.RUnlock() - met.counters[metric].Inc() + met.Lock() + defer met.Unlock() + cntr, ok := met.counters[metric] + if !ok { + cntr = met.cReg(metric) + } + cntr.Inc() } func (met *MetricGroupsCache) CAdd(metric string, val float64) { - met.RLock() - defer met.RUnlock() - met.counters[metric].Add(val) + met.Lock() + defer met.Unlock() + cntr, ok := met.counters[metric] + if !ok { + cntr = met.cReg(metric) + } + cntr.Add(val) } func (met *MetricGroupsCache) GIs(metric string) bool { - met.RLock() - defer met.RUnlock() + met.Lock() + defer met.Unlock() _, ok := met.gauges[metric] return ok } func (met *MetricGroupsCache) GGet(metric string) Gauge { - met.RLock() - defer met.RUnlock() - return met.gauges[metric] + met.Lock() + defer met.Unlock() + gaug, ok := met.gauges[metric] + if !ok { + gaug = met.gReg(metric) + } + return gaug } func (met *MetricGroupsCache) GSet(metric string, val float64) { - met.RLock() - defer met.RUnlock() - met.gauges[metric].Set(val) + met.Lock() + defer met.Unlock() + gaug, ok := met.gauges[metric] + if !ok { + gaug = met.gReg(metric) + } + gaug.Set(val) } func (met *MetricGroupsCache) GAdd(metric string, val float64) { - met.RLock() - defer met.RUnlock() - met.gauges[metric].Add(val) + met.Lock() + defer met.Unlock() + gaug, ok := met.gauges[metric] + if !ok { + gaug = met.gReg(metric) + } + gaug.Add(val) } func (met *MetricGroupsCache) GInc(metric string) { - met.RLock() - defer met.RUnlock() - met.gauges[metric].Inc() + met.Lock() + defer met.Unlock() + gaug, ok := met.gauges[metric] + if !ok { + gaug = met.gReg(metric) + } + gaug.Inc() } func (met *MetricGroupsCache) GDec(metric string) { - met.RLock() - defer met.RUnlock() - met.gauges[metric].Dec() -} - -func (met *MetricGroupsCache) CombineCounterGroupsWithPrefix(prefix string, srcs ...map[string]Counter) { met.Lock() defer met.Unlock() + gaug, ok := met.gauges[metric] + if !ok { + gaug = met.gReg(metric) + } + gaug.Dec() +} + +func (met *MetricGroupsCache) combineCounterGroupsWithPrefix(prefix string, srcs ...map[string]Counter) { for _, src := range srcs { for k, v := range src { met.counters[prefix+k] = v @@ -141,12 +225,22 @@ func (met *MetricGroupsCache) CombineCounterGroupsWithPrefix(prefix string, srcs } } +func (met *MetricGroupsCache) CombineCounterGroupsWithPrefix(prefix string, srcs ...map[string]Counter) { + met.Lock() + defer met.Unlock() + met.combineCounterGroupsWithPrefix(prefix, srcs...) +} + func (met *MetricGroupsCache) CombineCounterGroups(srcs ...map[string]Counter) { met.Lock() defer met.Unlock() + met.combineCounterGroupsWithPrefix("", srcs...) +} + +func (met *MetricGroupsCache) combineGaugeGroupsWithPrefix(prefix string, srcs ...map[string]Gauge) { for _, src := range srcs { for k, v := range src { - met.counters[k] = v + met.gauges[prefix+k] = v } } } @@ -154,27 +248,28 @@ func (met *MetricGroupsCache) CombineCounterGroups(srcs ...map[string]Counter) { func (met *MetricGroupsCache) CombineGaugeGroupsWithPrefix(prefix string, srcs ...map[string]Gauge) { met.Lock() defer met.Unlock() - for _, src := range srcs { - for k, v := range src { - met.gauges[prefix+k] = v - } - } + met.combineGaugeGroupsWithPrefix(prefix, srcs...) } 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 - } - } + met.combineGaugeGroupsWithPrefix("", srcs...) } 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 +} + +func NewMetricGroupsCacheWithRegisterers(regcnt MetricGroupsCacheCounterRegisterer, reggau MetricGroupsCacheGaugeRegisterer) *MetricGroupsCache { + entry := NewMetricGroupsCache() + entry.regcnt = regcnt + entry.reggau = reggau return entry } @@ -206,10 +301,6 @@ func NewMetrics(url, namespace string, r *mux.Router) *Metrics { if url == "" { url = "/ric/v1/metrics" } - if namespace == "" { - namespace = "ricxapp" - } - Logger.Info("Serving metrics on: url=%s namespace=%s", url, namespace) // Expose 'metrics' endpoint with standard golang metrics used by prometheus @@ -233,22 +324,29 @@ func (m *Metrics) getFullName(opts prometheus.Opts, labels []string) string { return fmt.Sprintf("%s_%s_%s_%s", opts.Namespace, opts.Subsystem, opts.Name, labelname) } -/* - * Handling counters - */ +// +// +// 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.Info("Register new counter with opts: %v", opts) + Logger.Debug("Register new counter with opts: %v", opts) cache_allcounters[id] = promauto.NewCounter(prometheus.CounterOpts(opts)) } return cache_allcounters[id] } +// +// +// func (m *Metrics) RegisterCounterGroup(optsgroup []CounterOpts, subsytem string) map[string]Counter { c := make(map[string]Counter) for _, opts := range optsgroup { @@ -257,200 +355,123 @@ func (m *Metrics) RegisterCounterGroup(optsgroup []CounterOpts, subsytem string) return c } -/* - * Handling gauges - */ -func (m *Metrics) RegisterGauge(opts CounterOpts, subsytem string) Gauge { +// +// +// +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 - id := m.getFullName(prometheus.Opts(opts), []string{}) - if _, ok := cache_allgauges[id]; !ok { - Logger.Info("Register new gauge with opts: %v", opts) - cache_allgauges[id] = promauto.NewGauge(prometheus.GaugeOpts(opts)) - } - return cache_allgauges[id] -} - -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) + 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 c -} - -/* - * Handling counter vectors - * - * Examples: - - //--------- - vec := Metric.RegisterCounterVec( - CounterOpts{Name: "counter0", Help: "counter0"}, - []string{"host"}, - "SUBSYSTEM") - - stat:=Metric.GetCounterFromVect([]string{"localhost:8888"},vec) - stat.Inc() - - //--------- - vec := Metric.RegisterCounterVecGroup( - []CounterOpts{ - {Name: "counter1", Help: "counter1"}, - {Name: "counter2", Help: "counter2"}, - }, - []string{"host"}, - "SUBSYSTEM") - - stats:=Metric.GetCounterGroupFromVects([]string{"localhost:8888"}, vec) - stats["counter1"].Inc() -*/ - -func (m *Metrics) RegisterCounterVec(opts CounterOpts, labelNames []string, subsytem string) CounterVec { - 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.Info("Register new counter vector with opts: %v labelNames: %v", opts, labelNames) + 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[id] = entry + cache_allcountervects[vecid] = entry } - entry := cache_allcountervects[id] + entry := cache_allcountervects[vecid] if strSliceCompare(entry.Labels, labelNames) == false { - Logger.Warn("id:%s cached counter vec labels dont match %v != %v", id, entry.Labels, labelNames) + Logger.Warn("id:%s cached counter vec labels dont match %v != %v", vecid, entry.Labels, labelNames) + return nil } - return entry + 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) RegisterCounterVecGroup(optsgroup []CounterOpts, labelNames []string, subsytem string) map[string]CounterVec { - c := make(map[string]CounterVec) +// +// +// +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.RegisterCounterVec(opts, labelNames, subsytem) + c[opts.Name] = m.RegisterLabeledCounter(opts, labelNames, labelValues, subsytem) } return c } -func (m *Metrics) GetCounterFromVect(labelValues []string, vec CounterVec) (c Counter) { +// +// +// +func (m *Metrics) RegisterGauge(opts CounterOpts, subsytem string) Gauge { globalLock.Lock() defer globalLock.Unlock() - id := m.getFullName(prometheus.Opts(vec.Opts), labelValues) - if _, ok := cache_allcounters[id]; !ok { - Logger.Info("Register new counter from vector with opts: %v labelValues: %v", vec.Opts, labelValues) - cache_allcounters[id] = vec.Vec.WithLabelValues(labelValues...) + 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 } - return cache_allcounters[id] -} - -func (m *Metrics) GetCounterGroupFromVects(labelValues []string, vects ...map[string]CounterVec) map[string]Counter { - c := make(map[string]Counter) - for _, vect := range vects { - for name, vec := range vect { - c[name] = m.GetCounterFromVect(labelValues, vec) - } + if _, ok := cache_allgauges[id]; !ok { + Logger.Debug("Register new gauge with opts: %v", opts) + cache_allgauges[id] = promauto.NewGauge(prometheus.GaugeOpts(opts)) } - return c + return cache_allgauges[id] } -func (m *Metrics) GetCounterGroupFromVectsWithPrefix(prefix string, labelValues []string, vects ...map[string]CounterVec) map[string]Counter { - c := make(map[string]Counter) - for _, vect := range vects { - for name, vec := range vect { - c[prefix+name] = m.GetCounterFromVect(labelValues, vec) - } +// +// +// +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) } return c } -/* - * Handling gauge vectors - * - * Examples: - - //--------- - vec := Metric.RegisterGaugeVec( - CounterOpts{Name: "gauge0", Help: "gauge0"}, - []string{"host"}, - "SUBSYSTEM") - - stat:=Metric.GetGaugeFromVect([]string{"localhost:8888"},vec) - stat.Inc() - - //--------- - vecgrp := Metric.RegisterGaugeVecGroup( - []CounterOpts{ - {Name: "gauge1", Help: "gauge1"}, - {Name: "gauge2", Help: "gauge2"}, - }, - []string{"host"}, - "SUBSYSTEM") - - stats:=Metric.GetGaugeGroupFromVects([]string{"localhost:8888"},vecgrp) - stats["gauge1"].Inc() -*/ - -func (m *Metrics) RegisterGaugeVec(opt CounterOpts, labelNames []string, subsytem string) GaugeVec { +// +// +// +func (m *Metrics) RegisterLabeledGauge(opts CounterOpts, labelNames []string, labelValues []string, subsytem string) Gauge { globalLock.Lock() defer globalLock.Unlock() - opt.Namespace = m.Namespace - opt.Subsystem = subsytem - id := m.getFullName(prometheus.Opts(opt), []string{}) - if _, ok := cache_allgaugevects[id]; !ok { - Logger.Info("Register new gauge vector with opt: %v labelNames: %v", opt, labelNames) + 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 = opt + entry.Opts = opts entry.Labels = labelNames entry.Vec = promauto.NewGaugeVec(prometheus.GaugeOpts(entry.Opts), entry.Labels) - cache_allgaugevects[id] = entry + cache_allgaugevects[vecid] = entry } - entry := cache_allgaugevects[id] + entry := cache_allgaugevects[vecid] if strSliceCompare(entry.Labels, labelNames) == false { - Logger.Warn("id:%s cached gauge vec labels dont match %v != %v", id, entry.Labels, labelNames) + Logger.Warn("id:%s cached gauge vec labels dont match %v != %v", vecid, entry.Labels, labelNames) + return nil } - return entry -} - -func (m *Metrics) RegisterGaugeVecGroup(opts []CounterOpts, labelNames []string, subsytem string) map[string]GaugeVec { - c := make(map[string]GaugeVec) - for _, opt := range opts { - c[opt.Name] = m.RegisterGaugeVec(opt, labelNames, subsytem) + 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 c + return cache_allgauges[valid] } -func (m *Metrics) GetGaugeFromVect(labelValues []string, vec GaugeVec) Gauge { - globalLock.Lock() - defer globalLock.Unlock() - id := m.getFullName(prometheus.Opts(vec.Opts), labelValues) - if _, ok := cache_allgauges[id]; !ok { - Logger.Info("Register new gauge from vector with opts: %v labelValues: %v", vec.Opts, labelValues) - cache_allgauges[id] = vec.Vec.WithLabelValues(labelValues...) - } - return cache_allgauges[id] -} - -func (m *Metrics) GetGaugeGroupFromVects(labelValues []string, vects ...map[string]GaugeVec) map[string]Gauge { - c := make(map[string]Gauge) - for _, vect := range vects { - for name, vec := range vect { - c[name] = m.GetGaugeFromVect(labelValues, vec) - } - } - return c -} - -func (m *Metrics) GetGaugeGroupFromVectsWithPrefix(prefix string, labelValues []string, vects ...map[string]GaugeVec) map[string]Gauge { +// +// +// +func (m *Metrics) RegisterLabeledGaugeGroup(optsgroup []CounterOpts, labelNames []string, labelValues []string, subsytem string) map[string]Gauge { c := make(map[string]Gauge) - for _, vect := range vects { - for name, vec := range vect { - c[prefix+name] = m.GetGaugeFromVect(labelValues, vec) - } + for _, opts := range optsgroup { + c[opts.Name] = m.RegisterLabeledGauge(opts, labelNames, labelValues, subsytem) } return c }