cwtch/server/metrics/metrics.go

package metrics

import (
	"sync"
	"sync/atomic"
	"time"
)

type counter struct {
	startTime time.Time
	count     uint64
}

// Counter providers a threadsafe counter to use for storing long running counts
type Counter interface {
	Add(unit int)
	Reset()

	Count() int
	GetStarttime() time.Time
}

// NewCounter initializes a counter starting at time.Now() and a count of 0 and returns it
func NewCounter() Counter {
	c := &counter{startTime: time.Now(), count: 0}
	return c
}

// Add add a count of unit to the counter
func (c *counter) Add(unit int) {
	atomic.AddUint64(&c.count, uint64(unit))
}

// Count returns the count since Start
func (c *counter) Count() int {
	return int(atomic.LoadUint64(&c.count))
}

func (c *counter) Reset() {
	atomic.StoreUint64(&c.count, 0)
	c.startTime = time.Now()
}

// GetStarttime returns the starttime of the counter
func (c *counter) GetStarttime() time.Time {
	return c.startTime
}

type monitorHistory struct {
	starttime           time.Time
	perMinutePerHour    [60]float64
	timeLastHourRotate  time.Time
	perHourForDay       [24]float64
	timeLastDayRotate   time.Time
	perDayForWeek       [7]float64
	timeLastWeekRotate  time.Time
	perWeekForMonth     [4]float64
	timeLastMonthRotate time.Time
	perMonthForYear     [12]float64

	monitor func() float64

	breakChannel chan bool
	lock         sync.Mutex
}

// MonitorHistory runs a monitor every minute and rotates and averages the results out across time
type MonitorHistory interface {
	Start()
	Stop()

	Minutes() []float64
	Hours() []float64
	Days() []float64
	Weeks() []float64
	Months() []float64
}

// NewMonitorHistory returns a new MonitorHistory with starttime of time.Now and Started running with supplied monitor
func NewMonitorHistory(monitor func() float64) MonitorHistory {
	mh := &monitorHistory{starttime: time.Now(), monitor: monitor, breakChannel: make(chan bool)}
	mh.Start()
	return mh
}

// Start starts a monitorHistory go rountine to run the monitor at intervals and rotate history
func (mh *monitorHistory) Start() {
	go mh.monitorThread()
}

// Stop stops a monitorHistory go routine
func (mh *monitorHistory) Stop() {
	mh.breakChannel <- true
}

// Minutes returns the last 60 minute monitoring results
func (mh *monitorHistory) Minutes() []float64 {
	return mh.returnCopy(mh.perMinutePerHour[:])
}

// Hours returns the last 24 hourly averages of monitor results
func (mh *monitorHistory) Hours() []float64 {
	return mh.returnCopy(mh.perHourForDay[:])
}

// Days returns the last 7 day averages of monitor results
func (mh *monitorHistory) Days() []float64 {
	return mh.returnCopy(mh.perDayForWeek[:])
}

// Weeks returns the last 4 weeks of averages of monitor results
func (mh *monitorHistory) Weeks() []float64 {
	return mh.returnCopy(mh.perWeekForMonth[:])
}

// Months returns the last 12 months of averages of monitor results
func (mh *monitorHistory) Months() []float64 {
	return mh.returnCopy(mh.perMonthForYear[:])
}

func (mh *monitorHistory) returnCopy(slice []float64) []float64 {
	retSlice := make([]float64, len(slice))
	mh.lock.Lock()
	for i, v := range slice {
		retSlice[i] = v
	}
	mh.lock.Unlock()
	return retSlice
}

func rotateAndAvg(array []float64, newVal float64) float64 {
	total := float64(0.0)
	for i := len(array) - 1; i > 0; i-- {
		array[i] = array[i-1]
		total += array[i]
	}
	array[0] = newVal
	total += newVal
	return total / float64(len(array))
}
func average(array []float64) float64 {
	total := float64(0)
	for _, x := range array {
		total += x
	}
	return total / float64(len(array))
}

// monitorThread is the goroutine in a monitorHistory that does per minute monitoring and rotation
func (mh *monitorHistory) monitorThread() {
	timeout := time.Duration(0) // first pass right away

	for {
		select {
		case <-time.After(timeout):
			mh.lock.Lock()

			minuteAvg := rotateAndAvg(mh.perMinutePerHour[:], mh.monitor())

			if time.Now().Sub(mh.timeLastHourRotate) > time.Hour {
				rotateAndAvg(mh.perHourForDay[:], minuteAvg)
				mh.timeLastHourRotate = time.Now()
			}

			if time.Now().Sub(mh.timeLastDayRotate) > time.Hour*24 {
				rotateAndAvg(mh.perDayForWeek[:], average(mh.perHourForDay[:]))
				mh.timeLastDayRotate = time.Now()
			}

			if time.Now().Sub(mh.timeLastWeekRotate) > time.Hour*24*7 {
				rotateAndAvg(mh.perWeekForMonth[:], average(mh.perDayForWeek[:]))
				mh.timeLastWeekRotate = time.Now()
			}

			if time.Now().Sub(mh.timeLastMonthRotate) > time.Hour*24*7*4 {
				rotateAndAvg(mh.perMonthForYear[:], average(mh.perWeekForMonth[:]))
				mh.timeLastMonthRotate = time.Now()
			}

			mh.lock.Unlock()

			// Repeat every minute
			timeout = time.Duration(time.Minute)

		case <-mh.breakChannel:
			return
		}
	}
}