pkg/xapp/metrics.go

   1 /*
   2 ==================================================================================
   3   Copyright (c) 2019 AT&T Intellectual Property.
   4   Copyright (c) 2019 Nokia
   5
   6    Licensed under the Apache License, Version 2.0 (the "License");
   7    you may not use this file except in compliance with the License.
   8    You may obtain a copy of the License at
   9
  10        http://www.apache.org/licenses/LICENSE-2.0
  11
  12    Unless required by applicable law or agreed to in writing, software
  13    distributed under the License is distributed on an "AS IS" BASIS,
  14    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15    See the License for the specific language governing permissions and
  16    limitations under the License.
  17 ==================================================================================
  18 */
  19
  20 package xapp
  21
  22 import (
  23         "fmt"
  24         "github.com/gorilla/mux"
  25         "github.com/prometheus/client_golang/prometheus"
  26         "github.com/prometheus/client_golang/prometheus/promauto"
  27         "github.com/prometheus/client_golang/prometheus/promhttp"
  28         "sync"
  29 )
  30
  31 //-----------------------------------------------------------------------------
  32 // Alias
  33 //-----------------------------------------------------------------------------
  34 type CounterOpts prometheus.Opts
  35 type Counter prometheus.Counter
  36 type Gauge prometheus.Gauge
  37
  38 //-----------------------------------------------------------------------------
  39 //
  40 //-----------------------------------------------------------------------------
  41
  42 type MetricGroupsCache struct {
  43         sync.RWMutex //This is for map locking
  44         counters     map[string]Counter
  45         gauges       map[string]Gauge
  46 }
  47
  48 func (met *MetricGroupsCache) CIs(metric string) bool {
  49         met.RLock()
  50         defer met.RUnlock()
  51         _, ok := met.counters[metric]
  52         return ok
  53 }
  54
  55 func (met *MetricGroupsCache) CGet(metric string) Counter {
  56         met.RLock()
  57         defer met.RUnlock()
  58         return met.counters[metric]
  59 }
  60
  61 func (met *MetricGroupsCache) CInc(metric string) {
  62         met.RLock()
  63         defer met.RUnlock()
  64         met.counters[metric].Inc()
  65 }
  66
  67 func (met *MetricGroupsCache) CAdd(metric string, val float64) {
  68         met.RLock()
  69         defer met.RUnlock()
  70         met.counters[metric].Add(val)
  71 }
  72
  73 func (met *MetricGroupsCache) GIs(metric string) bool {
  74         met.RLock()
  75         defer met.RUnlock()
  76         _, ok := met.gauges[metric]
  77         return ok
  78 }
  79
  80 func (met *MetricGroupsCache) GGet(metric string) Gauge {
  81         met.RLock()
  82         defer met.RUnlock()
  83         return met.gauges[metric]
  84 }
  85
  86 func (met *MetricGroupsCache) GSet(metric string, val float64) {
  87         met.RLock()
  88         defer met.RUnlock()
  89         met.gauges[metric].Set(val)
  90 }
  91
  92 func (met *MetricGroupsCache) GInc(metric string) {
  93         met.RLock()
  94         defer met.RUnlock()
  95         met.gauges[metric].Inc()
  96 }
  97
  98 func (met *MetricGroupsCache) GDec(metric string) {
  99         met.RLock()
 100         defer met.RUnlock()
 101         met.gauges[metric].Dec()
 102 }
 103
 104 func (met *MetricGroupsCache) CombineCounterGroups(srcs ...map[string]Counter) {
 105         met.Lock()
 106         defer met.Unlock()
 107         for _, src := range srcs {
 108                 for k, v := range src {
 109                         met.counters[k] = v
 110                 }
 111         }
 112 }
 113
 114 func (met *MetricGroupsCache) CombineGaugeGroups(srcs ...map[string]Gauge) {
 115         met.Lock()
 116         defer met.Unlock()
 117         for _, src := range srcs {
 118                 for k, v := range src {
 119                         met.gauges[k] = v
 120                 }
 121         }
 122 }
 123
 124 func NewMetricGroupsCache() *MetricGroupsCache {
 125         entry := &MetricGroupsCache{}
 126         entry.counters = make(map[string]Counter)
 127         entry.gauges = make(map[string]Gauge)
 128         return entry
 129 }
 130
 131 //-----------------------------------------------------------------------------
 132 // All counters/gauges registered via Metrics instances:
 133 // Counter names are build from: namespace, subsystem, metric and possible labels
 134 //-----------------------------------------------------------------------------
 135 var globalLock sync.Mutex
 136 var cache_allcounters map[string]Counter
 137 var cache_allgauges map[string]Gauge
 138
 139 func init() {
 140         cache_allcounters = make(map[string]Counter)
 141         cache_allgauges = make(map[string]Gauge)
 142 }
 143
 144 //-----------------------------------------------------------------------------
 145 //
 146 //-----------------------------------------------------------------------------
 147 type Metrics struct {
 148         Namespace string
 149 }
 150
 151 func NewMetrics(url, namespace string, r *mux.Router) *Metrics {
 152         if url == "" {
 153                 url = "/ric/v1/metrics"
 154         }
 155         if namespace == "" {
 156                 namespace = "ricxapp"
 157         }
 158
 159         Logger.Info("Serving metrics on: url=%s namespace=%s", url, namespace)
 160
 161         // Expose 'metrics' endpoint with standard golang metrics used by prometheus
 162         r.Handle(url, promhttp.Handler())
 163
 164         return &Metrics{Namespace: namespace}
 165 }
 166
 167 /*
 168  * Helpers
 169  */
 170 func (m *Metrics) getFullName(opts prometheus.Opts, labels []string) string {
 171         labelname := ""
 172         for _, lbl := range labels {
 173                 if len(labelname) == 0 {
 174                         labelname += lbl
 175                 } else {
 176                         labelname += "_" + lbl
 177                 }
 178         }
 179         return fmt.Sprintf("%s_%s_%s_%s", opts.Namespace, opts.Subsystem, opts.Name, labelname)
 180 }
 181
 182 /*
 183  * Handling counters
 184  */
 185 func (m *Metrics) registerCounter(opts CounterOpts) Counter {
 186         Logger.Info("Register new counter with opts: %v", opts)
 187         return promauto.NewCounter(prometheus.CounterOpts(opts))
 188 }
 189
 190 func (m *Metrics) RegisterCounterGroup(opts []CounterOpts, subsytem string) (c map[string]Counter) {
 191         globalLock.Lock()
 192         defer globalLock.Unlock()
 193         c = make(map[string]Counter)
 194         for _, opt := range opts {
 195                 opt.Namespace = m.Namespace
 196                 opt.Subsystem = subsytem
 197
 198                 id := m.getFullName(prometheus.Opts(opt), []string{})
 199                 if _, ok := cache_allcounters[id]; !ok {
 200                         cache_allcounters[id] = m.registerCounter(opt)
 201                 }
 202
 203                 c[opt.Name] = cache_allcounters[id]
 204         }
 205
 206         return
 207 }
 208
 209 /*
 210  * Handling gauges
 211  */
 212 func (m *Metrics) registerGauge(opts CounterOpts) Gauge {
 213         Logger.Info("Register new gauge with opts: %v", opts)
 214         return promauto.NewGauge(prometheus.GaugeOpts(opts))
 215 }
 216
 217 func (m *Metrics) RegisterGaugeGroup(opts []CounterOpts, subsytem string) (c map[string]Gauge) {
 218         globalLock.Lock()
 219         defer globalLock.Unlock()
 220         c = make(map[string]Gauge)
 221         for _, opt := range opts {
 222                 opt.Namespace = m.Namespace
 223                 opt.Subsystem = subsytem
 224
 225                 id := m.getFullName(prometheus.Opts(opt), []string{})
 226                 if _, ok := cache_allgauges[id]; !ok {
 227                         cache_allgauges[id] = m.registerGauge(opt)
 228                 }
 229
 230                 c[opt.Name] = cache_allgauges[id]
 231         }
 232
 233         return
 234 }
 235
 236 /*
 237  * Handling counter vectors
 238  *
 239  * Example:
 240
 241         vec := Metric.RegisterCounterVecGroup(
 242                 []CounterOpts{
 243                         {Name: "counter1", Help: "counter1"},
 244                         {Name: "counter2", Help: "counter2"},
 245                 },
 246                 []string{"host"},
 247                 "SUBSYSTEM")
 248
 249         stat:=Metric.GetCounterGroupFromVects([]string{"localhost:8888"}, vec)
 250
 251 */
 252 type CounterVec struct {
 253         Vec  *prometheus.CounterVec
 254         Opts CounterOpts
 255 }
 256
 257 func (m *Metrics) registerCounterVec(opts CounterOpts, labelNames []string) *prometheus.CounterVec {
 258         Logger.Info("Register new counter vector with opts: %v labelNames: %v", opts, labelNames)
 259         return promauto.NewCounterVec(prometheus.CounterOpts(opts), labelNames)
 260 }
 261
 262 func (m *Metrics) RegisterCounterVecGroup(opts []CounterOpts, labelNames []string, subsytem string) (c map[string]CounterVec) {
 263         c = make(map[string]CounterVec)
 264         for _, opt := range opts {
 265                 entry := CounterVec{}
 266                 entry.Opts = opt
 267                 entry.Opts.Namespace = m.Namespace
 268                 entry.Opts.Subsystem = subsytem
 269                 entry.Vec = m.registerCounterVec(entry.Opts, labelNames)
 270                 c[opt.Name] = entry
 271         }
 272         return
 273 }
 274
 275 func (m *Metrics) GetCounterGroupFromVectsWithPrefix(prefix string, labels []string, vects ...map[string]CounterVec) (c map[string]Counter) {
 276         globalLock.Lock()
 277         defer globalLock.Unlock()
 278         c = make(map[string]Counter)
 279         for _, vec := range vects {
 280                 for name, opt := range vec {
 281
 282                         id := m.getFullName(prometheus.Opts(opt.Opts), labels)
 283                         if _, ok := cache_allcounters[id]; !ok {
 284                                 Logger.Info("Register new counter from vector with opts: %v labels: %v prefix: %s", opt.Opts, labels, prefix)
 285                                 cache_allcounters[id] = opt.Vec.WithLabelValues(labels...)
 286                         }
 287                         c[prefix+name] = cache_allcounters[id]
 288                 }
 289         }
 290         return
 291 }
 292
 293 func (m *Metrics) GetCounterGroupFromVects(labels []string, vects ...map[string]CounterVec) (c map[string]Counter) {
 294         return m.GetCounterGroupFromVectsWithPrefix("", labels, vects...)
 295 }
 296
 297 /*
 298  * Handling gauge vectors
 299  *
 300  * Example:
 301
 302         vec := Metric.RegisterGaugeVecGroup(
 303                 []CounterOpts{
 304                         {Name: "gauge1", Help: "gauge1"},
 305                         {Name: "gauge2", Help: "gauge2"},
 306                 },
 307                 []string{"host"},
 308                 "SUBSYSTEM")
 309
 310         stat:=Metric.GetGaugeGroupFromVects([]string{"localhost:8888"},vec)
 311
 312 */
 313 type GaugeVec struct {
 314         Vec  *prometheus.GaugeVec
 315         Opts CounterOpts
 316 }
 317
 318 func (m *Metrics) registerGaugeVec(opts CounterOpts, labelNames []string) *prometheus.GaugeVec {
 319         Logger.Info("Register new gauge vector with opts: %v labelNames: %v", opts, labelNames)
 320         return promauto.NewGaugeVec(prometheus.GaugeOpts(opts), labelNames)
 321 }
 322
 323 func (m *Metrics) RegisterGaugeVecGroup(opts []CounterOpts, labelNames []string, subsytem string) (c map[string]GaugeVec) {
 324         c = make(map[string]GaugeVec)
 325         for _, opt := range opts {
 326                 entry := GaugeVec{}
 327                 entry.Opts = opt
 328                 entry.Opts.Namespace = m.Namespace
 329                 entry.Opts.Subsystem = subsytem
 330                 entry.Vec = m.registerGaugeVec(entry.Opts, labelNames)
 331                 c[opt.Name] = entry
 332
 333         }
 334         return
 335 }
 336
 337 func (m *Metrics) GetGaugeGroupFromVectsWithPrefix(prefix string, labels []string, vects ...map[string]GaugeVec) (c map[string]Gauge) {
 338         globalLock.Lock()
 339         defer globalLock.Unlock()
 340         c = make(map[string]Gauge)
 341         for _, vec := range vects {
 342                 for name, opt := range vec {
 343
 344                         id := m.getFullName(prometheus.Opts(opt.Opts), labels)
 345                         if _, ok := cache_allgauges[id]; !ok {
 346                                 Logger.Info("Register new gauge from vector with opts: %v labels: %v prefix: %s", opt.Opts, labels, prefix)
 347                                 cache_allgauges[id] = opt.Vec.WithLabelValues(labels...)
 348                         }
 349                         c[prefix+name] = cache_allgauges[id]
 350                 }
 351         }
 352         return
 353 }
 354
 355 func (m *Metrics) GetGaugeGroupFromVects(labels []string, vects ...map[string]GaugeVec) (c map[string]Gauge) {
 356         return m.GetGaugeGroupFromVectsWithPrefix("", labels, vects...)
 357 }