def _encode_span(
self, span: Span, encoded_local_endpoint: zipkin_pb2.Endpoint
) -> zipkin_pb2.Span:
context = span.get_span_context()
# pylint: disable=no-member
encoded_span = zipkin_pb2.Span(
trace_id=self._encode_trace_id(context.trace_id),
id=self._encode_span_id(context.span_id),
name=span.name,
timestamp=self._nsec_to_usec_round(span.start_time),
duration=self._nsec_to_usec_round(span.end_time - span.start_time),
local_endpoint=encoded_local_endpoint,
kind=self.SPAN_KIND_MAP[span.kind],
)
tags = self._extract_tags_from_span(span)
if tags:
encoded_span.tags.update(tags)
annotations = self._encode_annotations(span.events)
if annotations:
encoded_span.annotations.extend(annotations)
debug = self._encode_debug(context)
if debug:
encoded_span.debug = debug
parent_id = self._get_parent_id(span.parent)
if parent_id is not None:
encoded_span.parent_id = self._encode_span_id(parent_id)
return encoded_span
def _test_encode_max_tag_length(self, max_tag_value_length: int):
otel_span, expected_tag_output = self.get_data_for_max_tag_length_test(
max_tag_value_length)
service_name = otel_span.name
expected_output = zipkin_pb2.ListOfSpans(spans=[
zipkin_pb2.Span(
trace_id=ProtobufEncoder._encode_trace_id(
otel_span.context.trace_id),
id=ProtobufEncoder._encode_span_id(otel_span.context.span_id),
name=service_name,
timestamp=ProtobufEncoder._nsec_to_usec_round(
otel_span.start_time),
duration=ProtobufEncoder._nsec_to_usec_round(
otel_span.end_time - otel_span.start_time),
local_endpoint=zipkin_pb2.Endpoint(service_name=service_name),
kind=ProtobufEncoder.SPAN_KIND_MAP[SpanKind.INTERNAL],
tags=expected_tag_output,
annotations=None,
debug=True,
)
])
actual_output = zipkin_pb2.ListOfSpans.FromString(
ProtobufEncoder(max_tag_value_length).serialize([otel_span],
NodeEndpoint()))
self.assertEqual(actual_output, expected_output)
def test_encode(self):
local_endpoint = zipkin_pb2.Endpoint(service_name=TEST_SERVICE_NAME)
span_kind = ProtobufEncoder.SPAN_KIND_MAP[SpanKind.INTERNAL]
otel_spans = self.get_exhaustive_otel_span_list()
trace_id = ProtobufEncoder._encode_trace_id(
otel_spans[0].context.trace_id
)
expected_output = zipkin_pb2.ListOfSpans(
spans=[
zipkin_pb2.Span(
trace_id=trace_id,
id=ProtobufEncoder._encode_span_id(
otel_spans[0].context.span_id
),
name=otel_spans[0].name,
timestamp=ProtobufEncoder._nsec_to_usec_round(
otel_spans[0].start_time
),
duration=(
ProtobufEncoder._nsec_to_usec_round(
otel_spans[0].end_time - otel_spans[0].start_time
)
),
local_endpoint=local_endpoint,
kind=span_kind,
tags={
"key_bool": "false",
"key_string": "hello_world",
"key_float": "111.22",
"otel.status_code": "OK",
},
debug=True,
parent_id=ProtobufEncoder._encode_span_id(
otel_spans[0].parent.span_id
),
annotations=[
zipkin_pb2.Annotation(
timestamp=ProtobufEncoder._nsec_to_usec_round(
otel_spans[0].events[0].timestamp
),
value=json.dumps(
{
"event0": {
"annotation_bool": True,
"annotation_string": "annotation_test",
"key_float": 0.3,
}
},
sort_keys=True,
),
),
],
),
zipkin_pb2.Span(
trace_id=trace_id,
id=ProtobufEncoder._encode_span_id(
otel_spans[1].context.span_id
),
name=otel_spans[1].name,
timestamp=ProtobufEncoder._nsec_to_usec_round(
otel_spans[1].start_time
),
duration=(
ProtobufEncoder._nsec_to_usec_round(
otel_spans[1].end_time - otel_spans[1].start_time
)
),
local_endpoint=local_endpoint,
kind=span_kind,
tags={
"key_resource": "some_resource",
"otel.status_code": "ERROR",
"error": "Example description",
},
debug=False,
),
zipkin_pb2.Span(
trace_id=trace_id,
id=ProtobufEncoder._encode_span_id(
otel_spans[2].context.span_id
),
name=otel_spans[2].name,
timestamp=ProtobufEncoder._nsec_to_usec_round(
otel_spans[2].start_time
),
duration=(
ProtobufEncoder._nsec_to_usec_round(
otel_spans[2].end_time - otel_spans[2].start_time
)
),
local_endpoint=local_endpoint,
kind=span_kind,
tags={
"key_string": "hello_world",
"key_resource": "some_resource",
},
debug=False,
),
zipkin_pb2.Span(
trace_id=trace_id,
id=ProtobufEncoder._encode_span_id(
otel_spans[3].context.span_id
),
name=otel_spans[3].name,
timestamp=ProtobufEncoder._nsec_to_usec_round(
otel_spans[3].start_time
),
duration=(
ProtobufEncoder._nsec_to_usec_round(
otel_spans[3].end_time - otel_spans[3].start_time
)
),
local_endpoint=local_endpoint,
kind=span_kind,
tags={NAME_KEY: "name", VERSION_KEY: "version"},
debug=False,
),
],
)
actual_output = zipkin_pb2.ListOfSpans.FromString(
ProtobufEncoder().serialize(otel_spans, NodeEndpoint())
)
self.assertEqual(actual_output, expected_output)