func BenchmarkManyDifferentSensors(t *testing.B) {
r := rand.New(rand.NewSource(438))
for i := 0; i < 1000; i++ {
bucket := "response_time" + strconv.Itoa(i)
for i := 0; i < 10000; i++ {
m := &common.Metric{bucket, r.Float64(), "ms", r.Float32(), 0}
timer.Add(timers, m)
}
}
for i := 0; i < 1000; i++ {
bucket := "count" + strconv.Itoa(i)
for i := 0; i < 10000; i++ {
a := r.Float64()
counters[bucket] = a
}
}
for i := 0; i < 1000; i++ {
bucket := "gauge" + strconv.Itoa(i)
for i := 0; i < 10000; i++ {
a := r.Float64()
gauges[bucket] = a
}
}
var buff bytes.Buffer
now := time.Now().Unix()
t.ResetTimer()
processTimers(&buff, now, commonPercentiles)
processCounters(&buff, now, commonPercentiles)
processGauges(&buff, now, commonPercentiles)
}
func TestLowerPercentile(t *testing.T) {
// Some data with expected mean of 20
d := []byte("time:0|ms\ntime:1|ms\ntime:2|ms\ntime:3|ms")
packets := udp.ParseMessage(d, prefix_internal, output, udp.ParseLine)
for _, p := range packets {
timer.Add(timers, p)
}
var buff bytes.Buffer
var num int64
num += processTimers(&buff, time.Now().Unix(), Percentiles{
&Percentile{
-75,
"-75",
},
})
assert.Equal(t, num, int64(1))
dataForGraphite := buff.String()
meanRegexp := regexp.MustCompile(`time\.upper_75 1\.`)
matched := meanRegexp.MatchString(dataForGraphite)
assert.Equal(t, matched, false)
meanRegexp = regexp.MustCompile(`time\.lower_75 1\.`)
matched = meanRegexp.MatchString(dataForGraphite)
assert.Equal(t, matched, true)
}
func TestMetrics20Timer(t *testing.T) {
d := []byte("foo=bar.target_type=gauge.unit=ms:5|ms\nfoo=bar.target_type=gauge.unit=ms:10|ms")
packets := udp.ParseMessage(d, prefix_internal, output, udp.ParseLine)
for _, p := range packets {
timer.Add(timers, p)
}
var buff bytes.Buffer
var num int64
num += processTimers(&buff, time.Now().Unix(), Percentiles{
&Percentile{
75,
"75",
},
})
dataForGraphite := buff.String()
assert.T(t, strings.Contains(dataForGraphite, "foo=bar.target_type=gauge.unit=ms.stat=upper_75 10.000000"))
assert.T(t, strings.Contains(dataForGraphite, "foo=bar.target_type=gauge.unit=ms.stat=mean_75 7.500000"))
assert.T(t, strings.Contains(dataForGraphite, "foo=bar.target_type=gauge.unit=ms.stat=sum_75 15.000000"))
assert.T(t, strings.Contains(dataForGraphite, "foo=bar.target_type=gauge.unit=ms.stat=mean 7.500000"))
assert.T(t, strings.Contains(dataForGraphite, "foo=bar.target_type=gauge.unit=ms.stat=median 7.500000"))
assert.T(t, strings.Contains(dataForGraphite, "foo=bar.target_type=gauge.unit=ms.stat=std 2.500000"))
assert.T(t, strings.Contains(dataForGraphite, "foo=bar.target_type=gauge.unit=ms.stat=sum 15.000000"))
assert.T(t, strings.Contains(dataForGraphite, "foo=bar.target_type=gauge.unit=ms.stat=upper 10.000000"))
assert.T(t, strings.Contains(dataForGraphite, "foo=bar.target_type=gauge.unit=ms.stat=lower 5.000000"))
assert.T(t, strings.Contains(dataForGraphite, "foo=bar.target_type=count.unit=Pckt.orig_unit=ms.pckt_type=sent.direction=in 2"))
assert.T(t, strings.Contains(dataForGraphite, "foo=bar.target_type=rate.unit=Pcktps.orig_unit=ms.pckt_type=sent.direction=in 0.200000"))
}
func BenchmarkOneBigTimer(t *testing.B) {
r := rand.New(rand.NewSource(438))
bucket := "response_time"
for i := 0; i < 10000000; i++ {
m := &common.Metric{bucket, r.Float64(), "ms", r.Float32(), 0}
timer.Add(timers, m)
}
var buff bytes.Buffer
t.ResetTimer()
processTimers(&buff, time.Now().Unix(), commonPercentiles)
}
// metricsMonitor basically guards the metrics datastructures.
// it typically receives metrics on the Metrics channel but also responds to
// external signals and every flushInterval, computes and flushes the data
func metricsMonitor() {
period := time.Duration(*flushInterval) * time.Second
ticker := time.NewTicker(period)
for {
select {
case sig := <-signalchan:
switch sig {
case syscall.SIGTERM, syscall.SIGINT:
fmt.Printf("!! Caught signal %d... shutting down\n", sig)
if err := submit(time.Now().Add(period)); err != nil {
log.Printf("ERROR: %s", err)
}
return
default:
fmt.Printf("unknown signal %d, ignoring\n", sig)
}
case <-ticker.C:
if err := submit(time.Now().Add(period)); err != nil {
log.Printf("ERROR: %s", err)
}
events.Broadcast <- "flush"
case s := <-Metrics:
var name string
if s.Modifier == "ms" {
timer.Add(timers, s)
name = "timer"
} else if s.Modifier == "g" {
gauges[s.Bucket] = s.Value
name = "gauge"
} else {
counter.Add(counters, s)
name = "counter"
}
k := fmt.Sprintf("%sdirection=in.statsd_type=%s.target_type=count.unit=Metric", prefix_internal, name)
_, ok := counters[k]
if !ok {
counters[k] = 1
} else {
counters[k] += 1
}
}
}
}
func TestMean(t *testing.T) {
// Some data with expected mean of 20
d := []byte("response_time:0|ms\nresponse_time:30|ms\nresponse_time:30|ms")
packets := udp.ParseMessage(d, prefix_internal, output, udp.ParseLine)
for _, p := range packets {
timer.Add(timers, p)
}
var buff bytes.Buffer
var num int64
num += processTimers(&buff, time.Now().Unix(), Percentiles{})
assert.Equal(t, num, int64(1))
dataForGraphite := buff.String()
pattern := `response_time\.mean 20\.[0-9]+ `
meanRegexp := regexp.MustCompile(pattern)
matched := meanRegexp.MatchString(dataForGraphite)
assert.Equal(t, matched, true)
}