Skip to content

Commit

Permalink
more per-database metrics
Browse files Browse the repository at this point in the history
  • Loading branch information
@marcinbudny
marcinbudny committed May 4, 2018
1 parent 891982c commit fdbf089
Showing 1 changed file with 149 additions and 47 deletions.
196 changes: 149 additions & 47 deletions collector.go
View file
@@ -1,10 +1,10 @@
package main

import (
"strconv"
"regexp"
"github.com/prometheus/client_golang/prometheus"
jp "github.com/buger/jsonparser"
"github.com/prometheus/client_golang/prometheus"
"regexp"
"strconv"
)

const (
Expand All @@ -13,35 +13,54 @@ const (
)

type exporter struct {
up prometheus.Gauge
workingSet prometheus.Gauge
cpuTime prometheus.Counter
isLeader prometheus.Gauge
requestCount prometheus.Counter
documentPutCount prometheus.Counter
documentPutBytes prometheus.Counter
mapIndexIndexedCount prometheus.Counter
mapReduceIndexMappedCount prometheus.Counter
mapReduceIndexReducedCount prometheus.Counter

databaseDocumentCount *prometheus.GaugeVec

up prometheus.Gauge
workingSet prometheus.Gauge
cpuTime prometheus.Counter
isLeader prometheus.Gauge
requestCount prometheus.Counter
documentPutCount prometheus.Counter
documentPutBytes prometheus.Counter
mapIndexIndexedCount prometheus.Counter
mapReduceIndexMappedCount prometheus.Counter
mapReduceIndexReducedCount prometheus.Counter

databaseDocumentCount *prometheus.GaugeVec
databaseIndexCount *prometheus.GaugeVec
databaseStaleIndexCount *prometheus.GaugeVec
databaseSize *prometheus.GaugeVec

databaseRequestCount *prometheus.CounterVec
databaseDocumentPutCount *prometheus.CounterVec
databaseDocumentPutBytes *prometheus.CounterVec
databaseMapIndexIndexedCount *prometheus.CounterVec
databaseMapReduceIndexMappedCount *prometheus.CounterVec
databaseMapReduceIndexReducedCount *prometheus.CounterVec
}

func newExporter() *exporter {
return &exporter{
up: createGauge("up", "Whether the RavenDB scrape was successful"),
workingSet: createGauge("working_set_bytes", "Process working set"),
cpuTime: createCounter("cpu_time_seconds", "CPU time"),
isLeader: createGauge("is_leader", "If 1, then node is the cluster leader, otherwise 0"),
requestCount: createCounter("request_count", "Server-wide request count"),
documentPutCount: createCounter("document_put_count", "Server-wide document puts count"),
documentPutBytes: createCounter("document_put_bytes", "Server-wide document put bytes"),
mapIndexIndexedCount: createCounter("mapindex_indexed_count", "Server-wide map index indexed count"),
mapReduceIndexMappedCount: createCounter("mapreduceindex_mapped_count", "Server-wide map-reduce index mapped count"),
mapReduceIndexReducedCount: createCounter("mapreduceindex_reduced_count", "Server-wide map-reduce index reduced count"),

databaseDocumentCount: createGaugeDatabaseVec("database_document_count", "Count of documents in a database"),
up: createGauge("up", "Whether the RavenDB scrape was successful"),
workingSet: createGauge("working_set_bytes", "Process working set"),
cpuTime: createCounter("cpu_time_seconds", "CPU time"),
isLeader: createGauge("is_leader", "If 1, then node is the cluster leader, otherwise 0"),
requestCount: createCounter("request_count", "Server-wide request count"),
documentPutCount: createCounter("document_put_count", "Server-wide document puts count"),
documentPutBytes: createCounter("document_put_bytes", "Server-wide document put bytes"),
mapIndexIndexedCount: createCounter("mapindex_indexed_count", "Server-wide map index indexed count"),
mapReduceIndexMappedCount: createCounter("mapreduceindex_mapped_count", "Server-wide map-reduce index mapped count"),
mapReduceIndexReducedCount: createCounter("mapreduceindex_reduced_count", "Server-wide map-reduce index reduced count"),

databaseDocumentCount: createDatabaseGaugeVec("database_document_count", "Count of documents in a database"),
databaseIndexCount: createDatabaseGaugeVec("database_index_count", "Count of indexes in a database"),
databaseStaleIndexCount: createDatabaseGaugeVec("database_stale_index_cont", "Count of stale indexes in a database"),
databaseSize: createDatabaseGaugeVec("database_size_bytes", "Database size in bytes"),

databaseRequestCount: createDatabaseCounterVec("database_request_count", "Database request count"),
databaseDocumentPutCount: createDatabaseCounterVec("database_document_put_count", "Database document puts count"),
databaseDocumentPutBytes: createDatabaseCounterVec("database_document_put_bytes", "Database document put bytes"),
databaseMapIndexIndexedCount: createDatabaseCounterVec("database_mapindex_indexed_count", "Database map index indexed count"),
databaseMapReduceIndexMappedCount: createDatabaseCounterVec("database_mapreduceindex_mapped_count", "Database map-reduce index mapped count"),
databaseMapReduceIndexReducedCount: createDatabaseCounterVec("database_mapreduceindex_reduced_count", "Database map-reduce index reduced count"),
}
}

Expand Down Expand Up @@ -99,12 +118,34 @@ func (e *exporter) Collect(ch chan<- prometheus.Metric) {
e.mapReduceIndexReducedCount.Set(getMapReduceIndexReducedCount(stats))
ch <- e.mapReduceIndexReducedCount

for _, dbs := range stats.dbStats {
e.databaseDocumentCount.WithLabelValues(dbs.database).Set(getDatabaseDocumentCount(dbs));
}
collectPerDatabaseGauge(stats, e.databaseDocumentCount, getDatabaseDocumentCount, ch)
collectPerDatabaseGauge(stats, e.databaseIndexCount, getDatabaseIndexCount, ch)
collectPerDatabaseGauge(stats, e.databaseStaleIndexCount, getDatabaseStaleIndexCount, ch)
collectPerDatabaseGauge(stats, e.databaseSize, getDatabaseSize, ch)

collectPerDatabaseCounter(stats, e.databaseRequestCount, getDatabaseRequestCount, ch)
collectPerDatabaseCounter(stats, e.databaseDocumentPutBytes, getDatabaseDocumentPutBytes, ch)
collectPerDatabaseCounter(stats, e.databaseDocumentPutCount, getDatabaseDocumentPutCount, ch)

collectPerDatabaseCounter(stats, e.databaseMapIndexIndexedCount, getDatabaseMapIndexIndexedCount, ch)
collectPerDatabaseCounter(stats, e.databaseMapReduceIndexMappedCount, getDatabaseMapReduceIndexMappedCount, ch)
collectPerDatabaseCounter(stats, e.databaseMapReduceIndexReducedCount, getDatabaseMapReduceIndexReducedCount, ch)

}
}

