def test_batch_sender_flush_calls_transport_handler_with_correct_params( empty_annotations_dict, empty_binary_annotations_dict, fake_endpoint, ): # Tests that the transport handler is called with the value returned # by encoder.encode_queue. transport_handler = mock.Mock() transport_handler.get_max_payload_bytes = lambda: None encoder = MockEncoder(encoded_queue='foobar') sender = logging_helper.ZipkinBatchSender( transport_handler=transport_handler, max_portion_size=None, encoder=encoder, ) with sender: sender.add_span( SpanBuilder( trace_id='000000000000000f', name='span', parent_id='0000000000000001', span_id='0000000000000002', timestamp=26.0, duration=4.0, annotations=empty_annotations_dict, tags=empty_binary_annotations_dict, kind=Kind.CLIENT, local_endpoint=fake_endpoint, service_name='test_service', report_timestamp=False, )) transport_handler.assert_called_once_with('foobar')
def test_batch_sender_add_span_too_big(fake_endpoint): # This time we set max_payload_bytes to 1000, so we have to send more batches. # Each encoded span is 175 bytes, so we can fit 5 of those in 1000 bytes. mock_transport_handler = mock.Mock(spec=MockTransportHandler) mock_transport_handler.get_max_payload_bytes = lambda: 1000 sender = logging_helper.ZipkinBatchSender( mock_transport_handler, 100, get_encoder(Encoding.V1_THRIFT), ) with sender: for _ in range(201): sender.add_span( Span( trace_id='000000000000000f', name='span', parent_id='0000000000000001', span_id='0000000000000002', kind=Kind.CLIENT, timestamp=26.0, duration=4.0, local_endpoint=fake_endpoint, annotations={}, tags={}, )) # 5 spans per batch, means we need 201 / 4 = 41 batches to send them all. assert mock_transport_handler.call_count == 41 for i in range(40): # The first 40 batches have 5 spans of 197 bytes + 5 bytes of # list headers = 990 bytes assert len(mock_transport_handler.call_args_list[i][0][0]) == 990 # The last batch has a single remaining span of 197 bytes + 5 bytes of # list headers = 202 bytes assert len(mock_transport_handler.call_args_list[40][0][0]) == 202
def test_batch_sender_add_span( empty_annotations_dict, empty_binary_annotations_dict, fake_endpoint, ): # This test verifies it's possible to add 1 span without throwing errors. # It also checks that exiting the ZipkinBatchSender context manager # triggers a flush of all the already added spans. encoder = MockEncoder(encoded_queue='foobar') sender = logging_helper.ZipkinBatchSender( transport_handler=MockTransportHandler(), max_portion_size=None, encoder=encoder, ) with sender: sender.add_span( SpanBuilder( trace_id='000000000000000f', name='span', parent_id='0000000000000001', span_id='0000000000000002', timestamp=26.0, duration=4.0, annotations=empty_annotations_dict, tags=empty_binary_annotations_dict, kind=Kind.CLIENT, local_endpoint=fake_endpoint, service_name='test_service', )) assert encoder.encode_queue.call_count == 1
def test_batch_sender_flush_calls_transport_handler_with_correct_params( mock_encode_bytes_list, empty_annotations_dict, empty_binary_annotations_dict, fake_endpoint, ): # Tests that the transport handler is called with the value returned # by thrift.encode_bytes_list. transport_handler = mock.Mock() transport_handler.get_max_payload_bytes = lambda: None sender = logging_helper.ZipkinBatchSender(transport_handler) with sender: sender.add_span( span_id='0000000000000002', parent_span_id='0000000000000001', trace_id='000000000000000f', span_name='span', annotations=empty_annotations_dict, binary_annotations=empty_binary_annotations_dict, timestamp_s=None, duration_s=None, endpoint=fake_endpoint, sa_endpoint=None, ) transport_handler.assert_called_once_with( mock_encode_bytes_list.return_value)
def test_batch_sender_add_span(fake_endpoint): # This test verifies it's possible to add 1 span without throwing errors. # It also checks that exiting the ZipkinBatchSender context manager # triggers a flush of all the already added spans. encoder = MockEncoder(encoded_queue="foobar") sender = logging_helper.ZipkinBatchSender( transport_handler=MockTransportHandler(), max_portion_size=None, encoder=encoder, ) with sender: sender.add_span( Span( trace_id="000000000000000f", name="span", parent_id="0000000000000001", span_id="0000000000000002", kind=Kind.CLIENT, timestamp=26.0, duration=4.0, local_endpoint=fake_endpoint, annotations={}, tags={}, ) ) assert encoder.encode_queue.call_count == 1
def test_batch_sender_defensive_about_transport_handler( mock_encode_bytes_list, create_sp, empty_annotations_dict, empty_binary_annotations_dict, fake_endpoint, ): """Make sure log_span doesn't try to call the transport handler if it's None.""" sender = logging_helper.ZipkinBatchSender(transport_handler=None) with sender: sender.add_span( span_id='0000000000000002', parent_span_id='0000000000000001', trace_id='00000000000000015', span_name='span', annotations=empty_annotations_dict, binary_annotations=empty_binary_annotations_dict, timestamp_s=None, duration_s=None, endpoint=fake_endpoint, sa_endpoint=None, ) assert create_sp.call_count == 1 assert mock_encode_bytes_list.call_count == 0
def test_batch_sender_add_span_too_big( empty_annotations_dict, empty_binary_annotations_dict, fake_endpoint, ): # This time we set max_payload_bytes to 1000, so we have to send more batches. # Each encoded span is 65 bytes, so we can fit 15 of those in 1000 bytes. mock_transport_handler = mock.Mock(spec=MockTransportHandler) mock_transport_handler.get_max_payload_bytes = lambda: 1000 sender = logging_helper.ZipkinBatchSender(mock_transport_handler, 100) with sender: for _ in range(201): sender.add_span( span_id='0000000000000002', parent_span_id='0000000000000001', trace_id='000000000000000f', span_name='span', annotations=empty_annotations_dict, binary_annotations=empty_binary_annotations_dict, timestamp_s=None, duration_s=None, endpoint=fake_endpoint, sa_endpoint=None, ) # 15 spans per batch, means we need 201 / 15 = 14 batches to send them all. assert mock_transport_handler.call_count == 14 for i in range(13): # The first 13 batches have 15 spans of 65 bytes + 5 bytes of # list headers = 980 bytes assert len(mock_transport_handler.call_args_list[i][0][0]) == 980 # The last batch has the 6 remaining spans of 65 bytes + 5 bytes of # list headers = 395 bytes assert len(mock_transport_handler.call_args_list[13][0][0]) == 395
def test_batch_sender_add_span_many_times( mock_encode_bytes_list, empty_annotations_dict, empty_binary_annotations_dict, fake_endpoint, ): # We create MAX_PORTION_SIZE * 2 + 1 spans, so we should trigger flush 3 # times, once every MAX_PORTION_SIZE spans. sender = logging_helper.ZipkinBatchSender(MockTransportHandler()) max_portion_size = logging_helper.ZipkinBatchSender.MAX_PORTION_SIZE with sender: for _ in range(max_portion_size * 2 + 1): sender.add_span( span_id='0000000000000002', parent_span_id='0000000000000001', trace_id='000000000000000f', span_name='span', annotations=empty_annotations_dict, binary_annotations=empty_binary_annotations_dict, timestamp_s=None, duration_s=None, endpoint=fake_endpoint, sa_endpoint=None, ) assert mock_encode_bytes_list.call_count == 3 assert len( mock_encode_bytes_list.call_args_list[0][0][0]) == max_portion_size assert len( mock_encode_bytes_list.call_args_list[1][0][0]) == max_portion_size assert len(mock_encode_bytes_list.call_args_list[2][0][0]) == 1
def test_batch_sender_with_error_on_exit(): sender = logging_helper.ZipkinBatchSender( MockTransportHandler(), None, MockEncoder(), ) with pytest.raises(ZipkinError): with sender: raise Exception("Error!")
def test_batch_sender_defensive_about_transport_handler( empty_annotations_dict, empty_binary_annotations_dict, fake_endpoint, ): """Make sure log_span doesn't try to call the transport handler if it's None.""" encoder = MockEncoder() sender = logging_helper.ZipkinBatchSender( transport_handler=None, max_portion_size=None, encoder=encoder, ) with sender: sender.add_span( SpanBuilder( trace_id='000000000000000f', name='span', parent_id='0000000000000001', span_id='0000000000000002', timestamp=26.0, duration=4.0, annotations=empty_annotations_dict, tags=empty_binary_annotations_dict, kind=Kind.CLIENT, local_endpoint=fake_endpoint, service_name='test_service', report_timestamp=False, )) assert encoder.encode_span.call_count == 1 assert encoder.encode_queue.call_count == 0
def test_batch_sender_add_span_many_times(fake_endpoint): # We create MAX_PORTION_SIZE * 2 + 1 spans, so we should trigger flush 3 # times, once every MAX_PORTION_SIZE spans. encoder = MockEncoder() sender = logging_helper.ZipkinBatchSender( transport_handler=MockTransportHandler(), max_portion_size=None, encoder=encoder, ) max_portion_size = logging_helper.ZipkinBatchSender.MAX_PORTION_SIZE with sender: for _ in range(max_portion_size * 2 + 1): sender.add_span( Span( trace_id='000000000000000f', name='span', parent_id='0000000000000001', span_id='0000000000000002', kind=Kind.CLIENT, timestamp=26.0, duration=4.0, local_endpoint=fake_endpoint, annotations={}, tags={}, )) assert encoder.encode_queue.call_count == 3 assert len( encoder.encode_queue.call_args_list[0][0][0]) == max_portion_size assert len( encoder.encode_queue.call_args_list[1][0][0]) == max_portion_size assert len(encoder.encode_queue.call_args_list[2][0][0]) == 1
def test_batch_sender_add_span(thrift_objs): # Not much logic here, so this is basically a smoke test sender = logging_helper.ZipkinBatchSender(mock_transport_handler) with sender: sender.add_span( span_id='0000000000000002', parent_span_id='0000000000000001', trace_id='000000000000000f', span_name='span', annotations='ann', binary_annotations='binary_ann', timestamp_s=None, duration_s=None, ) assert thrift_objs.call_count == 1
def test_batch_sender_flush_calls_transport_handler_with_correct_params( thrift_objs, create_sp): transport_handler = mock.Mock() sender = logging_helper.ZipkinBatchSender(transport_handler) with sender: sender.add_span( span_id='0000000000000002', parent_span_id='0000000000000001', trace_id='00000000000000015', span_name='span', annotations='ann', binary_annotations='binary_ann', timestamp_s=None, duration_s=None, ) transport_handler.assert_called_once_with(thrift_objs.return_value)
def test_batch_sender_defensive_about_transport_handler(thrift_obj, create_sp): """Make sure log_span doesn't try to call the transport handler if it's None.""" sender = logging_helper.ZipkinBatchSender(transport_handler=None) with sender: sender.add_span( span_id='0000000000000002', parent_span_id='0000000000000001', trace_id='00000000000000015', span_name='span', annotations='ann', binary_annotations='binary_ann', timestamp_s=None, duration_s=None, ) assert create_sp.call_count == 1 assert thrift_obj.call_count == 0
def test_batch_sender_add_span_many_times(thrift_obj): sender = logging_helper.ZipkinBatchSender(mock_transport_handler) max_portion_size = logging_helper.ZipkinBatchSender.MAX_PORTION_SIZE with sender: for _ in range(max_portion_size * 2 + 1): sender.add_span( span_id='0000000000000002', parent_span_id='0000000000000001', trace_id='000000000000000f', span_name='span', annotations='ann', binary_annotations='binary_ann', timestamp_s=None, duration_s=None, ) assert thrift_obj.call_count == 3 assert len(thrift_obj.call_args_list[0][0][0]) == max_portion_size assert len(thrift_obj.call_args_list[1][0][0]) == max_portion_size assert len(thrift_obj.call_args_list[2][0][0]) == 1
def test_batch_sender_add_span( mock_encode_bytes_list, empty_annotations_dict, empty_binary_annotations_dict, fake_endpoint, ): # This test verifies it's possible to add 1 span without throwing errors. # It also checks that exiting the ZipkinBatchSender context manager # triggers a flush of all the already added spans. sender = logging_helper.ZipkinBatchSender(MockTransportHandler()) with sender: sender.add_span( span_id='0000000000000002', parent_span_id='0000000000000001', trace_id='000000000000000f', span_name='span', annotations=empty_annotations_dict, binary_annotations=empty_binary_annotations_dict, timestamp_s=None, duration_s=None, endpoint=fake_endpoint, sa_endpoint=None, ) assert mock_encode_bytes_list.call_count == 1
def test_batch_sender_defensive_about_transport_handler(fake_endpoint): """Make sure log_span doesn't try to call the transport handler if it's None.""" encoder = MockEncoder() sender = logging_helper.ZipkinBatchSender( transport_handler=None, max_portion_size=None, encoder=encoder, ) with sender: sender.add_span( Span( trace_id="000000000000000f", name="span", parent_id="0000000000000001", span_id="0000000000000002", kind=Kind.CLIENT, timestamp=26.0, duration=4.0, local_endpoint=fake_endpoint, annotations={}, tags={}, ) ) assert encoder.encode_span.call_count == 1 assert encoder.encode_queue.call_count == 0
def test_batch_sender_with_error_on_exit(): sender = logging_helper.ZipkinBatchSender(mock_transport_handler) with pytest.raises(ZipkinError): with sender: raise Exception('Error!')