def __init__(
self,
name: str,
context: trace_api.SpanContext,
parent: trace_api.ParentSpan = None,
sampler: Optional[sampling.Sampler] = None,
trace_config: None = None, # TODO
resource: None = None, # TODO
attributes: types.Attributes = None, # TODO
events: Sequence[trace_api.Event] = None, # TODO
links: Sequence[trace_api.Link] = (),
kind: trace_api.SpanKind = trace_api.SpanKind.INTERNAL,
span_processor: SpanProcessor = SpanProcessor(),
) -> None:
self.name = name
self.context = context
self.parent = parent
self.sampler = sampler
self.trace_config = trace_config
self.resource = resource
self.kind = kind
self.span_processor = span_processor
self.status = trace_api.Status()
self._lock = threading.Lock()
if attributes is None:
self.attributes = Span.empty_attributes
else:
self.attributes = BoundedDict.from_map(
MAX_NUM_ATTRIBUTES, attributes
)
if events is None:
self.events = Span.empty_events
else:
self.events = BoundedList.from_seq(MAX_NUM_EVENTS, events)
if links is None:
self.links = Span.empty_links
else:
self.links = BoundedList.from_seq(MAX_NUM_LINKS, links)
self.end_time = None # type: Optional[int]
self.start_time = None # type: Optional[int]
def test_translate_to_collector(self):
trace_id = 0x6E0C63257DE34C926F9EFCD03927272E
span_id = 0x34BF92DEEFC58C92
parent_id = 0x1111111111111111
base_time = 683647322 * 10**9 # in ns
start_times = (
base_time,
base_time + 150 * 10**6,
base_time + 300 * 10**6,
)
durations = (50 * 10**6, 100 * 10**6, 200 * 10**6)
end_times = (
start_times[0] + durations[0],
start_times[1] + durations[1],
start_times[2] + durations[2],
)
span_context = trace_api.SpanContext(
trace_id,
span_id,
is_remote=False,
trace_flags=TraceFlags(TraceFlags.SAMPLED),
trace_state=trace_api.TraceState({"testKey": "testValue"}),
)
parent_context = trace_api.SpanContext(trace_id,
parent_id,
is_remote=False)
other_context = trace_api.SpanContext(trace_id,
span_id,
is_remote=False)
event_attributes = {
"annotation_bool": True,
"annotation_string": "annotation_test",
"key_float": 0.3,
}
event_timestamp = base_time + 50 * 10**6
event = trace.Event(
name="event0",
timestamp=event_timestamp,
attributes=event_attributes,
)
link_attributes = {"key_bool": True}
link_1 = trace_api.Link(context=other_context,
attributes=link_attributes)
link_2 = trace_api.Link(context=parent_context,
attributes=link_attributes)
span_1 = trace.Span(
name="test1",
context=span_context,
parent=parent_context,
events=(event, ),
links=(link_1, ),
kind=trace_api.SpanKind.CLIENT,
)
span_2 = trace.Span(
name="test2",
context=parent_context,
parent=None,
kind=trace_api.SpanKind.SERVER,
)
span_3 = trace.Span(
name="test3",
context=other_context,
links=(link_2, ),
parent=span_2.get_context(),
)
otel_spans = [span_1, span_2, span_3]
otel_spans[0].start(start_time=start_times[0])
otel_spans[0].set_attribute("key_bool", False)
otel_spans[0].set_attribute("key_string", "hello_world")
otel_spans[0].set_attribute("key_float", 111.22)
otel_spans[0].set_attribute("key_int", 333)
otel_spans[0].set_status(
trace_api.Status(
trace_api.status.StatusCanonicalCode.INTERNAL,
"test description",
))
otel_spans[0].end(end_time=end_times[0])
otel_spans[1].start(start_time=start_times[1])
otel_spans[1].set_status(
trace_api.Status(
trace_api.status.StatusCanonicalCode.INTERNAL,
{"test", "val"},
))
otel_spans[1].end(end_time=end_times[1])
otel_spans[2].start(start_time=start_times[2])
otel_spans[2].end(end_time=end_times[2])
output_spans = translate_to_collector(otel_spans)
self.assertEqual(len(output_spans), 3)
self.assertEqual(output_spans[0].trace_id,
b"n\x0cc%}\xe3L\x92o\x9e\xfc\xd09''.")
self.assertEqual(output_spans[0].span_id,
b"4\xbf\x92\xde\xef\xc5\x8c\x92")
self.assertEqual(output_spans[0].name,
trace_pb2.TruncatableString(value="test1"))
self.assertEqual(output_spans[1].name,
trace_pb2.TruncatableString(value="test2"))
self.assertEqual(output_spans[2].name,
trace_pb2.TruncatableString(value="test3"))
self.assertEqual(
output_spans[0].start_time.seconds,
int(start_times[0] / 1000000000),
)
self.assertEqual(output_spans[0].end_time.seconds,
int(end_times[0] / 1000000000))
self.assertEqual(output_spans[0].kind, trace_api.SpanKind.CLIENT.value)
self.assertEqual(output_spans[1].kind, trace_api.SpanKind.SERVER.value)
self.assertEqual(output_spans[0].parent_span_id,
b"\x11\x11\x11\x11\x11\x11\x11\x11")
self.assertEqual(output_spans[2].parent_span_id,
b"\x11\x11\x11\x11\x11\x11\x11\x11")
self.assertEqual(
output_spans[0].status.code,
trace_api.status.StatusCanonicalCode.INTERNAL.value,
)
self.assertEqual(output_spans[0].status.message, "test description")
self.assertEqual(len(output_spans[0].tracestate.entries), 1)
self.assertEqual(output_spans[0].tracestate.entries[0].key, "testKey")
self.assertEqual(output_spans[0].tracestate.entries[0].value,
"testValue")
self.assertEqual(
output_spans[0].attributes.attribute_map["key_bool"].bool_value,
False,
)
self.assertEqual(
output_spans[0].attributes.attribute_map["key_string"].
string_value.value,
"hello_world",
)
self.assertEqual(
output_spans[0].attributes.attribute_map["key_float"].double_value,
111.22,
)
self.assertEqual(
output_spans[0].attributes.attribute_map["key_int"].int_value, 333)
self.assertEqual(
output_spans[0].time_events.time_event[0].time.seconds, 683647322)
self.assertEqual(
output_spans[0].time_events.time_event[0].annotation.description.
value,
"event0",
)
self.assertEqual(
output_spans[0].time_events.time_event[0].annotation.attributes.
attribute_map["annotation_bool"].bool_value,
True,
)
self.assertEqual(
output_spans[0].time_events.time_event[0].annotation.attributes.
attribute_map["annotation_string"].string_value.value,
"annotation_test",
)
self.assertEqual(
output_spans[0].time_events.time_event[0].annotation.attributes.
attribute_map["key_float"].double_value,
0.3,
)
self.assertEqual(
output_spans[0].links.link[0].trace_id,
b"n\x0cc%}\xe3L\x92o\x9e\xfc\xd09''.",
)
self.assertEqual(
output_spans[0].links.link[0].span_id,
b"4\xbf\x92\xde\xef\xc5\x8c\x92",
)
self.assertEqual(
output_spans[0].links.link[0].type,
trace_pb2.Span.Link.Type.TYPE_UNSPECIFIED,
)
self.assertEqual(
output_spans[1].status.code,
trace_api.status.StatusCanonicalCode.INTERNAL.value,
)
self.assertEqual(
output_spans[2].links.link[0].type,
trace_pb2.Span.Link.Type.PARENT_LINKED_SPAN,
)
self.assertEqual(
output_spans[0].links.link[0].attributes.attribute_map["key_bool"].
bool_value,
True,
)