func collectPerDatabaseGauge(stats *stats, vec *prometheus.GaugeVec, collectFunc func(*dbStats) float64, ch chan<- prometheus.Metric) {
for _, dbs := range stats.dbStats {
vec.WithLabelValues(dbs.database).Set(collectFunc(dbs))
}
vec.Collect(ch)
}

e.databaseDocumentCount.Collect(ch)
func collectPerDatabaseCounter(stats *stats, vec *prometheus.CounterVec, collectFunc func(*dbStats) float64, ch chan<- prometheus.Metric) {
for _, dbs := range stats.dbStats {
vec.WithLabelValues(dbs.database).Set(collectFunc(dbs))
}
vec.Collect(ch)
}

func getCPUTime(stats *stats) float64 {
Expand All @@ -121,11 +162,11 @@ func getMemoryWorkingSet(stats *stats) float64 {
return value
}

func getIsLeader(stats * stats) float64 {
func getIsLeader(stats *stats) float64 {
value, _ := jp.GetString(stats.nodeInfo, "CurrentState")
if value == "Leader" {
return 1
}
}
return 0
}

Expand Down Expand Up @@ -164,6 +205,58 @@ func getDatabaseDocumentCount(dbStats *dbStats) float64 {
return value
}

func getDatabaseIndexCount(dbStats *dbStats) float64 {
value, _ := jp.GetFloat(dbStats.databaseStats, "CountOfIndexes")
return value
}

func getDatabaseStaleIndexCount(dbStats *dbStats) float64 {
count := 0
jp.ArrayEach(dbStats.databaseStats, func(value []byte, dataType jp.ValueType, offset int, err error) {
if isStale, _ := jp.GetBoolean(value, "IsStale"); isStale {
count++
}
}, "Indexes")

return float64(count)
}

func getDatabaseSize(dbStats *dbStats) float64 {
value, _ := jp.GetFloat(dbStats.databaseStats, "SizeOnDisk", "SizeInBytes")
return value
}

func getDatabaseRequestCount(dbStats *dbStats) float64 {
value, _ := jp.GetFloat(dbStats.metrics, "Requests", "RequestsPerSec", "Count")
return value
}

func getDatabaseDocumentPutCount(dbStats *dbStats) float64 {
value, _ := jp.GetFloat(dbStats.metrics, "Docs", "PutsPerSec", "Count")
return value
}

func getDatabaseDocumentPutBytes(dbStats *dbStats) float64 {
value, _ := jp.GetFloat(dbStats.metrics, "Docs", "BytesPutsPerSec", "Count")
return value
}

func getDatabaseMapIndexIndexedCount(dbStats *dbStats) float64 {
value, _ := jp.GetFloat(dbStats.metrics, "MapIndexes", "IndexedPerSec", "Count")
return value
}

func getDatabaseMapReduceIndexMappedCount(dbStats *dbStats) float64 {
value, _ := jp.GetFloat(dbStats.metrics, "MapIndexes", "MappedPerSec", "Count")
return value
}

func getDatabaseMapReduceIndexReducedCount(dbStats *dbStats) float64 {
value, _ := jp.GetFloat(dbStats.metrics, "MapIndexes", "ReducedPerSec", "Count")
return value
}


func createGauge(name string, help string) prometheus.Gauge {
return prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: namespace,
Expand All @@ -173,50 +266,59 @@ func createGauge(name string, help string) prometheus.Gauge {
})
}

