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) }