def test_max_tag_value_length(self):
span = trace._Span(
name="span",
resource=Resource(attributes={
"key_resource":
"some_resource some_resource some_more_resource"
}),
context=trace_api.SpanContext(
trace_id=0x000000000000000000000000DEADBEEF,
span_id=0x00000000DEADBEF0,
is_remote=False,
),
)
span.start()
span.set_attribute("key_bool", False)
span.set_attribute("key_string", "hello_world hello_world hello_world")
span.set_attribute("key_float", 111.22)
span.set_attribute("key_int", 1100)
span.set_attribute("key_tuple", ("tuple_element", "tuple_element2"))
span.end()
translate = Translate([span])
# does not truncate by default
# pylint: disable=protected-access
spans = translate._translate(ThriftTranslator())
tags_by_keys = {
tag.key: tag.vStr
for tag in spans[0].tags if tag.vType == 0
}
self.assertEqual("hello_world hello_world hello_world",
tags_by_keys["key_string"])
self.assertEqual("('tuple_element', 'tuple_element2')",
tags_by_keys["key_tuple"])
self.assertEqual(
"some_resource some_resource some_more_resource",
tags_by_keys["key_resource"],
)
# truncates when max_tag_value_length is passed
# pylint: disable=protected-access
spans = translate._translate(ThriftTranslator(max_tag_value_length=5))
tags_by_keys = {
tag.key: tag.vStr
for tag in spans[0].tags if tag.vType == 0
}
self.assertEqual("hello", tags_by_keys["key_string"])
self.assertEqual("('tup", tags_by_keys["key_tuple"])
self.assertEqual("some_", tags_by_keys["key_resource"])
def test_agent_client(self):
agent_client = jaeger_exporter.AgentClientUDP(
host_name="localhost", port=6354
)
translate = Translate([self._test_span])
# pylint: disable=protected-access
spans = translate._translate(ThriftTranslator())
batch = jaeger.Batch(
spans=spans, process=jaeger.Process(serviceName="xxx"),
)
agent_client.emit(batch)
def export(self, spans) -> SpanExportResult:
translator = Translate(spans)
if self.transport_format == TRANSPORT_FORMAT_PROTOBUF:
pb_translator = ProtobufTranslator(self.service_name)
jaeger_spans = translator._translate(pb_translator)
batch = model_pb2.Batch(spans=jaeger_spans)
request = PostSpansRequest(batch=batch)
self._collector_grpc_client.PostSpans(request)
else:
thrift_translator = ThriftTranslator()
jaeger_spans = translator._translate(thrift_translator)
batch = jaeger_thrift.Batch(
spans=jaeger_spans,
process=jaeger_thrift.Process(serviceName=self.service_name),
)
if self._collector_http_client is not None:
self._collector_http_client.submit(batch)
else:
self._agent_client.emit(batch)
return SpanExportResult.SUCCESS
def test_translate_to_jaeger(self):
# pylint: disable=invalid-name
self.maxDiff = None
span_names = ("test1", "test2", "test3")
trace_id = 0x6E0C63257DE34C926F9EFCD03927272E
trace_id_high = 0x6E0C63257DE34C92
trace_id_low = 0x6F9EFCD03927272E
span_id = 0x34BF92DEEFC58C92
parent_id = 0x1111111111111111
other_id = 0x2222222222222222
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
)
parent_span_context = trace_api.SpanContext(
trace_id, parent_id, is_remote=False
)
other_context = trace_api.SpanContext(
trace_id, other_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 = trace_api.Link(
context=other_context, attributes=link_attributes
)
default_tags = [
jaeger.Tag(
key="span.kind", vType=jaeger.TagType.STRING, vStr="internal",
),
]
otel_spans = [
trace._Span(
name=span_names[0],
context=span_context,
parent=parent_span_context,
events=(event,),
links=(link,),
kind=trace_api.SpanKind.CLIENT,
resource=Resource(
attributes={"key_resource": "some_resource"}
),
),
trace._Span(
name=span_names[1],
context=parent_span_context,
parent=None,
resource=Resource({}),
),
trace._Span(
name=span_names[2],
context=other_context,
parent=None,
resource=Resource({}),
instrumentation_info=InstrumentationInfo(
name="name", version="version"
),
),
]
otel_spans[0].start(start_time=start_times[0])
# added here to preserve order
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_tuple", ("tuple_element",))
otel_spans[0].set_status(
Status(StatusCode.ERROR, "Example description")
)
otel_spans[0].end(end_time=end_times[0])
otel_spans[1].start(start_time=start_times[1])
otel_spans[1].end(end_time=end_times[1])
otel_spans[2].start(start_time=start_times[2])
otel_spans[2].set_status(Status(StatusCode.OK, "Example description"))
otel_spans[2].end(end_time=end_times[2])
translate = Translate(otel_spans)
# pylint: disable=protected-access
spans = translate._translate(ThriftTranslator())
expected_spans = [
jaeger.Span(
operationName=span_names[0],
traceIdHigh=trace_id_high,
traceIdLow=trace_id_low,
spanId=span_id,
parentSpanId=parent_id,
startTime=start_times[0] // 10 ** 3,
duration=durations[0] // 10 ** 3,
flags=0,
tags=[
jaeger.Tag(
key="key_bool", vType=jaeger.TagType.BOOL, vBool=False
),
jaeger.Tag(
key="key_string",
vType=jaeger.TagType.STRING,
vStr="hello_world",
),
jaeger.Tag(
key="key_float",
vType=jaeger.TagType.DOUBLE,
vDouble=111.22,
),
jaeger.Tag(
key="key_tuple",
vType=jaeger.TagType.STRING,
vStr="('tuple_element',)",
),
jaeger.Tag(
key="key_resource",
vType=jaeger.TagType.STRING,
vStr="some_resource",
),
jaeger.Tag(
key="otel.status_code",
vType=jaeger.TagType.STRING,
vStr="ERROR",
),
jaeger.Tag(
key="otel.status_description",
vType=jaeger.TagType.STRING,
vStr="Example description",
),
jaeger.Tag(
key="span.kind",
vType=jaeger.TagType.STRING,
vStr="client",
),
jaeger.Tag(
key="error", vType=jaeger.TagType.BOOL, vBool=True
),
],
references=[
jaeger.SpanRef(
refType=jaeger.SpanRefType.FOLLOWS_FROM,
traceIdHigh=trace_id_high,
traceIdLow=trace_id_low,
spanId=other_id,
)
],
logs=[
jaeger.Log(
timestamp=event_timestamp // 10 ** 3,
fields=[
jaeger.Tag(
key="annotation_bool",
vType=jaeger.TagType.BOOL,
vBool=True,
),
jaeger.Tag(
key="annotation_string",
vType=jaeger.TagType.STRING,
vStr="annotation_test",
),
jaeger.Tag(
key="key_float",
vType=jaeger.TagType.DOUBLE,
vDouble=0.3,
),
jaeger.Tag(
key="message",
vType=jaeger.TagType.STRING,
vStr="event0",
),
],
)
],
),
jaeger.Span(
operationName=span_names[1],
traceIdHigh=trace_id_high,
traceIdLow=trace_id_low,
spanId=parent_id,
parentSpanId=0,
startTime=start_times[1] // 10 ** 3,
duration=durations[1] // 10 ** 3,
flags=0,
tags=default_tags,
),
jaeger.Span(
operationName=span_names[2],
traceIdHigh=trace_id_high,
traceIdLow=trace_id_low,
spanId=other_id,
parentSpanId=0,
startTime=start_times[2] // 10 ** 3,
duration=durations[2] // 10 ** 3,
flags=0,
tags=[
jaeger.Tag(
key="otel.status_code",
vType=jaeger.TagType.STRING,
vStr="OK",
),
jaeger.Tag(
key="otel.status_description",
vType=jaeger.TagType.STRING,
vStr="Example description",
),
jaeger.Tag(
key="span.kind",
vType=jaeger.TagType.STRING,
vStr="internal",
),
jaeger.Tag(
key=jaeger_exporter.translate.NAME_KEY,
vType=jaeger.TagType.STRING,
vStr="name",
),
jaeger.Tag(
key=jaeger_exporter.translate.VERSION_KEY,
vType=jaeger.TagType.STRING,
vStr="version",
),
],
),
]
# events are complicated to compare because order of fields
# (attributes) in otel is not important but in jeager it is
self.assertCountEqual(
spans[0].logs[0].fields, expected_spans[0].logs[0].fields
)
# get rid of fields to be able to compare the whole spans
spans[0].logs[0].fields = None
expected_spans[0].logs[0].fields = None
self.assertEqual(spans, expected_spans)