def test_gauge(self):
stats = MetricsAggregator('myhost')
# Track some counters.
stats.submit_packets('my.first.gauge:1|g')
stats.submit_packets('my.first.gauge:5|g')
stats.submit_packets('my.second.gauge:1.5|g')
# Ensure that gauges roll up correctly.
metrics = self.sort_metrics(stats.flush())
assert len(metrics) == 2
first, second = metrics
nt.assert_equals(first['metric'], 'my.first.gauge')
nt.assert_equals(first['points'][0][1], 5)
nt.assert_equals(first['host'], 'myhost')
nt.assert_equals(second['metric'], 'my.second.gauge')
nt.assert_equals(second['points'][0][1], 1.5)
# Ensure that old gauges get dropped due to old timestamps
stats.gauge('my.first.gauge', 5)
stats.gauge('my.first.gauge', 1, timestamp=1000000000)
stats.gauge('my.second.gauge', 20, timestamp=1000000000)
metrics = self.sort_metrics(stats.flush())
assert len(metrics) == 1
first = metrics[0]
nt.assert_equals(first['metric'], 'my.first.gauge')
nt.assert_equals(first['points'][0][1], 5)
nt.assert_equals(first['host'], 'myhost')
def test_histogram(self):
stats = MetricsAggregator('myhost')
# Sample all numbers between 1-100 many times. This
# means our percentiles should be relatively close to themselves.
percentiles = range(100)
random.shuffle(percentiles) # in place
for i in percentiles:
for j in xrange(20):
for type_ in ['h', 'ms']:
m = 'my.p:%s|%s' % (i, type_)
stats.submit_packets(m)
metrics = self.sort_metrics(stats.flush())
def assert_almost_equal(i, j, e=1):
# Floating point math?
assert abs(i - j) <= e, "%s %s %s" % (i, j, e)
nt.assert_equal(len(metrics), 5)
p95, pavg, pcount, pmax, pmed = self.sort_metrics(metrics)
nt.assert_equal(p95['metric'], 'my.p.95percentile')
assert_almost_equal(p95['points'][0][1], 95, 10)
assert_almost_equal(pmax['points'][0][1], 99, 1)
assert_almost_equal(pmed['points'][0][1], 50, 2)
assert_almost_equal(pavg['points'][0][1], 50, 2)
assert_almost_equal(pcount['points'][0][1], 4000, 0) # 100 * 20 * 2
nt.assert_equals(p95['host'], 'myhost')
# Ensure that histograms are reset.
metrics = self.sort_metrics(stats.flush())
assert not metrics
def test_gauge(self):
stats = MetricsAggregator('myhost', 1)
# Track some counters.
stats.submit('my.first.gauge:1|g')
stats.submit('my.first.gauge:5|g')
stats.submit('my.second.gauge:1.5|g')
# Ensure they roll up nicely.
time.sleep(1)
metrics = self.sort_metrics(stats.flush(False))
assert len(metrics) == 2
first, second = metrics
nt.assert_equals(first['metric'], 'my.first.gauge')
nt.assert_equals(first['points'][0][1], 5)
nt.assert_equals(first['host'], 'myhost')
nt.assert_equals(second['metric'], 'my.second.gauge')
nt.assert_equals(second['points'][0][1], 1.5)
# Ensure they shall be flushed no more.
metrics = stats.flush(False)
assert not len(metrics)
def test_histogram(self):
stats = MetricsAggregator('myhost')
# Sample all numbers between 1-100 many times. This
# means our percentiles should be relatively close to themselves.
percentiles = range(100)
random.shuffle(percentiles) # in place
for i in percentiles:
for j in xrange(20):
for type_ in ['h', 'ms']:
m = 'my.p:%s|%s' % (i, type_)
stats.submit_packets(m)
metrics = self.sort_metrics(stats.flush())
def assert_almost_equal(i, j, e=1):
# Floating point math?
assert abs(i - j) <= e, "%s %s %s" % (i, j, e)
nt.assert_equal(len(metrics), 5)
p95, pavg, pcount, pmax, pmed = self.sort_metrics(metrics)
nt.assert_equal(p95['metric'], 'my.p.95percentile')
assert_almost_equal(p95['points'][0][1], 95, 10)
assert_almost_equal(pmax['points'][0][1], 99, 1)
assert_almost_equal(pmed['points'][0][1], 50, 2)
assert_almost_equal(pavg['points'][0][1], 50, 2)
assert_almost_equal(pcount['points'][0][1], 4000, 0) # 100 * 20 * 2
nt.assert_equals(p95['host'], 'myhost')
# Ensure that histograms are reset.
metrics = self.sort_metrics(stats.flush())
assert not metrics
def test_counter(self):
stats = MetricsAggregator('myhost', 1)
# Track some counters.
stats.submit('my.first.counter:1|c')
stats.submit('my.first.counter:5|c')
stats.submit('my.second.counter:1|c')
stats.submit('my.third.counter:3|c')
time.sleep(1)
# Ensure they roll up nicely.
metrics = self.sort_metrics(stats.flush(False))
assert len(metrics) == 3
first, second, third = metrics
nt.assert_equals(first['metric'], 'my.first.counter')
nt.assert_equals(first['points'][0][1], 6)
nt.assert_equals(first['host'], 'myhost')
nt.assert_equals(second['metric'], 'my.second.counter')
nt.assert_equals(second['points'][0][1], 1)
nt.assert_equals(third['metric'], 'my.third.counter')
nt.assert_equals(third['points'][0][1], 3)
# Ensure they're gone now.
assert not len(stats.flush(False))
def test_gauge(self):
stats = MetricsAggregator('myhost')
# Track some counters.
stats.submit_packets('my.first.gauge:1|g')
stats.submit_packets('my.first.gauge:5|g')
stats.submit_packets('my.second.gauge:1.5|g')
# Ensure that gauges roll up correctly.
metrics = self.sort_metrics(stats.flush())
assert len(metrics) == 2
first, second = metrics
nt.assert_equals(first['metric'], 'my.first.gauge')
nt.assert_equals(first['points'][0][1], 5)
nt.assert_equals(first['host'], 'myhost')
nt.assert_equals(second['metric'], 'my.second.gauge')
nt.assert_equals(second['points'][0][1], 1.5)
# Ensure that old gauges get dropped due to old timestamps
stats.gauge('my.first.gauge', 5)
stats.gauge('my.first.gauge', 1, timestamp=1000000000)
stats.gauge('my.second.gauge', 20, timestamp=1000000000)
metrics = self.sort_metrics(stats.flush())
assert len(metrics) == 1
first = metrics[0]
nt.assert_equals(first['metric'], 'my.first.gauge')
nt.assert_equals(first['points'][0][1], 5)
nt.assert_equals(first['host'], 'myhost')
def test_counter(self):
stats = MetricsAggregator('myhost')
# Track some counters.
stats.submit_packets('my.first.counter:1|c')
stats.submit_packets('my.first.counter:5|c')
stats.submit_packets('my.second.counter:1|c')
stats.submit_packets('my.third.counter:3|c')
# Ensure they roll up nicely.
metrics = self.sort_metrics(stats.flush())
assert len(metrics) == 3
first, second, third = metrics
nt.assert_equals(first['metric'], 'my.first.counter')
nt.assert_equals(first['points'][0][1], 6)
nt.assert_equals(first['host'], 'myhost')
nt.assert_equals(second['metric'], 'my.second.counter')
nt.assert_equals(second['points'][0][1], 1)
nt.assert_equals(third['metric'], 'my.third.counter')
nt.assert_equals(third['points'][0][1], 3)
# Ensure that counters reset to zero.
metrics = self.sort_metrics(stats.flush())
first, second, third = metrics
nt.assert_equals(first['metric'], 'my.first.counter')
nt.assert_equals(first['points'][0][1], 0)
nt.assert_equals(second['metric'], 'my.second.counter')
nt.assert_equals(second['points'][0][1], 0)
nt.assert_equals(third['metric'], 'my.third.counter')
nt.assert_equals(third['points'][0][1], 0)
def test_counter(self):
stats = MetricsAggregator('myhost')
# Track some counters.
stats.submit_packets('my.first.counter:1|c')
stats.submit_packets('my.first.counter:5|c')
stats.submit_packets('my.second.counter:1|c')
stats.submit_packets('my.third.counter:3|c')
# Ensure they roll up nicely.
metrics = self.sort_metrics(stats.flush())
assert len(metrics) == 3
first, second, third = metrics
nt.assert_equals(first['metric'], 'my.first.counter')
nt.assert_equals(first['points'][0][1], 6)
nt.assert_equals(first['host'], 'myhost')
nt.assert_equals(second['metric'], 'my.second.counter')
nt.assert_equals(second['points'][0][1], 1)
nt.assert_equals(third['metric'], 'my.third.counter')
nt.assert_equals(third['points'][0][1], 3)
# Ensure that counters reset to zero.
metrics = self.sort_metrics(stats.flush())
first, second, third = metrics
nt.assert_equals(first['metric'], 'my.first.counter')
nt.assert_equals(first['points'][0][1], 0)
nt.assert_equals(second['metric'], 'my.second.counter')
nt.assert_equals(second['points'][0][1], 0)
nt.assert_equals(third['metric'], 'my.third.counter')
nt.assert_equals(third['points'][0][1], 0)
def test_rate(self):
stats = MetricsAggregator('myhost')
stats.submit_packets('my.rate:10|_dd-r')
# Sleep 1 second so the time interval > 0
time.sleep(1)
stats.submit_packets('my.rate:40|_dd-r')
# Check that the rate is calculated correctly
metrics = stats.flush()
nt.assert_equal(len(metrics), 1)
m = metrics[0]
nt.assert_equals(m['metric'], 'my.rate')
nt.assert_equals(m['points'][0][1], 30)
# Assert that no more rates are given
assert not stats.flush()
def test_tags(self):
stats = MetricsAggregator('myhost')
stats.submit_packets('gauge:1|c')
stats.submit_packets('gauge:2|c|@1')
stats.submit_packets('gauge:4|c|#tag1,tag2')
stats.submit_packets(
'gauge:8|c|#tag2,tag1') # Should be the same as above
stats.submit_packets('gauge:16|c|#tag3,tag4')
metrics = self.sort_metrics(stats.flush())
assert len(metrics) == 3
first, second, third = metrics
nt.assert_equal(first['metric'], 'gauge')
nt.assert_equal(first['tags'], None)
nt.assert_equal(first['points'][0][1], 3)
nt.assert_equal(first['host'], 'myhost')
nt.assert_equal(second['metric'], 'gauge')
nt.assert_equal(second['tags'], ('tag1', 'tag2'))
nt.assert_equal(second['points'][0][1], 12)
nt.assert_equal(second['host'], 'myhost')
nt.assert_equal(third['metric'], 'gauge')
nt.assert_equal(third['tags'], ('tag3', 'tag4'))
nt.assert_equal(third['points'][0][1], 16)
nt.assert_equal(third['host'], 'myhost')
def test_rate(self):
stats = MetricsAggregator('myhost')
stats.submit_packets('my.rate:10|_dd-r')
# Sleep 1 second so the time interval > 0
time.sleep(1)
stats.submit_packets('my.rate:40|_dd-r')
# Check that the rate is calculated correctly
metrics = stats.flush()
nt.assert_equal(len(metrics), 1)
m = metrics[0]
nt.assert_equals(m['metric'], 'my.rate')
nt.assert_equals(m['points'][0][1], 30)
# Assert that no more rates are given
assert not stats.flush()
def test_tags(self):
stats = MetricsAggregator('myhost')
stats.submit_packets('gauge:1|c')
stats.submit_packets('gauge:2|c|@1')
stats.submit_packets('gauge:4|c|#tag1,tag2')
stats.submit_packets('gauge:8|c|#tag2,tag1') # Should be the same as above
stats.submit_packets('gauge:16|c|#tag3,tag4')
metrics = self.sort_metrics(stats.flush())
assert len(metrics) == 3
first, second, third = metrics
nt.assert_equal(first['metric'], 'gauge')
nt.assert_equal(first['tags'], None)
nt.assert_equal(first['points'][0][1], 3)
nt.assert_equal(first['host'], 'myhost')
nt.assert_equal(second['metric'], 'gauge')
nt.assert_equal(second['tags'], ('tag1', 'tag2'))
nt.assert_equal(second['points'][0][1], 12)
nt.assert_equal(second['host'], 'myhost')
nt.assert_equal(third['metric'], 'gauge')
nt.assert_equal(third['tags'], ('tag3', 'tag4'))
nt.assert_equal(third['points'][0][1], 16)
nt.assert_equal(third['host'], 'myhost')
def test_tags(self):
stats = MetricsAggregator("myhost")
stats.submit_packets("gauge:1|c")
stats.submit_packets("gauge:2|c|@1")
stats.submit_packets("gauge:4|c|#tag1,tag2")
stats.submit_packets("gauge:8|c|#tag2,tag1") # Should be the same as above
stats.submit_packets("gauge:16|c|#tag3,tag4")
metrics = self.sort_metrics(stats.flush())
assert len(metrics) == 3
first, second, third = metrics
nt.assert_equal(first["metric"], "gauge")
nt.assert_equal(first["tags"], None)
nt.assert_equal(first["points"][0][1], 3)
nt.assert_equal(first["host"], "myhost")
nt.assert_equal(second["metric"], "gauge")
nt.assert_equal(second["tags"], ("tag1", "tag2"))
nt.assert_equal(second["points"][0][1], 12)
nt.assert_equal(second["host"], "myhost")
nt.assert_equal(third["metric"], "gauge")
nt.assert_equal(third["tags"], ("tag3", "tag4"))
nt.assert_equal(third["points"][0][1], 16)
nt.assert_equal(third["host"], "myhost")
def test_scientific_notation(self):
stats = MetricsAggregator('myhost', interval=10)
stats.submit_packets('test.scinot:9.512901e-05|g')
metrics = self.sort_metrics(stats.flush())
assert len(metrics) == 1
ts, val = metrics[0].get('points')[0]
nt.assert_almost_equal(val, 9.512901e-05)
def test_sets(self):
stats = MetricsAggregator("myhost")
stats.submit_packets("my.set:10|s")
stats.submit_packets("my.set:20|s")
stats.submit_packets("my.set:20|s")
stats.submit_packets("my.set:30|s")
stats.submit_packets("my.set:30|s")
stats.submit_packets("my.set:30|s")
# Assert that it's treated normally.
metrics = stats.flush()
nt.assert_equal(len(metrics), 1)
m = metrics[0]
nt.assert_equal(m["metric"], "my.set")
nt.assert_equal(m["points"][0][1], 3)
# Assert there are no more sets
assert not stats.flush()
def test_string_sets(self):
stats = MetricsAggregator('myhost')
stats.submit_packets('my.set:string|s')
stats.submit_packets('my.set:sets|s')
stats.submit_packets('my.set:sets|s')
stats.submit_packets('my.set:test|s')
stats.submit_packets('my.set:test|s')
stats.submit_packets('my.set:test|s')
# Assert that it's treated normally.
metrics = stats.flush()
nt.assert_equal(len(metrics), 1)
m = metrics[0]
nt.assert_equal(m['metric'], 'my.set')
nt.assert_equal(m['points'][0][1], 3)
# Assert there are no more sets
assert not stats.flush()
def test_string_sets(self):
stats = MetricsAggregator('myhost')
stats.submit_packets('my.set:string|s')
stats.submit_packets('my.set:sets|s')
stats.submit_packets('my.set:sets|s')
stats.submit_packets('my.set:test|s')
stats.submit_packets('my.set:test|s')
stats.submit_packets('my.set:test|s')
# Assert that it's treated normally.
metrics = stats.flush()
nt.assert_equal(len(metrics), 1)
m = metrics[0]
nt.assert_equal(m['metric'], 'my.set')
nt.assert_equal(m['points'][0][1], 3)
# Assert there are no more sets
assert not stats.flush()
def test_scientific_notation(self):
stats = MetricsAggregator('myhost', interval=10)
stats.submit_packets('test.scinot:9.512901e-05|g')
metrics = self.sort_metrics(stats.flush())
assert len(metrics) == 1
ts, val = metrics[0].get('points')[0]
nt.assert_almost_equal(val, 9.512901e-05)
def test_sampled_counter(self):
# Submit a sampled counter.
stats = MetricsAggregator("myhost")
stats.submit_packets("sampled.counter:1|c|@0.5")
metrics = stats.flush()
assert len(metrics) == 1
m = metrics[0]
assert m["metric"] == "sampled.counter"
nt.assert_equal(m["points"][0][1], 2)
def test_sampled_counter(self):
# Submit a sampled counter.
stats = MetricsAggregator('myhost')
stats.submit_packets('sampled.counter:1|c|@0.5')
metrics = stats.flush()
assert len(metrics) == 1
m = metrics[0]
assert m['metric'] == 'sampled.counter'
nt.assert_equal(m['points'][0][1], 2)
def test_sampled_counter(self):
# Submit a sampled counter.
stats = MetricsAggregator('myhost')
stats.submit_packets('sampled.counter:1|c|@0.5')
metrics = stats.flush()
assert len(metrics) == 1
m = metrics[0]
assert m['metric'] == 'sampled.counter'
nt.assert_equal(m['points'][0][1], 2)
def test_diagnostic_stats(self):
stats = MetricsAggregator('myhost')
for i in xrange(10):
stats.submit_packets('metric:10|c')
stats.send_packet_count('datadog.dogstatsd.packet.count')
metrics = self.sort_metrics(stats.flush())
nt.assert_equals(2, len(metrics))
first, second = metrics
nt.assert_equal(first['metric'], 'datadog.dogstatsd.packet.count')
nt.assert_equal(first['points'][0][1], 10)
def test_metrics_expiry(self):
# Ensure metrics eventually expire and stop submitting.
stats = MetricsAggregator('myhost', expiry_seconds=1)
stats.submit_packets('test.counter:123|c')
# Ensure points keep submitting
assert stats.flush()
assert stats.flush()
time.sleep(0.5)
assert stats.flush()
# Now sleep for longer than the expiry window and ensure
# no points are submitted
time.sleep(2)
m = stats.flush()
assert not m, str(m)
# If we submit again, we're all good.
stats.submit_packets('test.counter:123|c')
assert stats.flush()
def test_metrics_expiry(self):
# Ensure metrics eventually expire and stop submitting.
stats = MetricsAggregator('myhost', expiry_seconds=1)
stats.submit_packets('test.counter:123|c')
# Ensure points keep submitting
assert stats.flush()
assert stats.flush()
time.sleep(0.5)
assert stats.flush()
# Now sleep for longer than the expiry window and ensure
# no points are submitted
time.sleep(2)
m = stats.flush()
assert not m, str(m)
# If we submit again, we're all good.
stats.submit_packets('test.counter:123|c')
assert stats.flush()
def test_diagnostic_stats(self):
stats = MetricsAggregator("myhost")
for i in xrange(10):
stats.submit_packets("metric:10|c")
stats.send_packet_count("datadog.dogstatsd.packet.count")
metrics = self.sort_metrics(stats.flush())
nt.assert_equals(2, len(metrics))
first, second = metrics
nt.assert_equal(first["metric"], "datadog.dogstatsd.packet.count")
nt.assert_equal(first["points"][0][1], 10)
def test_diagnostic_stats(self):
stats = MetricsAggregator('myhost')
for i in xrange(10):
stats.submit_packets('metric:10|c')
stats.send_packet_count('datadog.dogstatsd.packet.count')
metrics = self.sort_metrics(stats.flush())
nt.assert_equals(2, len(metrics))
first, second = metrics
nt.assert_equal(first['metric'], 'datadog.dogstatsd.packet.count')
nt.assert_equal(first['points'][0][1], 10)
def test_batch_submission(self):
# Submit a sampled histogram.
stats = MetricsAggregator('myhost')
metrics = ['counter:1|c', 'counter:1|c', 'gauge:1|g']
packet = "\n".join(metrics)
stats.submit_packets(packet)
metrics = self.sort_metrics(stats.flush())
nt.assert_equal(2, len(metrics))
counter, gauge = metrics
assert counter['points'][0][1] == 2
assert gauge['points'][0][1] == 1
def test_sampled_histogram(self):
# Submit a sampled histogram.
stats = MetricsAggregator('myhost')
stats.submit_packets('sampled.hist:5|h|@0.5')
# Assert we scale up properly.
metrics = self.sort_metrics(stats.flush())
p95, pavg, pcount, pmax, pmed = self.sort_metrics(metrics)
nt.assert_equal(pcount['points'][0][1], 2)
for p in [p95, pavg, pmed, pmax]:
nt.assert_equal(p['points'][0][1], 5)
def test_gauge_sample_rate(self):
stats = MetricsAggregator("myhost")
# Submit a sampled gauge metric.
stats.submit_packets("sampled.gauge:10|g|@0.1")
# Assert that it's treated normally.
metrics = stats.flush()
nt.assert_equal(len(metrics), 1)
m = metrics[0]
nt.assert_equal(m["metric"], "sampled.gauge")
nt.assert_equal(m["points"][0][1], 10)
def test_gauge_sample_rate(self):
stats = MetricsAggregator('myhost')
# Submit a sampled gauge metric.
stats.submit_packets('sampled.gauge:10|g|@0.1')
# Assert that it's treated normally.
metrics = stats.flush()
nt.assert_equal(len(metrics), 1)
m = metrics[0]
nt.assert_equal(m['metric'], 'sampled.gauge')
nt.assert_equal(m['points'][0][1], 10)
def test_batch_submission(self):
# Submit a sampled histogram.
stats = MetricsAggregator('myhost')
metrics = ['counter:1|c', 'counter:1|c', 'gauge:1|g']
packet = "\n".join(metrics)
stats.submit_packets(packet)
metrics = self.sort_metrics(stats.flush())
nt.assert_equal(2, len(metrics))
counter, gauge = metrics
assert counter['points'][0][1] == 2
assert gauge['points'][0][1] == 1
def test_sampled_histogram(self):
# Submit a sampled histogram.
stats = MetricsAggregator('myhost')
stats.submit_packets('sampled.hist:5|h|@0.5')
# Assert we scale up properly.
metrics = self.sort_metrics(stats.flush())
p95, pavg, pcount, pmax, pmed = self.sort_metrics(metrics)
nt.assert_equal(pcount['points'][0][1], 2)
for p in [p95, pavg, pmed, pmax]:
nt.assert_equal(p['points'][0][1], 5)
def test_gauge_sample_rate(self):
stats = MetricsAggregator('myhost')
# Submit a sampled gauge metric.
stats.submit_packets('sampled.gauge:10|g|@0.1')
# Assert that it's treated normally.
metrics = stats.flush()
nt.assert_equal(len(metrics), 1)
m = metrics[0]
nt.assert_equal(m['metric'], 'sampled.gauge')
nt.assert_equal(m['points'][0][1], 10)
def test_diagnostic_stats(self):
stats = MetricsAggregator('myhost', 1)
for i in xrange(10):
stats.submit('metric:10|c')
time.sleep(1)
metrics = self.sort_metrics(stats.flush())
nt.assert_equals(2, len(metrics))
first, second = metrics
print metrics
nt.assert_equal(first['metric'], 'dd.dogstatsd.packet.count')
nt.assert_equal(first['points'][0][1], 10)
def test_histogram_normalization(self):
stats = MetricsAggregator('myhost', interval=10)
for i in range(5):
stats.submit_packets('h1:1|h')
for i in range(20):
stats.submit_packets('h2:1|h')
metrics = self.sort_metrics(stats.flush())
_, _, h1count, _, _, \
_, _, h2count, _, _ = metrics
nt.assert_equal(h1count['points'][0][1], 0.5)
nt.assert_equal(h2count['points'][0][1], 2)
def test_histogram_normalization(self):
stats = MetricsAggregator('myhost', interval=10)
for i in range(5):
stats.submit_packets('h1:1|h')
for i in range(20):
stats.submit_packets('h2:1|h')
metrics = self.sort_metrics(stats.flush())
_, _, h1count, _, _, \
_, _, h2count, _, _ = metrics
nt.assert_equal(h1count['points'][0][1], 0.5)
nt.assert_equal(h2count['points'][0][1], 2)
def test_sampled_histogram(self):
# Submit a sampled histogram.
stats = MetricsAggregator('myhost', 1)
stats.submit('sampled.hist:5|h|@0.5')
time.sleep(1)
# Assert we scale up properly.
metrics = self.sort_metrics(stats.flush(False))
p75, p85, p95, p99, pavg, pcount, pmin, pmax = self.sort_metrics(metrics)
nt.assert_equal(pcount['points'][0][1], 2)
for p in [p75, p85, p99, pavg, pmin, pmax]:
nt.assert_equal(p['points'][0][1], 5)
def test_histogram_counter(self):
# Test whether histogram.count == increment
# same deal with a sample rate
cnt = 100000
for run in [1, 2]:
stats = MetricsAggregator('myhost')
for i in xrange(cnt):
if run == 2:
stats.submit_packets('test.counter:1|c|@0.5')
stats.submit_packets('test.hist:1|ms|@0.5')
else:
stats.submit_packets('test.counter:1|c')
stats.submit_packets('test.hist:1|ms')
metrics = self.sort_metrics(stats.flush())
assert len(metrics) > 0
nt.assert_equal([m['points'][0][1] for m in metrics if m['metric'] == 'test.counter'], [cnt * run])
nt.assert_equal([m['points'][0][1] for m in metrics if m['metric'] == 'test.hist.count'], [cnt * run])
def test_gauge(self):
stats = MetricsAggregator("myhost")
# Track some counters.
stats.submit_packets("my.first.gauge:1|g")
stats.submit_packets("my.first.gauge:5|g")
stats.submit_packets("my.second.gauge:1.5|g")
# Ensure that gauges roll up correctly.
metrics = self.sort_metrics(stats.flush())
assert len(metrics) == 2
first, second = metrics
nt.assert_equals(first["metric"], "my.first.gauge")
nt.assert_equals(first["points"][0][1], 5)
nt.assert_equals(first["host"], "myhost")
nt.assert_equals(second["metric"], "my.second.gauge")
nt.assert_equals(second["points"][0][1], 1.5)
def test_gauge(self):
stats = MetricsAggregator('myhost')
# Track some counters.
stats.submit_packets('my.first.gauge:1|g')
stats.submit_packets('my.first.gauge:5|g')
stats.submit_packets('my.second.gauge:1.5|g')
# Ensure that gauges roll up correctly.
metrics = self.sort_metrics(stats.flush())
assert len(metrics) == 2
first, second = metrics
nt.assert_equals(first['metric'], 'my.first.gauge')
nt.assert_equals(first['points'][0][1], 5)
nt.assert_equals(first['host'], 'myhost')
nt.assert_equals(second['metric'], 'my.second.gauge')
nt.assert_equals(second['points'][0][1], 1.5)
def test_gauge(self):
stats = MetricsAggregator('myhost')
# Track some counters.
stats.submit_packets('my.first.gauge:1|g')
stats.submit_packets('my.first.gauge:5|g')
stats.submit_packets('my.second.gauge:1.5|g')
# Ensure that gauges roll up correctly.
metrics = self.sort_metrics(stats.flush())
assert len(metrics) == 2
first, second = metrics
nt.assert_equals(first['metric'], 'my.first.gauge')
nt.assert_equals(first['points'][0][1], 5)
nt.assert_equals(first['host'], 'myhost')
nt.assert_equals(second['metric'], 'my.second.gauge')
nt.assert_equals(second['points'][0][1], 1.5)
def test_counter_normalization(self):
stats = MetricsAggregator('myhost', interval=10)
# Assert counters are normalized.
stats.submit_packets('int:1|c')
stats.submit_packets('int:4|c')
stats.submit_packets('int:15|c')
stats.submit_packets('float:5|c')
metrics = self.sort_metrics(stats.flush())
assert len(metrics) == 2
floatc, intc = metrics
nt.assert_equal(floatc['metric'], 'float')
nt.assert_equal(floatc['points'][0][1], 0.5)
nt.assert_equal(floatc['host'], 'myhost')
nt.assert_equal(intc['metric'], 'int')
nt.assert_equal(intc['points'][0][1], 2)
nt.assert_equal(intc['host'], 'myhost')
def test_counter_normalization(self):
stats = MetricsAggregator('myhost', interval=10)
# Assert counters are normalized.
stats.submit_packets('int:1|c')
stats.submit_packets('int:4|c')
stats.submit_packets('int:15|c')
stats.submit_packets('float:5|c')
metrics = self.sort_metrics(stats.flush())
assert len(metrics) == 2
floatc, intc = metrics
nt.assert_equal(floatc['metric'], 'float')
nt.assert_equal(floatc['points'][0][1], 0.5)
nt.assert_equal(floatc['host'], 'myhost')
nt.assert_equal(intc['metric'], 'int')
nt.assert_equal(intc['points'][0][1], 2)
nt.assert_equal(intc['host'], 'myhost')
def test_histogram_counter(self):
# Test whether histogram.count == increment
# same deal with a sample rate
cnt = 100000
for run in [1, 2]:
stats = MetricsAggregator('myhost')
for i in xrange(cnt):
if run == 2:
stats.submit_packets('test.counter:1|c|@0.5')
stats.submit_packets('test.hist:1|ms|@0.5')
else:
stats.submit_packets('test.counter:1|c')
stats.submit_packets('test.hist:1|ms')
metrics = self.sort_metrics(stats.flush())
assert len(metrics) > 0
nt.assert_equal([
m['points'][0][1]
for m in metrics if m['metric'] == 'test.counter'
], [cnt * run])
nt.assert_equal([
m['points'][0][1]
for m in metrics if m['metric'] == 'test.hist.count'
], [cnt * run])
