def test_hook_exception(self):
message = 'exception message'
def exception_hook(exception, **kwargs):
self.assertIsInstance(exception, TimeExecutionException)
return dict(exception_message=str(exception))
def asserts(name, **data):
self.assertEqual(data['exception_message'], message)
configure(
backends=[AssertBackend(asserts)],
hooks=[exception_hook]
)
class TimeExecutionException(Exception):
pass
@time_execution
def go():
raise TimeExecutionException(message)
with self.assertRaises(TimeExecutionException):
go()
def test_with_origin(self):
with settings(origin='unit_test'):
go()
for metric in self._query_backend(go.fqn)['hits']['hits']:
self.assertEqual(metric['_source']['origin'], 'unit_test')
def test_with_origin(self):
with settings(origin="unit_test"):
go()
for metric in self._query_backend(go.get_fqn())["hits"]["hits"]:
self.assertEqual(metric["_source"]["origin"], "unit_test")
def test_with_origin(self):
with settings(origin='unit_test'):
go()
for metric in self._query_backend():
assert metric.value['origin'] == 'unit_test'
def test_duration_field(self):
with settings(duration_field='my_duration'):
go()
for metric in self._query_backend(go.fqn):
self.assertTrue('my_duration' in metric)
def test_duration_field(self):
with settings(duration_field="my_duration"):
go()
for metric in self._query_backend(go.fqn):
self.assertTrue("my_duration" in metric)
def test_with_origin(self):
with settings(origin='unit_test'):
go()
for metric in self._query_backend(go.fqn)['hits']['hits']:
self.assertEqual(metric['_source']['origin'], 'unit_test')
def test_with_origin(self):
with settings(origin="unit_test"):
go()
for metric in self._query_backend(go.fqn):
self.assertEqual(metric["origin"], "unit_test")
def test_double_start(self):
self.assertEqual(0, self.backend.fetched_items)
go()
time.sleep(2 * self.qtimeout)
self.assertEqual(1, self.backend.fetched_items)
# try to double start
self.backend.start_worker()
self.assertEqual(1, self.backend.fetched_items)
def test_with_arguments(self):
go('hello', world='world')
Dummy().go('hello', world='world')
metrics = self._query_backend()
assert len([m for m in metrics if m.value['name'] == get_fqn(go)]) == 1
assert len([m for m in metrics if m.value['name'] == get_fqn(Dummy().go)]) == 1
def test_double_start(self):
self.assertEqual(0, self.backend.fetched_items)
go()
time.sleep(2 * self.qtimeout)
self.assertEqual(1, self.backend.fetched_items)
# try to double start
self.backend.start_worker()
self.assertEqual(1, self.backend.fetched_items)
def test_duration_field(self):
configure(backends=[self.backend], duration_field='my_duration')
go()
for metric in self._query_backend(go.fqn)['hits']['hits']:
self.assertTrue('my_duration' in metric['_source'])
def test_duration_field(self):
configure(backends=[self.backend], duration_field='my_duration')
go()
for metric in self._query_backend(go.fqn)['hits']['hits']:
self.assertTrue('my_duration' in metric['_source'])
def test_with_arguments(self):
go('hello', world='world')
Dummy().go('hello', world='world')
metrics = list(self._query_backend(go.fqn))
self.assertEqual(len(metrics), 1)
metrics = list(self._query_backend(Dummy().go.fqn))
self.assertEqual(len(metrics), 1)
def test_with_arguments(self):
go('hello', world='world')
Dummy().go('hello', world='world')
metrics = self._query_backend(go.fqn)
self.assertEqual(metrics['hits']['total'], 1)
metrics = self._query_backend(Dummy().go.fqn)
self.assertEqual(metrics['hits']['total'], 1)
def test_with_arguments(self):
go('hello', world='world')
Dummy().go('hello', world='world')
metrics = self._query_backend(go.fqn)
self.assertEqual(metrics['hits']['total'], 1)
metrics = self._query_backend(Dummy().go.fqn)
self.assertEqual(metrics['hits']['total'], 1)
def test_with_arguments(self):
go('hello', world='world')
Dummy().go('hello', world='world')
metrics = list(self._query_backend(get_fqn(go)))
self.assertEqual(len(metrics), 1)
metrics = list(self._query_backend(get_fqn(Dummy().go)))
self.assertEqual(len(metrics), 1)
def test_with_arguments(self):
go("hello", world="world")
Dummy().go("hello", world="world")
metrics = list(self._query_backend(get_fqn(go)))
self.assertEqual(len(metrics), 1)
metrics = list(self._query_backend(get_fqn(Dummy().go)))
self.assertEqual(len(metrics), 1)
def test_with_arguments(self):
go("hello", world="world")
Dummy().go("hello", world="world")
metrics = self._query_backend(get_fqn(go))
self.assertEqual(metrics["hits"]["total"], 1)
metrics = self._query_backend(get_fqn(Dummy().go))
self.assertEqual(metrics["hits"]["total"], 1)
def test_time_execution(self):
count = 4
for i in range(count):
go()
metrics = list(self._query_backend(go.fqn))
self.assertEqual(len(metrics), count)
for metric in metrics:
self.assertTrue('value' in metric)
def test_time_execution(self):
count = 4
for i in range(count):
go()
metrics = self._query_backend(go.fqn)
self.assertEqual(metrics['hits']['total'], count)
for metric in metrics['hits']['hits']:
self.assertTrue('value' in metric['_source'])
def test_pipeline_present(self, mocked_index):
backend = ElasticsearchBackend(ELASTICSEARCH_HOST,
index="pipelinetest",
pipeline="custom-pipeline")
with settings(backends=[backend]):
go()
assert "pipeline" in mocked_index.call_args.kwargs
assert mocked_index.call_args.kwargs[
"pipeline"] == "custom-pipeline"
ElasticTestMixin._clear(backend)
def test_hook_func_kwargs(self):
param = "foo"
@time_execution
def go(param1):
return "200 OK"
def hook(response, exception, metric, func, func_args, func_kwargs):
assert func_kwargs["param1"] == param
with settings(hooks=[hook]):
go(param1=param)
def test_hook_func_kwargs(self):
param = 'foo'
@time_execution
def go(param1):
return '200 OK'
def hook(response, exception, metric, func_args, func_kwargs):
self.assertEqual(func_kwargs['param1'], param)
with settings(hooks=[hook]):
go(param1=param)
def test_hook_func_kwargs(self):
param = 'foo'
@time_execution
def go(param1):
return '200 OK'
def hook(response, exception, metric, func_args, func_kwargs):
assert func_kwargs['param1'] == param
with settings(hooks=[hook]):
go(param1=param)
def test_time_execution(self):
count = 4
for i in range(count):
go()
metrics = self._query_backend()
assert len(metrics) == count
for metric in metrics:
assert metric.value
def test_time_execution(self):
count = 4
for i in range(count):
go()
metrics = self._query_backend(go.fqn)
self.assertEqual(metrics['hits']['total'], count)
for metric in metrics['hits']['hits']:
self.assertTrue('value' in metric['_source'])
def test_hook_func_args(self):
param = 'foo'
@time_execution
def go(param1):
return '200 OK'
def hook(response, exception, metric, func_args, func_kwargs):
self.assertEqual(func_args[0], param)
with settings(hooks=[hook]):
go(param)
def test_decorator(self):
with freeze_time('2016-08-01 00:00:00'):
go()
# ensure worker thread catches up
time.sleep(2 * self.backend.bulk_timeout)
mocked_write = self.mocked_backend.bulk_write
self.assertEqual(1, self.backend.fetched_items)
mocked_write.assert_called_with([{
'timestamp': datetime(2016, 8, 1, 0, 0),
'hostname': SHORT_HOSTNAME,
'name': 'tests.conftest.go',
'value': 0.0,
}])
def test_hook_func_args(self):
param = 'foo'
def hook(response, exception, metric, func_args, func_kwargs):
self.assertEqual(func_args[0], param)
configure(hooks=[hook])
@time_execution
def go(param1):
return '200 OK'
go(param)
def test_hook_func_kwargs(self):
param = 'foo'
def hook(response, exception, metric, func_args, func_kwargs):
self.assertEqual(func_kwargs['param1'], param)
configure(hooks=[hook])
@time_execution
def go(param1):
return '200 OK'
go(param1=param)
def test_worker_sends_remainder(self):
self.stop_worker()
self.mocked_backend.bulk_write.side_effect = RuntimeError('mock')
loops_count = 3
self.assertTrue(loops_count < self.backend.bulk_size)
for _ in range(loops_count):
go()
self.backend.worker_limit = loops_count
self.backend.worker()
self.assertEqual(loops_count, self.backend.fetched_items)
mocked_bulk_write = self.mocked_backend.bulk_write
mocked_bulk_write.assert_called_once()
self.assertEqual(loops_count, len(mocked_bulk_write.call_args[0][0]))
def test_time_execution(self):
count = 4
for i in range(count):
go()
metrics = self._query_backend(go.get_fqn())
self.assertEqual(metrics["hits"]["total"], count)
for metric in metrics["hits"]["hits"]:
self.assertTrue("value" in metric["_source"])
self.assertFalse("origin" in metric["_source"])
def test_hook(self):
def test_args(**kwargs):
self.assertIn('response', kwargs)
self.assertIn('exception', kwargs)
self.assertIn('metric', kwargs)
return dict()
def test_metadata(*args, **kwargs):
return dict(test_key='test value')
with settings(hooks=[test_args, test_metadata]):
go()
for metric in self._query_backend():
assert metric.value['test_key'] == 'test value'
def test_hook(self):
def test_args(**kwargs):
self.assertIn("response", kwargs)
self.assertIn("exception", kwargs)
self.assertIn("metric", kwargs)
return dict()
def test_metadata(*args, **kwargs):
return dict(test_key="test value")
with settings(hooks=[test_args, test_metadata]):
go()
for metric in self._query_backend(go.get_fqn())["hits"]["hits"]:
self.assertEqual(metric["_source"]["test_key"], "test value")
def test_decorator(self):
now = datetime.now()
with freeze_time(now):
go()
# ensure worker thread catches up
time.sleep(2 * self.backend.bulk_timeout)
mocked_write = self.mocked_backend.bulk_write
self.assertEqual(1, self.backend.fetched_items)
mocked_write.assert_called_with([{
'timestamp': now,
'hostname': SHORT_HOSTNAME,
'name': 'tests.conftest.go',
'value': 0.0,
}])
def test_hook(self):
def test_args(**kwargs):
self.assertIn('response', kwargs)
self.assertIn('exception', kwargs)
self.assertIn('metric', kwargs)
return dict()
def test_metadata(*args, **kwargs):
return dict(test_key='test value')
with settings(hooks=[test_args, test_metadata]):
go()
for metric in self._query_backend(go.fqn)['hits']['hits']:
self.assertEqual(metric['_source']['test_key'], 'test value')
def test_hook(self):
def test_args(**kwargs):
self.assertIn('response', kwargs)
self.assertIn('exception', kwargs)
self.assertIn('metric', kwargs)
return dict()
def test_metadata(*args, **kwargs):
return dict(test_key='test value')
with settings(hooks=[test_args, test_metadata]):
go()
for metric in self._query_backend(go.fqn)['hits']['hits']:
self.assertEqual(metric['_source']['test_key'], 'test value')
def test_hook(self):
def test_args(**kwargs):
assert 'response' in kwargs
assert 'exception' in kwargs
assert 'metric' in kwargs
return dict()
def test_metadata(*args, **kwargs):
return dict(test_key='test value')
def asserts(name, **data):
assert data['test_key'] == 'test value'
with settings(backends=[AssertBackend(asserts)],
hooks=[test_args, test_metadata]):
go()
def test_queue_congestion(self):
# assure worker is stopped
self.stop_worker()
# fill in the queue
for _ in range(self.qsize * 2):
go()
self.assertTrue(self.backend._queue.full())
self.resume_worker(bulk_timeout=self.qtimeout)
# wait until all metrics are picked up
time.sleep(self.qsize * self.qtimeout)
# check that metrics in the queue were sent with bulk_write calls
call_args_list = self.mocked_backend.bulk_write.call_args_list
self.assertEqual(self.qsize,
sum(len(args[0]) for args, _ in call_args_list))
def test_hook(self):
def test_args(**kwargs):
assert "response" in kwargs
assert "exception" in kwargs
assert "metric" in kwargs
return dict()
def test_metadata(*args, **kwargs):
return dict(test_key="test value")
def asserts(name, **data):
assert data["test_key"] == "test value"
with settings(backends=[AssertBackend(asserts)],
hooks=[test_args, test_metadata]):
go()
def test_hook(self):
def test_args(**kwargs):
self.assertIn("response", kwargs)
self.assertIn("exception", kwargs)
self.assertIn("metric", kwargs)
return dict()
def test_metadata(*args, **kwargs):
return dict(test_key="test value")
with settings(hooks=[test_args, test_metadata]):
go()
for metric in self._query_backend(go.fqn):
self.assertEqual(metric["test_key"], "test value")
def test_hook(self):
def test_args(**kwargs):
self.assertIn('response', kwargs)
self.assertIn('exception', kwargs)
self.assertIn('metric', kwargs)
return dict()
def test_metadata(*args, **kwargs):
return dict(test_key='test value')
def asserts(name, **data):
self.assertEqual(data['test_key'], 'test value')
with settings(backends=[AssertBackend(asserts)],
hooks=[test_args, test_metadata]):
go()
def test_hook(self):
def test_args(**kwargs):
self.assertIn('response', kwargs)
self.assertIn('exception', kwargs)
self.assertIn('metric', kwargs)
return dict()
def test_metadata(*args, **kwargs):
return dict(test_key='test value')
configure(backends=[self.backend], hooks=[test_args, test_metadata])
go()
for metric in self._query_backend(go.fqn):
self.assertEqual(metric['test_key'], 'test value')
def test_worker_sends_remainder(self):
self.stop_worker()
self.mocked_backend.bulk_write.side_effect = RuntimeError('mock')
loops_count = 3
self.assertTrue(loops_count < self.backend.bulk_size)
for _ in range(loops_count):
go()
self.backend.worker_limit = loops_count
self.backend.worker()
self.assertEqual(loops_count, self.backend.fetched_items)
mocked_bulk_write = self.mocked_backend.bulk_write
mocked_bulk_write.assert_called_once()
self.assertEqual(
loops_count,
len(mocked_bulk_write.call_args[0][0])
)
def test_hook(self):
def test_args(**kwargs):
self.assertIn('response', kwargs)
self.assertIn('exception', kwargs)
self.assertIn('metric', kwargs)
return dict()
def test_metadata(*args, **kwargs):
return dict(test_key='test value')
configure(backends=[self.backend], hooks=[test_args, test_metadata])
go()
for metric in self._query_backend(go.fqn):
self.assertEqual(metric['test_key'], 'test value')
def test_queue_congestion(self):
# assure worker is stopped
self.stop_worker()
# fill in the queue
for _ in range(self.qsize * 2):
go()
self.assertTrue(self.backend._queue.full())
self.resume_worker(bulk_timeout=self.qtimeout)
# wait until all metrics are picked up
time.sleep(self.qsize * self.qtimeout)
# check that metrics in the queue were sent with bulk_write calls
call_args_list = self.mocked_backend.bulk_write.call_args_list
self.assertEqual(
self.qsize,
sum(len(args[0]) for args, _ in call_args_list)
)
def test_flush_metrics_when_parent_process_not_alive(self):
self.stop_worker()
loops = 3
with mock.patch.object(self.backend, 'parent_thread',
spec=Thread) as parent_thread:
parent_thread.is_alive.return_value = False
for _ in range(loops):
go()
#: do not allow flush metrics before checking if parent_thread is alive
self.backend.worker_limit = loops + 1
self.backend.worker()
mocked_bulk_write = self.mocked_backend.bulk_write
mocked_bulk_write.assert_called_once()
self.assertEqual(loops, len(mocked_bulk_write.call_args[0][0]))
def test_hook_exception_args(self):
message = 'exception message'
class TimeExecutionException(Exception):
def __init__(self, msg, required):
super(TimeExecutionException, self).__init__(msg)
def exception_hook(exception, **kwargs):
self.assertIsInstance(exception, TimeExecutionException)
return dict(exception_message=str(exception))
def asserts(name, **data):
self.assertEqual(data['exception_message'], message)
@time_execution
def go():
raise TimeExecutionException(message, True)
with settings(backends=[AssertBackend(asserts)],
hooks=[exception_hook]):
with self.assertRaises(TimeExecutionException):
go()
def test_duration_field(self):
with settings(duration_field='my_duration'):
go()
for metric in self._query_backend(go.fqn)['hits']['hits']:
self.assertTrue('my_duration' in metric['_source'])
def test_write_method(self):
go()
time.sleep(2 * self.backend.bulk_timeout)
metrics = self._query_backend(self.backend.backend, go.fqn)
self.assertEqual(metrics['hits']['total'], 1)
def test_write_error(self):
self.mocked_backend.write.side_effect = RuntimeError('mocked')
go()
time.sleep(2 * self.qtimeout)
