X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=pkg%2Fxapp%2Fmetrics.go;h=a90aaedd70e15c2f7b75a6bae983ae837e679c97;hb=2a05b784df856f77c8c4c0a64ddc4200f14adf13;hp=96f407ca5c9a2442f55380360f86deea02dbffd9;hpb=5bfa60ab8a5e5c7a351d0e6fadd34e55c2957944;p=ric-plt%2Fxapp-frame.git diff --git a/pkg/xapp/metrics.go b/pkg/xapp/metrics.go index 96f407c..a90aaed 100644 --- a/pkg/xapp/metrics.go +++ b/pkg/xapp/metrics.go @@ -35,6 +35,30 @@ type CounterOpts prometheus.Opts type Counter prometheus.Counter type Gauge prometheus.Gauge +type CounterVec struct { + Vec *prometheus.CounterVec + Opts CounterOpts + Labels []string +} + +type GaugeVec struct { + Vec *prometheus.GaugeVec + Opts CounterOpts + 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 +} + //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- @@ -52,6 +76,12 @@ func (met *MetricGroupsCache) CIs(metric string) bool { 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() @@ -71,12 +101,24 @@ func (met *MetricGroupsCache) GIs(metric string) bool { 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) GAdd(metric string, val float64) { + met.RLock() + defer met.RUnlock() + met.gauges[metric].Add(val) +} + func (met *MetricGroupsCache) GInc(metric string) { met.RLock() defer met.RUnlock() @@ -89,6 +131,16 @@ func (met *MetricGroupsCache) GDec(metric string) { met.gauges[metric].Dec() } +func (met *MetricGroupsCache) CombineCounterGroupsWithPrefix(prefix string, srcs ...map[string]Counter) { + met.Lock() + defer met.Unlock() + for _, src := range srcs { + for k, v := range src { + met.counters[prefix+k] = v + } + } +} + func (met *MetricGroupsCache) CombineCounterGroups(srcs ...map[string]Counter) { met.Lock() defer met.Unlock() @@ -99,6 +151,16 @@ 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 + } + } +} + func (met *MetricGroupsCache) CombineGaugeGroups(srcs ...map[string]Gauge) { met.Lock() defer met.Unlock() @@ -123,10 +185,14 @@ func NewMetricGroupsCache() *MetricGroupsCache { 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) } //----------------------------------------------------------------------------- @@ -167,65 +233,158 @@ 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) Counter { - Logger.Info("Register new counter with opts: %v", opts) - return promauto.NewCounter(prometheus.CounterOpts(opts)) +// +// +// +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_allcounters[id]; !ok { + Logger.Info("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 { + c[opts.Name] = m.RegisterCounter(opts, subsytem) + } + return c } -func (m *Metrics) RegisterCounterGroup(opts []CounterOpts, subsytem string) (c map[string]Counter) { +// +// +// +func (m *Metrics) RegisterLabeledCounter(opts CounterOpts, labelNames []string, labelValues []string, subsytem string) Counter { globalLock.Lock() defer globalLock.Unlock() - c = make(map[string]Counter) - for _, opt := range opts { - opt.Namespace = m.Namespace - opt.Subsystem = subsytem - - id := m.getFullName(prometheus.Opts(opt), []string{}) - if _, ok := cache_allcounters[id]; !ok { - cache_allcounters[id] = m.registerCounter(opt) - } + opts.Namespace = m.Namespace + opts.Subsystem = subsytem + vecid := m.getFullName(prometheus.Opts(opts), []string{}) + if _, ok := cache_allcountervects[vecid]; !ok { + Logger.Info("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) + } - c[opt.Name] = cache_allcounters[id] + valid := m.getFullName(prometheus.Opts(entry.Opts), labelValues) + if _, ok := cache_allcounters[valid]; !ok { + Logger.Info("Register new counter from vector with opts: %v labelValues: %v", entry.Opts, labelValues) + cache_allcounters[valid] = entry.Vec.WithLabelValues(labelValues...) } + return cache_allcounters[valid] - return } -/* - * 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) 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) RegisterGaugeGroup(opts []CounterOpts, subsytem string) (c map[string]Gauge) { +// +// +// +func (m *Metrics) RegisterGauge(opts CounterOpts, subsytem string) Gauge { globalLock.Lock() defer globalLock.Unlock() - c = make(map[string]Gauge) - for _, opt := range opts { - opt.Namespace = m.Namespace - opt.Subsystem = subsytem + 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] +} - id := m.getFullName(prometheus.Opts(opt), []string{}) - if _, ok := cache_allgauges[id]; !ok { - cache_allgauges[id] = m.registerGauge(opt) - } +// +// +// +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 +} - c[opt.Name] = cache_allgauges[id] +// +// +// +func (m *Metrics) RegisterLabeledGauge(opt CounterOpts, labelNames []string, labelValues []string, subsytem string) Gauge { + globalLock.Lock() + defer globalLock.Unlock() + opt.Namespace = m.Namespace + opt.Subsystem = subsytem + vecid := m.getFullName(prometheus.Opts(opt), []string{}) + if _, ok := cache_allgaugevects[vecid]; !ok { + Logger.Info("Register new gauge vector with opt: %v labelNames: %v", opt, labelNames) + entry := GaugeVec{} + entry.Opts = opt + 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) } + valid := m.getFullName(prometheus.Opts(entry.Opts), labelValues) + if _, ok := cache_allgauges[valid]; !ok { + Logger.Info("Register new gauge from vector with opts: %v labelValues: %v", entry.Opts, labelValues) + cache_allgauges[valid] = entry.Vec.WithLabelValues(labelValues...) + } + return cache_allgauges[valid] - return +} + +// +// +// +func (m *Metrics) RegisterLabeledGaugeGroup(opts []CounterOpts, labelNames []string, labelValues []string, subsytem string) map[string]Gauge { + c := make(map[string]Gauge) + for _, opt := range opts { + c[opt.Name] = m.RegisterLabeledGauge(opt, labelNames, labelValues, subsytem) + } + return c } /* * Handling counter vectors * - * Example: + * 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"}, @@ -234,60 +393,91 @@ func (m *Metrics) RegisterGaugeGroup(opts []CounterOpts, subsytem string) (c map []string{"host"}, "SUBSYSTEM") - stat:=Metric.GetCounterGroupFromVects([]string{"localhost:8888"}, vec) - + stats:=Metric.GetCounterGroupFromVects([]string{"localhost:8888"}, vec) + stats["counter1"].Inc() */ -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) +// Deprecated: Use RegisterLabeledCounter +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) + entry := CounterVec{} + entry.Opts = opts + entry.Labels = labelNames + entry.Vec = promauto.NewCounterVec(prometheus.CounterOpts(entry.Opts), entry.Labels) + cache_allcountervects[id] = entry + } + entry := cache_allcountervects[id] + if strSliceCompare(entry.Labels, labelNames) == false { + Logger.Warn("id:%s cached counter vec labels dont match %v != %v", id, entry.Labels, labelNames) + } + return entry } -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 +// Deprecated: Use RegisterLabeledCounterGroup +func (m *Metrics) RegisterCounterVecGroup(optsgroup []CounterOpts, labelNames []string, subsytem string) map[string]CounterVec { + c := make(map[string]CounterVec) + for _, opts := range optsgroup { + c[opts.Name] = m.RegisterCounterVec(opts, labelNames, subsytem) } - return + return c } -func (m *Metrics) GetCounterGroupFromVectsWithPrefix(prefix string, labels []string, vects ...map[string]CounterVec) (c map[string]Counter) { +// Deprecated: Use RegisterLabeledCounter +func (m *Metrics) GetCounterFromVect(labelValues []string, vec CounterVec) (c 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] + 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...) + } + return cache_allcounters[id] +} + +// Deprecated: Use RegisterLabeledCounterGroup +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) } } - return + return c } -func (m *Metrics) GetCounterGroupFromVects(labels []string, vects ...map[string]CounterVec) (c map[string]Counter) { - return m.GetCounterGroupFromVectsWithPrefix("", labels, vects...) +// Deprecated: Use RegisterLabeledCounterGroup +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) + } + } + return c } /* * Handling gauge vectors * - * Example: + * Examples: + + //--------- + vec := Metric.RegisterGaugeVec( + CounterOpts{Name: "gauge0", Help: "gauge0"}, + []string{"host"}, + "SUBSYSTEM") - vec := Metric.RegisterGaugeVecGroup( + stat:=Metric.GetGaugeFromVect([]string{"localhost:8888"},vec) + stat.Inc() + + //--------- + vecgrp := Metric.RegisterGaugeVecGroup( []CounterOpts{ {Name: "gauge1", Help: "gauge1"}, {Name: "gauge2", Help: "gauge2"}, @@ -295,51 +485,71 @@ func (m *Metrics) GetCounterGroupFromVects(labels []string, vects ...map[string] []string{"host"}, "SUBSYSTEM") - stat:=Metric.GetGaugeGroupFromVects([]string{"localhost:8888"},vec) - + stats:=Metric.GetGaugeGroupFromVects([]string{"localhost:8888"},vecgrp) + stats["gauge1"].Inc() */ -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 { +// Deprecated: Use RegisterLabeledGauge +func (m *Metrics) RegisterGaugeVec(opt CounterOpts, labelNames []string, subsytem string) GaugeVec { + 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) 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 + entry.Labels = labelNames + entry.Vec = promauto.NewGaugeVec(prometheus.GaugeOpts(entry.Opts), entry.Labels) + cache_allgaugevects[id] = entry + } + entry := cache_allgaugevects[id] + if strSliceCompare(entry.Labels, labelNames) == false { + Logger.Warn("id:%s cached gauge vec labels dont match %v != %v", id, entry.Labels, labelNames) + } + return entry +} +// Deprecated: Use RegisterLabeledGaugeGroup +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) } - return + return c } -func (m *Metrics) GetGaugeGroupFromVectsWithPrefix(prefix string, labels []string, vects ...map[string]GaugeVec) (c map[string]Gauge) { +// Deprecated: Use RegisterLabeledGauge +func (m *Metrics) GetGaugeFromVect(labelValues []string, vec GaugeVec) 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] + 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] +} + +// Deprecated: Use RegisterLabeledGaugeGroup +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 + return c } -func (m *Metrics) GetGaugeGroupFromVects(labels []string, vects ...map[string]GaugeVec) (c map[string]Gauge) { - return m.GetGaugeGroupFromVectsWithPrefix("", labels, vects...) +// Deprecated: Use RegisterLabeledGaugeGroup +func (m *Metrics) GetGaugeGroupFromVectsWithPrefix(prefix string, labelValues []string, vects ...map[string]GaugeVec) map[string]Gauge { + c := make(map[string]Gauge) + for _, vect := range vects { + for name, vec := range vect { + c[prefix+name] = m.GetGaugeFromVect(labelValues, vec) + } + } + return c }