class DatadogMiddleware(object):
DD_TIMING_ATTRIBUTE = '_dd_start_time'
def __init__(self):
app_name = settings.DATADOG_APP_NAME
self.stats = ThreadStats()
self.stats.start()
self.error_metric = '{0}.errors'.format(app_name)
self.timing_metric = '{0}.request_time'.format(app_name)
self.event_tags = [app_name, 'exception']
def process_request(self, request):
setattr(request, self.DD_TIMING_ATTRIBUTE, time.time())
def process_response(self, request, response):
""" Submit timing metrics from the current request """
if not hasattr(request, self.DD_TIMING_ATTRIBUTE):
return response
# Calculate request time and submit to Datadog
request_time = time.time() - getattr(request, self.DD_TIMING_ATTRIBUTE)
tags = self._get_metric_tags(request)
self.stats.histogram(self.timing_metric, request_time, tags=tags)
return response
def process_exception(self, request, exception):
""" Captures Django view exceptions as Datadog events """
if isinstance(exception, Http404):
# Don't report 404 not found
return
# Get a formatted version of the traceback.
exc = traceback.format_exc()
# Make request.META json-serializable.
szble = {}
for k, v in request.META.items():
if isinstance(v, (list, basestring, bool, int, float, long)):
szble[k] = v
else:
szble[k] = str(v)
title = 'Exception from {0}'.format(request.path)
text = "Traceback:\n@@@\n{0}\n@@@\nMetadata:\n@@@\n{1}\n@@@" \
.format(exc, json.dumps(szble, indent=2))
# Submit the exception to Datadog
self.stats.event(title,
text,
alert_type='error',
aggregation_key=request.path,
tags=self.event_tags)
# Increment our errors metric
tags = self._get_metric_tags(request)
self.stats.increment(self.error_metric, tags=tags)
def _get_metric_tags(self, request):
return ['path:{0}'.format(request.path)]
def test_histogram_percentiles(self):
dog = ThreadStats()
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_metric_type(self):
"""
Checks the submitted metric's metric type.
"""
# Set up ThreadStats with a namespace
dog = ThreadStats(namespace="foo")
dog.start(roll_up_interval=1, flush_in_thread=False)
reporter = dog.reporter = self.reporter
# Send a few metrics
dog.gauge("gauge", 20, timestamp=100.0)
dog.increment("counter", timestamp=100.0)
dog.histogram('histogram.1', 20, 100.0)
dog.flush(200.0)
(first, second, p75, p85, p95, p99, avg, cnt, max_,
min_) = self.sort_metrics(reporter.metrics)
# Assert Metric type
nt.assert_equal(first['type'], 'rate')
nt.assert_equal(second['type'], 'gauge')
nt.assert_equal(p75['type'], 'gauge')
nt.assert_equal(p85['type'], 'gauge')
nt.assert_equal(p95['type'], 'gauge')
nt.assert_equal(p99['type'], 'gauge')
nt.assert_equal(avg['type'], 'gauge')
nt.assert_equal(cnt['type'], 'rate')
nt.assert_equal(max_['type'], 'gauge')
nt.assert_equal(min_['type'], 'gauge')
def test_histogram_percentiles(self):
dog = ThreadStats()
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_host(self):
dog = ThreadStats()
dog.start(roll_up_interval=10, flush_in_thread=False)
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)
assert len(metrics) == 6
[c1, c2, c3, g1, g2, g3] = metrics
assert c1['metric'] == 'counter'
assert c2['metric'] == 'counter'
assert c3['metric'] == 'counter'
assert c1['host'] is None
assert c1['tags'] is None
assert c1['points'][0][1] == 0.2
assert c2['host'] == 'test'
assert c2['tags'] is None
assert c2['points'][0][1] == 0.1
assert c3['host'] == 'test'
assert c3['tags'] == ['tag']
assert c3['points'][0][1] == 0.2
assert g1['metric'] == 'gauge'
assert g2['metric'] == 'gauge'
assert g3['metric'] == 'gauge'
assert g1['host'] is None
assert g1['points'][0][1] == 10
assert g2['host'] == ''
assert g2['points'][0][1] == 12
assert g3['host'] == 'test'
assert 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'
class DatadogMiddleware(object):
DD_TIMING_ATTRIBUTE = '_dd_start_time'
def __init__(self):
app_name = settings.DATADOG_APP_NAME
self.stats = ThreadStats()
self.stats.start()
self.error_metric = '{0}.errors'.format(app_name)
self.timing_metric = '{0}.request_time'.format(app_name)
self.event_tags = [app_name, 'exception']
def process_request(self, request):
setattr(request, self.DD_TIMING_ATTRIBUTE, time.time())
def process_response(self, request, response):
""" Submit timing metrics from the current request """
if not hasattr(request, self.DD_TIMING_ATTRIBUTE):
return response
# Calculate request time and submit to Datadog
request_time = time.time() - getattr(request, self.DD_TIMING_ATTRIBUTE)
tags = self._get_metric_tags(request)
self.stats.histogram(self.timing_metric, request_time, tags=tags)
return response
def process_exception(self, request, exception):
""" Captures Django view exceptions as Datadog events """
if isinstance(exception, Http404):
# Don't report 404 not found
return
# Get a formatted version of the traceback.
exc = traceback.format_exc()
# Make request.META json-serializable.
szble = {}
for k, v in request.META.items():
if isinstance(v, (list, basestring, bool, int, float, long)):
szble[k] = v
else:
szble[k] = str(v)
title = 'Exception from {0}'.format(request.path)
text = "Traceback:\n@@@\n{0}\n@@@\nMetadata:\n@@@\n{1}\n@@@" \
.format(exc, json.dumps(szble, indent=2))
# Submit the exception to Datadog
self.stats.event(title, text, alert_type='error', aggregation_key=request.path, tags=self.event_tags)
# Increment our errors metric
tags = self._get_metric_tags(request)
self.stats.increment(self.error_metric, tags=tags)
def _get_metric_tags(self, request):
return ['path:{0}'.format(request.path)]
def test_constant_tags(self):
"""
Constant tags are attached to all metrics.
"""
dog = ThreadStats(constant_tags=["type:constant"])
dog.start(roll_up_interval=1, flush_in_thread=False)
dog.reporter = self.reporter
# 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)
# Assertions on all metrics
self.assertMetric(count=6)
# Assertions on gauges
self.assertMetric(name='gauge', value=10, tags=["type:constant"], count=1)
self.assertMetric(name="gauge", value=15,
tags=["env:production", "db", "type:constant"], count=1) # noqa
self.assertMetric(name="gauge", value=20, tags=["env:staging", "type:constant"], count=1)
# Assertions on counters
self.assertMetric(name="counter", value=1, tags=["type:constant"], count=1)
self.assertMetric(name="counter", value=1,
tags=["env:production", "db", "type:constant"], count=1) # noqa
self.assertMetric(name="counter", value=1, tags=["env:staging", "type:constant"], count=1)
# Ensure histograms work as well.
@dog.timed('timed', tags=['version:1'])
def do_nothing():
"""
A function that does nothing, but being timed.
"""
pass
with patch("datadog.threadstats.base.time", return_value=300):
do_nothing()
dog.histogram('timed', 20, timestamp=300.0, tags=['db', 'version:2'])
self.reporter.metrics = []
dog.flush(400.0)
# Histograms, and related metric types, produce 8 different metrics
self.assertMetric(tags=["version:1", "type:constant"], count=8)
self.assertMetric(tags=["db", "version:2", "type:constant"], count=8)
def test_host(self):
dog = ThreadStats()
dog.start(roll_up_interval=10, flush_in_thread=False)
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'], None)
nt.assert_equal(c1['tags'], None)
nt.assert_equal(c1['points'][0][1], 0.2)
nt.assert_equal(c2['host'], 'test')
nt.assert_equal(c2['tags'], None)
nt.assert_equal(c2['points'][0][1], 0.1)
nt.assert_equal(c3['host'], 'test')
nt.assert_equal(c3['tags'], ['tag'])
nt.assert_equal(c3['points'][0][1], 0.2)
(nt.assert_equal(g['metric'], 'gauge') for g in [g1, g2, g3])
nt.assert_equal(g1['host'], None)
nt.assert_equal(g1['points'][0][1], 10)
nt.assert_equal(g2['host'], '')
nt.assert_equal(g2['points'][0][1], 12)
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_host(self):
dog = ThreadStats()
dog.start(roll_up_interval=10, flush_in_thread=False)
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"], None)
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"], None)
nt.assert_equal(g1["points"][0][1], 10)
nt.assert_equal(g2["host"], "")
nt.assert_equal(g2["points"][0][1], 12)
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_host(self):
dog = ThreadStats()
dog.start(roll_up_interval=10, flush_in_thread=False)
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'], None)
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'], None)
nt.assert_equal(g1['points'][0][1], 10)
nt.assert_equal(g2['host'], '')
nt.assert_equal(g2['points'][0][1], 12)
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_constant_tags(self):
"""
Constant tags are attached to all metrics.
"""
dog = ThreadStats(constant_tags=["type:constant"])
dog.start(roll_up_interval=1, flush_in_thread=False)
dog.reporter = self.reporter
# 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)
# Assertions on all metrics
self.assertMetric(count=6)
# Assertions on gauges
self.assertMetric(name='gauge', value=10, tags=["type:constant"], count=1)
self.assertMetric(name="gauge", value=15, tags=["env:production", "db", "type:constant"], count=1) # noqa
self.assertMetric(name="gauge", value=20, tags=["env:staging", "type:constant"], count=1)
# Assertions on counters
self.assertMetric(name="counter", value=1, tags=["type:constant"], count=1)
self.assertMetric(name="counter", value=1, tags=["env:production", "db", "type:constant"], count=1) # noqa
self.assertMetric(name="counter", value=1, tags=["env:staging", "type:constant"], count=1)
# Ensure histograms work as well.
@dog.timed('timed', tags=['version:1'])
def do_nothing():
"""
A function that does nothing, but being timed.
"""
pass
with patch("datadog.threadstats.base.time", return_value=300):
do_nothing()
dog.histogram('timed', 20, timestamp=300.0, tags=['db', 'version:2'])
self.reporter.metrics = []
dog.flush(400.0)
# Histograms, and related metric types, produce 8 different metrics
self.assertMetric(tags=["version:1", "type:constant"], count=8)
self.assertMetric(tags=["db", "version:2", "type:constant"], count=8)
def test_constant_tags(self):
dog = ThreadStats(constant_tags=['type:constant'])
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'], ['env:production', 'db', 'type:constant'])
nt.assert_equal(c1['points'][0][1], 1)
nt.assert_equal(c2['tags'], ['env:staging', 'type:constant'])
nt.assert_equal(c2['points'][0][1], 1)
nt.assert_equal(c3['tags'], ['type:constant'])
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'], ['env:production', 'db', 'type:constant'])
nt.assert_equal(g1['points'][0][1], 15)
nt.assert_equal(g2['tags'], ['env:staging', 'type:constant'])
nt.assert_equal(g2['points'][0][1], 20)
nt.assert_equal(g3['tags'], ['type:constant'])
nt.assert_equal(g3['points'][0][1], 10)
# 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_constant_tags(self):
dog = ThreadStats(constant_tags=["type:constant"])
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"], ["env:production", "db", "type:constant"])
nt.assert_equal(c1["points"][0][1], 1)
nt.assert_equal(c2["tags"], ["env:staging", "type:constant"])
nt.assert_equal(c2["points"][0][1], 1)
nt.assert_equal(c3["tags"], ["type:constant"])
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"], ["env:production", "db", "type:constant"])
nt.assert_equal(g1["points"][0][1], 15)
nt.assert_equal(g2["tags"], ["env:staging", "type:constant"])
nt.assert_equal(g2["points"][0][1], 20)
nt.assert_equal(g3["tags"], ["type:constant"])
nt.assert_equal(g3["points"][0][1], 10)
# 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_constant_tags(self):
dog = ThreadStats(constant_tags=['type:constant'])
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'], ['env:production', 'db', 'type:constant'])
nt.assert_equal(c1['points'][0][1], 1)
nt.assert_equal(c2['tags'], ['env:staging', 'type:constant'])
nt.assert_equal(c2['points'][0][1], 1)
nt.assert_equal(c3['tags'], ['type:constant'])
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'], ['env:production', 'db', 'type:constant'])
nt.assert_equal(g1['points'][0][1], 15)
nt.assert_equal(g2['tags'], ['env:staging', 'type:constant'])
nt.assert_equal(g2['points'][0][1], 20)
nt.assert_equal(g3['tags'], ['type:constant'])
nt.assert_equal(g3['points'][0][1], 10)
# 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 = ThreadStats()
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], 0.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], 0.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], 0.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_histogram(self):
dog = ThreadStats()
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)
assert 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
assert h1avg1['metric'] == 'histogram.1.avg'
assert h1avg1['points'][0][0] == 100.0
assert h1avg1['points'][0][1] == 35
assert h1cnt1['metric'] == 'histogram.1.count'
assert h1cnt1['points'][0][0] == 100.0
assert h1cnt1['points'][0][1] == 0.4
assert h1min1['metric'] == 'histogram.1.min'
assert h1min1['points'][0][1] == 20
assert h1max1['metric'] == 'histogram.1.max'
assert h1max1['points'][0][1] == 50
assert h1751['metric'] == 'histogram.1.75percentile'
assert h1751['points'][0][1] == 40
assert h1991['metric'] == 'histogram.1.99percentile'
assert h1991['points'][0][1] == 50
assert h1avg2['metric'] == 'histogram.1.avg'
assert h1avg2['points'][0][0] == 110.0
assert h1avg2['points'][0][1] == 40
assert h1cnt2['metric'] == 'histogram.1.count'
assert h1cnt2['points'][0][0] == 110.0
assert h1cnt2['points'][0][1] == 0.3
assert h1752['metric'] == 'histogram.1.75percentile'
assert h1752['points'][0][0] == 110.0
assert h1752['points'][0][1] == 40.0
assert h1992['metric'] == 'histogram.1.99percentile'
assert h1992['points'][0][0] == 110.0
assert h1992['points'][0][1] == 50.0
assert h2avg1['metric'] == 'histogram.2.avg'
assert h2avg1['points'][0][0] == 100.0
assert h2avg1['points'][0][1] == 40
assert h2cnt1['metric'] == 'histogram.2.count'
assert h2cnt1['points'][0][0] == 100.0
assert h2cnt1['points'][0][1] == 0.1
# Flush again ensure they're gone.
dog.reporter.metrics = []
dog.flush(140.0)
assert len(dog.reporter.metrics) == 8
dog.reporter.metrics = []
dog.flush(200.0)
assert len(dog.reporter.metrics) == 0
def test_histogram(self):
dog = ThreadStats()
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)