Skip to content

Take control over your live stream video by running it yourself. Streaming + chat out of the box.

2.8 KB
Raw Blame
package utils

import (
	"sort"
	"sync"
	"time"
)

// PerformanceTracker records the start times of named events and
// maintains a small rolling sample of their durations, exposing the
// average. State is held per-instance: construct with NewPerformanceTracker
// and inject into the component that needs it.
type PerformanceTracker struct {
	lock sync.Mutex

	// The "start" timestamp of a timing event.
	pointsInTime map[string]time.Time

	// A collection of timestamp durations for returning the average of.
	durationStorage map[string][]float64
}

// NewPerformanceTracker constructs an empty PerformanceTracker.
func NewPerformanceTracker() *PerformanceTracker {
	return &PerformanceTracker{
		pointsInTime:    make(map[string]time.Time),
		durationStorage: make(map[string][]float64),
	}
}

// StartPerformanceMonitor will keep track of the start time of this event.
func (t *PerformanceTracker) StartPerformanceMonitor(key string) {
	t.lock.Lock()
	if len(t.durationStorage[key]) > 20 {
		t.durationStorage[key] = removeHighValue(t.durationStorage[key])
	}
	t.pointsInTime[key] = time.Now()
	t.lock.Unlock()
}

// GetAveragePerformance will return the average durations for the event.
func (t *PerformanceTracker) GetAveragePerformance(key string) float64 {
	t.lock.Lock()
	defer t.lock.Unlock()

	timestamp := t.pointsInTime[key]
	if timestamp.IsZero() {
		return 0
	}

	delta := time.Since(timestamp).Seconds()
	t.durationStorage[key] = append(t.durationStorage[key], delta)
	if len(t.durationStorage[key]) < 8 {
		return 0
	}
	t.durationStorage[key] = removeHighValue(t.durationStorage[key])

	return Avg(t.durationStorage[key])
}

func removeHighValue(values []float64) []float64 {
	sort.Float64s(values)
	return values[:len(values)-1]
}

// Avg will return the average value from a slice of float64s.
func Avg(values []float64) float64 {
	total := 0.0
	for _, number := range values {
		total += number
	}
	average := total / float64(len(values))
	return average
}

// Sum returns the sum of a slice of values.
func Sum(values []float64) float64 {
	total := 0.0
	for _, number := range values {
		total += number
	}
	return total
}

// MinMax will return the min and max values from a slice of float64s.
func MinMax(array []float64) (float64, float64) {
	max := array[0]
	min := array[0]
	for _, value := range array {
		if max < value {
			max = value
		}
		if min > value {
			min = value
		}
	}
	return min, max
}

func mean(input []float64) float64 {
	sum := Sum(input)

	return sum / float64(len(input))
}

// Median gets the median number in a slice of numbers.
func Median(input []float64) float64 {
	if len(input) == 1 {
		return input[0]
	}

	c := make([]float64, len(input))
	copy(c, input)

	var median float64
	l := len(c)
	if l%2 == 0 {
		median = mean(c[l/2-1 : l/2+1])
	} else {
		median = c[l/2]
	}

	return median
}