def test_batch_sender_add_span_not_sampled_with_firehose(
add_span_mock, flush_mock, time_mock):
attr = ZipkinAttrs(
trace_id='0000000000000001',
span_id='0000000000000002',
parent_span_id=None,
flags=None,
is_sampled=False,
)
span_storage = SpanStorage()
transport_handler = mock.Mock()
firehose_handler = mock.Mock()
context = logging_helper.ZipkinLoggingContext(
zipkin_attrs=attr,
endpoint=create_endpoint(80, 'test_server', '127.0.0.1'),
span_name='span_name',
transport_handler=transport_handler,
report_root_timestamp=False,
span_storage=span_storage,
firehose_handler=firehose_handler,
service_name='test_server',
encoding=Encoding.V1_JSON,
)
context.start_timestamp = 24
context.response_status_code = 200
context.binary_annotations_dict = {'k': 'v'}
time_mock.return_value = 42
context.emit_spans()
assert add_span_mock.call_count == 1
assert flush_mock.call_count == 1
def test_batch_sender_add_span_not_sampled_with_firehose(
add_span_mock, flush_mock, time_mock):
attr = ZipkinAttrs(
trace_id='0000000000000001',
span_id='0000000000000002',
parent_span_id=None,
flags=None,
is_sampled=False,
)
log_handler = logging_helper.ZipkinLoggerHandler(attr)
transport_handler = mock.Mock()
firehose_handler = mock.Mock()
context = logging_helper.ZipkinLoggingContext(
zipkin_attrs=attr,
thrift_endpoint='thrift_endpoint',
log_handler=log_handler,
span_name='span_name',
transport_handler=transport_handler,
report_root_timestamp=False,
firehose_handler=firehose_handler,
)
context.start_timestamp = 24
context.response_status_code = 200
context.binary_annotations_dict = {'k': 'v'}
time_mock.return_value = 42
context.log_spans()
assert add_span_mock.call_count == 1
assert flush_mock.call_count == 1
def test_batch_sender_add_span_not_called_if_not_sampled(
add_span_mock, flush_mock):
attr = ZipkinAttrs(
trace_id='0000000000000001',
span_id='0000000000000002',
parent_span_id=None,
flags=None,
is_sampled=False,
)
span_storage = SpanStorage()
transport_handler = mock.Mock()
context = logging_helper.ZipkinLoggingContext(
zipkin_attrs=attr,
endpoint=create_endpoint(80, 'test_server', '127.0.0.1'),
span_name='span_name',
transport_handler=transport_handler,
report_root_timestamp=False,
span_storage=span_storage,
service_name='test_server',
encoding=Encoding.V1_JSON,
)
context.emit_spans()
assert add_span_mock.call_count == 0
assert flush_mock.call_count == 0
def test_batch_sender_add_span_not_sampled_with_firehose(
add_span_mock, flush_mock, time_mock
):
attr = ZipkinAttrs(
trace_id="0000000000000001",
span_id="0000000000000002",
parent_span_id=None,
flags=None,
is_sampled=False,
)
tracer = MockTracer()
transport_handler = mock.Mock()
firehose_handler = mock.Mock()
context = logging_helper.ZipkinLoggingContext(
zipkin_attrs=attr,
endpoint=create_endpoint(80, "test_server", "127.0.0.1"),
span_name="span_name",
transport_handler=transport_handler,
report_root_timestamp=False,
get_tracer=lambda: tracer,
firehose_handler=firehose_handler,
service_name="test_server",
encoding=Encoding.V1_JSON,
)
context.start_timestamp = 24
context.response_status_code = 200
context.tags = {"k": "v"}
time_mock.return_value = 42
context.emit_spans()
assert add_span_mock.call_count == 1
assert flush_mock.call_count == 1
def test_zipkin_logging_client_context_log_spans(copy_endpoint_mock,
bin_ann_list_builder,
ann_list_builder,
add_span_mock, flush_mock,
time_mock):
# This lengthy function tests that the logging context properly
# logs root client span
trace_id = '000000000000000f'
client_span_id = '0000000000000003'
attr = ZipkinAttrs(
trace_id=trace_id,
span_id=client_span_id,
parent_span_id=None,
flags=None,
is_sampled=True,
)
handler = logging_helper.ZipkinLoggerHandler(attr)
handler.client_spans = []
# Each of the thrift annotation helpers just reflects its first arg
# so the annotation dicts can be checked.
ann_list_builder.side_effect = lambda x, y: x
bin_ann_list_builder.side_effect = lambda x, y: x
transport_handler = mock.Mock()
context = logging_helper.ZipkinLoggingContext(
zipkin_attrs=attr,
thrift_endpoint='thrift_endpoint',
log_handler=handler,
span_name='GET /foo',
transport_handler=transport_handler,
report_root_timestamp=True,
client_context=True)
context.start_timestamp = 24
context.response_status_code = 200
context.binary_annotations_dict = {'k': 'v'}
time_mock.return_value = 42
expected_server_annotations = {'cs': 24, 'cr': 42}
expected_server_bin_annotations = {'k': 'v'}
context.log_spans()
log_call = add_span_mock.call_args_list[0]
assert log_call[1] == {
'span_id': client_span_id,
'parent_span_id': None,
'trace_id': trace_id,
'span_name': 'GET /foo',
'annotations': expected_server_annotations,
'binary_annotations': expected_server_bin_annotations,
'duration_s': 18,
'timestamp_s': 24,
}
assert flush_mock.call_count == 1
def test_zipkin_logging_client_context_emit_spans(add_span_mock, flush_mock,
time_mock, fake_endpoint):
# This lengthy function tests that the logging context properly
# logs root client span
trace_id = '000000000000000f'
client_span_id = '0000000000000003'
attr = ZipkinAttrs(
trace_id=trace_id,
span_id=client_span_id,
parent_span_id=None,
flags=None,
is_sampled=True,
)
span_storage = SpanStorage()
transport_handler = mock.Mock()
context = logging_helper.ZipkinLoggingContext(
zipkin_attrs=attr,
endpoint=fake_endpoint,
span_name='GET /foo',
transport_handler=transport_handler,
report_root_timestamp=True,
span_storage=span_storage,
client_context=True,
service_name='test_server',
encoding=Encoding.V1_JSON,
)
context.start_timestamp = 24
context.response_status_code = 200
context.binary_annotations_dict = {'k': 'v'}
time_mock.return_value = 42
context.emit_spans()
log_call = add_span_mock.call_args_list[0]
assert log_call[0][1].build_v1_span() == SpanBuilder(
trace_id=trace_id,
name='GET /foo',
parent_id=None,
span_id=client_span_id,
timestamp=24.0,
duration=18.0,
annotations={
'cs': 24,
'cr': 42
},
tags={
'k': 'v'
},
kind=Kind.CLIENT,
service_name='test_server',
local_endpoint=fake_endpoint,
).build_v1_span()
assert flush_mock.call_count == 1
def context():
attr = ZipkinAttrs(None, None, None, None, False)
log_handler = logging_helper.ZipkinLoggerHandler(attr)
transport_handler = mock.Mock()
return logging_helper.ZipkinLoggingContext(
attr,
'thrift_endpoint',
log_handler,
'span_name',
transport_handler,
)
def context():
attr = ZipkinAttrs(None, None, None, None, False)
log_handler = logging_helper.ZipkinLoggerHandler(attr)
return logging_helper.ZipkinLoggingContext(
zipkin_attrs=attr,
thrift_endpoint='thrift_endpoint',
log_handler=log_handler,
span_name='span_name',
transport_handler=mock_transport_handler,
report_root_timestamp=False,
)
def test_zipkin_logging_client_context_emit_spans(
add_span_mock, flush_mock, time_mock, fake_endpoint
):
# This lengthy function tests that the logging context properly
# logs root client span
trace_id = "000000000000000f"
client_span_id = "0000000000000003"
attr = ZipkinAttrs(
trace_id=trace_id,
span_id=client_span_id,
parent_span_id=None,
flags=None,
is_sampled=True,
)
tracer = MockTracer()
transport_handler = mock.Mock()
context = logging_helper.ZipkinLoggingContext(
zipkin_attrs=attr,
endpoint=fake_endpoint,
span_name="GET /foo",
transport_handler=transport_handler,
report_root_timestamp=True,
get_tracer=lambda: tracer,
client_context=True,
service_name="test_server",
encoding=Encoding.V1_JSON,
)
context.start_timestamp = 24
context.response_status_code = 200
context.tags = {"k": "v"}
time_mock.return_value = 42
context.emit_spans()
log_call = add_span_mock.call_args_list[0]
assert (
log_call[0][1].build_v1_span()
== Span(
trace_id=trace_id,
name="GET /foo",
parent_id=None,
span_id=client_span_id,
kind=Kind.CLIENT,
timestamp=24.0,
duration=18.0,
local_endpoint=fake_endpoint,
annotations={"cs": 24, "cr": 42},
tags={"k": "v"},
).build_v1_span()
)
assert flush_mock.call_count == 1
def context():
attr = ZipkinAttrs(None, None, None, None, False)
return logging_helper.ZipkinLoggingContext(
zipkin_attrs=attr,
endpoint=create_endpoint(80, 'test_server', '127.0.0.1'),
span_name='span_name',
transport_handler=MockTransportHandler(),
report_root_timestamp=False,
span_storage=SpanStorage(),
service_name='test_server',
encoding=Encoding.V1_JSON,
)
def context():
attr = ZipkinAttrs(None, None, None, None, False)
log_handler = logging_helper.ZipkinLoggerHandler(attr)
return logging_helper.ZipkinLoggingContext(
zipkin_attrs=attr,
endpoint=_encoding_helpers.create_endpoint(80, 'test_server',
'127.0.0.1'),
log_handler=log_handler,
span_name='span_name',
transport_handler=MockTransportHandler(),
report_root_timestamp=False,
)
def test_zipkin_logging_client_context_log_spans(add_span_mock, flush_mock,
time_mock, fake_endpoint):
# This lengthy function tests that the logging context properly
# logs root client span
trace_id = '000000000000000f'
client_span_id = '0000000000000003'
attr = ZipkinAttrs(
trace_id=trace_id,
span_id=client_span_id,
parent_span_id=None,
flags=None,
is_sampled=True,
)
handler = logging_helper.ZipkinLoggerHandler(attr)
handler.client_spans = []
transport_handler = mock.Mock()
context = logging_helper.ZipkinLoggingContext(
zipkin_attrs=attr,
endpoint=fake_endpoint,
log_handler=handler,
span_name='GET /foo',
transport_handler=transport_handler,
report_root_timestamp=True,
client_context=True)
context.start_timestamp = 24
context.response_status_code = 200
context.binary_annotations_dict = {'k': 'v'}
time_mock.return_value = 42
expected_server_annotations = {'cs': 24, 'cr': 42}
expected_server_bin_annotations = {'k': 'v'}
context.log_spans()
log_call = add_span_mock.call_args_list[0]
assert log_call[1] == {
'span_id': client_span_id,
'parent_span_id': None,
'trace_id': trace_id,
'span_name': 'GET /foo',
'annotations': expected_server_annotations,
'binary_annotations': expected_server_bin_annotations,
'duration_s': 18,
'timestamp_s': 24,
'endpoint': fake_endpoint,
'sa_endpoint': None,
}
assert flush_mock.call_count == 1
def test_log_span_not_called_if_not_sampled(log_span_mock):
attr = ZipkinAttrs(
trace_id='0000000000000001',
span_id='0000000000000002',
parent_span_id=None,
flags=None,
is_sampled=False,
)
log_handler = logging_helper.ZipkinLoggerHandler(attr)
transport_handler = mock.Mock()
context = logging_helper.ZipkinLoggingContext(attr, 'thrift_endpoint',
log_handler, 'span_name',
transport_handler)
context.log_spans()
assert log_span_mock.call_count == 0
def test_batch_sender_add_span_not_called_if_not_sampled(
add_span_mock, flush_mock):
attr = ZipkinAttrs(
trace_id='0000000000000001',
span_id='0000000000000002',
parent_span_id=None,
flags=None,
is_sampled=False,
)
log_handler = logging_helper.ZipkinLoggerHandler(attr)
transport_handler = mock.Mock()
context = logging_helper.ZipkinLoggingContext(
zipkin_attrs=attr,
thrift_endpoint='thrift_endpoint',
log_handler=log_handler,
span_name='span_name',
transport_handler=transport_handler,
report_root_timestamp=False,
)
context.log_spans()
assert add_span_mock.call_count == 0
assert flush_mock.call_count == 0
def test_zipkin_logging_context(time_mock):
# Tests the context manager aspects of the ZipkinLoggingContext
time_mock.return_value = 42
attr = ZipkinAttrs(None, None, None, None, False)
tracer = MockTracer()
context = logging_helper.ZipkinLoggingContext(
zipkin_attrs=attr,
endpoint=create_endpoint(80, "test_server", "127.0.0.1"),
span_name="span_name",
transport_handler=MockTransportHandler(),
report_root_timestamp=False,
get_tracer=lambda: tracer,
service_name="test_server",
encoding=Encoding.V1_JSON,
)
# Ignore the actual logging part
with mock.patch.object(context, "emit_spans"):
context.start()
assert context.start_timestamp == 42
context.stop()
# Make sure the handler and the zipkin attrs are gone
assert context.emit_spans.call_count == 1
def test_batch_sender_add_span_not_called_if_not_sampled(add_span_mock, flush_mock):
attr = ZipkinAttrs(
trace_id="0000000000000001",
span_id="0000000000000002",
parent_span_id=None,
flags=None,
is_sampled=False,
)
tracer = MockTracer()
transport_handler = mock.Mock()
context = logging_helper.ZipkinLoggingContext(
zipkin_attrs=attr,
endpoint=create_endpoint(80, "test_server", "127.0.0.1"),
span_name="span_name",
transport_handler=transport_handler,
report_root_timestamp=False,
get_tracer=lambda: tracer,
service_name="test_server",
encoding=Encoding.V1_JSON,
)
context.emit_spans()
assert add_span_mock.call_count == 0
assert flush_mock.call_count == 0
def test_zipkin_logging_server_context_log_spans(copy_endpoint_mock,
bin_ann_list_builder,
ann_list_builder,
log_span_mock, time_mock):
# This lengthy function tests that the logging context properly
# logs both client and server spans, while attaching extra annotations
# logged throughout the context of the trace.
trace_id = '000000000000000f'
parent_span_id = '0000000000000001'
server_span_id = '0000000000000002'
client_span_id = '0000000000000003'
client_span_name = 'breadcrumbs'
client_svc_name = 'svc'
attr = ZipkinAttrs(
trace_id=trace_id,
span_id=server_span_id,
parent_span_id=parent_span_id,
flags=None,
is_sampled=True,
)
handler = logging_helper.ZipkinLoggerHandler(attr)
extra_server_annotations = {
'parent_span_id': None,
'annotations': {
'foo': 1
},
'binary_annotations': {
'what': 'whoa'
},
}
extra_client_annotations = {
'parent_span_id': client_span_id,
'annotations': {
'ann1': 1
},
'binary_annotations': {
'bann1': 'aww'
},
}
handler.extra_annotations = [
extra_server_annotations,
extra_client_annotations,
]
handler.client_spans = [{
'span_id': client_span_id,
'parent_span_id': None,
'span_name': client_span_name,
'service_name': client_svc_name,
'annotations': {
'ann2': 2,
'cs': 26,
'cr': 30
},
'binary_annotations': {
'bann2': 'yiss'
},
}]
# Each of the thrift annotation helpers just reflects its first arg
# so the annotation dicts can be checked.
ann_list_builder.side_effect = lambda x, y: x
bin_ann_list_builder.side_effect = lambda x, y: x
transport_handler = mock.Mock()
context = logging_helper.ZipkinLoggingContext(
zipkin_attrs=attr,
thrift_endpoint='thrift_endpoint',
log_handler=handler,
span_name='GET /foo',
transport_handler=transport_handler,
report_root_timestamp=True,
)
context.start_timestamp = 24
context.response_status_code = 200
context.binary_annotations_dict = {'k': 'v'}
time_mock.return_value = 42
expected_server_annotations = {'foo': 1, 'sr': 24, 'ss': 42}
expected_server_bin_annotations = {'k': 'v', 'what': 'whoa'}
expected_client_annotations = {'ann1': 1, 'ann2': 2, 'cs': 26, 'cr': 30}
expected_client_bin_annotations = {'bann1': 'aww', 'bann2': 'yiss'}
context.log_spans()
client_log_call, server_log_call = log_span_mock.call_args_list
assert server_log_call[1] == {
'span_id': server_span_id,
'parent_span_id': parent_span_id,
'trace_id': trace_id,
'span_name': 'GET /foo',
'annotations': expected_server_annotations,
'binary_annotations': expected_server_bin_annotations,
'transport_handler': transport_handler,
'duration_s': 18,
'timestamp_s': 24,
}
assert client_log_call[1] == {
'span_id': client_span_id,
'parent_span_id': server_span_id,
'trace_id': trace_id,
'span_name': client_span_name,
'annotations': expected_client_annotations,
'binary_annotations': expected_client_bin_annotations,
'transport_handler': transport_handler,
'duration_s': 4,
'timestamp_s': 26,
}
def test_zipkin_logging_server_context_log_spans(add_span_mock, flush_mock,
time_mock, fake_endpoint):
# This lengthy function tests that the logging context properly
# logs both client and server spans, while attaching extra annotations
# logged throughout the context of the trace.
trace_id = '000000000000000f'
parent_span_id = '0000000000000001'
server_span_id = '0000000000000002'
client_span_id = '0000000000000003'
client_span_name = 'breadcrumbs'
client_svc_name = 'svc'
attr = ZipkinAttrs(
trace_id=trace_id,
span_id=server_span_id,
parent_span_id=parent_span_id,
flags=None,
is_sampled=True,
)
handler = logging_helper.ZipkinLoggerHandler(attr)
extra_server_annotations = {
'parent_span_id': None,
'annotations': {
'foo': 1
},
'binary_annotations': {
'what': 'whoa'
},
}
extra_client_annotations = {
'parent_span_id': client_span_id,
'annotations': {
'ann1': 1
},
'binary_annotations': {
'bann1': 'aww'
},
}
handler.extra_annotations = [
extra_server_annotations,
extra_client_annotations,
]
handler.client_spans = [{
'span_id': client_span_id,
'parent_span_id': None,
'span_name': client_span_name,
'service_name': client_svc_name,
'annotations': {
'ann2': 2,
'cs': 26,
'cr': 30
},
'binary_annotations': {
'bann2': 'yiss'
},
}]
transport_handler = mock.Mock()
context = logging_helper.ZipkinLoggingContext(
zipkin_attrs=attr,
endpoint=fake_endpoint,
log_handler=handler,
span_name='GET /foo',
transport_handler=transport_handler,
report_root_timestamp=True,
)
context.start_timestamp = 24
context.response_status_code = 200
context.binary_annotations_dict = {'k': 'v'}
time_mock.return_value = 42
expected_server_annotations = {'foo': 1, 'sr': 24, 'ss': 42}
expected_server_bin_annotations = {'k': 'v', 'what': 'whoa'}
expected_client_annotations = {'ann1': 1, 'ann2': 2, 'cs': 26, 'cr': 30}
expected_client_bin_annotations = {'bann1': 'aww', 'bann2': 'yiss'}
context.log_spans()
client_log_call, server_log_call = add_span_mock.call_args_list
assert server_log_call[1] == {
'span_id': server_span_id,
'parent_span_id': parent_span_id,
'trace_id': trace_id,
'span_name': 'GET /foo',
'annotations': expected_server_annotations,
'binary_annotations': expected_server_bin_annotations,
'duration_s': 18,
'timestamp_s': 24,
'endpoint': fake_endpoint,
'sa_endpoint': None,
}
assert client_log_call[1] == {
'span_id': client_span_id,
'parent_span_id': server_span_id,
'trace_id': trace_id,
'span_name': client_span_name,
'annotations': expected_client_annotations,
'binary_annotations': expected_client_bin_annotations,
'duration_s': 4,
'timestamp_s': 26,
'endpoint': _encoding_helpers.create_endpoint(80, 'svc', '127.0.0.1'),
'sa_endpoint': None,
}
assert flush_mock.call_count == 1
def test_zipkin_logging_server_context_emit_spans(
add_span_mock, flush_mock, time_mock, fake_endpoint
):
# This lengthy function tests that the logging context properly
# logs both client and server spans.
trace_id = "000000000000000f"
parent_span_id = "0000000000000001"
server_span_id = "0000000000000002"
client_span_id = "0000000000000003"
client_span_name = "breadcrumbs"
attr = ZipkinAttrs(
trace_id=trace_id,
span_id=server_span_id,
parent_span_id=parent_span_id,
flags=None,
is_sampled=True,
)
tracer = MockTracer()
client_span = Span(
trace_id=trace_id,
name=client_span_name,
parent_id=server_span_id,
span_id=client_span_id,
kind=Kind.CLIENT,
timestamp=26.0,
duration=4.0,
local_endpoint=create_endpoint(service_name="test_server"),
annotations={"ann2": 2, "cs": 26, "cr": 30},
tags={"bann2": "yiss"},
)
tracer.get_spans().append(client_span)
transport_handler = mock.Mock()
context = logging_helper.ZipkinLoggingContext(
zipkin_attrs=attr,
endpoint=fake_endpoint,
span_name="GET /foo",
transport_handler=transport_handler,
report_root_timestamp=True,
get_tracer=lambda: tracer,
service_name="test_server",
encoding=Encoding.V1_JSON,
)
context.start_timestamp = 24
context.response_status_code = 200
context.tags = {"k": "v"}
time_mock.return_value = 42
context.emit_spans()
client_log_call, server_log_call = add_span_mock.call_args_list
assert (
server_log_call[0][1].build_v1_span()
== Span(
trace_id=trace_id,
name="GET /foo",
parent_id=parent_span_id,
span_id=server_span_id,
kind=Kind.SERVER,
timestamp=24.0,
duration=18.0,
local_endpoint=fake_endpoint,
annotations={"sr": 24, "ss": 42},
tags={"k": "v"},
).build_v1_span()
)
assert client_log_call[0][1] == client_span
assert flush_mock.call_count == 1
def test_zipkin_logging_server_context_emit_spans(add_span_mock, flush_mock,
time_mock, fake_endpoint):
# This lengthy function tests that the logging context properly
# logs both client and server spans.
trace_id = '000000000000000f'
parent_span_id = '0000000000000001'
server_span_id = '0000000000000002'
client_span_id = '0000000000000003'
client_span_name = 'breadcrumbs'
client_svc_name = 'svc'
attr = ZipkinAttrs(
trace_id=trace_id,
span_id=server_span_id,
parent_span_id=parent_span_id,
flags=None,
is_sampled=True,
)
span_storage = SpanStorage()
client_span = SpanBuilder(
trace_id=trace_id,
name=client_span_name,
parent_id=server_span_id,
span_id=client_span_id,
timestamp=26.0,
duration=4.0,
annotations={
'ann2': 2,
'cs': 26,
'cr': 30
},
tags={'bann2': 'yiss'},
kind=Kind.CLIENT,
service_name=client_svc_name,
)
span_storage.append(client_span)
transport_handler = mock.Mock()
context = logging_helper.ZipkinLoggingContext(
zipkin_attrs=attr,
endpoint=fake_endpoint,
span_name='GET /foo',
transport_handler=transport_handler,
report_root_timestamp=True,
span_storage=span_storage,
service_name='test_server',
encoding=Encoding.V1_JSON,
)
context.start_timestamp = 24
context.response_status_code = 200
context.binary_annotations_dict = {'k': 'v'}
time_mock.return_value = 42
context.emit_spans()
client_log_call, server_log_call = add_span_mock.call_args_list
assert server_log_call[0][1].build_v1_span() == SpanBuilder(
trace_id=trace_id,
name='GET /foo',
parent_id=parent_span_id,
span_id=server_span_id,
timestamp=24.0,
duration=18.0,
annotations={
'sr': 24,
'ss': 42
},
tags={
'k': 'v'
},
kind=Kind.SERVER,
service_name=client_svc_name,
local_endpoint=fake_endpoint,
).build_v1_span()
assert client_log_call[0][1] == client_span
assert flush_mock.call_count == 1
