252 lines
6.5 KiB
Go
252 lines
6.5 KiB
Go
package metrics
|
|
|
|
import (
|
|
"math"
|
|
"sync"
|
|
"sync/atomic"
|
|
"time"
|
|
)
|
|
|
|
// Meters count events to produce exponentially-weighted moving average rates
|
|
// at one-, five-, and fifteen-minutes and a mean rate.
|
|
type Meter interface {
|
|
Count() int64
|
|
Mark(int64)
|
|
Rate1() float64
|
|
Rate5() float64
|
|
Rate15() float64
|
|
RateMean() float64
|
|
Snapshot() Meter
|
|
Stop()
|
|
}
|
|
|
|
// GetOrRegisterMeter returns an existing Meter or constructs and registers a
|
|
// new StandardMeter.
|
|
// Be sure to unregister the meter from the registry once it is of no use to
|
|
// allow for garbage collection.
|
|
func GetOrRegisterMeter(name string, r Registry) Meter {
|
|
if nil == r {
|
|
r = DefaultRegistry
|
|
}
|
|
return r.GetOrRegister(name, NewMeter).(Meter)
|
|
}
|
|
|
|
// NewMeter constructs a new StandardMeter and launches a goroutine.
|
|
// Be sure to call Stop() once the meter is of no use to allow for garbage collection.
|
|
func NewMeter() Meter {
|
|
if UseNilMetrics {
|
|
return NilMeter{}
|
|
}
|
|
m := newStandardMeter()
|
|
arbiter.Lock()
|
|
defer arbiter.Unlock()
|
|
arbiter.meters[m] = struct{}{}
|
|
if !arbiter.started {
|
|
arbiter.started = true
|
|
go arbiter.tick()
|
|
}
|
|
return m
|
|
}
|
|
|
|
// NewMeter constructs and registers a new StandardMeter and launches a
|
|
// goroutine.
|
|
// Be sure to unregister the meter from the registry once it is of no use to
|
|
// allow for garbage collection.
|
|
func NewRegisteredMeter(name string, r Registry) Meter {
|
|
c := NewMeter()
|
|
if nil == r {
|
|
r = DefaultRegistry
|
|
}
|
|
r.Register(name, c)
|
|
return c
|
|
}
|
|
|
|
// MeterSnapshot is a read-only copy of another Meter.
|
|
type MeterSnapshot struct {
|
|
count int64
|
|
rate1, rate5, rate15, rateMean uint64
|
|
}
|
|
|
|
// Count returns the count of events at the time the snapshot was taken.
|
|
func (m *MeterSnapshot) Count() int64 { return m.count }
|
|
|
|
// Mark panics.
|
|
func (*MeterSnapshot) Mark(n int64) {
|
|
panic("Mark called on a MeterSnapshot")
|
|
}
|
|
|
|
// Rate1 returns the one-minute moving average rate of events per second at the
|
|
// time the snapshot was taken.
|
|
func (m *MeterSnapshot) Rate1() float64 { return math.Float64frombits(m.rate1) }
|
|
|
|
// Rate5 returns the five-minute moving average rate of events per second at
|
|
// the time the snapshot was taken.
|
|
func (m *MeterSnapshot) Rate5() float64 { return math.Float64frombits(m.rate5) }
|
|
|
|
// Rate15 returns the fifteen-minute moving average rate of events per second
|
|
// at the time the snapshot was taken.
|
|
func (m *MeterSnapshot) Rate15() float64 { return math.Float64frombits(m.rate15) }
|
|
|
|
// RateMean returns the meter's mean rate of events per second at the time the
|
|
// snapshot was taken.
|
|
func (m *MeterSnapshot) RateMean() float64 { return math.Float64frombits(m.rateMean) }
|
|
|
|
// Snapshot returns the snapshot.
|
|
func (m *MeterSnapshot) Snapshot() Meter { return m }
|
|
|
|
// Stop is a no-op.
|
|
func (m *MeterSnapshot) Stop() {}
|
|
|
|
// NilMeter is a no-op Meter.
|
|
type NilMeter struct{}
|
|
|
|
// Count is a no-op.
|
|
func (NilMeter) Count() int64 { return 0 }
|
|
|
|
// Mark is a no-op.
|
|
func (NilMeter) Mark(n int64) {}
|
|
|
|
// Rate1 is a no-op.
|
|
func (NilMeter) Rate1() float64 { return 0.0 }
|
|
|
|
// Rate5 is a no-op.
|
|
func (NilMeter) Rate5() float64 { return 0.0 }
|
|
|
|
// Rate15is a no-op.
|
|
func (NilMeter) Rate15() float64 { return 0.0 }
|
|
|
|
// RateMean is a no-op.
|
|
func (NilMeter) RateMean() float64 { return 0.0 }
|
|
|
|
// Snapshot is a no-op.
|
|
func (NilMeter) Snapshot() Meter { return NilMeter{} }
|
|
|
|
// Stop is a no-op.
|
|
func (NilMeter) Stop() {}
|
|
|
|
// StandardMeter is the standard implementation of a Meter.
|
|
type StandardMeter struct {
|
|
snapshot *MeterSnapshot
|
|
a1, a5, a15 EWMA
|
|
startTime time.Time
|
|
stopped uint32
|
|
}
|
|
|
|
func newStandardMeter() *StandardMeter {
|
|
return &StandardMeter{
|
|
snapshot: &MeterSnapshot{},
|
|
a1: NewEWMA1(),
|
|
a5: NewEWMA5(),
|
|
a15: NewEWMA15(),
|
|
startTime: time.Now(),
|
|
}
|
|
}
|
|
|
|
// Stop stops the meter, Mark() will be a no-op if you use it after being stopped.
|
|
func (m *StandardMeter) Stop() {
|
|
if atomic.CompareAndSwapUint32(&m.stopped, 0, 1) {
|
|
arbiter.Lock()
|
|
delete(arbiter.meters, m)
|
|
arbiter.Unlock()
|
|
}
|
|
}
|
|
|
|
// Count returns the number of events recorded.
|
|
func (m *StandardMeter) Count() int64 {
|
|
return atomic.LoadInt64(&m.snapshot.count)
|
|
}
|
|
|
|
// Mark records the occurance of n events.
|
|
func (m *StandardMeter) Mark(n int64) {
|
|
if atomic.LoadUint32(&m.stopped) == 1 {
|
|
return
|
|
}
|
|
|
|
atomic.AddInt64(&m.snapshot.count, n)
|
|
|
|
m.a1.Update(n)
|
|
m.a5.Update(n)
|
|
m.a15.Update(n)
|
|
m.updateSnapshot()
|
|
}
|
|
|
|
// Rate1 returns the one-minute moving average rate of events per second.
|
|
func (m *StandardMeter) Rate1() float64 {
|
|
return math.Float64frombits(atomic.LoadUint64(&m.snapshot.rate1))
|
|
}
|
|
|
|
// Rate5 returns the five-minute moving average rate of events per second.
|
|
func (m *StandardMeter) Rate5() float64 {
|
|
return math.Float64frombits(atomic.LoadUint64(&m.snapshot.rate5))
|
|
}
|
|
|
|
// Rate15 returns the fifteen-minute moving average rate of events per second.
|
|
func (m *StandardMeter) Rate15() float64 {
|
|
return math.Float64frombits(atomic.LoadUint64(&m.snapshot.rate15))
|
|
}
|
|
|
|
// RateMean returns the meter's mean rate of events per second.
|
|
func (m *StandardMeter) RateMean() float64 {
|
|
return math.Float64frombits(atomic.LoadUint64(&m.snapshot.rateMean))
|
|
}
|
|
|
|
// Snapshot returns a read-only copy of the meter.
|
|
func (m *StandardMeter) Snapshot() Meter {
|
|
copiedSnapshot := MeterSnapshot{
|
|
count: atomic.LoadInt64(&m.snapshot.count),
|
|
rate1: atomic.LoadUint64(&m.snapshot.rate1),
|
|
rate5: atomic.LoadUint64(&m.snapshot.rate5),
|
|
rate15: atomic.LoadUint64(&m.snapshot.rate15),
|
|
rateMean: atomic.LoadUint64(&m.snapshot.rateMean),
|
|
}
|
|
return &copiedSnapshot
|
|
}
|
|
|
|
func (m *StandardMeter) updateSnapshot() {
|
|
rate1 := math.Float64bits(m.a1.Rate())
|
|
rate5 := math.Float64bits(m.a5.Rate())
|
|
rate15 := math.Float64bits(m.a15.Rate())
|
|
rateMean := math.Float64bits(float64(m.Count()) / time.Since(m.startTime).Seconds())
|
|
|
|
atomic.StoreUint64(&m.snapshot.rate1, rate1)
|
|
atomic.StoreUint64(&m.snapshot.rate5, rate5)
|
|
atomic.StoreUint64(&m.snapshot.rate15, rate15)
|
|
atomic.StoreUint64(&m.snapshot.rateMean, rateMean)
|
|
}
|
|
|
|
func (m *StandardMeter) tick() {
|
|
m.a1.Tick()
|
|
m.a5.Tick()
|
|
m.a15.Tick()
|
|
m.updateSnapshot()
|
|
}
|
|
|
|
// meterArbiter ticks meters every 5s from a single goroutine.
|
|
// meters are references in a set for future stopping.
|
|
type meterArbiter struct {
|
|
sync.RWMutex
|
|
started bool
|
|
meters map[*StandardMeter]struct{}
|
|
ticker *time.Ticker
|
|
}
|
|
|
|
var arbiter = meterArbiter{ticker: time.NewTicker(5e9), meters: make(map[*StandardMeter]struct{})}
|
|
|
|
// Ticks meters on the scheduled interval
|
|
func (ma *meterArbiter) tick() {
|
|
for {
|
|
select {
|
|
case <-ma.ticker.C:
|
|
ma.tickMeters()
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ma *meterArbiter) tickMeters() {
|
|
ma.RLock()
|
|
defer ma.RUnlock()
|
|
for meter := range ma.meters {
|
|
meter.tick()
|
|
}
|
|
}
|