def test_agent_client_split(self): agent_client = jaeger_exporter.AgentClientUDP( host_name="localhost", port=6354, max_packet_size=250, split_oversized_batches=True, ) translator = jaeger_exporter.Translate((self._test_span, )) small_batch = jaeger.Batch( # pylint: disable=protected-access spans=translator._translate(ThriftTranslator()), process=jaeger.Process(serviceName="xxx"), ) with unittest.mock.patch("socket.socket.sendto", autospec=True) as fake_sendto: agent_client.emit(small_batch) self.assertEqual(fake_sendto.call_count, 1) translator = jaeger_exporter.Translate([self._test_span] * 2) large_batch = jaeger.Batch( # pylint: disable=protected-access spans=translator._translate(ThriftTranslator()), process=jaeger.Process(serviceName="xxx"), ) with unittest.mock.patch("socket.socket.sendto", autospec=True) as fake_sendto: agent_client.emit(large_batch) self.assertEqual(fake_sendto.call_count, 2)
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 == jaeger.TagType.STRING } 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 == jaeger.TagType.STRING } 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: # Populate service_name from first span # We restrict any SpanProcessor to be only associated with a single # TracerProvider, so it is safe to assume that all Spans in a single # batch all originate from one TracerProvider (and in turn have all # the same service.name) if spans: service_name = spans[0].resource.attributes.get(SERVICE_NAME) if service_name: self.service_name = service_name translator = Translate(spans) thrift_translator = ThriftTranslator(self._max_tag_value_length) 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 _translate_spans_with_dropped_attributes(): span = get_span_with_dropped_attributes_events_links() translate = Translate([span]) # pylint: disable=protected-access return translate._translate(ThriftTranslator(max_tag_value_length=5))
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)) 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="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)