Changeset View
Changeset View
Standalone View
Standalone View
swh/core/tests/test_statsd.py
| Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines | def __init__(self): | ||||
| self.payloads = deque() | self.payloads = deque() | ||||
| def send(self, payload): | def send(self, payload): | ||||
| assert type(payload) == bytes | assert type(payload) == bytes | ||||
| self.payloads.append(payload) | self.payloads.append(payload) | ||||
| def recv(self): | def recv(self): | ||||
| try: | try: | ||||
| return self.payloads.popleft().decode('utf-8') | return self.payloads.popleft().decode("utf-8") | ||||
| except IndexError: | except IndexError: | ||||
| return None | return None | ||||
| def close(self): | def close(self): | ||||
| pass | pass | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return str(self.payloads) | return str(self.payloads) | ||||
| class BrokenSocket(FakeSocket): | class BrokenSocket(FakeSocket): | ||||
| def send(self, payload): | def send(self, payload): | ||||
| raise socket.error("Socket error") | raise socket.error("Socket error") | ||||
| class SlowSocket(FakeSocket): | class SlowSocket(FakeSocket): | ||||
| def send(self, payload): | def send(self, payload): | ||||
| raise socket.timeout("Socket timeout") | raise socket.timeout("Socket timeout") | ||||
| class TestStatsd(unittest.TestCase): | class TestStatsd(unittest.TestCase): | ||||
| def setUp(self): | def setUp(self): | ||||
| """ | """ | ||||
| Set up a default Statsd instance and mock the socket. | Set up a default Statsd instance and mock the socket. | ||||
| """ | """ | ||||
| # | # | ||||
| self.statsd = Statsd() | self.statsd = Statsd() | ||||
| self.statsd._socket = FakeSocket() | self.statsd._socket = FakeSocket() | ||||
| def recv(self): | def recv(self): | ||||
| return self.statsd.socket.recv() | return self.statsd.socket.recv() | ||||
| def test_set(self): | def test_set(self): | ||||
| self.statsd.set('set', 123) | self.statsd.set("set", 123) | ||||
| assert self.recv() == 'set:123|s' | assert self.recv() == "set:123|s" | ||||
| def test_gauge(self): | def test_gauge(self): | ||||
| self.statsd.gauge('gauge', 123.4) | self.statsd.gauge("gauge", 123.4) | ||||
| assert self.recv() == 'gauge:123.4|g' | assert self.recv() == "gauge:123.4|g" | ||||
| def test_counter(self): | def test_counter(self): | ||||
| self.statsd.increment('page.views') | self.statsd.increment("page.views") | ||||
| self.assertEqual('page.views:1|c', self.recv()) | self.assertEqual("page.views:1|c", self.recv()) | ||||
| self.statsd.increment('page.views', 11) | self.statsd.increment("page.views", 11) | ||||
| self.assertEqual('page.views:11|c', self.recv()) | self.assertEqual("page.views:11|c", self.recv()) | ||||
| self.statsd.decrement('page.views') | self.statsd.decrement("page.views") | ||||
| self.assertEqual('page.views:-1|c', self.recv()) | self.assertEqual("page.views:-1|c", self.recv()) | ||||
| self.statsd.decrement('page.views', 12) | self.statsd.decrement("page.views", 12) | ||||
| self.assertEqual('page.views:-12|c', self.recv()) | self.assertEqual("page.views:-12|c", self.recv()) | ||||
| def test_histogram(self): | def test_histogram(self): | ||||
| self.statsd.histogram('histo', 123.4) | self.statsd.histogram("histo", 123.4) | ||||
| self.assertEqual('histo:123.4|h', self.recv()) | self.assertEqual("histo:123.4|h", self.recv()) | ||||
| def test_tagged_gauge(self): | def test_tagged_gauge(self): | ||||
| self.statsd.gauge('gt', 123.4, tags={'country': 'china', 'age': 45}) | self.statsd.gauge("gt", 123.4, tags={"country": "china", "age": 45}) | ||||
| self.assertEqual('gt:123.4|g|#age:45,country:china', self.recv()) | self.assertEqual("gt:123.4|g|#age:45,country:china", self.recv()) | ||||
| def test_tagged_counter(self): | def test_tagged_counter(self): | ||||
| self.statsd.increment('ct', tags={'country': 'españa'}) | self.statsd.increment("ct", tags={"country": "españa"}) | ||||
| self.assertEqual('ct:1|c|#country:españa', self.recv()) | self.assertEqual("ct:1|c|#country:españa", self.recv()) | ||||
| def test_tagged_histogram(self): | def test_tagged_histogram(self): | ||||
| self.statsd.histogram('h', 1, tags={'test_tag': 'tag_value'}) | self.statsd.histogram("h", 1, tags={"test_tag": "tag_value"}) | ||||
| self.assertEqual('h:1|h|#test_tag:tag_value', self.recv()) | self.assertEqual("h:1|h|#test_tag:tag_value", self.recv()) | ||||
| def test_sample_rate(self): | def test_sample_rate(self): | ||||
| self.statsd.increment('c', sample_rate=0) | self.statsd.increment("c", sample_rate=0) | ||||
| assert not self.recv() | assert not self.recv() | ||||
| for i in range(10000): | for i in range(10000): | ||||
| self.statsd.increment('sampled_counter', sample_rate=0.3) | self.statsd.increment("sampled_counter", sample_rate=0.3) | ||||
| self.assert_almost_equal(3000, len(self.statsd.socket.payloads), 150) | self.assert_almost_equal(3000, len(self.statsd.socket.payloads), 150) | ||||
| self.assertEqual('sampled_counter:1|c|@0.3', self.recv()) | self.assertEqual("sampled_counter:1|c|@0.3", self.recv()) | ||||
| def test_tags_and_samples(self): | def test_tags_and_samples(self): | ||||
| for i in range(100): | for i in range(100): | ||||
| self.statsd.gauge('gst', 23, tags={"sampled": True}, | self.statsd.gauge("gst", 23, tags={"sampled": True}, sample_rate=0.9) | ||||
| sample_rate=0.9) | |||||
| self.assert_almost_equal(90, len(self.statsd.socket.payloads), 10) | self.assert_almost_equal(90, len(self.statsd.socket.payloads), 10) | ||||
| self.assertEqual('gst:23|g|@0.9|#sampled:True', self.recv()) | self.assertEqual("gst:23|g|@0.9|#sampled:True", self.recv()) | ||||
| def test_timing(self): | def test_timing(self): | ||||
| self.statsd.timing('t', 123) | self.statsd.timing("t", 123) | ||||
| self.assertEqual('t:123|ms', self.recv()) | self.assertEqual("t:123|ms", self.recv()) | ||||
| def test_metric_namespace(self): | def test_metric_namespace(self): | ||||
| """ | """ | ||||
| Namespace prefixes all metric names. | Namespace prefixes all metric names. | ||||
| """ | """ | ||||
| self.statsd.namespace = "foo" | self.statsd.namespace = "foo" | ||||
| self.statsd.gauge('gauge', 123.4) | self.statsd.gauge("gauge", 123.4) | ||||
| self.assertEqual('foo.gauge:123.4|g', self.recv()) | self.assertEqual("foo.gauge:123.4|g", self.recv()) | ||||
| # Test Client level constant tags | # Test Client level constant tags | ||||
| def test_gauge_constant_tags(self): | def test_gauge_constant_tags(self): | ||||
| self.statsd.constant_tags = { | self.statsd.constant_tags = {"bar": "baz"} | ||||
| 'bar': 'baz', | self.statsd.gauge("gauge", 123.4) | ||||
| } | assert self.recv() == "gauge:123.4|g|#bar:baz" | ||||
| self.statsd.gauge('gauge', 123.4) | |||||
| assert self.recv() == 'gauge:123.4|g|#bar:baz' | |||||
| def test_counter_constant_tag_with_metric_level_tags(self): | def test_counter_constant_tag_with_metric_level_tags(self): | ||||
| self.statsd.constant_tags = { | self.statsd.constant_tags = {"bar": "baz", "foo": True} | ||||
| 'bar': 'baz', | self.statsd.increment("page.views", tags={"extra": "extra"}) | ||||
| 'foo': True, | self.assertEqual("page.views:1|c|#bar:baz,extra:extra,foo:True", self.recv()) | ||||
| } | |||||
| self.statsd.increment('page.views', tags={'extra': 'extra'}) | |||||
| self.assertEqual( | |||||
| 'page.views:1|c|#bar:baz,extra:extra,foo:True', | |||||
| self.recv(), | |||||
| ) | |||||
| def test_gauge_constant_tags_with_metric_level_tags_twice(self): | def test_gauge_constant_tags_with_metric_level_tags_twice(self): | ||||
| metric_level_tag = {'foo': 'bar'} | metric_level_tag = {"foo": "bar"} | ||||
| self.statsd.constant_tags = {'bar': 'baz'} | self.statsd.constant_tags = {"bar": "baz"} | ||||
| self.statsd.gauge('gauge', 123.4, tags=metric_level_tag) | self.statsd.gauge("gauge", 123.4, tags=metric_level_tag) | ||||
| assert self.recv() == 'gauge:123.4|g|#bar:baz,foo:bar' | assert self.recv() == "gauge:123.4|g|#bar:baz,foo:bar" | ||||
| # sending metrics multiple times with same metric-level tags | # sending metrics multiple times with same metric-level tags | ||||
| # should not duplicate the tags being sent | # should not duplicate the tags being sent | ||||
| self.statsd.gauge('gauge', 123.4, tags=metric_level_tag) | self.statsd.gauge("gauge", 123.4, tags=metric_level_tag) | ||||
| assert self.recv() == 'gauge:123.4|g|#bar:baz,foo:bar' | assert self.recv() == "gauge:123.4|g|#bar:baz,foo:bar" | ||||
| def assert_almost_equal(self, a, b, delta): | def assert_almost_equal(self, a, b, delta): | ||||
| self.assertTrue( | self.assertTrue( | ||||
| 0 <= abs(a - b) <= delta, | 0 <= abs(a - b) <= delta, "%s - %s not within %s" % (a, b, delta) | ||||
| "%s - %s not within %s" % (a, b, delta) | |||||
| ) | ) | ||||
| def test_socket_error(self): | def test_socket_error(self): | ||||
| self.statsd._socket = BrokenSocket() | self.statsd._socket = BrokenSocket() | ||||
| self.statsd.gauge('no error', 1) | self.statsd.gauge("no error", 1) | ||||
| assert True, 'success' | assert True, "success" | ||||
| def test_socket_timeout(self): | def test_socket_timeout(self): | ||||
| self.statsd._socket = SlowSocket() | self.statsd._socket = SlowSocket() | ||||
| self.statsd.gauge('no error', 1) | self.statsd.gauge("no error", 1) | ||||
| assert True, 'success' | assert True, "success" | ||||
| def test_timed(self): | def test_timed(self): | ||||
| """ | """ | ||||
| Measure the distribution of a function's run time. | Measure the distribution of a function's run time. | ||||
| """ | """ | ||||
| @self.statsd.timed('timed.test') | |||||
| @self.statsd.timed("timed.test") | |||||
| def func(a, b, c=1, d=1): | def func(a, b, c=1, d=1): | ||||
| """docstring""" | """docstring""" | ||||
| time.sleep(0.5) | time.sleep(0.5) | ||||
| return (a, b, c, d) | return (a, b, c, d) | ||||
| self.assertEqual('func', func.__name__) | self.assertEqual("func", func.__name__) | ||||
| self.assertEqual('docstring', func.__doc__) | self.assertEqual("docstring", func.__doc__) | ||||
| result = func(1, 2, d=3) | result = func(1, 2, d=3) | ||||
| # Assert it handles args and kwargs correctly. | # Assert it handles args and kwargs correctly. | ||||
| self.assertEqual(result, (1, 2, 1, 3)) | self.assertEqual(result, (1, 2, 1, 3)) | ||||
| packet = self.recv() | packet = self.recv() | ||||
| name_value, type_ = packet.split('|') | name_value, type_ = packet.split("|") | ||||
| name, value = name_value.split(':') | name, value = name_value.split(":") | ||||
| self.assertEqual('ms', type_) | self.assertEqual("ms", type_) | ||||
| self.assertEqual('timed.test', name) | self.assertEqual("timed.test", name) | ||||
| self.assert_almost_equal(500, float(value), 100) | self.assert_almost_equal(500, float(value), 100) | ||||
| def test_timed_exception(self): | def test_timed_exception(self): | ||||
| """ | """ | ||||
| Exception bubble out of the decorator and is reported | Exception bubble out of the decorator and is reported | ||||
| to statsd as a dedicated counter. | to statsd as a dedicated counter. | ||||
| """ | """ | ||||
| @self.statsd.timed('timed.test') | |||||
| @self.statsd.timed("timed.test") | |||||
| def func(a, b, c=1, d=1): | def func(a, b, c=1, d=1): | ||||
| """docstring""" | """docstring""" | ||||
| time.sleep(0.5) | time.sleep(0.5) | ||||
| return (a / b, c, d) | return (a / b, c, d) | ||||
| self.assertEqual('func', func.__name__) | self.assertEqual("func", func.__name__) | ||||
| self.assertEqual('docstring', func.__doc__) | self.assertEqual("docstring", func.__doc__) | ||||
| with self.assertRaises(ZeroDivisionError): | with self.assertRaises(ZeroDivisionError): | ||||
| func(1, 0) | func(1, 0) | ||||
| packet = self.recv() | packet = self.recv() | ||||
| name_value, type_ = packet.split('|') | name_value, type_ = packet.split("|") | ||||
| name, value = name_value.split(':') | name, value = name_value.split(":") | ||||
| self.assertEqual('c', type_) | self.assertEqual("c", type_) | ||||
| self.assertEqual('timed.test_error_count', name) | self.assertEqual("timed.test_error_count", name) | ||||
| self.assertEqual(int(value), 1) | self.assertEqual(int(value), 1) | ||||
| def test_timed_no_metric(self, ): | def test_timed_no_metric(self,): | ||||
| """ | """ | ||||
| Test using a decorator without providing a metric. | Test using a decorator without providing a metric. | ||||
| """ | """ | ||||
| @self.statsd.timed() | @self.statsd.timed() | ||||
| def func(a, b, c=1, d=1): | def func(a, b, c=1, d=1): | ||||
| """docstring""" | """docstring""" | ||||
| time.sleep(0.5) | time.sleep(0.5) | ||||
| return (a, b, c, d) | return (a, b, c, d) | ||||
| self.assertEqual('func', func.__name__) | self.assertEqual("func", func.__name__) | ||||
| self.assertEqual('docstring', func.__doc__) | self.assertEqual("docstring", func.__doc__) | ||||
| result = func(1, 2, d=3) | result = func(1, 2, d=3) | ||||
| # Assert it handles args and kwargs correctly. | # Assert it handles args and kwargs correctly. | ||||
| self.assertEqual(result, (1, 2, 1, 3)) | self.assertEqual(result, (1, 2, 1, 3)) | ||||
| packet = self.recv() | packet = self.recv() | ||||
| name_value, type_ = packet.split('|') | name_value, type_ = packet.split("|") | ||||
| name, value = name_value.split(':') | name, value = name_value.split(":") | ||||
| self.assertEqual('ms', type_) | self.assertEqual("ms", type_) | ||||
| self.assertEqual('swh.core.tests.test_statsd.func', name) | self.assertEqual("swh.core.tests.test_statsd.func", name) | ||||
| self.assert_almost_equal(500, float(value), 100) | self.assert_almost_equal(500, float(value), 100) | ||||
| def test_timed_coroutine(self): | def test_timed_coroutine(self): | ||||
| """ | """ | ||||
| Measure the distribution of a coroutine function's run time. | Measure the distribution of a coroutine function's run time. | ||||
| Warning: Python >= 3.5 only. | Warning: Python >= 3.5 only. | ||||
| """ | """ | ||||
| import asyncio | import asyncio | ||||
| @self.statsd.timed('timed.test') | @self.statsd.timed("timed.test") | ||||
| @asyncio.coroutine | @asyncio.coroutine | ||||
| def print_foo(): | def print_foo(): | ||||
| """docstring""" | """docstring""" | ||||
| time.sleep(0.5) | time.sleep(0.5) | ||||
| print("foo") | print("foo") | ||||
| loop = asyncio.new_event_loop() | loop = asyncio.new_event_loop() | ||||
| loop.run_until_complete(print_foo()) | loop.run_until_complete(print_foo()) | ||||
| loop.close() | loop.close() | ||||
| # Assert | # Assert | ||||
| packet = self.recv() | packet = self.recv() | ||||
| name_value, type_ = packet.split('|') | name_value, type_ = packet.split("|") | ||||
| name, value = name_value.split(':') | name, value = name_value.split(":") | ||||
| self.assertEqual('ms', type_) | self.assertEqual("ms", type_) | ||||
| self.assertEqual('timed.test', name) | self.assertEqual("timed.test", name) | ||||
| self.assert_almost_equal(500, float(value), 100) | self.assert_almost_equal(500, float(value), 100) | ||||
| def test_timed_context(self): | def test_timed_context(self): | ||||
| """ | """ | ||||
| Measure the distribution of a context's run time. | Measure the distribution of a context's run time. | ||||
| """ | """ | ||||
| # In milliseconds | # In milliseconds | ||||
| with self.statsd.timed('timed_context.test') as timer: | with self.statsd.timed("timed_context.test") as timer: | ||||
| self.assertIsInstance(timer, TimedContextManagerDecorator) | self.assertIsInstance(timer, TimedContextManagerDecorator) | ||||
| time.sleep(0.5) | time.sleep(0.5) | ||||
| packet = self.recv() | packet = self.recv() | ||||
| name_value, type_ = packet.split('|') | name_value, type_ = packet.split("|") | ||||
| name, value = name_value.split(':') | name, value = name_value.split(":") | ||||
| self.assertEqual('ms', type_) | self.assertEqual("ms", type_) | ||||
| self.assertEqual('timed_context.test', name) | self.assertEqual("timed_context.test", name) | ||||
| self.assert_almost_equal(500, float(value), 100) | self.assert_almost_equal(500, float(value), 100) | ||||
| self.assert_almost_equal(500, timer.elapsed, 100) | self.assert_almost_equal(500, timer.elapsed, 100) | ||||
| def test_timed_context_exception(self): | def test_timed_context_exception(self): | ||||
| """ | """ | ||||
| Exception bubbles out of the `timed` context manager and is | Exception bubbles out of the `timed` context manager and is | ||||
| reported to statsd as a dedicated counter. | reported to statsd as a dedicated counter. | ||||
| """ | """ | ||||
| class ContextException(Exception): | class ContextException(Exception): | ||||
| pass | pass | ||||
| def func(self): | def func(self): | ||||
| with self.statsd.timed('timed_context.test'): | with self.statsd.timed("timed_context.test"): | ||||
| time.sleep(0.5) | time.sleep(0.5) | ||||
| raise ContextException() | raise ContextException() | ||||
| # Ensure the exception was raised. | # Ensure the exception was raised. | ||||
| self.assertRaises(ContextException, func, self) | self.assertRaises(ContextException, func, self) | ||||
| # Ensure the timing was recorded. | # Ensure the timing was recorded. | ||||
| packet = self.recv() | packet = self.recv() | ||||
| name_value, type_ = packet.split('|') | name_value, type_ = packet.split("|") | ||||
| name, value = name_value.split(':') | name, value = name_value.split(":") | ||||
| self.assertEqual('c', type_) | self.assertEqual("c", type_) | ||||
| self.assertEqual('timed_context.test_error_count', name) | self.assertEqual("timed_context.test_error_count", name) | ||||
| self.assertEqual(int(value), 1) | self.assertEqual(int(value), 1) | ||||
| def test_timed_context_no_metric_name_exception(self): | def test_timed_context_no_metric_name_exception(self): | ||||
| """Test that an exception occurs if using a context manager without a | """Test that an exception occurs if using a context manager without a | ||||
| metric name. | metric name. | ||||
| """ | """ | ||||
| def func(self): | def func(self): | ||||
| with self.statsd.timed(): | with self.statsd.timed(): | ||||
| time.sleep(0.5) | time.sleep(0.5) | ||||
| # Ensure the exception was raised. | # Ensure the exception was raised. | ||||
| self.assertRaises(TypeError, func, self) | self.assertRaises(TypeError, func, self) | ||||
| # Ensure the timing was recorded. | # Ensure the timing was recorded. | ||||
| packet = self.recv() | packet = self.recv() | ||||
| self.assertEqual(packet, None) | self.assertEqual(packet, None) | ||||
| def test_timed_start_stop_calls(self): | def test_timed_start_stop_calls(self): | ||||
| timer = self.statsd.timed('timed_context.test') | timer = self.statsd.timed("timed_context.test") | ||||
| timer.start() | timer.start() | ||||
| time.sleep(0.5) | time.sleep(0.5) | ||||
| timer.stop() | timer.stop() | ||||
| packet = self.recv() | packet = self.recv() | ||||
| name_value, type_ = packet.split('|') | name_value, type_ = packet.split("|") | ||||
| name, value = name_value.split(':') | name, value = name_value.split(":") | ||||
| self.assertEqual('ms', type_) | self.assertEqual("ms", type_) | ||||
| self.assertEqual('timed_context.test', name) | self.assertEqual("timed_context.test", name) | ||||
| self.assert_almost_equal(500, float(value), 100) | self.assert_almost_equal(500, float(value), 100) | ||||
| def test_batched(self): | def test_batched(self): | ||||
| self.statsd.open_buffer() | self.statsd.open_buffer() | ||||
| self.statsd.gauge('page.views', 123) | self.statsd.gauge("page.views", 123) | ||||
| self.statsd.timing('timer', 123) | self.statsd.timing("timer", 123) | ||||
| self.statsd.close_buffer() | self.statsd.close_buffer() | ||||
| self.assertEqual('page.views:123|g\ntimer:123|ms', self.recv()) | self.assertEqual("page.views:123|g\ntimer:123|ms", self.recv()) | ||||
| def test_context_manager(self): | def test_context_manager(self): | ||||
| fake_socket = FakeSocket() | fake_socket = FakeSocket() | ||||
| with Statsd() as statsd: | with Statsd() as statsd: | ||||
| statsd._socket = fake_socket | statsd._socket = fake_socket | ||||
| statsd.gauge('page.views', 123) | statsd.gauge("page.views", 123) | ||||
| statsd.timing('timer', 123) | statsd.timing("timer", 123) | ||||
| self.assertEqual('page.views:123|g\ntimer:123|ms', fake_socket.recv()) | self.assertEqual("page.views:123|g\ntimer:123|ms", fake_socket.recv()) | ||||
| def test_batched_buffer_autoflush(self): | def test_batched_buffer_autoflush(self): | ||||
| fake_socket = FakeSocket() | fake_socket = FakeSocket() | ||||
| with Statsd() as statsd: | with Statsd() as statsd: | ||||
| statsd._socket = fake_socket | statsd._socket = fake_socket | ||||
| for i in range(51): | for i in range(51): | ||||
| statsd.increment('mycounter') | statsd.increment("mycounter") | ||||
| self.assertEqual( | self.assertEqual( | ||||
| '\n'.join(['mycounter:1|c' for i in range(50)]), | "\n".join(["mycounter:1|c" for i in range(50)]), fake_socket.recv() | ||||
| fake_socket.recv(), | |||||
| ) | ) | ||||
| self.assertEqual('mycounter:1|c', fake_socket.recv()) | self.assertEqual("mycounter:1|c", fake_socket.recv()) | ||||
| def test_module_level_instance(self): | def test_module_level_instance(self): | ||||
| from swh.core.statsd import statsd | from swh.core.statsd import statsd | ||||
| self.assertTrue(isinstance(statsd, Statsd)) | self.assertTrue(isinstance(statsd, Statsd)) | ||||
| def test_instantiating_does_not_connect(self): | def test_instantiating_does_not_connect(self): | ||||
| local_statsd = Statsd() | local_statsd = Statsd() | ||||
| self.assertEqual(None, local_statsd._socket) | self.assertEqual(None, local_statsd._socket) | ||||
| def test_accessing_socket_opens_socket(self): | def test_accessing_socket_opens_socket(self): | ||||
| local_statsd = Statsd() | local_statsd = Statsd() | ||||
| try: | try: | ||||
| self.assertIsNotNone(local_statsd.socket) | self.assertIsNotNone(local_statsd.socket) | ||||
| finally: | finally: | ||||
| local_statsd.close_socket() | local_statsd.close_socket() | ||||
| def test_accessing_socket_multiple_times_returns_same_socket(self): | def test_accessing_socket_multiple_times_returns_same_socket(self): | ||||
| local_statsd = Statsd() | local_statsd = Statsd() | ||||
| fresh_socket = FakeSocket() | fresh_socket = FakeSocket() | ||||
| local_statsd._socket = fresh_socket | local_statsd._socket = fresh_socket | ||||
| self.assertEqual(fresh_socket, local_statsd.socket) | self.assertEqual(fresh_socket, local_statsd.socket) | ||||
| self.assertNotEqual(FakeSocket(), local_statsd.socket) | self.assertNotEqual(FakeSocket(), local_statsd.socket) | ||||
| def test_tags_from_environment(self): | def test_tags_from_environment(self): | ||||
| with preserve_envvars('STATSD_TAGS'): | with preserve_envvars("STATSD_TAGS"): | ||||
| os.environ['STATSD_TAGS'] = 'country:china,age:45' | os.environ["STATSD_TAGS"] = "country:china,age:45" | ||||
| statsd = Statsd() | statsd = Statsd() | ||||
| statsd._socket = FakeSocket() | statsd._socket = FakeSocket() | ||||
| statsd.gauge('gt', 123.4) | statsd.gauge("gt", 123.4) | ||||
| self.assertEqual('gt:123.4|g|#age:45,country:china', | self.assertEqual("gt:123.4|g|#age:45,country:china", statsd.socket.recv()) | ||||
| statsd.socket.recv()) | |||||
| def test_tags_from_environment_and_constant(self): | def test_tags_from_environment_and_constant(self): | ||||
| with preserve_envvars('STATSD_TAGS'): | with preserve_envvars("STATSD_TAGS"): | ||||
| os.environ['STATSD_TAGS'] = 'country:china,age:45' | os.environ["STATSD_TAGS"] = "country:china,age:45" | ||||
| statsd = Statsd(constant_tags={'country': 'canada'}) | statsd = Statsd(constant_tags={"country": "canada"}) | ||||
| statsd._socket = FakeSocket() | statsd._socket = FakeSocket() | ||||
| statsd.gauge('gt', 123.4) | statsd.gauge("gt", 123.4) | ||||
| self.assertEqual('gt:123.4|g|#age:45,country:canada', | self.assertEqual("gt:123.4|g|#age:45,country:canada", statsd.socket.recv()) | ||||
| statsd.socket.recv()) | |||||
| def test_tags_from_environment_warning(self): | def test_tags_from_environment_warning(self): | ||||
| with preserve_envvars('STATSD_TAGS'): | with preserve_envvars("STATSD_TAGS"): | ||||
| os.environ['STATSD_TAGS'] = 'valid:tag,invalid_tag' | os.environ["STATSD_TAGS"] = "valid:tag,invalid_tag" | ||||
| with pytest.warns(UserWarning) as record: | with pytest.warns(UserWarning) as record: | ||||
| statsd = Statsd() | statsd = Statsd() | ||||
| assert len(record) == 1 | assert len(record) == 1 | ||||
| assert 'invalid_tag' in record[0].message.args[0] | assert "invalid_tag" in record[0].message.args[0] | ||||
| assert 'valid:tag' not in record[0].message.args[0] | assert "valid:tag" not in record[0].message.args[0] | ||||
| assert statsd.constant_tags == {'valid': 'tag'} | assert statsd.constant_tags == {"valid": "tag"} | ||||
| def test_gauge_doesnt_send_none(self): | def test_gauge_doesnt_send_none(self): | ||||
| self.statsd.gauge('metric', None) | self.statsd.gauge("metric", None) | ||||
| assert self.recv() is None | assert self.recv() is None | ||||
| def test_increment_doesnt_send_none(self): | def test_increment_doesnt_send_none(self): | ||||
| self.statsd.increment('metric', None) | self.statsd.increment("metric", None) | ||||
| assert self.recv() is None | assert self.recv() is None | ||||
| def test_decrement_doesnt_send_none(self): | def test_decrement_doesnt_send_none(self): | ||||
| self.statsd.decrement('metric', None) | self.statsd.decrement("metric", None) | ||||
| assert self.recv() is None | assert self.recv() is None | ||||
| def test_timing_doesnt_send_none(self): | def test_timing_doesnt_send_none(self): | ||||
| self.statsd.timing('metric', None) | self.statsd.timing("metric", None) | ||||
| assert self.recv() is None | assert self.recv() is None | ||||
| def test_histogram_doesnt_send_none(self): | def test_histogram_doesnt_send_none(self): | ||||
| self.statsd.histogram('metric', None) | self.statsd.histogram("metric", None) | ||||
| assert self.recv() is None | assert self.recv() is None | ||||
| def test_param_host(self): | def test_param_host(self): | ||||
| with preserve_envvars('STATSD_HOST', 'STATSD_PORT'): | with preserve_envvars("STATSD_HOST", "STATSD_PORT"): | ||||
| os.environ['STATSD_HOST'] = 'test-value' | os.environ["STATSD_HOST"] = "test-value" | ||||
| os.environ['STATSD_PORT'] = '' | os.environ["STATSD_PORT"] = "" | ||||
| local_statsd = Statsd(host='actual-test-value') | local_statsd = Statsd(host="actual-test-value") | ||||
| self.assertEqual(local_statsd.host, 'actual-test-value') | self.assertEqual(local_statsd.host, "actual-test-value") | ||||
| self.assertEqual(local_statsd.port, 8125) | self.assertEqual(local_statsd.port, 8125) | ||||
| def test_param_port(self): | def test_param_port(self): | ||||
| with preserve_envvars('STATSD_HOST', 'STATSD_PORT'): | with preserve_envvars("STATSD_HOST", "STATSD_PORT"): | ||||
| os.environ['STATSD_HOST'] = '' | os.environ["STATSD_HOST"] = "" | ||||
| os.environ['STATSD_PORT'] = '12345' | os.environ["STATSD_PORT"] = "12345" | ||||
| local_statsd = Statsd(port=4321) | local_statsd = Statsd(port=4321) | ||||
| self.assertEqual(local_statsd.host, 'localhost') | self.assertEqual(local_statsd.host, "localhost") | ||||
| self.assertEqual(local_statsd.port, 4321) | self.assertEqual(local_statsd.port, 4321) | ||||
| def test_envvar_host(self): | def test_envvar_host(self): | ||||
| with preserve_envvars('STATSD_HOST', 'STATSD_PORT'): | with preserve_envvars("STATSD_HOST", "STATSD_PORT"): | ||||
| os.environ['STATSD_HOST'] = 'test-value' | os.environ["STATSD_HOST"] = "test-value" | ||||
| os.environ['STATSD_PORT'] = '' | os.environ["STATSD_PORT"] = "" | ||||
| local_statsd = Statsd() | local_statsd = Statsd() | ||||
| self.assertEqual(local_statsd.host, 'test-value') | self.assertEqual(local_statsd.host, "test-value") | ||||
| self.assertEqual(local_statsd.port, 8125) | self.assertEqual(local_statsd.port, 8125) | ||||
| def test_envvar_port(self): | def test_envvar_port(self): | ||||
| with preserve_envvars('STATSD_HOST', 'STATSD_PORT'): | with preserve_envvars("STATSD_HOST", "STATSD_PORT"): | ||||
| os.environ['STATSD_HOST'] = '' | os.environ["STATSD_HOST"] = "" | ||||
| os.environ['STATSD_PORT'] = '12345' | os.environ["STATSD_PORT"] = "12345" | ||||
| local_statsd = Statsd() | local_statsd = Statsd() | ||||
| self.assertEqual(local_statsd.host, 'localhost') | self.assertEqual(local_statsd.host, "localhost") | ||||
| self.assertEqual(local_statsd.port, 12345) | self.assertEqual(local_statsd.port, 12345) | ||||
| def test_namespace_added(self): | def test_namespace_added(self): | ||||
| local_statsd = Statsd(namespace='test-namespace') | local_statsd = Statsd(namespace="test-namespace") | ||||
| local_statsd._socket = FakeSocket() | local_statsd._socket = FakeSocket() | ||||
| local_statsd.gauge('gauge', 123.4) | local_statsd.gauge("gauge", 123.4) | ||||
| assert local_statsd.socket.recv() == 'test-namespace.gauge:123.4|g' | assert local_statsd.socket.recv() == "test-namespace.gauge:123.4|g" | ||||
| def test_contextmanager_empty(self): | def test_contextmanager_empty(self): | ||||
| with self.statsd: | with self.statsd: | ||||
| assert True, 'success' | assert True, "success" | ||||
| def test_contextmanager_buffering(self): | def test_contextmanager_buffering(self): | ||||
| with self.statsd as s: | with self.statsd as s: | ||||
| s.gauge('gauge', 123.4) | s.gauge("gauge", 123.4) | ||||
| s.gauge('gauge_other', 456.78) | s.gauge("gauge_other", 456.78) | ||||
| self.assertIsNone(s.socket.recv()) | self.assertIsNone(s.socket.recv()) | ||||
| self.assertEqual(self.recv(), 'gauge:123.4|g\ngauge_other:456.78|g') | self.assertEqual(self.recv(), "gauge:123.4|g\ngauge_other:456.78|g") | ||||
| def test_timed_elapsed(self): | def test_timed_elapsed(self): | ||||
| with self.statsd.timed('test_timer') as t: | with self.statsd.timed("test_timer") as t: | ||||
| pass | pass | ||||
| self.assertGreaterEqual(t.elapsed, 0) | self.assertGreaterEqual(t.elapsed, 0) | ||||
| self.assertEqual(self.recv(), 'test_timer:%s|ms' % t.elapsed) | self.assertEqual(self.recv(), "test_timer:%s|ms" % t.elapsed) | ||||