From 1a5e5c394052c6708d8d8535e16c0e9565185e5e Mon Sep 17 00:00:00 2001 From: Hippolyte HENRY Date: Mon, 10 Feb 2020 18:23:12 +0100 Subject: [PATCH] Revert dogstatsd telemetry --- .gitignore | 1 - README.md | 7 -- datadog/dogstatsd/base.py | 91 +++------------ tests/unit/dogstatsd/test_statsd.py | 172 ++++++++-------------------- 4 files changed, 60 insertions(+), 211 deletions(-) diff --git a/.gitignore b/.gitignore index 549e0f33e..88709193e 100644 --- a/.gitignore +++ b/.gitignore @@ -42,4 +42,3 @@ pip-log.txt .eggs/ .env/ .idea/ -*.swp diff --git a/README.md b/README.md index 695dc7eb0..4b8b370c1 100644 --- a/README.md +++ b/README.md @@ -126,13 +126,6 @@ After the client is created, you can start sending events to your Datadog Event After the client is created, you can start sending Service Checks to Datadog. See the dedicated [Service Check Submission: DogStatsD documentation](https://docs.datadoghq.com/developers/service_checks/dogstatsd_service_checks_submission/?tab=python) to see how to submit a Service Check to Datadog. -### Monitoring this client - -This client automatically injects telemetry about itself in the DogStatsD stream. -Those metrics will not be counted as custom and will not be billed. This feature can be disabled using the `statsd.disable_telemetry()` method. - -See [Telemetry documentation](https://docs.datadoghq.com/developers/dogstatsd/high_throughput/?tab=python#client-side-telemetry) to learn more about it. - ## Thread Safety `DogStatsD` and `ThreadStats` are thread-safe. diff --git a/datadog/dogstatsd/base.py b/datadog/dogstatsd/base.py index 36bd08eaa..8af35c48e 100644 --- a/datadog/dogstatsd/base.py +++ b/datadog/dogstatsd/base.py @@ -18,7 +18,6 @@ from datadog.dogstatsd.context import TimedContextManagerDecorator from datadog.dogstatsd.route import get_default_route from datadog.util.compat import text -from datadog.util.config import get_version # Logging log = logging.getLogger('datadog.dogstatsd') @@ -36,7 +35,7 @@ class DogStatsd(object): def __init__(self, host=DEFAULT_HOST, port=DEFAULT_PORT, max_buffer_size=50, namespace=None, constant_tags=None, use_ms=False, use_default_route=False, - socket_path=None, default_sample_rate=1, disable_telemetry=False): + socket_path=None, default_sample_rate=1): """ Initialize a DogStatsd object. @@ -107,12 +106,10 @@ def __init__(self, host=DEFAULT_HOST, port=DEFAULT_PORT, max_buffer_size=50, nam self.socket_path = socket_path self.host = None self.port = None - transport = "uds" else: self.socket_path = None self.host = self.resolve_host(host, use_default_route) self.port = int(port) - transport = "udp" # Socket self.socket = None @@ -135,21 +132,6 @@ def __init__(self, host=DEFAULT_HOST, port=DEFAULT_PORT, max_buffer_size=50, nam self.use_ms = use_ms self.default_sample_rate = default_sample_rate - # init telemetry - self._client_tags = [ - "client:py", - "client_version:{}".format(get_version()), - "client_transport:{}".format(transport), - ] - self._reset_telementry() - self._telemetry = not disable_telemetry - - def disable_telemetry(self): - self._telemetry = False - - def enable_telemetry(self): - self._telemetry = True - def __enter__(self): self.open_buffer(self.max_buffer_size) return self @@ -321,17 +303,6 @@ def close_socket(self): log.error("Unexpected error: %s", str(e)) self.socket = None - def _serialize_metric(self, metric, metric_type, value, tags, sample_rate=1): - # Create/format the metric packet - return "%s%s:%s|%s%s%s" % ( - (self.namespace + ".") if self.namespace else "", - metric, - value, - metric_type, - ("|@" + text(sample_rate)) if sample_rate != 1 else "", - ("|#" + ",".join(tags)) if tags else "", - ) - def _report(self, metric, metric_type, value, tags, sample_rate): """ Create a metric packet and send it. @@ -341,9 +312,6 @@ def _report(self, metric, metric_type, value, tags, sample_rate): if value is None: return - if self._telemetry: - self.metrics_count += 1 - if sample_rate is None: sample_rate = self.default_sample_rate @@ -352,53 +320,27 @@ def _report(self, metric, metric_type, value, tags, sample_rate): # Resolve the full tag list tags = self._add_constant_tags(tags) - payload = self._serialize_metric(metric, metric_type, value, tags, sample_rate) + + # Create/format the metric packet + payload = "%s%s:%s|%s%s%s" % ( + (self.namespace + ".") if self.namespace else "", + metric, + value, + metric_type, + ("|@" + text(sample_rate)) if sample_rate != 1 else "", + ("|#" + ",".join(tags)) if tags else "", + ) # Send it self._send(payload) - def _reset_telementry(self): - self.metrics_count = 0 - self.events_count = 0 - self.service_checks_count = 0 - self.bytes_sent = 0 - self.bytes_dropped = 0 - self.packets_sent = 0 - self.packets_dropped = 0 - - def _flush_telemetry(self): - telemetry_tags = self._add_constant_tags(self._client_tags) - return "\n%s\n%s\n%s\n%s\n%s\n%s\n%s" % ( - self._serialize_metric("datadog.dogstatsd.client.metrics", - "c", self.metrics_count, telemetry_tags), - self._serialize_metric("datadog.dogstatsd.client.events", - "c", self.events_count, telemetry_tags), - self._serialize_metric("datadog.dogstatsd.client.service_checks", - "c", self.service_checks_count, telemetry_tags), - self._serialize_metric("datadog.dogstatsd.client.bytes_sent", - "c", self.bytes_sent, telemetry_tags), - self._serialize_metric("datadog.dogstatsd.client.bytes_dropped", - "c", self.bytes_dropped, telemetry_tags), - self._serialize_metric("datadog.dogstatsd.client.packets_sent", - "c", self.packets_sent, telemetry_tags), - self._serialize_metric("datadog.dogstatsd.client.packets_dropped", - "c", self.packets_dropped, telemetry_tags), - ) - def _send_to_server(self, packet): - if self._telemetry: - packet += self._flush_telemetry() try: # If set, use socket directly (self.socket or self.get_socket()).send(packet.encode(self.encoding)) - if self._telemetry: - self._reset_telementry() - self.packets_sent += 1 - self.bytes_sent += len(packet) - return except socket.timeout: # dogstatsd is overflowing, drop the packets (mimicks the UDP behaviour) - pass + return except (socket.herror, socket.gaierror) as se: log.warning("Error submitting packet: {}, dropping the packet and closing the socket".format(se)) self.close_socket() @@ -410,10 +352,7 @@ def _send_to_server(self, packet): self.close_socket() except Exception as e: log.error("Unexpected error: %s", str(e)) - - if self._telemetry: - self.bytes_dropped += len(packet) - self.packets_dropped += 1 + return def _send_to_buffer(self, packet): self.buffer.append(packet) @@ -466,8 +405,6 @@ def event(self, title, text, alert_type=None, aggregation_key=None, raise Exception(u'Event "%s" payload is too big (more than 8KB), ' 'event discarded' % title) - if self._telemetry: - self.events_count += 1 self._send(string) def service_check(self, check_name, status, tags=None, timestamp=None, @@ -493,8 +430,6 @@ def service_check(self, check_name, status, tags=None, timestamp=None, if message: string = u'{0}|m:{1}'.format(string, message) - if self._telemetry: - self.service_checks_count += 1 self._send(string) def _add_constant_tags(self, tags): diff --git a/tests/unit/dogstatsd/test_statsd.py b/tests/unit/dogstatsd/test_statsd.py index 4e516aab9..367224a58 100644 --- a/tests/unit/dogstatsd/test_statsd.py +++ b/tests/unit/dogstatsd/test_statsd.py @@ -26,7 +26,6 @@ from datadog.dogstatsd.base import DogStatsd from datadog.dogstatsd.context import TimedContextManagerDecorator from datadog.util.compat import is_higher_py35, is_p3k -from datadog.util.config import get_version from tests.util.contextmanagers import preserve_environment_variable from tests.unit.dogstatsd.fixtures import load_fixtures @@ -70,30 +69,11 @@ def send(self, payload): class OverflownSocket(FakeSocket): def send(self, payload): - error = socker.error("Socker error") + error = socket.error("Socker error") error.errno = errno.EAGAIN raise error -def telemetry_metrics(metrics=1, events=0, service_checks=0, bytes_sent=0, bytes_dropped=0, packets_sent=0, packets_dropped=0, transport="udp", tags="", namespace=""): - version = get_version() - if tags: - tags = "," + tags - - return "\n{}datadog.dogstatsd.client.metrics:{}|c|#client:py,client_version:{},client_transport:{}{}\n".format(namespace, metrics, version, transport, tags) \ - + "{}datadog.dogstatsd.client.events:{}|c|#client:py,client_version:{},client_transport:{}{}\n".format(namespace, events, version, transport, tags) \ - + "{}datadog.dogstatsd.client.service_checks:{}|c|#client:py,client_version:{},client_transport:{}{}\n".format(namespace, service_checks, version, transport, tags) \ - + "{}datadog.dogstatsd.client.bytes_sent:{}|c|#client:py,client_version:{},client_transport:{}{}\n".format(namespace, bytes_sent, version, transport, tags) \ - + "{}datadog.dogstatsd.client.bytes_dropped:{}|c|#client:py,client_version:{},client_transport:{}{}\n".format(namespace, bytes_dropped, version, transport, tags) \ - + "{}datadog.dogstatsd.client.packets_sent:{}|c|#client:py,client_version:{},client_transport:{}{}\n".format(namespace, packets_sent, version, transport, tags) \ - + "{}datadog.dogstatsd.client.packets_dropped:{}|c|#client:py,client_version:{},client_transport:{}{}".format(namespace, packets_dropped, version, transport, tags) - -def assert_equal_telemetry(expected_payload, actual_payload, telemetry=None): - if telemetry is None: - telemetry = telemetry_metrics() - expected_payload += telemetry - return assert_equal(expected_payload, actual_payload) - class TestDogStatsd(unittest.TestCase): def setUp(self): @@ -109,9 +89,6 @@ def setUp(self): self._procfs_mock = patch('datadog.util.compat.builtins.open', mock_open()) self._procfs_mock.__enter__().return_value.readlines.return_value = route_data.split("\n") - #def setup_method(self, method): - # self.statsd._reset_telementry() - def tearDown(self): """ Unmock the proc filesystem. @@ -186,46 +163,42 @@ def test_default_route(self): def test_set(self): self.statsd.set('set', 123) - assert_equal_telemetry('set:123|s', self.recv()) + assert self.recv() == 'set:123|s' def test_gauge(self): self.statsd.gauge('gauge', 123.4) - assert_equal_telemetry('gauge:123.4|g', self.recv()) + assert self.recv() == 'gauge:123.4|g' def test_counter(self): self.statsd.increment('page.views') - assert_equal_telemetry('page.views:1|c', self.recv()) + assert_equal('page.views:1|c', self.recv()) - self.statsd._reset_telementry() self.statsd.increment('page.views', 11) - assert_equal_telemetry('page.views:11|c', self.recv()) + assert_equal('page.views:11|c', self.recv()) - self.statsd._reset_telementry() self.statsd.decrement('page.views') - assert_equal_telemetry('page.views:-1|c', self.recv()) + assert_equal('page.views:-1|c', self.recv()) - self.statsd._reset_telementry() self.statsd.decrement('page.views', 12) - assert_equal_telemetry('page.views:-12|c', self.recv()) + assert_equal('page.views:-12|c', self.recv()) def test_histogram(self): self.statsd.histogram('histo', 123.4) - assert_equal_telemetry('histo:123.4|h', self.recv()) + assert_equal('histo:123.4|h', self.recv()) def test_tagged_gauge(self): self.statsd.gauge('gt', 123.4, tags=['country:china', 'age:45', 'blue']) - assert_equal_telemetry('gt:123.4|g|#country:china,age:45,blue', self.recv()) + assert_equal('gt:123.4|g|#country:china,age:45,blue', self.recv()) def test_tagged_counter(self): self.statsd.increment('ct', tags=[u'country:españa', 'red']) - assert_equal_telemetry(u'ct:1|c|#country:españa,red', self.recv()) + assert_equal(u'ct:1|c|#country:españa,red', self.recv()) def test_tagged_histogram(self): self.statsd.histogram('h', 1, tags=['red']) - assert_equal_telemetry('h:1|h|#red', self.recv()) + assert_equal('h:1|h|#red', self.recv()) def test_sample_rate(self): - self.statsd._telemetry = False # disabling telemetry since sample_rate imply randomness self.statsd.increment('c', sample_rate=0) assert not self.recv() for i in range(10000): @@ -234,7 +207,6 @@ def test_sample_rate(self): assert_equal('sampled_counter:1|c|@0.3', self.recv()) def test_default_sample_rate(self): - self.statsd._telemetry = False # disabling telemetry since sample_rate imply randomness self.statsd.default_sample_rate = 0.3 for i in range(10000): self.statsd.increment('sampled_counter') @@ -242,7 +214,6 @@ def test_default_sample_rate(self): assert_equal('sampled_counter:1|c|@0.3', self.recv()) def test_tags_and_samples(self): - self.statsd._telemetry = False # disabling telemetry since sample_rate imply randomness for i in range(100): self.statsd.gauge('gst', 23, tags=["sampled"], sample_rate=0.9) @@ -253,28 +224,24 @@ def test_tags_and_samples(self): def test_timing(self): self.statsd.timing('t', 123) - assert_equal_telemetry('t:123|ms', self.recv()) + assert_equal('t:123|ms', self.recv()) def test_event(self): self.statsd.event('Title', u'L1\nL2', priority='low', date_happened=1375296969) - assert_equal_telemetry(u'_e{5,6}:Title|L1\\nL2|d:1375296969|p:low', self.recv(), telemetry=telemetry_metrics(metrics=0, events=1)) - - self.statsd._reset_telementry() + assert_equal(u'_e{5,6}:Title|L1\\nL2|d:1375296969|p:low', self.recv()) self.statsd.event('Title', u'♬ †øU †øU ¥ºu T0µ ♪', aggregation_key='key', tags=['t1', 't2:v2']) - assert_equal_telemetry(u'_e{5,19}:Title|♬ †øU †øU ¥ºu T0µ ♪|k:key|#t1,t2:v2', self.recv(), telemetry=telemetry_metrics(metrics=0, events=1)) + assert_equal(u'_e{5,19}:Title|♬ †øU †øU ¥ºu T0µ ♪|k:key|#t1,t2:v2', self.recv()) def test_event_constant_tags(self): self.statsd.constant_tags = ['bar:baz', 'foo'] self.statsd.event('Title', u'L1\nL2', priority='low', date_happened=1375296969) - assert_equal_telemetry(u'_e{5,6}:Title|L1\\nL2|d:1375296969|p:low|#bar:baz,foo', self.recv(), telemetry=telemetry_metrics(metrics=0, events=1, tags="bar:baz,foo")) - - self.statsd._reset_telementry() + assert_equal(u'_e{5,6}:Title|L1\\nL2|d:1375296969|p:low|#bar:baz,foo', self.recv()) self.statsd.event('Title', u'♬ †øU †øU ¥ºu T0µ ♪', aggregation_key='key', tags=['t1', 't2:v2']) - assert_equal_telemetry(u'_e{5,19}:Title|♬ †øU †øU ¥ºu T0µ ♪|k:key|#t1,t2:v2,bar:baz,foo', self.recv(), telemetry=telemetry_metrics(metrics=0, events=1, tags="bar:baz,foo")) + assert_equal(u'_e{5,19}:Title|♬ †øU †øU ¥ºu T0µ ♪|k:key|#t1,t2:v2,bar:baz,foo', self.recv()) def test_service_check(self): now = int(time.time()) @@ -282,9 +249,9 @@ def test_service_check(self): 'my_check.name', self.statsd.WARNING, tags=['key1:val1', 'key2:val2'], timestamp=now, hostname='i-abcd1234', message=u"♬ †øU \n†øU ¥ºu|m: T0µ ♪") - assert_equal_telemetry( + assert_equal( u'_sc|my_check.name|{0}|d:{1}|h:i-abcd1234|#key1:val1,key2:val2|m:{2}' - .format(self.statsd.WARNING, now, u"♬ †øU \\n†øU ¥ºu|m\: T0µ ♪"), self.recv(), telemetry=telemetry_metrics(metrics=0, service_checks=1)) + .format(self.statsd.WARNING, now, u"♬ †øU \\n†øU ¥ºu|m\: T0µ ♪"), self.recv()) def test_service_check_constant_tags(self): self.statsd.constant_tags = ['bar:baz', 'foo'] @@ -293,19 +260,17 @@ def test_service_check_constant_tags(self): 'my_check.name', self.statsd.WARNING, timestamp=now, hostname='i-abcd1234', message=u"♬ †øU \n†øU ¥ºu|m: T0µ ♪") - assert_equal_telemetry( + assert_equal( u'_sc|my_check.name|{0}|d:{1}|h:i-abcd1234|#bar:baz,foo|m:{2}' - .format(self.statsd.WARNING, now, u"♬ †øU \\n†øU ¥ºu|m\: T0µ ♪"), self.recv(), telemetry=telemetry_metrics(metrics=0, service_checks=1, tags="bar:baz,foo")) - - self.statsd._reset_telementry() + .format(self.statsd.WARNING, now, u"♬ †øU \\n†øU ¥ºu|m\: T0µ ♪"), self.recv()) self.statsd.service_check( 'my_check.name', self.statsd.WARNING, tags=['key1:val1', 'key2:val2'], timestamp=now, hostname='i-abcd1234', message=u"♬ †øU \n†øU ¥ºu|m: T0µ ♪") - assert_equal_telemetry( + assert_equal( u'_sc|my_check.name|{0}|d:{1}|h:i-abcd1234|#key1:val1,key2:val2,bar:baz,foo|m:{2}' - .format(self.statsd.WARNING, now, u"♬ †øU \\n†øU ¥ºu|m\: T0µ ♪"), self.recv(), telemetry=telemetry_metrics(metrics=0, service_checks=1, tags="bar:baz,foo")) + .format(self.statsd.WARNING, now, u"♬ †øU \\n†øU ¥ºu|m\: T0µ ♪"), self.recv()) def test_metric_namespace(self): """ @@ -313,31 +278,29 @@ def test_metric_namespace(self): """ self.statsd.namespace = "foo" self.statsd.gauge('gauge', 123.4) - assert_equal_telemetry('foo.gauge:123.4|g', self.recv(), telemetry=telemetry_metrics(namespace="foo.")) + assert_equal('foo.gauge:123.4|g', self.recv()) # Test Client level contant tags def test_gauge_constant_tags(self): self.statsd.constant_tags=['bar:baz', 'foo'] self.statsd.gauge('gauge', 123.4) - assert_equal_telemetry('gauge:123.4|g|#bar:baz,foo', self.recv(), telemetry=telemetry_metrics(tags="bar:baz,foo")) + assert self.recv() == 'gauge:123.4|g|#bar:baz,foo' def test_counter_constant_tag_with_metric_level_tags(self): self.statsd.constant_tags=['bar:baz', 'foo'] self.statsd.increment('page.views', tags=['extra']) - assert_equal_telemetry('page.views:1|c|#extra,bar:baz,foo', self.recv(), telemetry=telemetry_metrics(tags="bar:baz,foo")) + assert_equal('page.views:1|c|#extra,bar:baz,foo', self.recv()) def test_gauge_constant_tags_with_metric_level_tags_twice(self): metric_level_tag = ['foo:bar'] self.statsd.constant_tags=['bar:baz'] self.statsd.gauge('gauge', 123.4, tags=metric_level_tag) - assert_equal_telemetry('gauge:123.4|g|#foo:bar,bar:baz', self.recv(), telemetry=telemetry_metrics(tags="bar:baz")) - - self.statsd._reset_telementry() + assert self.recv() == 'gauge:123.4|g|#foo:bar,bar:baz' # sending metrics multiple times with same metric-level tags # should not duplicate the tags being sent self.statsd.gauge('gauge', 123.4, tags=metric_level_tag) - assert_equal_telemetry('gauge:123.4|g|#foo:bar,bar:baz', self.recv(), telemetry=telemetry_metrics(tags="bar:baz")) + assert self.recv() == 'gauge:123.4|g|#foo:bar,bar:baz' @staticmethod def assert_almost_equal(a, b, delta): @@ -371,7 +334,7 @@ def func(a, b, c=1, d=1): # Assert it handles args and kwargs correctly. assert_equal(result, (1, 2, 1, 3)) - packet = self.recv().split("\n")[0] # ignore telemetry packet + packet = self.recv() name_value, type_ = packet.split('|') name, value = name_value.split(':') @@ -388,7 +351,7 @@ def func(a, b, c=1, d=1): func(1, 2, d=3) - packet = self.recv().split("\n")[0] # ignore telemetry packet + packet = self.recv() name_value, type_ = packet.split('|') name, value = name_value.split(':') @@ -413,7 +376,7 @@ def func(a, b, c=1, d=1): func(1, 2, d=3) # Assess the packet - packet = self.recv().split("\n")[0] # ignore telemetry packet + packet = self.recv() name_value, type_ = packet.split('|') name, value = name_value.split(':') @@ -430,7 +393,7 @@ def func(a, b, c=1, d=1): func(1, 2, d=3) - packet = self.recv().split("\n")[0] # ignore telemetry packet + packet = self.recv() name_value, type_ = packet.split('|') name, value = name_value.split(':') @@ -456,7 +419,7 @@ def func(a, b, c=1, d=1): # Assert it handles args and kwargs correctly. assert_equal(result, (1, 2, 1, 3)) - packet = self.recv().split("\n")[0] # ignore telemetry packet + packet = self.recv() name_value, type_ = packet.split('|') name, value = name_value.split(':') @@ -485,7 +448,7 @@ def print_foo(): loop.close() # Assert - packet = self.recv().split("\n")[0] # ignore telemetry packet + packet = self.recv() name_value, type_ = packet.split('|') name, value = name_value.split(':') @@ -502,7 +465,7 @@ def test_timed_context(self): assert isinstance(timer, TimedContextManagerDecorator) time.sleep(0.5) - packet = self.recv().split("\n")[0] # ignore telemetry packet + packet = self.recv() name_value, type_ = packet.split('|') name, value = name_value.split(':') @@ -515,7 +478,7 @@ def test_timed_context(self): with self.statsd.timed('timed_context.test', use_ms=True) as timer: time.sleep(0.5) - packet = self.recv().split("\n")[0] # ignore telemetry packet + packet = self.recv() name_value, type_ = packet.split('|') name, value = name_value.split(':') @@ -541,7 +504,7 @@ def func(self): func(self) # Ensure the timing was recorded. - packet = self.recv().split("\n")[0] # ignore telemetry packet + packet = self.recv() name_value, type_ = packet.split('|') name, value = name_value.split(':') @@ -571,7 +534,7 @@ def test_timed_start_stop_calls(self): time.sleep(0.5) timer.stop() - packet = self.recv().split("\n")[0] # ignore telemetry packet + packet = self.recv() name_value, type_ = packet.split('|') name, value = name_value.split(':') @@ -585,7 +548,7 @@ def test_timed_start_stop_calls(self): time.sleep(0.5) timer.stop() - packet = self.recv().split("\n")[0] # ignore telemetry packet + packet = self.recv() name_value, type_ = packet.split('|') name, value = name_value.split(':') @@ -599,34 +562,7 @@ def test_batched(self): self.statsd.timing('timer', 123) self.statsd.close_buffer() - assert_equal_telemetry("page.views:123|g\ntimer:123|ms", self.recv(), telemetry=telemetry_metrics(metrics=2)) - - def test_telemetry(self): - self.statsd.metrics_count = 1 - self.statsd.events_count = 2 - self.statsd.service_checks_count = 3 - self.statsd.bytes_sent = 4 - self.statsd.bytes_dropped = 5 - self.statsd.packets_sent = 6 - self.statsd.packets_dropped = 7 - - self.statsd.open_buffer() - self.statsd.gauge('page.views', 123) - self.statsd.close_buffer() - - telemetry = telemetry_metrics(metrics=2, events=2, service_checks=3, bytes_sent=4, - bytes_dropped=5, packets_sent=6, packets_dropped=7) - - payload = "page.views:123|g" - assert_equal_telemetry(payload, self.recv(), telemetry=telemetry) - - assert_equal(0, self.statsd.metrics_count) - assert_equal(0, self.statsd.events_count) - assert_equal(0, self.statsd.service_checks_count) - assert_equal(len(payload) + len(telemetry), self.statsd.bytes_sent) - assert_equal(0, self.statsd.bytes_dropped) - assert_equal(1, self.statsd.packets_sent) - assert_equal(0, self.statsd.packets_dropped) + assert_equal('page.views:123|g\ntimer:123|ms', self.recv()) def test_context_manager(self): fake_socket = FakeSocket() @@ -635,23 +571,17 @@ def test_context_manager(self): statsd.gauge('page.views', 123) statsd.timing('timer', 123) - assert_equal_telemetry("page.views:123|g\ntimer:123|ms", fake_socket.recv(), telemetry=telemetry_metrics(metrics=2)) + assert_equal('page.views:123|g\ntimer:123|ms', fake_socket.recv()) def test_batched_buffer_autoflush(self): fake_socket = FakeSocket() - bytes_sent = 0 with DogStatsd() as statsd: statsd.socket = fake_socket for i in range(51): statsd.increment('mycounter') - payload = '\n'.join(['mycounter:1|c' for i in range(50)]) - - telemetry = telemetry_metrics(metrics=50) - bytes_sent += len(payload)+len(telemetry) - - assert_equal_telemetry(payload, fake_socket.recv(), telemetry=telemetry) + assert_equal('\n'.join(['mycounter:1|c' for i in range(50)]), fake_socket.recv()) - assert_equal_telemetry('mycounter:1|c', fake_socket.recv(), telemetry=telemetry_metrics(packets_sent=1, bytes_sent=bytes_sent)) + assert_equal('mycounter:1|c', fake_socket.recv()) def test_module_level_instance(self): assert isinstance(statsd, DogStatsd) @@ -680,9 +610,7 @@ def test_tags_from_environment(self): statsd = DogStatsd() statsd.socket = FakeSocket() statsd.gauge('gt', 123.4) - assert_equal_telemetry('gt:123.4|g|#country:china,age:45,blue', - statsd.socket.recv(), - telemetry=telemetry_metrics(tags="country:china,age:45,blue")) + assert_equal('gt:123.4|g|#country:china,age:45,blue', statsd.socket.recv()) def test_tags_from_environment_and_constant(self): with preserve_environment_variable('DATADOG_TAGS'): @@ -690,8 +618,7 @@ def test_tags_from_environment_and_constant(self): statsd = DogStatsd(constant_tags=['country:canada', 'red']) statsd.socket = FakeSocket() statsd.gauge('gt', 123.4) - tags="country:canada,red,country:china,age:45,blue" - assert_equal_telemetry('gt:123.4|g|#'+tags, statsd.socket.recv(), telemetry=telemetry_metrics(tags=tags)) + assert_equal('gt:123.4|g|#country:canada,red,country:china,age:45,blue', statsd.socket.recv()) def test_entity_tag_from_environment(self): with preserve_environment_variable('DD_ENTITY_ID'): @@ -699,9 +626,7 @@ def test_entity_tag_from_environment(self): statsd = DogStatsd() statsd.socket = FakeSocket() statsd.gauge('gt', 123.4) - assert_equal_telemetry('gt:123.4|g|#dd.internal.entity_id:04652bb7-19b7-11e9-9cc6-42010a9c016d', - statsd.socket.recv(), - telemetry=telemetry_metrics(tags="dd.internal.entity_id:04652bb7-19b7-11e9-9cc6-42010a9c016d")) + assert_equal('gt:123.4|g|#dd.internal.entity_id:04652bb7-19b7-11e9-9cc6-42010a9c016d', statsd.socket.recv()) def test_entity_tag_from_environment_and_constant(self): with preserve_environment_variable('DD_ENTITY_ID'): @@ -709,9 +634,7 @@ def test_entity_tag_from_environment_and_constant(self): statsd = DogStatsd(constant_tags=['country:canada', 'red']) statsd.socket = FakeSocket() statsd.gauge('gt', 123.4) - assert_equal_telemetry('gt:123.4|g|#country:canada,red,dd.internal.entity_id:04652bb7-19b7-11e9-9cc6-42010a9c016d', - statsd.socket.recv(), - telemetry=telemetry_metrics(tags="country:canada,red,dd.internal.entity_id:04652bb7-19b7-11e9-9cc6-42010a9c016d")) + assert_equal('gt:123.4|g|#country:canada,red,dd.internal.entity_id:04652bb7-19b7-11e9-9cc6-42010a9c016d', statsd.socket.recv()) def test_entity_tag_and_tags_from_environment_and_constant(self): with preserve_environment_variable('DATADOG_TAGS'): @@ -721,8 +644,7 @@ def test_entity_tag_and_tags_from_environment_and_constant(self): statsd = DogStatsd(constant_tags=['country:canada', 'red']) statsd.socket = FakeSocket() statsd.gauge('gt', 123.4) - tags = "country:canada,red,country:china,age:45,blue,dd.internal.entity_id:04652bb7-19b7-11e9-9cc6-42010a9c016d" - assert_equal_telemetry('gt:123.4|g|#'+tags, statsd.socket.recv(), telemetry=telemetry_metrics(tags=tags)) + assert_equal('gt:123.4|g|#country:canada,red,country:china,age:45,blue,dd.internal.entity_id:04652bb7-19b7-11e9-9cc6-42010a9c016d', statsd.socket.recv()) def test_gauge_doesnt_send_None(self): self.statsd.gauge('metric', None)