forked from pingcap/tidb
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathmetric.go
112 lines (95 loc) · 2.38 KB
/
metric.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
// Copyright 2015 PingCAP, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// See the License for the specific language governing permissions and
// limitations under the License.
package metric
import (
"os"
"sync"
"time"
"github.com/rcrowley/go-metrics"
)
var (
r = metrics.NewRegistry()
once sync.Once
)
// Register registers a new metric for observation.
func Register(name string, m interface{}) {
r.Register(name, m)
}
// Inc increases specific counter metric.
func Inc(name string, i int64) {
if c := r.GetOrRegister(name, metrics.NewCounter()); c != nil {
c.(metrics.Counter).Inc(i)
}
}
// RecordTime records time elapse from startTime for given metric.
func RecordTime(name string, startTime time.Time) {
if h := r.GetOrRegister(name, metrics.NewHistogram(metrics.NewUniformSample(100))); h != nil {
elapse := time.Since(startTime).Nanoseconds() / int64(time.Millisecond)
h.(metrics.Histogram).Update(elapse)
}
}
// RunMetric reports metric result over a given time interval.
func RunMetric(interval time.Duration) {
once.Do(func() {
go func() {
metrics.Write(r, interval, os.Stdout)
}()
})
}
// TPSMetrics is the metrics for tps (Transaction Per Second)
type TPSMetrics interface {
// Add c transactions
Add(c int64)
// Get current tps
Get() int64
}
// Simple tps metrics
// Accumulate txn count in a second and reset the counter at each second.
type tpsMetrics struct {
meter metrics.Counter
tps int64
mu sync.Mutex
}
func (tm *tpsMetrics) Add(c int64) {
tm.meter.Inc(c)
}
func (tm *tpsMetrics) Get() int64 {
tm.mu.Lock()
defer tm.mu.Unlock()
return tm.tps
}
func (tm *tpsMetrics) tick() {
tm.mu.Lock()
defer tm.mu.Unlock()
t := tm.meter.Count()
tm.meter.Clear()
tm.tps = t
}
func (tm *tpsMetrics) updateTPS() {
for {
tm.tick()
time.Sleep(1 * time.Second)
}
}
func newTPSMetrics() *tpsMetrics {
return &tpsMetrics{
meter: metrics.NewCounter(),
}
}
// NewTPSMetrics creates a tpsMetrics and starts its ticker.
func NewTPSMetrics() TPSMetrics {
m := newTPSMetrics()
// Tick and update tps
go m.updateTPS()
return m
}