services/keepstore/metrics.go

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 package main
   6
   7 import (
   8         "fmt"
   9
  10         "git.curoverse.com/arvados.git/sdk/go/httpserver"
  11         "github.com/prometheus/client_golang/prometheus"
  12 )
  13
  14 type nodeMetrics struct {
  15         reg *prometheus.Registry
  16 }
  17
  18 func (m *nodeMetrics) setupBufferPoolMetrics(b *bufferPool) {
  19         m.reg.MustRegister(prometheus.NewGaugeFunc(
  20                 prometheus.GaugeOpts{
  21                         Namespace: "arvados",
  22                         Subsystem: "keepstore",
  23                         Name:      "bufferpool_allocated_bytes",
  24                         Help:      "Number of bytes allocated to buffers",
  25                 },
  26                 func() float64 { return float64(b.Alloc()) },
  27         ))
  28         m.reg.MustRegister(prometheus.NewGaugeFunc(
  29                 prometheus.GaugeOpts{
  30                         Namespace: "arvados",
  31                         Subsystem: "keepstore",
  32                         Name:      "bufferpool_max_buffers",
  33                         Help:      "Maximum number of buffers allowed",
  34                 },
  35                 func() float64 { return float64(b.Cap()) },
  36         ))
  37         m.reg.MustRegister(prometheus.NewGaugeFunc(
  38                 prometheus.GaugeOpts{
  39                         Namespace: "arvados",
  40                         Subsystem: "keepstore",
  41                         Name:      "bufferpool_inuse_buffers",
  42                         Help:      "Number of buffers in use",
  43                 },
  44                 func() float64 { return float64(b.Len()) },
  45         ))
  46 }
  47
  48 func (m *nodeMetrics) setupWorkQueueMetrics(q *WorkQueue, qName string) {
  49         m.reg.MustRegister(prometheus.NewGaugeFunc(
  50                 prometheus.GaugeOpts{
  51                         Namespace: "arvados",
  52                         Subsystem: "keepstore",
  53                         Name:      fmt.Sprintf("%s_queue_inprogress_entries", qName),
  54                         Help:      fmt.Sprintf("Number of %s requests in progress", qName),
  55                 },
  56                 func() float64 { return float64(getWorkQueueStatus(q).InProgress) },
  57         ))
  58         m.reg.MustRegister(prometheus.NewGaugeFunc(
  59                 prometheus.GaugeOpts{
  60                         Namespace: "arvados",
  61                         Subsystem: "keepstore",
  62                         Name:      fmt.Sprintf("%s_queue_pending_entries", qName),
  63                         Help:      fmt.Sprintf("Number of queued %s requests", qName),
  64                 },
  65                 func() float64 { return float64(getWorkQueueStatus(q).Queued) },
  66         ))
  67 }
  68
  69 func (m *nodeMetrics) setupRequestMetrics(rc httpserver.RequestCounter) {
  70         m.reg.MustRegister(prometheus.NewGaugeFunc(
  71                 prometheus.GaugeOpts{
  72                         Namespace: "arvados",
  73                         Subsystem: "keepstore",
  74                         Name:      "concurrent_requests",
  75                         Help:      "Number of requests in progress",
  76                 },
  77                 func() float64 { return float64(rc.Current()) },
  78         ))
  79         m.reg.MustRegister(prometheus.NewGaugeFunc(
  80                 prometheus.GaugeOpts{
  81                         Namespace: "arvados",
  82                         Subsystem: "keepstore",
  83                         Name:      "max_concurrent_requests",
  84                         Help:      "Maximum number of concurrent requests",
  85                 },
  86                 func() float64 { return float64(rc.Max()) },
  87         ))
  88 }
  89
  90 type volumeMetricsVecs struct {
  91         ioBytes     *prometheus.CounterVec
  92         errCounters *prometheus.CounterVec
  93         opsCounters *prometheus.CounterVec
  94 }
  95
  96 func newVolumeMetricsVecs(reg *prometheus.Registry) *volumeMetricsVecs {
  97         m := &volumeMetricsVecs{}
  98         m.opsCounters = prometheus.NewCounterVec(
  99                 prometheus.CounterOpts{
 100                         Namespace: "arvados",
 101                         Subsystem: "keepstore",
 102                         Name:      "volume_operations",
 103                         Help:      "Number of volume operations",
 104                 },
 105                 []string{"device_id", "operation"},
 106         )
 107         reg.MustRegister(m.opsCounters)
 108         m.errCounters = prometheus.NewCounterVec(
 109                 prometheus.CounterOpts{
 110                         Namespace: "arvados",
 111                         Subsystem: "keepstore",
 112                         Name:      "volume_errors",
 113                         Help:      "Number of volume errors",
 114                 },
 115                 []string{"device_id", "error_type"},
 116         )
 117         reg.MustRegister(m.errCounters)
 118         m.ioBytes = prometheus.NewCounterVec(
 119                 prometheus.CounterOpts{
 120                         Namespace: "arvados",
 121                         Subsystem: "keepstore",
 122                         Name:      "volume_io_bytes",
 123                         Help:      "Volume I/O traffic in bytes",
 124                 },
 125                 []string{"device_id", "direction"},
 126         )
 127         reg.MustRegister(m.ioBytes)
 128
 129         return m
 130 }