def test_run_hooks_and_send_presend_hook(self):
''' ensure send works when presend hook is defined '''
m_client = Mock()
tracer = SynchronousTracer(m_client)
m_span = Mock()
def _presend_hook(fields):
fields["thing i want"] = "put it there"
del fields["thing i don't want"]
m_span = Mock()
m_span.event.fields.return_value = {
"thing i don't want": "get it out of here",
"happy data": "so happy",
}
tracer.register_hooks(presend=_presend_hook)
with patch('beeline.trace._should_sample') as m_sample_fn:
m_sample_fn.return_value = True
tracer._run_hooks_and_send(m_span)
m_span.event.send_presampled.assert_called_once_with() # pylint: disable=no-member
self.assertDictEqual(
m_span.event.fields(),
{
"thing i want": "put it there",
"happy data": "so happy",
},
)
def test_run_hooks_and_send_sampler(self):
''' ensure send works with a sampler hook defined '''
m_client = Mock()
tracer = SynchronousTracer(m_client)
m_span = Mock()
def _sampler_drop_all(fields):
return False, 0
tracer.register_hooks(sampler=_sampler_drop_all)
with patch('beeline.trace._should_sample') as m_sample_fn:
m_sample_fn.return_value = True
tracer._run_hooks_and_send(m_span)
# sampler ensures we drop everything
m_span.event.send.assert_not_called() # pylint: disable=no-member
m_span.event.send_presampled.assert_not_called() # pylint: disable=no-member
def _sampler_drop_none(fields):
return True, 100
tracer.register_hooks(sampler=_sampler_drop_none)
m_span.reset_mock()
with patch('beeline.trace._should_sample') as m_sample_fn:
m_sample_fn.return_value = True
tracer._run_hooks_and_send(m_span)
# sampler drops nothing, _should_sample rigged to always return true so
# we always call send_presampled
m_span.event.send.assert_not_called() # pylint: disable=no-member
m_span.event.send_presampled.assert_called_once_with() # pylint: disable=no-member
# ensure event is updated with new sample rate
self.assertEqual(m_span.event.sample_rate, 100)
def test_run_hooks_and_send_no_hooks(self):
''' ensure send works when no hooks defined '''
m_client = Mock()
tracer = SynchronousTracer(m_client)
m_span = Mock()
with patch('beeline.trace._should_sample') as m_sample_fn:
m_sample_fn.return_value = True
tracer._run_hooks_and_send(m_span)
# no hooks - trace's _should_sample is rigged to always return True, so we
# always call send_presampled
# send should never be called because at a minimum we always do deterministic
# sampling
m_span.event.send.assert_not_called() # pylint: disable=no-member
m_span.event.send_presampled.assert_called_once_with() # pylint: disable=no-member
def test_add_rollup_field_propagates(self):
m_client = Mock()
tracer = SynchronousTracer(m_client)
tracer._run_hooks_and_send = Mock()
span1 = tracer.start_trace(context={'name': 'root'})
event1 = m_client.new_event.return_value
span2 = tracer.start_span(context={'name': 'middle'})
event2 = m_client.new_event.return_value
span3 = tracer.start_span(context={'name': 'inner1'})
event3 = m_client.new_event.return_value
tracer.add_rollup_field('database_ms', 17)
tracer.add_rollup_field('calories', 180)
tracer.add_rollup_field('database_ms', 23.1)
event3.add_field.reset_mock()
tracer.finish_span(span3)
event3.add_field.assert_has_calls([
call('database_ms', 17.0 + 23.1),
call('calories', 180.0),
call('duration_ms', ANY),
],
any_order=True)
span4 = tracer.start_span(context={'name': 'inner2'})
event4 = m_client.new_event.return_value
tracer.add_rollup_field('calories', 120)
event4.add_field.reset_mock()
tracer.finish_span(span4)
event4.add_field.assert_has_calls([
call('calories', 120.0),
call('duration_ms', ANY),
],
any_order=True)
event2.add_field.reset_mock()
tracer.finish_span(span2)
event2.add_field.assert_has_calls(
[
# This intermediate span doesn't get any rollup fields.
call('duration_ms', ANY),
],
any_order=True)
event1.add_field.reset_mock()
tracer.finish_span(span1)
event1.add_field.assert_has_calls([
call('rollup.database_ms', 17.0 + 23.1),
call('rollup.calories', 180.0 + 120.0),
call('duration_ms', ANY),
],
any_order=True)
def test_custom_dataset_propagates_to_event(self):
dataset = 'flibble'
m_client = Mock()
tracer = SynchronousTracer(m_client)
tracer._run_hooks_and_send = Mock()
span = tracer.start_trace(dataset=dataset)
event = m_client.new_event.return_value
tracer.finish_span(span)
self.assertEqual(event.dataset, dataset)