def test_telemetry_flush_interval_alternate_destination(self):
statsd = DogStatsd(telemetry_host='foo')
fake_socket = FakeSocket()
statsd.socket = fake_socket
fake_telemetry_socket = FakeSocket()
statsd.telemetry_socket = fake_telemetry_socket
assert statsd.telemetry_host != None
assert statsd.telemetry_port != None
assert statsd._dedicated_telemetry_destination()
# set the last flush time in the future to be sure we won't flush
statsd._last_flush_time = time.time(
) + statsd._telemetry_flush_interval
statsd.gauge('gauge', 123.4)
assert_equal('gauge:123.4|g', fake_socket.recv())
t1 = time.time()
# setting the last flush time in the past to trigger a telemetry flush
statsd._last_flush_time = t1 - statsd._telemetry_flush_interval - 1
statsd.gauge('gauge', 123.4)
assert_equal('gauge:123.4|g', fake_socket.recv())
assert_equal_telemetry('',
fake_telemetry_socket.recv(),
telemetry=telemetry_metrics(metrics=2,
bytes_sent=13 * 2,
packets_sent=2))
# assert that _last_flush_time has been updated
assert t1 < statsd._last_flush_time
def test_tags_from_environment_and_constant(self):
with preserve_environment_variable('DATADOG_TAGS'):
os.environ['DATADOG_TAGS'] = 'country:china,age:45,blue'
statsd = DogStatsd(constant_tags=['country:canada', 'red'])
statsd.socket = FakeSocket()
statsd.gauge('gt', 123.4)
t.assert_equal('gt:123.4|g|#country:canada,red,country:china,age:45,blue', statsd.socket.recv())
def test_telemetry_flush_interval(self):
statsd = DogStatsd()
fake_socket = FakeSocket()
statsd.socket = fake_socket
# set the last flush time in the future to be sure we won't flush
statsd._last_flush_time = time.time(
) + statsd._telemetry_flush_interval
statsd.gauge('gauge', 123.4)
metric = 'gauge:123.4|g'
assert_equal(metric, fake_socket.recv())
t1 = time.time()
# setting the last flush time in the past to trigger a telemetry flush
statsd._last_flush_time = t1 - statsd._telemetry_flush_interval - 1
statsd.gauge('gauge', 123.4)
assert_equal_telemetry(metric,
fake_socket.recv(2),
telemetry=telemetry_metrics(metrics=2,
bytes_sent=2 *
len(metric),
packets_sent=2))
# assert that _last_flush_time has been updated
assert t1 < statsd._last_flush_time
def test_telemetry_flush_interval(self):
dogstatsd = DogStatsd()
fake_socket = FakeSocket()
dogstatsd.socket = fake_socket
# set the last flush time in the future to be sure we won't flush
dogstatsd._last_flush_time = time.time(
) + dogstatsd._telemetry_flush_interval
dogstatsd.gauge('gauge', 123.4)
metric = 'gauge:123.4|g'
self.assertEqual(metric, fake_socket.recv())
time1 = time.time()
# setting the last flush time in the past to trigger a telemetry flush
dogstatsd._last_flush_time = time1 - dogstatsd._telemetry_flush_interval - 1
dogstatsd.gauge('gauge', 123.4)
self.assert_equal_telemetry(metric,
fake_socket.recv(2),
telemetry=telemetry_metrics(
metrics=2,
bytes_sent=2 * len(metric),
packets_sent=2))
# assert that _last_flush_time has been updated
self.assertTrue(time1 < dogstatsd._last_flush_time)
def test_telemetry_flush_interval_alternate_destination(self):
dogstatsd = DogStatsd(telemetry_host='foo')
fake_socket = FakeSocket()
dogstatsd.socket = fake_socket
fake_telemetry_socket = FakeSocket()
dogstatsd.telemetry_socket = fake_telemetry_socket
self.assertIsNotNone(dogstatsd.telemetry_host)
self.assertIsNotNone(dogstatsd.telemetry_port)
self.assertTrue(dogstatsd._dedicated_telemetry_destination())
# set the last flush time in the future to be sure we won't flush
dogstatsd._last_flush_time = time.time(
) + dogstatsd._telemetry_flush_interval
dogstatsd.gauge('gauge', 123.4)
self.assertEqual('gauge:123.4|g', fake_socket.recv())
time1 = time.time()
# setting the last flush time in the past to trigger a telemetry flush
dogstatsd._last_flush_time = time1 - dogstatsd._telemetry_flush_interval - 1
dogstatsd.gauge('gauge', 123.4)
self.assertEqual('gauge:123.4|g', fake_socket.recv())
self.assert_equal_telemetry('',
fake_telemetry_socket.recv(),
telemetry=telemetry_metrics(
metrics=2,
bytes_sent=13 * 2,
packets_sent=2))
# assert that _last_flush_time has been updated
self.assertTrue(time1 < dogstatsd._last_flush_time)
def test_tags_from_environment_and_constant(self):
with preserve_environment_variable('DATADOG_TAGS'):
os.environ['DATADOG_TAGS'] = 'country:china,age:45,blue'
statsd = DogStatsd(constant_tags=['country:canada', 'red'])
statsd.socket = FakeSocket()
statsd.gauge('gt', 123.4)
t.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'):
os.environ['DD_ENTITY_ID'] = '04652bb7-19b7-11e9-9cc6-42010a9c016d'
statsd = DogStatsd()
statsd.socket = FakeSocket()
statsd.gauge('gt', 123.4)
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'):
os.environ['DD_ENTITY_ID'] = '04652bb7-19b7-11e9-9cc6-42010a9c016d'
statsd = DogStatsd(constant_tags=['country:canada', 'red'])
statsd.socket = FakeSocket()
statsd.gauge('gt', 123.4)
t.assert_equal(
'gt:123.4|g|#country:canada,red,dd.internal.entity_id:04652bb7-19b7-11e9-9cc6-42010a9c016d',
statsd.socket.recv())
def test_tags_from_environment(self):
with preserve_environment_variable('DATADOG_TAGS'):
os.environ['DATADOG_TAGS'] = 'country:china,age:45,blue'
dogstatsd = DogStatsd(telemetry_min_flush_interval=0)
dogstatsd.socket = FakeSocket()
dogstatsd.gauge('gt', 123.4)
metric = 'gt:123.4|g|#country:china,age:45,blue'
self.assertEqual(metric, dogstatsd.socket.recv())
self.assertEqual(telemetry_metrics(tags="country:china,age:45,blue", bytes_sent=len(metric)), dogstatsd.socket.recv())
def test_tags_from_environment_and_constant(self):
with preserve_environment_variable('DATADOG_TAGS'):
os.environ['DATADOG_TAGS'] = 'country:china,age:45,blue'
statsd = DogStatsd(constant_tags=['country:canada', 'red'], telemetry_min_flush_interval=0)
statsd.socket = FakeSocket()
statsd.gauge('gt', 123.4)
tags="country:canada,red,country:china,age:45,blue"
metric = 'gt:123.4|g|#'+tags
assert_equal(metric, statsd.socket.recv())
assert_equal(telemetry_metrics(tags=tags, bytes_sent=len(metric)), statsd.socket.recv())
def test_tags_from_environment(self):
with preserve_environment_variable('DATADOG_TAGS'):
os.environ['DATADOG_TAGS'] = 'country:china,age:45,blue'
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"))
def test_entity_tag_from_environment_and_constant(self):
with preserve_environment_variable('DD_ENTITY_ID'):
os.environ['DD_ENTITY_ID'] = '04652bb7-19b7-11e9-9cc6-42010a9c016d'
statsd = DogStatsd(constant_tags=['country:canada', 'red'], telemetry_min_flush_interval=0)
statsd.socket = FakeSocket()
statsd.gauge('gt', 123.4)
metric = 'gt:123.4|g|#country:canada,red,dd.internal.entity_id:04652bb7-19b7-11e9-9cc6-42010a9c016d'
assert_equal(metric, statsd.socket.recv())
assert_equal(
telemetry_metrics(tags="country:canada,red,dd.internal.entity_id:04652bb7-19b7-11e9-9cc6-42010a9c016d",
bytes_sent=len(metric)), statsd.socket.recv())
def test_entity_tag_from_environment(self):
with preserve_environment_variable('DD_ENTITY_ID'):
os.environ['DD_ENTITY_ID'] = '04652bb7-19b7-11e9-9cc6-42010a9c016d'
dogstatsd = DogStatsd(telemetry_min_flush_interval=0)
dogstatsd.socket = FakeSocket()
dogstatsd.gauge('gt', 123.4)
metric = 'gt:123.4|g|#dd.internal.entity_id:04652bb7-19b7-11e9-9cc6-42010a9c016d'
self.assertEqual(metric, dogstatsd.socket.recv())
self.assertEqual(
telemetry_metrics(tags="dd.internal.entity_id:04652bb7-19b7-11e9-9cc6-42010a9c016d", bytes_sent=len(metric)),
dogstatsd.socket.recv())
def test_entity_tag_and_tags_from_environment_and_constant(self):
with preserve_environment_variable('DATADOG_TAGS'):
os.environ['DATADOG_TAGS'] = 'country:china,age:45,blue'
with preserve_environment_variable('DD_ENTITY_ID'):
os.environ['DD_ENTITY_ID'] = '04652bb7-19b7-11e9-9cc6-42010a9c016d'
dogstatsd = DogStatsd(constant_tags=['country:canada', 'red'], telemetry_min_flush_interval=0)
dogstatsd.socket = FakeSocket()
dogstatsd.gauge('gt', 123.4)
tags = "country:canada,red,country:china,age:45,blue,dd.internal.entity_id:04652bb7-19b7-11e9-9cc6-42010a9c016d"
metric = 'gt:123.4|g|#'+tags
self.assertEqual(metric, dogstatsd.socket.recv())
self.assertEqual(telemetry_metrics(tags=tags, bytes_sent=len(metric)), dogstatsd.socket.recv())
def test_dogstatsd_initialization_with_dd_env_service_version(self):
"""
Dogstatsd should automatically use DD_ENV, DD_SERVICE, and DD_VERSION (if present)
to set {env, service, version} as global tags for all metrics emitted.
"""
cases = [
# Test various permutations of setting DD_* env vars, as well as other global tag configuration.
# An empty string signifies that the env var either isn't set or that it is explicitly set to empty string.
('', '', '', '', [], []),
('prod', '', '', '', [], ['env:prod']),
('prod', 'dog', '', '', [], ['env:prod', 'service:dog']),
('prod', 'dog', 'abc123', '', [], ['env:prod', 'service:dog', 'version:abc123']),
('prod', 'dog', 'abc123', 'env:prod,type:app', [], ['env:prod', 'env:prod', 'service:dog', 'type:app', 'version:abc123']),
('prod', 'dog', 'abc123', 'env:prod2,type:app', [], ['env:prod', 'env:prod2', 'service:dog', 'type:app', 'version:abc123']),
('prod', 'dog', 'abc123', '', ['env:prod', 'type:app'], ['env:prod', 'env:prod', 'service:dog', 'type:app', 'version:abc123']),
('prod', 'dog', 'abc123', '', ['env:prod2', 'type:app'], ['env:prod', 'env:prod2', 'service:dog', 'type:app', 'version:abc123']),
('prod', 'dog', 'abc123', 'env:prod3,custom_tag:cat', ['env:prod2', 'type:app'], ['custom_tag:cat', 'env:prod', 'env:prod2', 'env:prod3', 'service:dog', 'type:app', 'version:abc123']),
]
for case in cases:
dd_env, dd_service, dd_version, datadog_tags, constant_tags, global_tags = case
with EnvVars(
env_vars={
'DATADOG_TAGS': datadog_tags,
'DD_ENV': dd_env,
'DD_SERVICE': dd_service,
'DD_VERSION': dd_version,
}
):
dogstatsd = DogStatsd(constant_tags=constant_tags, telemetry_min_flush_interval=0)
dogstatsd.socket = FakeSocket()
# Guarantee consistent ordering, regardless of insertion order.
dogstatsd.constant_tags.sort()
self.assertEqual(global_tags, dogstatsd.constant_tags)
# Make call with no tags passed; only the globally configured tags will be used.
global_tags_str = ','.join([t for t in global_tags])
dogstatsd.gauge('gt', 123.4)
# Protect against the no tags case.
metric = 'gt:123.4|g|#{}'.format(global_tags_str) if global_tags_str else 'gt:123.4|g'
self.assertEqual(metric, dogstatsd.socket.recv())
self.assertEqual(telemetry_metrics(tags=global_tags_str, bytes_sent=len(metric)), dogstatsd.socket.recv())
dogstatsd._reset_telemetry()
# Make another call with local tags passed.
passed_tags = ['env:prod', 'version:def456', 'custom_tag:toad']
all_tags_str = ','.join([t for t in passed_tags + global_tags])
dogstatsd.gauge('gt', 123.4, tags=passed_tags)
metric = 'gt:123.4|g|#{}'.format(all_tags_str)
self.assertEqual(metric, dogstatsd.socket.recv())
self.assertEqual(telemetry_metrics(tags=global_tags_str, bytes_sent=len(metric)), dogstatsd.socket.recv())
def test_entity_tag_and_tags_from_environment_and_constant(self):
with preserve_environment_variable('DATADOG_TAGS'):
os.environ['DATADOG_TAGS'] = 'country:china,age:45,blue'
with preserve_environment_variable('DD_ENTITY_ID'):
os.environ[
'DD_ENTITY_ID'] = '04652bb7-19b7-11e9-9cc6-42010a9c016d'
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))
def test_timing(self):
"""
Timings can be submitted from concurrent threads.
"""
# Create a DogStatsd client with a mocked socket
statsd = DogStatsd()
statsd.socket = self.socket
# Samples
values = set(range(10000))
# Submit metrics from different threads
self._submit_with_multiple_threads(statsd, "timing", values)
# All metrics were properly submitted
self.assertMetrics(values)
def test_timing(self):
"""
Timings can be submitted from concurrent threads.
"""
# Create a DogStatsd client with a mocked socket
statsd = DogStatsd()
statsd.socket = self.socket
# Samples
values = set(range(10000))
# Submit metrics from different threads
self._submit_with_multiple_threads(statsd, "timing", values)
# All metrics were properly submitted
self.assertMetrics(values)
def test_decrement(self):
"""
Decrements can be submitted from concurrent threads.
"""
# Create a DogStatsd client with a mocked socket
statsd = DogStatsd()
statsd.socket = self.socket
# Samples
values = set(range(10000))
expected_value = set([-value for value in values])
# Submit metrics from different threads
self._submit_with_multiple_threads(statsd, "decrement", expected_value)
# All metrics were properly submitted
self.assertMetrics(values)
def test_decrement(self):
"""
Decrements can be submitted from concurrent threads.
"""
# Create a DogStatsd client with a mocked socket
statsd = DogStatsd()
statsd.socket = self.socket
# Samples
values = set(range(10000))
expected_value = set([-value for value in values])
# Submit metrics from different threads
self._submit_with_multiple_threads(statsd, "decrement", expected_value)
# All metrics were properly submitted
self.assertMetrics(values)
def test_timed_context_manager_threaded(self, mock_time):
"""
`timed` context manager plays well with concurrent threads.
"""
# Create a DogStatsd client with a mocked socket
statsd = DogStatsd()
statsd.socket = self.socket
# Set up the mocked time
mock_time.return_value = 0
# Method to time
def bar():
"""
Wait 5 time units and return.
"""
initial_time = mock_time.return_value
with statsd.timed("foo"):
while mock_time.return_value < initial_time + 2:
pass
# Run the method within multiple threads
threads = []
for value in range(10):
t = threading.Thread(target=bar)
threads.append(t)
# Bump time so that previous thread can complete
mock_time.return_value += 1
t.start()
# Sleep to let the threads start
time.sleep(0.1)
# Bump time so that all threads completes
time.sleep(0.1)
mock_time.return_value += 1
time.sleep(0.1)
mock_time.return_value += 1
for t in threads:
t.join()
# All metrics were properly submitted
expected_values = [2 for _ in range(0, 10)]
self.assertMetrics(expected_values)
def test_timed_context_manager_threaded(self, mock_time):
"""
`timed` context manager plays well with concurrent threads.
"""
# Create a DogStatsd client with a mocked socket
statsd = DogStatsd()
statsd.socket = self.socket
# Set up the mocked time
mock_time.return_value = 0
# Method to time
def bar():
"""
Wait 5 time units and return.
"""
initial_time = mock_time.return_value
with statsd.timed("foo"):
while mock_time.return_value < initial_time + 2:
pass
# Run the method within multiple threads
threads = []
for value in range(10):
t = threading.Thread(target=bar)
threads.append(t)
# Bump time so that previous thread can complete
mock_time.return_value += 1
t.start()
# Sleep to let the threads start
time.sleep(0.1)
# Bump time so that all threads completes
time.sleep(0.1)
mock_time.return_value += 1
time.sleep(0.1)
mock_time.return_value += 1
for t in threads:
t.join()
# All metrics were properly submitted
expected_values = [2 for _ in xrange(0, 10)]
self.assertMetrics(expected_values)
def test_telemetry_flush_interval_batch(self):
dogstatsd = DogStatsd()
fake_socket = FakeSocket()
dogstatsd.socket = fake_socket
dogstatsd.open_buffer()
dogstatsd.gauge('gauge1', 1)
dogstatsd.gauge('gauge2', 2)
time1 = time.time()
# setting the last flush time in the past to trigger a telemetry flush
dogstatsd._last_flush_time = time1 - statsd._telemetry_flush_interval -1
dogstatsd.close_buffer()
metric = 'gauge1:1|g\ngauge2:2|g'
self.assert_equal_telemetry(metric, fake_socket.recv(2), telemetry=telemetry_metrics(metrics=2, bytes_sent=len(metric)))
# assert that _last_flush_time has been updated
self.assertTrue(time1 < dogstatsd._last_flush_time)
def test_accessing_socket_multiple_times_returns_same_socket(self):
dogpound = DogStatsd()
fresh_socket = FakeSocket()
dogpound.socket = fresh_socket
self.assertEqual(fresh_socket, dogpound.get_socket())
self.assertNotEqual(FakeSocket(), dogpound.get_socket())
def test_accessing_socket_multiple_times_returns_same_socket(self):
dogpound = DogStatsd()
fresh_socket = FakeSocket()
dogpound.socket = fresh_socket
assert_equal(fresh_socket, dogpound.get_socket())
assert FakeSocket() != dogpound.get_socket()
def test_accessing_socket_multiple_times_returns_same_socket(self):
dogpound = DogStatsd()
fresh_socket = FakeSocket()
dogpound.socket = fresh_socket
t.assert_equal(fresh_socket, dogpound.get_socket())
t.assert_not_equal(FakeSocket(), dogpound.get_socket())
