Refactor code timestampStr to microseconds (#332)

* Refactor Code

* Change microsecond abbreviation: ms -> mus

Author: mayurkale22

opencensus/trace/exporters/jaeger_exporter.py

@@ -14,8 +14,6 @@
 
 """Export the spans data to Jaeger."""
 
-import calendar
-import datetime
 import logging
 import socket
 
@@ -26,12 +24,12 @@
 from opencensus.trace.exporters import base
 from opencensus.trace.exporters.gen.jaeger import agent, jaeger
 from opencensus.trace.exporters.transports import sync
+from opencensus.trace.utils import timestamp_to_microseconds
 
 DEFAULT_HOST_NAME = 'localhost'
 DEFAULT_AGENT_PORT = 6831
 DEFAULT_ENDPOINT = '/api/traces?format=jaeger.thrift'
 
-ISO_DATETIME_REGEX = '%Y-%m-%dT%H:%M:%S.%fZ'
 UDP_PACKET_MAX_LENGTH = 65000
 
 logging = logging.getLogger(__name__)
@@ -176,19 +174,9 @@ def translate_to_jaeger(self, span_datas):
         jaeger_spans = []
 
         for span in span_datas:
-            start_datetime = datetime.datetime.strptime(
-                span.start_time, ISO_DATETIME_REGEX)
-            start_microsec = calendar.timegm(start_datetime.timetuple()) \
-                * 1e6 \
-                + start_datetime.microsecond
-
-            end_datetime = datetime.datetime.strptime(
-                span.end_time, ISO_DATETIME_REGEX)
-            end_microsec = calendar.timegm(end_datetime.timetuple()) \
-                * 1e6 \
-                + end_datetime.microsecond
-
-            duration_microsec = end_microsec - start_microsec
+            start_timestamp_ms = timestamp_to_microseconds(span.start_time)
+            end_timestamp_ms = timestamp_to_microseconds(span.end_time)
+            duration_ms = end_timestamp_ms - start_timestamp_ms
 
             tags = _extract_tags(span.attributes)
 
@@ -220,8 +208,8 @@ def translate_to_jaeger(self, span_datas):
                 traceIdLow=_convert_hex_str_to_int(trace_id[16:32]),
                 spanId=_convert_hex_str_to_int(span_id),
                 operationName=span.name,
-                startTime=int(round(start_microsec)),
-                duration=int(round(duration_microsec)),
+                startTime=int(round(start_timestamp_ms)),
+                duration=int(round(duration_ms)),
                 tags=tags,
                 logs=logs,
                 references=refs,
@@ -290,12 +278,9 @@ def _extract_logs_from_span(span):
             vType=jaeger.TagType.STRING,
             vStr=annotation.description))
 
-        event_time = datetime.datetime.strptime(
-            time_event.timestamp, ISO_DATETIME_REGEX)
-        timestamp = calendar.timegm(event_time.timetuple()) \
-            * 1e6 + event_time.microsecond
-
-        logs.append(jaeger.Log(timestamp=int(round(timestamp)), fields=fields))
+        event_timestamp = timestamp_to_microseconds(time_event.timestamp)
+        logs.append(jaeger.Log(timestamp=int(round(event_timestamp)),
+                               fields=fields))
     return logs
 
 

opencensus/trace/exporters/zipkin_exporter.py

@@ -14,25 +14,21 @@
 
 """Export the spans data to Zipkin Collector."""
 
-import calendar
-import datetime
 import json
 import logging
 
 import requests
 
 from opencensus.trace.exporters import base
 from opencensus.trace.exporters.transports import sync
-from opencensus.trace.utils import check_str_length
+from opencensus.trace.utils import check_str_length, timestamp_to_microseconds
 
 DEFAULT_ENDPOINT = '/api/v2/spans'
 DEFAULT_HOST_NAME = 'localhost'
 DEFAULT_PORT = 9411
 DEFAULT_PROTOCOL = 'http'
 ZIPKIN_HEADERS = {'Content-Type': 'application/json'}
 
-ISO_DATETIME_REGEX = '%Y-%m-%dT%H:%M:%S.%fZ'
-
 SPAN_KIND_MAP = {
     0: None,  # span kind unspecified
     1: "SERVER",
@@ -152,28 +148,16 @@ def translate_to_zipkin(self, span_datas):
 
         for span in span_datas:
             # Timestamp in zipkin spans is int of microseconds.
-            start_datetime = datetime.datetime.strptime(
-                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.end_time,
-                ISO_DATETIME_REGEX)
-            end_timestamp_ms = calendar.timegm(
-                end_datetime.timetuple()) * 1000 * 1000 \
-                + end_datetime.microsecond
-
-            duration_ms = end_timestamp_ms - start_timestamp_ms
+            start_timestamp_mus = timestamp_to_microseconds(span.start_time)
+            end_timestamp_mus = timestamp_to_microseconds(span.end_time)
+            duration_mus = end_timestamp_mus - start_timestamp_mus
 
             zipkin_span = {
                 'traceId': span.context.trace_id,
                 'id': str(span.span_id),
                 'name': span.name,
-                'timestamp': int(round(start_timestamp_ms)),
-                'duration': int(round(duration_ms)),
+                'timestamp': int(round(start_timestamp_mus)),
+                'duration': int(round(duration_mus)),
                 'localEndpoint': local_endpoint,
                 'tags': _extract_tags_from_span(span.attributes),
                 'annotations': _extract_annotations_from_span(span),
@@ -225,11 +209,8 @@ def _extract_annotations_from_span(span):
         if not annotation:
             continue
 
-        event_time = datetime.datetime.strptime(time_event.timestamp,
-                                                ISO_DATETIME_REGEX)
-        epoch_time = calendar.timegm(
-            event_time.timetuple()) * 1e6 + event_time.microsecond
-        annotations.append({'timestamp': int(round(epoch_time)),
+        event_timestamp_mus = timestamp_to_microseconds(time_event.timestamp)
+        annotations.append({'timestamp': int(round(event_timestamp_mus)),
                             'value': annotation.description})
 
     return annotations

opencensus/trace/utils.py

@@ -12,11 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import calendar
+import datetime
+
 UTF8 = 'utf-8'
 
 # Max length is 128 bytes for a truncatable string.
 MAX_LENGTH = 128
 
+ISO_DATETIME_REGEX = '%Y-%m-%dT%H:%M:%S.%fZ'
+
 
 def _get_truncatable_str(str_to_convert):
     """Truncate a string if exceed limit and record the truncated bytes
@@ -56,3 +61,14 @@ def check_str_length(str_to_check, limit=MAX_LENGTH):
     result = str(str_bytes.decode(UTF8, errors='ignore'))
 
     return (result, truncated_byte_count)
+
+
+def timestamp_to_microseconds(timestamp):
+    """Convert a timestamp string into a microseconds value
+    :param timestamp
+    :return time in microseconds
+    """
+    timestamp_str = datetime.datetime.strptime(timestamp, ISO_DATETIME_REGEX)
+    epoch_time_secs = calendar.timegm(timestamp_str.timetuple())
+    epoch_time_mus = epoch_time_secs * 1e6 + timestamp_str.microsecond
+    return epoch_time_mus