Use SpanData objects to emit spans on Zipkin Exporter (#217)

Author: sonmezonur

opencensus/trace/exporters/zipkin_exporter.py

@@ -21,9 +21,9 @@
 
 import requests
 
-from opencensus.trace import span_data
 from opencensus.trace.exporters import base
 from opencensus.trace.exporters.transports import sync
+from opencensus.trace.utils import check_str_length
 
 DEFAULT_ENDPOINT = '/api/v2/spans'
 DEFAULT_HOST_NAME = 'localhost'
@@ -100,15 +100,9 @@ def emit(self, span_datas):
         :param list of opencensus.trace.span_data.SpanData span_datas:
             SpanData tuples to emit
         """
-        # convert to the legacy trace json for easier refactoring
-        # TODO: refactor this to use the span data directly
-        trace = span_data.format_legacy_trace_json(span_datas)
-
-        trace_id = trace.get('traceId')
-        spans = trace.get('spans')
 
         try:
-            zipkin_spans = self.translate_to_zipkin(trace_id, spans)
+            zipkin_spans = self.translate_to_zipkin(span_datas)
             result = requests.post(
                 url=self.url,
                 data=json.dumps(zipkin_spans),
@@ -124,18 +118,22 @@ def emit(self, span_datas):
     def export(self, span_datas):
         self.transport.export(span_datas)
 
-    def translate_to_zipkin(self, trace_id, spans):
+    def translate_to_zipkin(self, span_datas):
         """Translate the opencensus spans to zipkin spans.
 
-        :type trace_id: str
-        :param trace_id: Trace ID.
-
-        :type spans: list
-        :param spans: List of spans to be exported.
+        :type span_datas: list of :class:
+            `~opencensus.trace.span_data.SpanData`
+        :param span_datas:
+            SpanData tuples to emit
 
         :rtype: list
         :returns: List of zipkin format spans.
         """
+
+        top_span = span_datas[0]
+        trace_id = top_span.context.trace_id if top_span.context is not None \
+            else None
+
         local_endpoint = {
             'serviceName': self.service_name,
             'port': self.port,
@@ -149,17 +147,17 @@ def translate_to_zipkin(self, trace_id, spans):
 
         zipkin_spans = []
 
-        for span in spans:
+        for span in span_datas:
             # Timestamp in zipkin spans is int of microseconds.
             start_datetime = datetime.datetime.strptime(
-                span.get('startTime'),
+                span.start_time,
                 ISO_DATETIME_REGEX)
             start_timestamp_ms = calendar.timegm(
                 start_datetime.timetuple()) * 1000 * 1000 \
                 + start_datetime.microsecond
 
             end_datetime = datetime.datetime.strptime(
-                span.get('endTime'),
+                span.end_time,
                 ISO_DATETIME_REGEX)
             end_timestamp_ms = calendar.timegm(
                 end_datetime.timetuple()) * 1000 * 1000 \
@@ -169,16 +167,16 @@ def translate_to_zipkin(self, trace_id, spans):
 
             zipkin_span = {
                 'traceId': trace_id,
-                'id': str(span.get('spanId')),
-                'name': span.get('displayName', {}).get('value'),
+                'id': str(span.span_id),
+                'name': span.name,
                 'timestamp': int(round(start_timestamp_ms)),
                 'duration': int(round(duration_ms)),
                 'localEndpoint': local_endpoint,
-                'tags': _extract_tags_from_span(span),
+                'tags': _extract_tags_from_span(span.attributes),
             }
 
-            span_kind = span.get('kind')
-            parent_span_id = span.get('parentSpanId')
+            span_kind = span.span_kind
+            parent_span_id = span.parent_span_id
 
             if span_kind is not None:
                 kind = SPAN_KIND_MAP.get(span_kind)
@@ -195,18 +193,16 @@ def translate_to_zipkin(self, trace_id, spans):
         return zipkin_spans
 
 
-def _extract_tags_from_span(span):
+def _extract_tags_from_span(attr):
+    if attr is None:
+        return {}
     tags = {}
-    for attribute_key, attribute_value in span.get(
-            'attributes', {}).get('attributeMap', {}).items():
-        if not isinstance(attribute_value, dict):
-            continue
-        if attribute_value.get('string_value') is not None:
-            value = attribute_value.get('string_value').get('value')
-        elif attribute_value.get('int_value') is not None:
-            value = str(attribute_value.get('int_value'))
-        elif attribute_value.get('bool_value') is not None:
-            value = str(attribute_value.get('bool_value'))
+    for attribute_key, attribute_value in attr.items():
+        if isinstance(attribute_value, (int, bool)):
+            value = str(attribute_value)
+        elif isinstance(attribute_value, str):
+            res, _ = check_str_length(str_to_check=attribute_value)
+            value = res
         else:
             logging.warn('Could not serialize tag {}'.format(attribute_key))
             continue

tests/unit/trace/exporters/test_zipkin_exporter.py

@@ -208,45 +208,25 @@ def test_translate_to_zipkin_span_kind_none(self):
         # Test ipv4 local endpoint
         exporter_ipv4 = zipkin_exporter.ZipkinExporter(
             service_name='my_service', ipv4=ipv4)
-        ipv4_trace = span_data_module.format_legacy_trace_json(spans_ipv4)
         zipkin_spans_ipv4 = exporter_ipv4.translate_to_zipkin(
-            trace_id=trace_id,
-            spans=ipv4_trace.get('spans'))
+            span_datas=spans_ipv4)
 
         self.assertEqual(zipkin_spans_ipv4, expected_zipkin_spans_ipv4)
 
         # Test ipv6 local endpoint
         exporter_ipv6 = zipkin_exporter.ZipkinExporter(
             service_name='my_service', ipv6=ipv6)
-        ipv6_trace = span_data_module.format_legacy_trace_json(spans_ipv6)
         zipkin_spans_ipv6 = exporter_ipv6.translate_to_zipkin(
-            trace_id=trace_id,
-            spans=ipv6_trace.get('spans')
-        )
+            span_datas=spans_ipv6)
 
         self.assertEqual(zipkin_spans_ipv6, expected_zipkin_spans_ipv6)
 
     def test_ignore_incorrect_spans(self):
-        span1 = {
-            'attributes': {
-                'attributeMap': {
-                    'float_value': {
-                        'value': 0.1
-                    }
-                }
-            }
-        }
-        self.assertEqual(zipkin_exporter._extract_tags_from_span(span1), {})
-
-        span2 = {
-            'attributes': {
-                'attributeMap': {
-                    'bool_value': False
-                }
+        attributes = {'float_value': 0.1}
+        self.assertEqual(zipkin_exporter._extract_tags_from_span(attributes), {})
 
-            }
-        }
-        self.assertEqual(zipkin_exporter._extract_tags_from_span(span2), {})
+        attributes = None
+        self.assertEqual(zipkin_exporter._extract_tags_from_span(attributes), {})
 
 
 class MockTransport(object):