func createGaugeDatabaseVec(name string, help string) *prometheus.GaugeVec {
func createDatabaseGaugeVec(name string, help string) *prometheus.GaugeVec {
return prometheus.NewGaugeVec(prometheus.GaugeOpts{
Namespace: namespace,
Subsystem: subsystem,
Name: name,
Help: help,
}, []string { "database" })
}, []string{"database"})
}

func createCounter(name string, help string) prometheus.Counter {
return prometheus.NewCounter(prometheus.CounterOpts {
Namespace: namespace,
Subsystem: subsystem,
Name: name,
Help: help,
return prometheus.NewCounter(prometheus.CounterOpts{
Namespace: namespace,
Subsystem: subsystem,
Name: name,
Help: help,
})
}

func createDatabaseCounterVec(name string, help string) *prometheus.CounterVec {
return prometheus.NewCounterVec(prometheus.CounterOpts{
Namespace: namespace,
Subsystem: subsystem,
Name: name,
Help: help,
}, []string{"database"})
}

var timespanRegex = regexp.MustCompile(`((?P<days>\d+)\.)?(?P<hours>\d{2}):(?P<minutes>\d{2}):(?P<seconds>\d{2})(\.(?P<secondfraction>\d{7}))?`)

func timeSpanToSeconds(timespanString string) float64 {

var result float64

matches := matchNamedGroups(timespanRegex, timespanString)
if daysString, ok := matches["days"]; ok {
days, _ := strconv.Atoi(daysString)
result = result + float64(days) * 24 * 60 * 60
result = result + float64(days)*24*60*60
}
if hoursString, ok := matches["hours"]; ok {
hours, _ := strconv.Atoi(hoursString)
result = result + float64(hours) * 60 * 60
result = result + float64(hours)*60*60
}
if minutesString, ok := matches["minutes"]; ok {
minutes, _ := strconv.Atoi(minutesString)
result = result + float64(minutes) * 60
result = result + float64(minutes)*60
}
if secondsString, ok := matches["seconds"]; ok {
seconds, _ := strconv.Atoi(secondsString)
result = result + float64(seconds)
result = result + float64(seconds)
}
if secondFractionString, ok := matches["secondfraction"]; ok {
secondFraction, _ := strconv.Atoi(secondFractionString)
result = result + float64(secondFraction) / 10000000
result = result + float64(secondFraction)/10000000
}

return result
Expand Down

0 comments on commit fdbf089

Please sign in to comment.