forked from cloudfoundry/locket
/
db_metrics.go
113 lines (96 loc) · 3.66 KB
/
db_metrics.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
package metrics
import (
"os"
"time"
"code.cloudfoundry.org/bbs/db/sqldb/helpers"
"code.cloudfoundry.org/bbs/db/sqldb/helpers/monitor"
"code.cloudfoundry.org/clock"
loggingclient "code.cloudfoundry.org/diego-logging-client"
"code.cloudfoundry.org/lager/v3"
"github.com/tedsuo/ifrit"
)
const (
dbOpenConnectionsMetric = "DBOpenConnections"
dbWaitDurationMetric = "DBWaitDuration"
dbWaitCountMetric = "DBWaitCount"
dbQueriesTotalMetric = "DBQueriesTotal"
dbQueriesSucceededMetric = "DBQueriesSucceeded"
dbQueriesFailedMetric = "DBQueriesFailed"
dbQueriesInFlightMetric = "DBQueriesInFlight"
dbQueryDurationMaxMetric = "DBQueryDurationMax"
)
type dbMetricsNotifier struct {
logger lager.Logger
ticker clock.Clock
metricsInterval time.Duration
lockDB helpers.QueryableDB
metronClient loggingclient.IngressClient
queryMonitor monitor.Monitor
}
func NewDBMetricsNotifier(logger lager.Logger, ticker clock.Clock, metronClient loggingclient.IngressClient, metricsInterval time.Duration, lockDB helpers.QueryableDB, queryMonitor monitor.Monitor) ifrit.Runner {
return &dbMetricsNotifier{
logger: logger,
ticker: ticker,
metricsInterval: metricsInterval,
lockDB: lockDB,
metronClient: metronClient,
queryMonitor: queryMonitor,
}
}
func (notifier *dbMetricsNotifier) Run(signals <-chan os.Signal, ready chan<- struct{}) error {
logger := notifier.logger.Session("metrics-notifier")
logger.Info("starting", lager.Data{"interval": notifier.metricsInterval})
defer logger.Info("completed")
close(ready)
tick := notifier.ticker.NewTicker(notifier.metricsInterval)
for {
select {
case <-signals:
return nil
case <-tick.C():
logger.Debug("emitting-metrics")
openConnections := notifier.lockDB.OpenConnections()
waitDuration := notifier.lockDB.WaitDuration()
waitCount := notifier.lockDB.WaitCount()
queriesTotal := notifier.queryMonitor.Total()
queriesSucceeded := notifier.queryMonitor.Succeeded()
queriesFailed := notifier.queryMonitor.Failed()
queriesInFlightMax := notifier.queryMonitor.ReadAndResetInFlightMax()
queryDurationMax := notifier.queryMonitor.ReadAndResetDurationMax()
err := notifier.metronClient.SendMetric(dbOpenConnectionsMetric, openConnections)
if err != nil {
logger.Error("failed-sending-db-open-connections-count", err)
}
err = notifier.metronClient.SendDuration(dbWaitDurationMetric, waitDuration)
if err != nil {
logger.Error("failed-sending-db-wait-duration", err)
}
err = notifier.metronClient.SendMetric(dbWaitCountMetric, int(waitCount))
if err != nil {
logger.Error("failed-sending-db-wait-count", err)
}
logger.Debug("sending-queries-total-metric", lager.Data{"value": queriesTotal})
err = notifier.metronClient.SendMetric(dbQueriesTotalMetric, int(queriesTotal))
if err != nil {
logger.Error("failed-sending-db-queries-total-count", err)
}
err = notifier.metronClient.SendMetric(dbQueriesSucceededMetric, int(queriesSucceeded))
if err != nil {
logger.Error("failed-sending-db-queries-succeeded-count", err)
}
err = notifier.metronClient.SendMetric(dbQueriesFailedMetric, int(queriesFailed))
if err != nil {
logger.Error("failed-sending-db-queries-failed-count", err)
}
err = notifier.metronClient.SendMetric(dbQueriesInFlightMetric, int(queriesInFlightMax))
if err != nil {
logger.Error("failed-sending-db-queries-in-flight-count", err)
}
err = notifier.metronClient.SendDuration(dbQueryDurationMaxMetric, queryDurationMax)
if err != nil {
logger.Error("failed-sending-db-query-duration-max", err)
}
logger.Debug("emitted-metrics")
}
}
}