137 lines
2.6 KiB
Go
137 lines
2.6 KiB
Go
package memmetrics
|
|
|
|
import (
|
|
"time"
|
|
|
|
"github.com/mailgun/timetools"
|
|
)
|
|
|
|
type ratioOptSetter func(r *RatioCounter) error
|
|
|
|
// RatioClock sets a clock
|
|
func RatioClock(clock timetools.TimeProvider) ratioOptSetter {
|
|
return func(r *RatioCounter) error {
|
|
r.clock = clock
|
|
return nil
|
|
}
|
|
}
|
|
|
|
// RatioCounter calculates a ratio of a/a+b over a rolling window of predefined buckets
|
|
type RatioCounter struct {
|
|
clock timetools.TimeProvider
|
|
a *RollingCounter
|
|
b *RollingCounter
|
|
}
|
|
|
|
// NewRatioCounter creates a new RatioCounter
|
|
func NewRatioCounter(buckets int, resolution time.Duration, options ...ratioOptSetter) (*RatioCounter, error) {
|
|
rc := &RatioCounter{}
|
|
|
|
for _, o := range options {
|
|
if err := o(rc); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
if rc.clock == nil {
|
|
rc.clock = &timetools.RealTime{}
|
|
}
|
|
|
|
a, err := NewCounter(buckets, resolution, CounterClock(rc.clock))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
b, err := NewCounter(buckets, resolution, CounterClock(rc.clock))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
rc.a = a
|
|
rc.b = b
|
|
return rc, nil
|
|
}
|
|
|
|
// Reset reset the counter
|
|
func (r *RatioCounter) Reset() {
|
|
r.a.Reset()
|
|
r.b.Reset()
|
|
}
|
|
|
|
// IsReady returns true if the counter is ready
|
|
func (r *RatioCounter) IsReady() bool {
|
|
return r.a.countedBuckets+r.b.countedBuckets >= len(r.a.values)
|
|
}
|
|
|
|
// CountA gets count A
|
|
func (r *RatioCounter) CountA() int64 {
|
|
return r.a.Count()
|
|
}
|
|
|
|
// CountB gets count B
|
|
func (r *RatioCounter) CountB() int64 {
|
|
return r.b.Count()
|
|
}
|
|
|
|
// Resolution gets resolution
|
|
func (r *RatioCounter) Resolution() time.Duration {
|
|
return r.a.Resolution()
|
|
}
|
|
|
|
// Buckets gets buckets
|
|
func (r *RatioCounter) Buckets() int {
|
|
return r.a.Buckets()
|
|
}
|
|
|
|
// WindowSize gets windows size
|
|
func (r *RatioCounter) WindowSize() time.Duration {
|
|
return r.a.WindowSize()
|
|
}
|
|
|
|
// ProcessedCount gets processed count
|
|
func (r *RatioCounter) ProcessedCount() int64 {
|
|
return r.CountA() + r.CountB()
|
|
}
|
|
|
|
// Ratio gets ratio
|
|
func (r *RatioCounter) Ratio() float64 {
|
|
a := r.a.Count()
|
|
b := r.b.Count()
|
|
// No data, return ok
|
|
if a+b == 0 {
|
|
return 0
|
|
}
|
|
return float64(a) / float64(a+b)
|
|
}
|
|
|
|
// IncA increment counter A
|
|
func (r *RatioCounter) IncA(v int) {
|
|
r.a.Inc(v)
|
|
}
|
|
|
|
// IncB increment counter B
|
|
func (r *RatioCounter) IncB(v int) {
|
|
r.b.Inc(v)
|
|
}
|
|
|
|
// TestMeter a test meter
|
|
type TestMeter struct {
|
|
Rate float64
|
|
NotReady bool
|
|
WindowSize time.Duration
|
|
}
|
|
|
|
// GetWindowSize gets windows size
|
|
func (tm *TestMeter) GetWindowSize() time.Duration {
|
|
return tm.WindowSize
|
|
}
|
|
|
|
// IsReady returns true if the meter is ready
|
|
func (tm *TestMeter) IsReady() bool {
|
|
return !tm.NotReady
|
|
}
|
|
|
|
// GetRate gets rate
|
|
func (tm *TestMeter) GetRate() float64 {
|
|
return tm.Rate
|
|
}
|