X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=pkg%2Fxapp%2Fmetrics.go;h=8e13f7c0cef42760a52c6a40288351f0f7afbc4e;hb=79f0680fd7bbf1c8a8c6e2a842cb18020e387a47;hp=73a9b62179f887cde2c1c1ec05daf07b81a2b066;hpb=64924383d9229860a167370a785dd6de0a38786b;p=ric-plt%2Fxapp-frame.git diff --git a/pkg/xapp/metrics.go b/pkg/xapp/metrics.go index 73a9b62..8e13f7c 100644 --- a/pkg/xapp/metrics.go +++ b/pkg/xapp/metrics.go @@ -20,13 +20,30 @@ 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 //----------------------------------------------------------------------------- @@ -34,256 +51,427 @@ type CounterOpts prometheus.Opts 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 }