def profile_cpu_bound_program():
real_dog = DogStatsApi()
real_dog.reporter = NullReporter()
fake_dog = NullDogStatsApi()
for type_, dog in [('real', real_dog), ('fake', fake_dog)]:
print('\n\n\nTESTING %s\n\n' % type_)
dog.start()
program = CPUBoundProgram(dog)
yappi.start()
program.run()
yappi.print_stats(sort_type=yappi.SORTTYPE_TSUB, sort_order=yappi.SORTORDER_DESC)
yappi.stop()
yappi.clear_stats()
def test_histogram_percentiles(self):
dog = DogStatsApi()
dog.start(roll_up_interval=10, flush_in_thread=False)
reporter = dog.reporter = MemoryReporter()
# Sample all numbers between 1-100 many times. This
# means our percentiles should be relatively close to themselves.
percentiles = list(range(100))
random.shuffle(percentiles) # in place
for i in percentiles:
for j in range(20):
dog.histogram('percentiles', i, 1000.0)
dog.flush(2000.0)
metrics = reporter.metrics
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), 8)
p75, p85, p95, p99, _, _, _, _ = self.sort_metrics(metrics)
nt.assert_equal(p75['metric'], 'percentiles.75percentile')
nt.assert_equal(p75['points'][0][0], 1000.0)
assert_almost_equal(p75['points'][0][1], 75, 8)
assert_almost_equal(p85['points'][0][1], 85, 8)
assert_almost_equal(p95['points'][0][1], 95, 8)
assert_almost_equal(p99['points'][0][1], 99, 8)
def profile_cpu_bound_program():
real_dog = DogStatsApi()
real_dog.reporter = NullReporter()
fake_dog = NullDogStatsApi()
for type_, dog in [('real', real_dog), ('fake', fake_dog)]:
print('\n\n\nTESTING %s\n\n' % type_)
dog.start()
program = CPUBoundProgram(dog)
yappi.start()
program.run()
yappi.print_stats(sort_type=yappi.SORTTYPE_TSUB,
sort_order=yappi.SORTORDER_DESC)
yappi.stop()
yappi.clear_stats()
def test_disabled_mode(self):
dog = DogStatsApi()
reporter = dog.reporter = MemoryReporter()
dog.start(disabled=True, flush_interval=1, roll_up_interval=1)
dog.gauge('testing', 1, timestamp=1000)
dog.gauge('testing', 2, timestamp=1000)
dog.flush(2000.0)
assert not reporter.metrics
def test_flushing_in_thread(self):
dog = DogStatsApi()
dog.start(roll_up_interval=1,
flush_interval=1,
flush_in_greenlet=True,
api_key=API_KEY)
now = time.time()
dog.gauge('test.dogapi.greenlet.gauge.%s' % now, 3)
dog.increment('test.dogapi.greenlet.counter.%s' % now)
dog.increment('test.dogapi.greenlet.counter.%s' % now)
dog.histogram('test.dogapi.greenlet.histogram.%s' % now, 20)
dog.histogram('test.dogapi.greenlet.histogram.%s' % now, 30)
time.sleep(3)
assert 1 <= dog.flush_count <= 5
def test_default_host_and_device(self):
dog = DogStatsApi()
dog.start(roll_up_interval=1, flush_in_thread=False)
reporter = dog.reporter = MemoryReporter()
dog.gauge('my.gauge', 1, 100.0)
dog.flush(1000)
metric = reporter.metrics[0]
assert not metric['device']
assert metric['host']
def test_custom_host_and_device(self):
dog = DogStatsApi()
dog.start(roll_up_interval=1, flush_in_thread=False, host='host', device='dev')
reporter = dog.reporter = MemoryReporter()
dog.gauge('my.gauge', 1, 100.0)
dog.flush(1000)
metric = reporter.metrics[0]
nt.assert_equal(metric['device'], 'dev')
nt.assert_equal(metric['host'], 'host')
def test_flushing_in_thread(self):
dog = DogStatsApi()
dog.start(roll_up_interval=1,
flush_interval=1,
flush_in_greenlet=True,
api_key=API_KEY)
now = time.time()
dog.gauge('test.dogapi.greenlet.gauge.%s' % now , 3)
dog.increment('test.dogapi.greenlet.counter.%s' % now)
dog.increment('test.dogapi.greenlet.counter.%s' % now)
dog.histogram('test.dogapi.greenlet.histogram.%s' % now, 20)
dog.histogram('test.dogapi.greenlet.histogram.%s' % now, 30)
time.sleep(3)
assert 1 <= dog.flush_count <= 5
def measure_thousands_of_metrics():
dog = DogStatsApi()
dog.start(api_key='apikey_3', api_host="https://app.datad0g.com")
yappi.start()
@dog.timed('timed')
def timed():
pass
for i in range(100):
for j in range(1000):
name = j % 100
dog.gauge('gauge.%s' % name, j)
dog.increment('counter.%s' % name, j)
dog.histogram('histogram.%s' % name, j)
timed()
print('run %s' % i)
yappi.print_stats(sort_type=yappi.SORTTYPE_TSUB,
sort_order=yappi.SORTORDER_DESC)
def measure_thousands_of_metrics():
dog = DogStatsApi()
dog.start(api_key='apikey_3', api_host="https://app.datad0g.com")
yappi.start()
@dog.timed('timed')
def timed():
pass
for i in range(100):
for j in range(1000):
name = j % 100
dog.gauge('gauge.%s' % name, j)
dog.increment('counter.%s' % name, j)
dog.histogram('histogram.%s' % name, j)
timed()
print('run %s' % i)
yappi.print_stats(sort_type=yappi.SORTTYPE_TSUB, sort_order=yappi.SORTORDER_DESC)
def test_timed_decorator(self):
dog = DogStatsApi()
dog.start(roll_up_interval=1, flush_in_thread=False)
reporter = dog.reporter = MemoryReporter()
@dog.timed('timed.test')
def func(a, b, c=1, d=1):
"""docstring"""
return (a, b, c, d)
nt.assert_equal(func.__name__, 'func')
nt.assert_equal(func.__doc__, 'docstring')
result = func(1, 2, d=3)
# Assert it handles args and kwargs correctly.
nt.assert_equal(result, (1, 2, 1, 3))
time.sleep(1) # Argh. I hate this.
dog.flush()
metrics = self.sort_metrics(reporter.metrics)
nt.assert_equal(len(metrics), 8)
(_, _, _, _, avg, count, max_, min_) = metrics
nt.assert_equal(avg['metric'], 'timed.test.avg')
nt.assert_equal(count['metric'], 'timed.test.count')
nt.assert_equal(max_['metric'], 'timed.test.max')
nt.assert_equal(min_['metric'], 'timed.test.min')
def test_threadsafe_correctness(self):
raise SkipTest("Passing on threadsafe for now")
# A test to ensure we flush the expected values
# when we have lots of threads writing to dog api
dog = DogStatsApi()
dog.start(flush_interval=1, roll_up_interval=1)
reporter = dog.reporter = MemoryReporter()
class MetricProducer(threading.Thread):
def id(self):
return threading.current_thread().ident
def run(self):
print('running %s' % self.id())
self.gauges = []
self.count = 0
end_time = time.time() + random.randint(0, 5)
while time.time() < end_time:
m = 'gauge.%s.%s' % (time.time(), self.id())
self.gauges.append(m)
dog.gauge(m, 1)
# Also, increment a counter and ensure it works ok.
dog.increment('metric.count')
self.count += 1
time.sleep(0.01)
# Start writing to dog api in a bunch of threads.
num_threads = 10
threads = [MetricProducer() for i in range(num_threads)]
[t.start() for t in threads]
# Also write a few metrics in the main thread.
expected_gauges = ['gauge.%s' % i for i in range(100)]
for g in expected_gauges:
dog.gauge(g, 1)
print('waiting for threads to finish')
[t.join() for t in threads]
# Wait for the flush/ roll up to complete.
time.sleep(3)
metrics = reporter.metrics
metric_names = sorted((m['metric'] for m in metrics))
#
# Make sure we have the correct number of gauges.
#
for t in threads:
expected_gauges += t.gauges
expected_gauges.sort()
gauges = [m for m in metric_names if 'gauge' in m]
nt.assert_equal(gauges, expected_gauges)
# assert the count is correct
expected_count = sum((t.count for t in threads))
actual_count = (sum((m['points'][0][1] for m in metrics if
m['metric'] == 'metric.count')))
nt.assert_equal(actual_count, expected_count)
def test_histogram_percentiles(self):
dog = DogStatsApi()
dog.start(roll_up_interval=10, flush_in_thread=False)
reporter = dog.reporter = MemoryReporter()
# Sample all numbers between 1-100 many times. This
# means our percentiles should be relatively close to themselves.
percentiles = list(range(100))
random.shuffle(percentiles) # in place
for i in percentiles:
for j in range(20):
dog.histogram('percentiles', i, 1000.0)
dog.flush(2000.0)
metrics = reporter.metrics
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), 8)
p75, p85, p95, p99, _, _, _, _ = self.sort_metrics(metrics)
nt.assert_equal(p75['metric'], 'percentiles.75percentile')
nt.assert_equal(p75['points'][0][0], 1000.0)
assert_almost_equal(p75['points'][0][1], 75, 8)
assert_almost_equal(p85['points'][0][1], 85, 8)
assert_almost_equal(p95['points'][0][1], 95, 8)
assert_almost_equal(p99['points'][0][1], 99, 8)
def test_gauge(self):
# Create some fake metrics.
dog = DogStatsApi()
dog.start(roll_up_interval=10, flush_in_thread=False)
reporter = dog.reporter = MemoryReporter()
dog.gauge('test.gauge.1', 20, 100.0)
dog.gauge('test.gauge.1', 22, 105.0)
dog.gauge('test.gauge.2', 30, 115.0)
dog.gauge('test.gauge.3', 30, 125.0)
dog.flush(120.0)
# Assert they've been properly flushed.
metrics = self.sort_metrics(reporter.metrics)
nt.assert_equal(len(metrics), 2)
(first, second) = metrics
nt.assert_equal(first['metric'], 'test.gauge.1')
nt.assert_equal(first['points'][0][0], 100.0)
nt.assert_equal(first['points'][0][1], 22)
nt.assert_equal(second['metric'], 'test.gauge.2')
# Flush again and make sure we're progressing.
reporter.metrics = []
dog.flush(130.0)
nt.assert_equal(len(reporter.metrics), 1)
# Finally, make sure we've flushed all metrics.
reporter.metrics = []
dog.flush(150.0)
nt.assert_equal(len(reporter.metrics), 0)
def test_stop(self):
dog = DogStatsApi()
reporter = dog.reporter = MemoryReporter()
dog.start(flush_interval=1, roll_up_interval=1)
for i in range(10):
dog.gauge('metric', i)
time.sleep(2)
flush_count = dog.flush_count
assert flush_count
dog.stop()
for i in range(10):
dog.gauge('metric', i)
time.sleep(2)
for i in range(10):
dog.gauge('metric', i)
time.sleep(2)
assert dog.flush_count in [flush_count, flush_count+1]
def test_host(self):
dog = DogStatsApi()
dog.start(roll_up_interval=10, flush_in_thread=False, host='default')
reporter = dog.reporter = MemoryReporter()
# Post the same metric with different tags.
dog.gauge('gauge', 12, timestamp=100.0, host='') # unset the host
dog.gauge('gauge', 10, timestamp=100.0)
dog.gauge('gauge', 15, timestamp=100.0, host='test')
dog.gauge('gauge', 15, timestamp=100.0, host='test')
dog.increment('counter', timestamp=100.0)
dog.increment('counter', timestamp=100.0)
dog.increment('counter', timestamp=100.0, host='test')
dog.increment('counter', timestamp=100.0, host='test', tags=['tag'])
dog.increment('counter', timestamp=100.0, host='test', tags=['tag'])
dog.flush(200.0)
metrics = self.sort_metrics(reporter.metrics)
nt.assert_equal(len(metrics), 6)
[c1, c2, c3, g1, g2, g3] = metrics
(nt.assert_equal(c['metric'], 'counter') for c in [c1, c2, c3])
nt.assert_equal(c1['host'], 'default')
nt.assert_equal(c1['tags'], None)
nt.assert_equal(c1['points'][0][1], 2)
nt.assert_equal(c2['host'], 'test')
nt.assert_equal(c2['tags'], None)
nt.assert_equal(c2['points'][0][1], 1)
nt.assert_equal(c3['host'], 'test')
nt.assert_equal(c3['tags'], ['tag'])
nt.assert_equal(c3['points'][0][1], 2)
(nt.assert_equal(g['metric'], 'gauge') for g in [g1, g2, g3])
nt.assert_equal(g1['host'], '')
nt.assert_equal(g1['points'][0][1], 12)
nt.assert_equal(g2['host'], 'default')
nt.assert_equal(g2['points'][0][1], 10)
nt.assert_equal(g3['host'], 'test')
nt.assert_equal(g3['points'][0][1], 15)
# Ensure histograms work as well.
@dog.timed('timed', host='test')
def test():
pass
test()
dog.histogram('timed', 20, timestamp=300.0, host='test')
reporter.metrics = []
dog.flush(400)
for metric in reporter.metrics:
assert metric['host'] == 'test'
def test_tags(self):
dog = DogStatsApi()
dog.start(roll_up_interval=10, flush_in_thread=False)
reporter = dog.reporter = MemoryReporter()
# Post the same metric with different tags.
dog.gauge('gauge', 10, timestamp=100.0)
dog.gauge('gauge', 15, timestamp=100.0, tags=['env:production', 'db'])
dog.gauge('gauge', 20, timestamp=100.0, tags=['env:staging'])
dog.increment('counter', timestamp=100.0)
dog.increment('counter', timestamp=100.0, tags=['env:production', 'db'])
dog.increment('counter', timestamp=100.0, tags=['env:staging'])
dog.flush(200.0)
metrics = self.sort_metrics(reporter.metrics)
nt.assert_equal(len(metrics), 6)
[c1, c2, c3, g1, g2, g3] = metrics
(nt.assert_equal(c['metric'], 'counter') for c in [c1, c2, c3])
nt.assert_equal(c1['tags'], None)
nt.assert_equal(c1['points'][0][1], 1)
nt.assert_equal(c2['tags'], ['env:production', 'db'])
nt.assert_equal(c2['points'][0][1], 1)
nt.assert_equal(c3['tags'], ['env:staging'])
nt.assert_equal(c3['points'][0][1], 1)
(nt.assert_equal(c['metric'], 'gauge') for c in [g1, g2, g3])
nt.assert_equal(g1['tags'], None)
nt.assert_equal(g1['points'][0][1], 10)
nt.assert_equal(g2['tags'], ['env:production', 'db'])
nt.assert_equal(g2['points'][0][1], 15)
nt.assert_equal(g3['tags'], ['env:staging'])
nt.assert_equal(g3['points'][0][1], 20)
# Ensure histograms work as well.
@dog.timed('timed', tags=['version:1'])
def test():
pass
test()
dog.histogram('timed', 20, timestamp=300.0, tags=['db', 'version:2'])
reporter.metrics = []
dog.flush(400)
for metric in reporter.metrics:
assert metric['tags'] # this is enough
def test_histogram(self):
dog = DogStatsApi()
dog.start(roll_up_interval=10, flush_in_thread=False)
reporter = dog.reporter = MemoryReporter()
# Add some histogram metrics.
dog.histogram('histogram.1', 20, 100.0)
dog.histogram('histogram.1', 30, 105.0)
dog.histogram('histogram.1', 40, 106.0)
dog.histogram('histogram.1', 50, 106.0)
dog.histogram('histogram.1', 30, 110.0)
dog.histogram('histogram.1', 50, 115.0)
dog.histogram('histogram.1', 40, 116.0)
dog.histogram('histogram.2', 40, 100.0)
dog.histogram('histogram.3', 50, 134.0)
# Flush and ensure they roll up properly.
dog.flush(120.0)
metrics = self.sort_metrics(reporter.metrics)
nt.assert_equal(len(metrics), 24)
# Test histograms elsewhere.
(h1751, h1851, h1951, h1991, h1avg1, h1cnt1, h1max1, h1min1,
_, _, _, _, h2avg1, h2cnt1, h2max1, h2min1,
h1752, _, _, h1992, h1avg2, h1cnt2, h1max2, h1min2) = metrics
nt.assert_equal(h1avg1['metric'], 'histogram.1.avg')
nt.assert_equal(h1avg1['points'][0][0], 100.0)
nt.assert_equal(h1avg1['points'][0][1], 35)
nt.assert_equal(h1cnt1['metric'], 'histogram.1.count')
nt.assert_equal(h1cnt1['points'][0][0], 100.0)
nt.assert_equal(h1cnt1['points'][0][1], 4)
nt.assert_equal(h1min1['metric'], 'histogram.1.min')
nt.assert_equal(h1min1['points'][0][1], 20)
nt.assert_equal(h1max1['metric'], 'histogram.1.max')
nt.assert_equal(h1max1['points'][0][1], 50)
nt.assert_equal(h1751['metric'], 'histogram.1.75percentile')
nt.assert_equal(h1751['points'][0][1], 40)
nt.assert_equal(h1991['metric'], 'histogram.1.99percentile')
nt.assert_equal(h1991['points'][0][1], 50)
nt.assert_equal(h1avg2['metric'], 'histogram.1.avg')
nt.assert_equal(h1avg2['points'][0][0], 110.0)
nt.assert_equal(h1avg2['points'][0][1], 40)
nt.assert_equal(h1cnt2['metric'], 'histogram.1.count')
nt.assert_equal(h1cnt2['points'][0][0], 110.0)
nt.assert_equal(h1cnt2['points'][0][1], 3)
nt.assert_equal(h1752['metric'], 'histogram.1.75percentile')
nt.assert_equal(h1752['points'][0][0], 110.0)
nt.assert_equal(h1752['points'][0][1], 40.0)
nt.assert_equal(h1992['metric'], 'histogram.1.99percentile')
nt.assert_equal(h1992['points'][0][0], 110.0)
nt.assert_equal(h1992['points'][0][1], 50.0)
nt.assert_equal(h2avg1['metric'], 'histogram.2.avg')
nt.assert_equal(h2avg1['points'][0][0], 100.0)
nt.assert_equal(h2avg1['points'][0][1], 40)
nt.assert_equal(h2cnt1['metric'], 'histogram.2.count')
nt.assert_equal(h2cnt1['points'][0][0], 100.0)
nt.assert_equal(h2cnt1['points'][0][1], 1)
# Flush again ensure they're gone.
dog.reporter.metrics = []
dog.flush(140.0)
nt.assert_equal(len(dog.reporter.metrics), 8)
dog.reporter.metrics = []
dog.flush(200.0)
nt.assert_equal(len(dog.reporter.metrics), 0)
def test_counter(self):
# Create some fake metrics.
dog = DogStatsApi()
dog.start(roll_up_interval=10, flush_in_thread=False)
reporter = dog.reporter = MemoryReporter()
dog.increment('test.counter.1', timestamp=1000.0)
dog.increment('test.counter.1', value=2, timestamp=1005.0)
dog.increment('test.counter.2', timestamp=1015.0)
dog.increment('test.counter.3', timestamp=1025.0)
dog.flush(1021.0)
# Assert they've been properly flushed.
metrics = self.sort_metrics(reporter.metrics)
nt.assert_equal(len(metrics), 2)
(first, second) = metrics
nt.assert_equal(first['metric'], 'test.counter.1')
nt.assert_equal(first['points'][0][0], 1000.0)
nt.assert_equal(first['points'][0][1], 3)
nt.assert_equal(second['metric'], 'test.counter.2')
# Flush again and make sure we're progressing.
reporter.metrics = []
dog.flush(1030.0)
nt.assert_equal(len(reporter.metrics), 1)
# Finally, make sure we've flushed all metrics.
reporter.metrics = []
dog.flush(1050.0)
nt.assert_equal(len(reporter.metrics), 0)
